A way to test transactional hooks?

[gaggle]

Hi,

I'm using typeorm-transactional-cls-hooked's hooks feature to emit events on transaction success. E.g. like this:

  @Transactional()
  async foo(): {
    const foo = await this.fooRepository.save();
    runOnTransactionCommit(async () => {
      event.emit()
    });
  }

But this library rejects all transactions by its very nature, so I can't test transaction-success logic. Uh oh.

Would it possible that this code here should manually fire off the success-hook? Something like:

    static async run(func: RunFunction) {
        await func();

+       // Fire all callbacks from typeorm-transactional-cls-hooked
+       getTransactionalContextHook.get('commit').forEach((cb)=>{cb()}
+       // I'm just pretending there's a way for this to work, I actually have no idea as I haven't made sense of the underlying code yet

        // Once the function has run, we throw an exception to ensure that the
        // transaction rolls back.
        throw new RollbackErrorException(
            `This is thrown to cause a rollback on the transaction.`,
        );
    }

WDYT? Am I asking for the impossible here?

[kerren]

Hi @gaggle, thanks for creating this issue!

I'm not sure about this one, unfortunately. The problem is that the commit hooks would only run on successful transactions but we make sure that they fail each time to avoid the transaction committing to the database. From my current knowledge, I don't think we'd be able to achieve the commit hooks because we need the transaction to fail. I would assume that the rollback and complete hooks would work though.

I'm happy to go into further detail around this if you'd like? But I do think that this isn't possible with the current setup because we need the transaction to fail for everything to be rolled back.

[gaggle]

Yeah ultimately this library needs the transaction to fail, that's true. Forgive me as I may speak out of ignorance of how the code actually works, but is it not the case that if we pretend there's a way to invoke all the runOnTransactionCommit-callbacks manually, then if this library did that just before the library reverts the transaction (that is: just after await func()), then we would get the hooks firing off correctly as seen from the calling code?

If backwards compatibility is a worry it could be made opt-in via a flag or a function to run?

Also happy to hear if it's not actually a good idea in your opinion ofc.

[kerren]

Hmm, I'm really unsure if it's possible to do this. We can look into it but I think it may not work as expected. Do you perhaps have the capacity for the first attempt on this and then we can modify it to fit the library and merge it in?