如何防止 sequelize 中的嵌套查询/捕获？

Question

我认为我正在尽可能地防止嵌套查询，但老实说我不确定。我知道这里的调用都可以在单个选择查询中执行，但我这样做是为了简化示例。

// This example is in TypeScript

// find user
User.find({where:{username:'user'}})

    // if found user
    .then(function(user) {

        return User.find({where:{username:'other_user'}})

            // if found other_user
            .then(function(other_user) {
                // do stuff
                return whatever_i_need
            }

            // if something went wrong, go straight to parent catch
            .catch(function(err) {
                // do stuff
                throw new Error()
            }
    }

    // if previous .then() returned success
    .then(function(data) {

        return User.find({where:{username:'yet_another_user'}})

            // if found yet_another_user
            .then(function(yet_another_user) {
                // do stuff
                return whatever_i_need_again
            }

            // if something went wrong, go straight to parent catch
            .catch(function(err) {
                // do stuff
                throw new Error()
            }
    }

    // if anything threw an error at any point in time
    .catch(function(err) {
        // handle the error
    }

但是，这会导致嵌套的 Promise，而这正是 Promise 所要防止的。这是为承诺推荐的“最大深度”，还是我错过了什么？有没有更好的方法来链接查询？

Answer 1

返回嵌套的promise，而不是在内部块中处理它以展平结构。

User.find({where:{username:'user'}})
.then(function(user) {
  if (user) { // if found user
    // do stuff
    return User.find({where:{username:'other_user'}});
  }
  throw new Error('user not-found');
})
.then(function(other_user) {
  if (other_user) { // if found other_user
    // do stuff
    return whatever_i_need;
  }
  throw new Error('other_user not-found');
})
.then(function(data) {
  return User.find({where:{username:'yet_another_user'}})
})
.then(function(yet_another_user) {
  if (yet_another_user) { // if found yet_another_user
    // do stuff
    return whatever_i_need_again;
  }
  throw new Error('yet_another_user not-found');
}
.then(function(data){
  // do stuff
})
.catch(function(err) { // if anything threw an error at any point in time
  // handle the error
}

请注意，已解决的承诺意味着查询已成功完成。就是这样。成功的查询并不能保证返回结果。空结果是已解决的承诺的有效结果。

还要注意，resolve 或 reject 回调的返回值将用已解决的 Promise 包装，然后传递给下一个 then 块，形成一个有意义的 Promise 链。感谢@Matt 关于这一点的后续反馈。

Answer 2

两点：

• 删除.catch(function(err) { throw new Error() }。它只会删除错误消息。
• 你可以unnest内部then调用

应该是这样的

User.find({where:{username:'user'}})
.then(function(user) {
    return User.find({where:{username:'other_user'}})
})
.then(function(other_user) {
    // do stuff
     return whatever_i_need
})
// if previous .then() returned success
.then(function(data) {
    return User.find({where:{username:'yet_another_user'}})
})
// if found yet_another_user
.then(function(yet_another_user) {
    // do stuff
    return whatever_i_need_again
})
// if anything threw an error at any point in time
.catch(function(err) {
    // handle the error
})