Fixed current transaction cleanup for outer transaction

Author: oskardudycz

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

@@ -85,21 +85,18 @@ export const sqliteTransaction =
       commit: async function () {
         const client = (await getClient) as SQLiteClientOrPoolClient;
 
-        try {
-          if (allowNestedTransactions) {
-            if (transactionCounter.level > 1) {
-              if (options?.useSavepoints) {
-                await client.command(
-                  SQL`RELEASE transaction${SQL.plain(transactionCounter.level.toString())}`,
-                );
-              }
-              transactionCounter.decrement();
-
-              return;
-            }
-
-            transactionCounter.reset();
+        if (allowNestedTransactions && transactionCounter.level > 1) {
+          if (options?.useSavepoints) {
+            await client.command(
+              SQL`RELEASE transaction${SQL.plain(transactionCounter.level.toString())}`,
+            );
           }
+          transactionCounter.decrement();
+          return;
+        }
+
+        try {
+          if (allowNestedTransactions) transactionCounter.reset();
           hasBegun = false;
           await client.command(SQL`COMMIT`);
         } finally {
@@ -111,14 +108,13 @@ export const sqliteTransaction =
       },
       rollback: async function (error?: unknown) {
         const client = (await getClient) as SQLiteClientOrPoolClient;
-        try {
-          if (allowNestedTransactions) {
-            if (transactionCounter.level > 1) {
-              transactionCounter.decrement();
-              return;
-            }
-          }
 
+        if (allowNestedTransactions && transactionCounter.level > 1) {
+          transactionCounter.decrement();
+          return;
+        }
+
+        try {
           hasBegun = false;
           await client.command(SQL`ROLLBACK`);
         } finally {

src/packages/dumbo/src/storage/sqlite/d1/transactions/d1Transaction.ts

@@ -90,31 +90,27 @@ export const d1Transaction =
       commit: async function () {
         const client = await getDatabaseClient();
 
-        try {
-          if (allowNestedTransactions) {
-            if (transactionCounter.level > 1) {
-              transactionCounter.decrement();
-
-              return;
-            }
+        if (allowNestedTransactions && transactionCounter.level > 1) {
+          transactionCounter.decrement();
+          return;
+        }
 
-            transactionCounter.reset();
-          }
+        try {
+          if (allowNestedTransactions) transactionCounter.reset();
           sessionClient = null;
         } finally {
           if (options?.close) await options?.close(client);
         }
       },
       rollback: async function (error?: unknown) {
         const client = await getDatabaseClient();
-        try {
-          if (allowNestedTransactions) {
-            if (transactionCounter.level > 1) {
-              transactionCounter.decrement();
-              return;
-            }
-          }
 
+        if (allowNestedTransactions && transactionCounter.level > 1) {
+          transactionCounter.decrement();
+          return;
+        }
+
+        try {
           sessionClient = null;
         } finally {
           if (options?.close) await options?.close(client, error);

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

@@ -76,6 +76,44 @@ describe('SQLite3 Transactions', () => {
           await pool.close();
         }
       });
+      it('keeps the outer transaction open after a sibling nested transaction commits', async () => {
+        const pool = sqlite3Pool({
+          fileName,
+          transactionOptions: { allowNestedTransactions: true },
+        });
+
+        try {
+          await pool.execute.command(
+            SQL`CREATE TABLE test_table (id INTEGER PRIMARY KEY, value TEXT)`,
+          );
+
+          await pool.withTransaction(async (outerTx) => {
+            await pool.withTransaction(async (innerTx) => {
+              await innerTx.execute.command(
+                SQL`INSERT INTO test_table (id, value) VALUES (1, 'first')`,
+              );
+            });
+
+            await pool.withTransaction(async (innerTx) => {
+              await innerTx.execute.command(
+                SQL`INSERT INTO test_table (id, value) VALUES (2, 'second')`,
+              );
+            });
+
+            await outerTx.execute.command(
+              SQL`INSERT INTO test_table (id, value) VALUES (3, 'outer')`,
+            );
+          });
+
+          const rows = await pool.execute.query<{ count: number }>(
+            SQL`SELECT COUNT(*) as count FROM test_table`,
+          );
+          assert.strictEqual(rows.rows[0]?.count, 3);
+        } finally {
+          await pool.close();
+        }
+      });
+
       it('should fail with an error if transaction nested is false', async () => {
         const pool = sqlite3Pool({
           fileName,