Expose executionPromise for transactors

src/transaction.js

@@ -20,7 +20,7 @@ class Transaction extends EventEmitter {
 
     // If there is no container provided, assume user wants to get instance of transaction and use it directly
     if (!container) {
-      this.initPromise = new Bluebird((resolve, reject) => {
+      this.initPromise = new Promise((resolve, reject) => {
         this.initRejectFn = reject;
         container = (transactor) => {
           resolve(transactor);
@@ -57,6 +57,11 @@ class Transaction extends EventEmitter {
             return makeTransactor(this, connection, trxClient);
           })
           .then((transactor) => {
+            transactor.executionPromise = new Promise((resolve, reject) => {
+              this.executionRejectFn = reject;
+              this.executionResolveFn = resolve;
+            });
+
             // If we've returned a "thenable" = require(the transaction container, assume
             // the rollback and commit are chained to this object's success / failure.
             // Directly thrown errors are treated as automatic rollbacks.
@@ -79,14 +84,20 @@ class Transaction extends EventEmitter {
           })
           .catch((e) => {
             if (this.initRejectFn) {
-              this.initRejectFn();
+              this.initRejectFn(e);
             }
             return this._rejecter(e);
           });
 
         return new Bluebird((resolver, rejecter) => {
-          this._resolver = resolver;
-          this._rejecter = rejecter;
+          this._resolver = (value) => {
+            this.executionResolveFn(value);
+            resolver(value);
+          };
+          this._rejecter = (err) => {
+            this.executionRejectFn(err);
+            rejecter(err);
+          };
         });
       }
     ).catch((err) => {

test/unit/knex.js

@@ -326,6 +326,66 @@ describe('knex', () => {
       });
   });
 
+  it('supports accessing execution promise from standalone transaction', async () => {
+    const knex = Knex(sqliteConfig);
+
+    const trx = await knex.transaction();
+    const executionPromise = trx.executionPromise;
+    expect(executionPromise).to.be.ok;
+
+    expect(trx.client.transacting).to.equal(true);
+    const rows = await knex.transacting(trx).select(knex.raw('1 as result'));
+    expect(rows[0].result).to.equal(1);
+    await trx.commit();
+
+    const result = await executionPromise;
+    expect(result).to.be.undefined;
+  });
+
+  it('supports accessing execution promise from transaction with a callback', async () => {
+    const knex = Knex(sqliteConfig);
+    const trxPromise = new Promise(async (resolve, reject) => {
+      knex.transaction((transaction) => {
+        resolve(transaction);
+      });
+    });
+    const trx = await trxPromise;
+    const executionPromise = trx.executionPromise;
+    expect(executionPromise).to.be.ok;
+
+    expect(trx.client.transacting).to.equal(true);
+    const rows = await knex.transacting(trx).select(knex.raw('1 as result'));
+    expect(rows[0].result).to.equal(1);
+    await trx.commit();
+
+    const result = await executionPromise;
+    expect(result).to.be.undefined;
+  });
+
+  it('rejects execution promise if there was a rollback', async () => {
+    const knex = Knex(sqliteConfig);
+
+    const trx = await knex.transaction();
+    const executionPromise = trx.executionPromise;
+
+    expect(trx.client.transacting).to.equal(true);
+    const rows = await knex.transacting(trx).select(knex.raw('1 as result'));
+    expect(rows[0].result).to.equal(1);
+    await trx.rollback();
+
+    let errorWasThrown;
+    try {
+      await executionPromise;
+    } catch (err) {
+      errorWasThrown = true;
+      expect(err.message).to.equal(
+        'Transaction rejected with non-error: undefined'
+      );
+    }
+
+    expect(errorWasThrown).to.be.true;
+  });
+
   it('creating transaction copy with user params should throw an error', () => {
     if (!sqliteConfig) {
       return;

types/index.d.ts

@@ -1401,6 +1401,8 @@ declare namespace Knex {
 
   interface Transaction<TRecord extends {} = any, TResult = any>
     extends Knex<TRecord, TResult> {
+    executionPromise: Promise<TResult>;
+
     query<TRecord extends {} = any, TResult = void>(
       conn: any,
       sql: any,