fix: database queue promise chaining

Author: chrispader

package/src/DatabaseQueue.ts

@@ -62,25 +62,27 @@ export function closeDatabase(dbName: string) {
   databaseQueues.delete(dbName)
 }
 
-export function queueOperationAsync<
-  OperationCallback extends () => Promise<Result>,
-  Result = void,
->(dbName: string, callback: OperationCallback) {
+export function queueOperationAsync<Result>(
+  dbName: string,
+  callback: () => Promise<Result>,
+) {
   const databaseQueue = getDatabaseQueue(dbName)
 
   return new Promise<Result>((resolve, reject) => {
+    async function start() {
+      try {
+        const result = await callback()
+        resolve(result)
+      } catch (error) {
+        reject(error)
+      } finally {
+        databaseQueue.inProgress = false
+        startOperationAsync(dbName)
+      }
+    }
+
     const operation: QueuedOperation = {
-      start: async () => {
-        try {
-          const result = await callback()
-          resolve(result)
-        } catch (error) {
-          reject(error)
-        } finally {
-          databaseQueue.inProgress = false
-          startOperationAsync(dbName)
-        }
-      },
+      start,
     }
 
     databaseQueue.queue.push(operation)
@@ -99,7 +101,9 @@ function startOperationAsync(dbName: string) {
   queue.inProgress = true
 
   const operation = queue.queue.shift()!
-  setImmediate(operation.start)
+  setImmediate(() => {
+    operation.start()
+  })
 }
 
 export function startOperationSync<

package/src/operations/transaction.ts

@@ -1,4 +1,3 @@
-import { HybridNitroSQLite } from '../nitro'
 import { queueOperationAsync, throwIfDatabaseIsNotOpen } from '../DatabaseQueue'
 import type {
   QueryResult,
@@ -9,20 +8,19 @@ import type {
 import { execute, executeAsync } from './execute'
 import NitroSQLiteError from '../NitroSQLiteError'
 
-export const transaction = (
+export const transaction = async <Result = void>(
   dbName: string,
-  fn: (tx: Transaction) => Promise<void> | void,
+  transactionCallback: (tx: Transaction) => Promise<Result>,
   isExclusive = false,
-): Promise<void> => {
+) => {
   throwIfDatabaseIsNotOpen(dbName)
 
   let isFinalized = false
 
-  // Local transaction context object implementation
-  const executeOnTransaction = <Data extends QueryResultRow = never>(
+  const executeOnTransaction = <Row extends QueryResultRow = never>(
     query: string,
     params?: SQLiteQueryParams,
-  ): QueryResult<Data> => {
+  ): QueryResult<Row> => {
     if (isFinalized) {
       throw new NitroSQLiteError(
         `Cannot execute query on finalized transaction: ${dbName}`,
@@ -31,10 +29,10 @@ export const transaction = (
     return execute(dbName, query, params)
   }
 
-  const executeAsyncOnTransaction = <Data extends QueryResultRow = never>(
+  const executeAsyncOnTransaction = <Row extends QueryResultRow = never>(
     query: string,
     params?: SQLiteQueryParams,
-  ): Promise<QueryResult<Data>> => {
+  ): Promise<QueryResult<Row>> => {
     if (isFinalized) {
       throw new NitroSQLiteError(
         `Cannot execute query on finalized transaction: ${dbName}`,
@@ -49,9 +47,8 @@ export const transaction = (
         `Cannot execute commit on finalized transaction: ${dbName}`,
       )
     }
-    const result = HybridNitroSQLite.execute(dbName, 'COMMIT')
     isFinalized = true
-    return result
+    return execute(dbName, 'COMMIT')
   }
 
   const rollback = () => {
@@ -60,27 +57,28 @@ export const transaction = (
         `Cannot execute rollback on finalized transaction: ${dbName}`,
       )
     }
-    const result = HybridNitroSQLite.execute(dbName, 'ROLLBACK')
     isFinalized = true
-    return result
+    return execute(dbName, 'ROLLBACK')
   }
 
   try {
-    return queueOperationAsync(dbName, async () => {
+    return await queueOperationAsync(dbName, async () => {
       try {
-        await HybridNitroSQLite.executeAsync(
+        await executeAsync(
           dbName,
           isExclusive ? 'BEGIN EXCLUSIVE TRANSACTION' : 'BEGIN TRANSACTION',
         )
 
-        await fn({
+        const result = await transactionCallback({
           commit,
           execute: executeOnTransaction,
           executeAsync: executeAsyncOnTransaction,
           rollback,
         })
 
         if (!isFinalized) commit()
+
+        return result
       } catch (executionError) {
         if (!isFinalized) {
           try {
@@ -91,8 +89,6 @@ export const transaction = (
         }
 
         throw executionError
-      } finally {
-        isFinalized = false
       }
     })
   } catch (error) {