Whether the transaction operates normally when promise.all is used

[cokepizza]

Is there a chance that the transaction won't work properly if I use promise.all?

When testing with a lot of data, we found that occasionally some tables would be committed and others would be rolled back.

Is my test wrong?

The rough code is like this:

   try {
      await Promise.all([
        Table1.update(
          {
             …
          },
          {
            transaction,
          }
        ),
        Table2.increment(
          {
             …
          },
          {
            transaction,
          }
      ]);
      await transaction.commit();
    } catch (e) {
      await transaction.rollback();
    }

There seems to be a similar phenomenon in other ORMs, so I wonder if sequelize will also have this issue.
https://stackoverflow.com/questions/67988319/is-there-any-reason-to-use-promise-all-in-a-typeorm-transaction

[ephys]

Queries run in transactions are always run sequentially because transactions are per connection and only one query can be run on a single connection at a time

This means that if update runs first but errors, the transaction could be rolled back while increment is still queued to be run, making it theoretically possible for that query to run outside of the transaction. I have not encountered this issue but I think it's possible for it to happen.

They are queued by the connector library (pg, tedious, etc), so they are not aware of the state of our transaction object. I think we could prevent this problem from happening by having our own queue in the transaction, in which queries that belong to the transaction are put and queued, and discard them if the transaction closes

[cokepizza]

Thank you for your quick reply. If it works as you said, there is a possibility that the transaction is not applied properly. There was advice in another article to use Promise.allsettled, so I'll try it and see if it solves the problem. thank you!

[cokepizza]

As a result of the test, when promise.allsettled was used, not a single transaction-related issue occurred out of approximately 50,000 requests.

I replaced the existing promise.all by creating a function as follows:

export const promiseTx = async (promiseArr: any[]) => {
  const settled = await Promise.allSettled(promiseArr);

  for (const res of settled) {
    if (res.status === 'rejected') {
      throw res.reason;
    }
  }

  return settled.map((item) => item.status === 'fulfilled' && item.value);
};

[hlhdaiaaii]

Thanks a lot. This confirmation is exactly what I need. It took me hours figuring why rollback does not revert the whole changes at all when using Promise.all and whether it is due to either sequelize or database problem.