Node.js Sequelize和响应请求图

我试图对我的请求有一个响应GraphQL

我尝试了很多东西，但目前我一直都是序列响应，没有bucket响应属于关系

我有两张桌子：

序列[id|处于活动状态]

Bucket[id | fk|u language|u id | fk|u sequence|u id |处于活动状态]

model/sequence.js

model/bucket.js

schema.js

请求图ql

但我有一个结果，桶不装载：

{
  "data": {
    "createSequence": {
      "is_active": false,
      "buckets": []
    }
  }
}

我的变异：

最终的console.log显示了许多信息

sequence {
  dataValues: 
   { id: 416,
     is_active: false,
     created_at: 2019-03-29T20:33:56.196Z,
     updated_at: 2019-03-29T20:33:56.196Z,
     buckets: [ [Object] ] },
  _previousDataValues: 
   { id: 416,
     is_active: false,
     created_at: 2019-03-29T20:33:56.196Z,
     updated_at: 2019-03-29T20:33:56.196Z,
     buckets: [ [Object] ] },
  _changed: {},
  _modelOptions: 
   { timestamps: true,
     validate: {},
     freezeTableName: true,
     underscored: false,
     paranoid: false,
     rejectOnEmpty: false,
     whereCollection: { id: 416 },
     schema: null,
     schemaDelimiter: '',
     defaultScope: {},
     scopes: {},
     indexes: [],
     name: { plural: 'sequences', singular: 'sequence' },
     omitNull: false,
     createdAt: 'created_at',
     updatedAt: 'updated_at',
     sequelize: 
      Sequelize {
        options: [Object],
        config: [Object],
        dialect: [Object],
        queryInterface: [Object],
        models: [Object],
        modelManager: [Object],
        connectionManager: [Object],
        importCache: [Object],
        test: [Object] },
     hooks: {} },
  _options: 
   { isNewRecord: false,
     _schema: null,
     _schemaDelimiter: '',
     include: [ [Object] ],
     includeNames: [ 'buckets' ],
     includeMap: { buckets: [Object] },
     includeValidated: true,
     attributes: [ 'id', 'is_active', 'created_at', 'updated_at' ],
     raw: true },
  isNewRecord: false,
  buckets: 
   [ bucket {
       dataValues: [Object],
       _previousDataValues: [Object],
       _changed: {},
       _modelOptions: [Object],
       _options: [Object],
       isNewRecord: false } ] }

---

突变解析器返回一个Promise，该Promise解析为一个模型实例。此行返回了有问题的承诺：

return models.Sequence.create(input)

因此，服务器将等待该承诺得到解决，然后再向前传递值。其他行动也在等待这一承诺，但这些承诺没有得到回报，因此不会等待

你所要做的就是等待你所有的操作完成，然后再解决你的承诺

createSequence: async (parent, { input }) => {
  const sequence = await models.Sequence.create({
    is_active: input.is_active
  })
  if (!input.buckets) return sequence
  // You may have to modify your Sequence.buckets resolver to avoid fetching buckets again.
  sequence.buckets = await Promise.all(input.buckets.map(bucket => {
    // You can avoid these if checks by implementing stricter input types.
    // e.g. buckets: [BucketInput!]!
    if (!bucket) return null
    return models.Bucket.create({
      ...bucket,
      fk_sequence_id: sequence.id
    })
  }))
  return sequence
}

另外，确保Sequence.Bucket解析器没有用错误数据覆盖Bucket。您提供的解析器将尝试将bucket主键与sequence主键匹配，而不是将正确的外键与主键匹配

下面是一个可以工作的解析器：

buckets: (parent) => (
  parent.buckets // This line may conflict with some of your code and cause problems.
  || models.Bucket.findAll({
    where: {fk_sequence_id: parent.id}
  })
)

---

谢谢你的回答@JemiSalo！我已经实现了你的代码，但是我得到了相同的结果，在我的数组中总是没有bucket。我更新了我的后突变并删除了导入蓝鸟。我未能查看你的Sequence.Bucket解析器。您有一个导致问题的主要bug。我将更新我的答案以包含解决方案。在解析器中，我添加了一个返回parent.bucket | |。。。你能确认这是路吗？因为只有您的代码parent.bucket | |。。。在解析器中，返回null。非常感谢你的帮助！！！你拯救了这一天！分解我编写的解析器：如果parent.bucket是真实的，那么它将返回。当通过createSequence的解析返回父级时，就会出现这种情况。通常情况下，parent.Bucket为null或未定义，将返回Bucket.findAll承诺。我试着复制粘贴你的代码，它似乎工作。第一个值parent.bucket就是为了获得更好的性能。如果它引起问题，您可以将其丢弃。

...
Sequence      : {
    buckets(sequence) {
        return models.Bucket.findAll({
            where: {id: sequence.id}
        });
    },
    ...
},
...
Mutation    : {
createSequence(_, {input}) {
    let sequenceId = 0;

    // Create Sequence
    return models.Sequence.create(input)
                 .then((sequence) => {
                     sequenceId = sequence.id;
                     console.log('sequence created');
                     // Create Bucket
                     // Foreach on buckets

                     return Promise.map(input.buckets, function (bucket) {
                         bucket.fk_sequence_id = sequenceId;
                         console.log('bucket created');
                         return models.Bucket.create(bucket);
                     })

                 })
                 .then(() => {
                     console.log('load created', sequenceId);
                     return models.Sequence.findOne({
                         where  : {id: sequenceId},
                         include: [
                             {
                                 model: models.Bucket,
                                 where: { fk_sequence_id: sequenceId }
                             }
                         ]
                     }).then((response) => {
                         console.log(response);

                         return response;
                     })

                 });

},
}

sequence {
  dataValues: 
   { id: 416,
     is_active: false,
     created_at: 2019-03-29T20:33:56.196Z,
     updated_at: 2019-03-29T20:33:56.196Z,
     buckets: [ [Object] ] },
  _previousDataValues: 
   { id: 416,
     is_active: false,
     created_at: 2019-03-29T20:33:56.196Z,
     updated_at: 2019-03-29T20:33:56.196Z,
     buckets: [ [Object] ] },
  _changed: {},
  _modelOptions: 
   { timestamps: true,
     validate: {},
     freezeTableName: true,
     underscored: false,
     paranoid: false,
     rejectOnEmpty: false,
     whereCollection: { id: 416 },
     schema: null,
     schemaDelimiter: '',
     defaultScope: {},
     scopes: {},
     indexes: [],
     name: { plural: 'sequences', singular: 'sequence' },
     omitNull: false,
     createdAt: 'created_at',
     updatedAt: 'updated_at',
     sequelize: 
      Sequelize {
        options: [Object],
        config: [Object],
        dialect: [Object],
        queryInterface: [Object],
        models: [Object],
        modelManager: [Object],
        connectionManager: [Object],
        importCache: [Object],
        test: [Object] },
     hooks: {} },
  _options: 
   { isNewRecord: false,
     _schema: null,
     _schemaDelimiter: '',
     include: [ [Object] ],
     includeNames: [ 'buckets' ],
     includeMap: { buckets: [Object] },
     includeValidated: true,
     attributes: [ 'id', 'is_active', 'created_at', 'updated_at' ],
     raw: true },
  isNewRecord: false,
  buckets: 
   [ bucket {
       dataValues: [Object],
       _previousDataValues: [Object],
       _changed: {},
       _modelOptions: [Object],
       _options: [Object],
       isNewRecord: false } ] }

return models.Sequence.create(input)

createSequence: async (parent, { input }) => {
  const sequence = await models.Sequence.create({
    is_active: input.is_active
  })
  if (!input.buckets) return sequence
  // You may have to modify your Sequence.buckets resolver to avoid fetching buckets again.
  sequence.buckets = await Promise.all(input.buckets.map(bucket => {
    // You can avoid these if checks by implementing stricter input types.
    // e.g. buckets: [BucketInput!]!
    if (!bucket) return null
    return models.Bucket.create({
      ...bucket,
      fk_sequence_id: sequence.id
    })
  }))
  return sequence
}

buckets: (parent) => (
  parent.buckets // This line may conflict with some of your code and cause problems.
  || models.Bucket.findAll({
    where: {fk_sequence_id: parent.id}
  })
)