Ensured that default transaction options are passed to transactions

Author: oskardudycz

src/packages/dumbo/src/storage/sqlite/core/pool/dualPool.int.spec.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import * as fs from 'node:fs';
 import { afterAll, beforeAll, describe, it } from 'vitest';
-import { SQL } from '../../../../core';
+import { InvalidOperationError, SQL } from '../../../../core';
 import { sqlite3Pool } from '../../sqlite3';
 
 const withDeadline = { timeout: 30000 };
@@ -316,4 +316,87 @@ describe('SQLite Dual Connection Pool', () => {
       assert.equal(results.filter((r) => r instanceof Error).length, 0);
     },
   );
+
+  it(
+    'respects allowNestedTransactions from connectionOptions in dual pool writer',
+    withDeadline,
+    async () => {
+      const nestedTxFileName = 'nested-tx-test.db';
+
+      const pool = sqlite3Pool({
+        fileName: nestedTxFileName,
+        transactionOptions: { allowNestedTransactions: true },
+      });
+
+      try {
+        await pool.execute.command(
+          SQL`CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)`,
+        );
+
+        await pool.withTransaction(async (outerTx) => {
+          await outerTx.execute.command(
+            SQL`INSERT INTO test (value) VALUES ('outer')`,
+          );
+
+          await pool.withTransaction(async (innerTx) => {
+            await innerTx.execute.command(
+              SQL`INSERT INTO test (value) VALUES ('inner')`,
+            );
+          });
+        });
+
+        const result = await pool.execute.query(
+          SQL`SELECT COUNT(*) as count FROM test`,
+        );
+        assert.equal(result.rows[0]?.count, 2, 'Both rows should be present');
+      } finally {
+        await pool.close();
+        cleanupDb(nestedTxFileName);
+      }
+    },
+  );
+
+  it(
+    'dual pool writer: throws actionable error on nested withTransaction when allowNestedTransactions is false',
+    withDeadline,
+    async () => {
+      const nestedTxFileName = 'nested-tx-no-opts-test.db';
+
+      const pool = sqlite3Pool({ fileName: nestedTxFileName });
+
+      try {
+        await pool.execute.command(
+          SQL`CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)`,
+        );
+
+        await assert.rejects(
+          () =>
+            pool.withTransaction(async (outerTx) => {
+              await outerTx.execute.command(
+                SQL`INSERT INTO test (value) VALUES ('outer')`,
+              );
+              await pool.withTransaction(async (innerTx) => {
+                await innerTx.execute.command(
+                  SQL`INSERT INTO test (value) VALUES ('inner')`,
+                );
+              });
+            }),
+          (err: unknown) => {
+            assert.ok(
+              err instanceof InvalidOperationError,
+              `Expected InvalidOperationError, got ${String(err)}`,
+            );
+            assert.ok(
+              err.message.includes('allowNestedTransactions'),
+              `Error message should mention allowNestedTransactions, got: ${err.message}`,
+            );
+            return true;
+          },
+        );
+      } finally {
+        await pool.close();
+        cleanupDb(nestedTxFileName);
+      }
+    },
+  );
 });

src/packages/dumbo/src/storage/sqlite/core/transactions/index.ts

@@ -3,6 +3,7 @@ import type {
   JSONSerializer,
 } from '../../../../core';
 import {
+  InvalidOperationError,
   SQL,
   sqlExecutor,
   type DatabaseTransaction,
@@ -50,6 +51,8 @@ export const sqliteTransaction =
     allowNestedTransactions =
       options?.allowNestedTransactions ?? allowNestedTransactions;
 
+    let hasBegun = false;
+
     const transaction: DatabaseTransaction<ConnectionType> = {
       connection: connection(),
       driverType,
@@ -68,8 +71,14 @@ export const sqliteTransaction =
           }
 
           transactionCounter.increment();
+        } else if (hasBegun) {
+          throw new InvalidOperationError(
+            'Cannot start a nested transaction: allowNestedTransactions is false. ' +
+              'Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.',
+          );
         }
 
+        hasBegun = true;
         const mode = options?.mode ?? defaultTransactionMode ?? 'IMMEDIATE';
         await client.command(SQL`BEGIN ${SQL.plain(mode)} TRANSACTION`);
       },
@@ -91,6 +100,7 @@ export const sqliteTransaction =
 
             transactionCounter.reset();
           }
+          hasBegun = false;
           await client.command(SQL`COMMIT`);
         } finally {
           if (options?.close)
@@ -109,6 +119,7 @@ export const sqliteTransaction =
             }
           }
 
+          hasBegun = false;
           await client.command(SQL`ROLLBACK`);
         } finally {
           if (options?.close)
@@ -121,7 +132,10 @@ export const sqliteTransaction =
       execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), {
         connect: () => getClient,
       }),
-      _transactionOptions: options ?? {},
+      _transactionOptions: {
+        ...options,
+        allowNestedTransactions,
+      },
     };
 
     return transaction as InferTransactionFromConnection<ConnectionType>;

src/packages/dumbo/src/storage/sqlite/sqlite3/transactions/transactions.int.spec.ts

@@ -107,7 +107,7 @@ describe('SQLite3 Transactions', () => {
         } catch (error) {
           assert.strictEqual(
             (error as Error).message,
-            'SQLITE_ERROR: cannot start a transaction within a transaction',
+            'Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.',
           );
         } finally {
           await connection.close();