feat(transaction-manager): the transactions are now capable of returning results

Author: rmolinamir

config/tsconfig/base.json

@@ -2,6 +2,7 @@
   "$schema": "https://json.schemastore.org/tsconfig",
   "display": "Base",
   "compilerOptions": {
+    "allowUnreachableCode": false,
     "composite": false,
     "declaration": true,
     "declarationMap": true,

lib/postgres/src/__tests__/pg-transaction-manager.test.ts

@@ -67,6 +67,36 @@ describe('PgTransactionManager', () => {
     await expectEntries(db, [{ id: firstId }, { id: secondId }]);
   });
 
+  test('returns result from transaction', async () => {
+    const firstId = Uuid.generate();
+    const secondId = Uuid.generate();
+
+    const result = await manager.startTransaction(async (transaction) => {
+      await transaction.context
+        .insert(testTable)
+        .values([{ id: firstId }, { id: secondId }]);
+
+      return true;
+    });
+
+    expect(result).toBe(true);
+  });
+
+  test('returns undefined when transaction is rolled back', async () => {
+    const firstId = Uuid.generate();
+    const secondId = Uuid.generate();
+
+    const result = await manager.startTransaction(async (transaction) => {
+      await transaction.context
+        .insert(testTable)
+        .values([{ id: firstId }, { id: secondId }]);
+
+      await transaction.rollback();
+    });
+
+    expect(result).toBeUndefined();
+  });
+
   test('transaction is not committed when rolled back', async () => {
     const firstId = Uuid.generate();
     const secondId = Uuid.generate();

lib/postgres/src/nestjs/drizzle-orm.module.ts

@@ -123,5 +123,5 @@ export class DrizzleOrmModule {
     };
   }
 
-  private static OPTIONS_PROVIDER_TOKEN = Symbol('OPTIONS_PROVIDER_TOKEN');
+  private static OPTIONS_PROVIDER_TOKEN = Symbol('__optionsProviderToken__');
 }

lib/postgres/src/nestjs/pg-client.module.ts

@@ -132,5 +132,5 @@ export class PgClientModule
     };
   }
 
-  private static OPTIONS_PROVIDER_TOKEN = Symbol('OPTIONS_PROVIDER_TOKEN');
+  private static OPTIONS_PROVIDER_TOKEN = Symbol('__optionsProviderToken__');
 }

lib/postgres/src/pg-transaction-manager.ts

@@ -12,35 +12,39 @@ export class PgTransactionManager extends TransactionManager {
     super();
   }
 
-  public startTransaction(
-    callback: (transaction: PgTransaction) => Promise<void>
-  ): Promise<void> {
-    return PgTransactionManager.createTransaction(this.db, callback);
+  public startTransaction<Result>(
+    callback: (transaction: PgTransaction) => Promise<Result>
+  ) {
+    return PgTransactionManager.createTransaction<Result>(this.db, callback);
   }
 
-  public savePoint(
+  public savePoint<Result>(
     transaction: PgTransaction,
-    callback: (nestedTransaction: PgTransaction) => Promise<void>
-  ): Promise<void> {
-    return PgTransactionManager.createTransaction(
+    callback: (nestedTransaction: PgTransaction) => Promise<Result>
+  ) {
+    return PgTransactionManager.createTransaction<Result>(
       transaction.context,
       callback
     );
   }
 
   private static store = new AsyncLocalStorage<NodePgDatabaseTransaction>();
 
-  private static async createTransaction(
+  private static async createTransaction<Result>(
     pgDriver: NodePgDatabase | NodePgDatabaseTransaction,
-    callback: (transaction: PgTransaction) => Promise<void>
-  ): Promise<void> {
+    callback: (transaction: PgTransaction) => Promise<Result>
+  ) {
     try {
-      await pgDriver.transaction((context) => {
+      const res = await pgDriver.transaction<Result>((context) => {
         const transaction = new PgTransaction(this.store);
         return this.store.run(context, () => callback(transaction));
       });
+      return res;
     } catch (error) {
-      if (error instanceof TransactionRollbackError) return;
+      // Needed to cast because unreachable code after a `rollback` is not detected by the TypeScript compiler,
+      // even though the `ReturnType` of the `rollback` is `never`
+      // This is a workaround to make it work for now until it's fixed.
+      if (error instanceof TransactionRollbackError) return undefined as Result;
       const err = error instanceof Error ? error : new Error('Unknown error');
       throw new InvalidOperationException(err.message, error);
     }

lib/postgres/src/pg-transaction.ts

@@ -18,7 +18,7 @@ export class PgTransaction implements Transaction {
     return context;
   }
 
-  public rollback(): Promise<void> {
+  public rollback(): Promise<never> {
     return Promise.resolve(this.context.rollback());
   }
 }