fix(postgres): transaction-manager no longer catches rollaback errors

Author: rmolinamir

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

@@ -16,6 +16,7 @@ import { DrizzleOrmModule } from '../nestjs/drizzle-orm.module.js';
 import { PgTransactionManager } from '../pg-transaction-manager.js';
 import { NodePgDatabaseTransaction } from '../pg-transaction.js';
 import { testTable } from './test.table.js';
+import { InvalidOperationException } from '@ddd-framework/core';
 
 export const expectEntries = vi.fn(
   async (
@@ -80,34 +81,63 @@ describe('PgTransactionManager', () => {
     });
 
     expect(result).toBe(true);
+
+    await expectEntries(db, [{ id: firstId }, { id: secondId }]);
   });
 
-  test('returns undefined when transaction is rolled back', async () => {
+  test('transactions are automatically rolled back when an error occurs', 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 expect(() =>
+      manager.startTransaction(async (transaction) => {
+        await transaction.context
+          .insert(testTable)
+          .values([{ id: firstId }, { id: secondId }]);
 
-      await transaction.rollback();
-    });
+        throw new InvalidOperationException('An error occurred');
+      })
+    ).rejects.toThrow('An error occurred');
+
+    await expectEntries(db, []);
+  });
+
+  test('returns undefined when transaction is rolled back (unreachable code)', async () => {
+    const firstId = Uuid.generate();
+    const secondId = Uuid.generate();
+
+    let result: boolean | undefined;
+
+    try {
+      result = await manager.startTransaction(async (transaction) => {
+        await transaction.context
+          .insert(testTable)
+          .values([{ id: firstId }, { id: secondId }]);
+
+        await transaction.rollback();
+
+        return false;
+      });
+    } catch {}
 
     expect(result).toBeUndefined();
+
+    await expectEntries(db, []);
   });
 
-  test('transaction is not committed when rolled back', async () => {
+  test('transaction is not committed when manually rolled back', async () => {
     const firstId = Uuid.generate();
     const secondId = Uuid.generate();
 
-    await manager.startTransaction(async (transaction) => {
-      await transaction.context
-        .insert(testTable)
-        .values([{ id: firstId }, { id: secondId }]);
+    await expect(() =>
+      manager.startTransaction(async (transaction) => {
+        await transaction.context
+          .insert(testTable)
+          .values([{ id: firstId }, { id: secondId }]);
 
-      await transaction.rollback();
-    });
+        await transaction.rollback();
+      })
+    ).rejects.toThrow();
 
     await expectEntries(db, []);
   });
@@ -128,20 +158,22 @@ describe('PgTransactionManager', () => {
         { id: secondId }
       ]);
 
-      await manager.savePoint(transaction, async (nestedTransaction) => {
-        await nestedTransaction.context
-          .insert(testTable)
-          .values([{ id: thirdId }, { id: fourthId }]);
-
-        await expectEntries(nestedTransaction.context, [
-          { id: firstId },
-          { id: secondId },
-          { id: thirdId },
-          { id: fourthId }
-        ]);
-
-        await nestedTransaction.rollback();
-      });
+      await expect(() =>
+        manager.savePoint(transaction, async (nestedTransaction) => {
+          await nestedTransaction.context
+            .insert(testTable)
+            .values([{ id: thirdId }, { id: fourthId }]);
+
+          await expectEntries(nestedTransaction.context, [
+            { id: firstId },
+            { id: secondId },
+            { id: thirdId },
+            { id: fourthId }
+          ]);
+
+          await nestedTransaction.rollback();
+        })
+      ).rejects.toThrow();
     });
 
     await expectEntries(db, [{ id: firstId }, { id: secondId }]);

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

@@ -1,10 +1,6 @@
-import { TransactionRollbackError } from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import {
-  InvalidOperationException,
-  TransactionManager
-} from '@ddd-framework/core';
+import { TransactionManager } from '@ddd-framework/core';
 import { NodePgDatabaseTransaction, PgTransaction } from './pg-transaction.js';
 
 export class PgTransactionManager extends TransactionManager {
@@ -34,19 +30,9 @@ export class PgTransactionManager extends TransactionManager {
     pgDriver: NodePgDatabase | NodePgDatabaseTransaction,
     callback: (transaction: PgTransaction) => Promise<Result>
   ) {
-    try {
-      const res = await pgDriver.transaction<Result>((context) => {
-        const transaction = new PgTransaction(this.store);
-        return this.store.run(context, () => callback(transaction));
-      });
-      return res;
-    } catch (error) {
-      // 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);
-    }
+    return pgDriver.transaction<Result>((context) => {
+      const transaction = new PgTransaction(this.store);
+      return this.store.run(context, () => callback(transaction));
+    });
   }
 }