如何使用Sequelize将ID传递到其关联记录

Question

I'm building an app with Express on backend, Postgres for db and Sequelize for ORM.

I have 3 associated models:

Post
Event
Publishing , belongs to Post , belongs to Event

When I publish my Post , I update its state to 2, I need to create an Event and Publishing . Publishing will have the postId and eventId , among other things that I'm passing with a query. I tried the following code, it changes the state of the Post, creates an Event and Publishing, but they are not related to each other.

  publishPost(req) {
    return new Promise((resolve, reject) => {
      async.parallel({
        changeState: (callback) => {
          Post.findAll({
            where: { id: req.query.post_id },
            attributes: ['id', 'state']
          })
          .then((updateState) => {
            updateState.forEach((postState) => {
              postState.updateAttributes({ state: 2 });
            });
          })
          .then((updatedState) => {
            callback(null, updatedState);
          });
        },
        createEvent: (callback) => {
          Event.create({
            instructions: req.query.instructions,
          })
          .then((createdEvent) => {
            callback(null, createdEvent);
          });
        },
        createPublishing: (callback) => {
          Publishing.create({
            start_date: req.query.startDate,
            end_date: req.query.endDate,
          })
          .then((createdPublishing) => {
            callback(null, createdPublishing);
          });
        }
      }, (error, result) => {
        resolve(result);
      });
    });
  }

How can I pass the IDs of the two records to the third model?

Answer 1

There are several problems with your implementation! First of all, your promise never rejects.

Despite of that, you don't actually need to create a promise or use async for this, neither do you want them to run in parallel: If creating a Publishing record needs information about the Event , then you'd want to create first the event, so that you have its id , THEN pass it in the input for the publishing.

Another important thing, take a look at this piece of code:

  .then((updateState) => {
    updateState.forEach((postState) => {
      postState.updateAttributes({ state: 2 });
    });
  })
  .then((updatedState) => {
    callback(null, updatedState);
  });

Inside the first then, you are making multiple updates, which are promises. They will be dispatched and you never get their values back. Let me explain:

Think if you have just one update to make. It would be like this:

  .then((updateStates) => {
    return updateStates[0].updateAttributes({ state: 2 });
  })

See, we are returning a promise (in this case the update), so the next then will only be called when the update resolves.

If we do this:

  .then((updateStates) => {
    updateStates[0].updateAttributes({ state: 2 });
  })

It will dispatch the update (which takes time) but because you didn't return it, it will pass through and return nothing. Check this out:

 var promise1 = new Promise(function(resolve, reject) { setTimeout(function(){ resolve('foo') }, 2); }); var promise2 = new Promise(function(resolve, reject) { setTimeout(function(){ resolve('foo2') }, 2); }); promise1 .then(function(result){ promise2 }) .then(function(result){ console.log(result) //will print undefined }) promise1 .then(function(result){ return promise2 }) .then(function(result){ console.log(result) //will print foo2 }) 

So, you are calling multiple updates without getting their values back; if they fail, you'd never know.

Just one more thing: if something goes wrong along the way, you probably want to rollback all the changes made so far, for that, you should use transactions.

Maybe you should try something like this (not tested):

return Post.sequelize.transaction(function (t) {

    Post.findAll({
      where: { id: req.query.post_id },
      attributes: ['id', 'state']
    })
    .then((updatedStates) => {
      var promises = []
      updatedStates.forEach((postState) => {
        promises.push(postState.updateAttributes({ state: 2 },  {transaction: t}));
      });
      return Promise.all(promises);
    })
    .then((results) => {
      return Event.create({
        instructions: req.query.instructions,
      }, {transaction: t})
    })
    .then((createdEvent) => {
      return Publishing.create({
        post_id: req.query.post_id,
        event_id: createdEvent.id, //or event_id, depends on your model
        start_date: req.query.startDate,
        end_date: req.query.endDate,
      }, {transaction: t})
    });

}).then(function (result) {
  // Transaction has been committed
  // result is whatever the result of the promise chain returned to the transaction callback
}).catch(function (err) {
  // Transaction has been rolled back
  // err is whatever rejected the promise chain returned to the transaction callback
});