Hook with non-awaited async functions

[miguelvieiraramos]

Hello!!

I have assigned an function to the beforeUpdate hook of a Model, and this hook is supposed to receive a transaction. This function executes an async function that is not awaited and also receives the same transaction. Is it possible for this transaction to be committed before the non-awaited async function has a chance to push its query to the transaction?

The code is something like:

class User extends Model {}

User.init({...}, {
  hooks: {
    beforeUpdate: applyChanges,
  },
  sequelize
});

function applyChanges (user, { transaction } = {}) {
    foo(user, { transaction }); // note that this function is not being awaited
}

async function foo (user, { transaction } = {}) {
    await database.sequelize.query("some update query", {
       replacements: someReplacements,
       type: database.sequelize.QueryTypes.UPDATE,
       transaction,
   });
}

Can this transaction be committed before foo is able to push its update query to the transaction? I'm questioning this because when calling an async function without await, I assume it will run, but I can't be sure when, right? It will run asynchronously because the applyChanges function is not awaiting for it to resolve."

[ephys]

That is not something we can guarantee, you should await them before the end of the transaction:

const nonAwaitedTransactionQueries = new WeakMap();

User.beforeUpdate(applyChanges);

function applyChanges (user, { transaction } = {}) {
  const promise = foo(user, { transaction });

  if (transaction) {
    if (!nonAwaitedTransactionQueries.has(transaction)) {
      nonAwaitedTransactionQueries.set(transaction, [])
    }
    nonAwaitedTransactionQueries.get(transaction).push(promise);
  }
}

// in the transaction code

await sequelize.transaction((transaction) => {
  await user.save({ transaction });

  const promises = nonAwaitedTransactionQueries.get(transaction);

  await Promise.all(promises);
})

[miguelvieiraramos]

@ephys, thanks for taking the time to answer my question.

Is this solution you suggested would have the same result as assigning an async function to the hook and actually awaiting all the functions that can be awaited? If not, how do they differ?

[ephys]

Well, I was going to say that the subsequent queries would he executed sooner but that's not actually true, as all queries in a transaction are executed sequentially

I would therefore recommend to just await inside the hook