feat: implement locks for executeBatch

Author: chrispader

package/src/concurrency.ts

@@ -0,0 +1,8 @@
+export interface QueuedOperation {
+  start: () => void
+}
+
+export const locks: Record<
+  string,
+  { queue: QueuedOperation[]; inProgress: boolean }
+> = {}

package/src/nitro.ts

@@ -1,11 +1,5 @@
 import { NitroModules } from 'react-native-nitro-modules'
 import type { NitroSQLite as NitroSQLiteSpec } from './specs/NitroSQLite.nitro'
-import type { PendingTransaction } from './operations/transaction'
 
 export const HybridNitroSQLite =
   NitroModules.createHybridObject<NitroSQLiteSpec>('NitroSQLite')
-
-export const locks: Record<
-  string,
-  { queue: PendingTransaction[]; inProgress: boolean }
-> = {}

package/src/operations/executeBatch.ts

@@ -3,38 +3,78 @@ import {
   replaceWithNativeNullValue,
 } from '../nullHandling'
 import { HybridNitroSQLite } from '../nitro'
+import { locks, type QueuedOperation } from '../concurrency'
 import type {
   NativeSQLiteQueryParams,
   BatchQueryResult,
   BatchQueryCommand,
   NativeBatchQueryCommand,
 } from '../types'
+import { startNextOperation } from './transaction'
 
 export function executeBatch(
   dbName: string,
   commands: BatchQueryCommand[]
 ): BatchQueryResult {
+  if (locks[dbName] == null)
+    throw Error(`Nitro SQLite Error: No lock found on db: ${dbName}`)
+
   const transformedCommands = isSimpleNullHandlingEnabled()
     ? toNativeBatchQueryCommands(commands)
     : (commands as NativeBatchQueryCommand[])
 
-  const result = HybridNitroSQLite.executeBatch(dbName, transformedCommands)
-  return result
+  // If lock is immediately available, execute synchronously
+  if (!locks[dbName].inProgress && locks[dbName].queue.length === 0) {
+    locks[dbName].inProgress = true
+    try {
+      const result = HybridNitroSQLite.executeBatch(dbName, transformedCommands)
+      return result
+    } finally {
+      locks[dbName].inProgress = false
+      startNextOperation(dbName)
+    }
+  }
+
+  // Lock is busy - cannot execute synchronously
+  throw Error(
+    `Nitro SQLite Error: Database ${dbName} is busy with another operation. Use executeBatchAsync for queued execution.`
+  )
 }
 
 export async function executeBatchAsync(
   dbName: string,
   commands: BatchQueryCommand[]
 ): Promise<BatchQueryResult> {
+  if (locks[dbName] == null)
+    throw Error(`Nitro SQLite Error: No lock found on db: ${dbName}`)
+
   const transformedCommands = isSimpleNullHandlingEnabled()
     ? toNativeBatchQueryCommands(commands)
     : (commands as NativeBatchQueryCommand[])
 
-  const result = await HybridNitroSQLite.executeBatchAsync(
-    dbName,
-    transformedCommands
-  )
-  return result
+  async function run() {
+    try {
+      const result = await HybridNitroSQLite.executeBatchAsync(
+        dbName,
+        transformedCommands
+      )
+      return result
+    } finally {
+      locks[dbName]!.inProgress = false
+      startNextOperation(dbName)
+    }
+  }
+
+  return new Promise<BatchQueryResult>((resolve, reject) => {
+    const operation: QueuedOperation = {
+      start: () => {
+        run().then(resolve).catch(reject)
+      },
+    }
+
+    locks[dbName]?.queue.push(operation)
+    startNextOperation(dbName)
+  })
 }
 
 function toNativeBatchQueryCommands(

package/src/operations/transaction.ts

@@ -1,4 +1,5 @@
-import { locks, HybridNitroSQLite } from '../nitro'
+import { HybridNitroSQLite } from '../nitro'
+import { locks, type QueuedOperation } from '../concurrency'
 import type {
   QueryResult,
   Transaction,
@@ -7,19 +8,6 @@ import type {
 } from '../types'
 import { execute, executeAsync } from './execute'
 
-export interface PendingTransaction {
-  /*
-   * The start function should not throw or return a promise because the
-   * queue just calls it and does not monitor for failures or completions.
-   *
-   * It should catch any errors and call the resolve or reject of the wrapping
-   * promise when complete.
-   *
-   * It should also automatically commit or rollback the transaction if needed
-   */
-  start: () => void
-}
-
 export const transaction = (
   dbName: string,
   fn: (tx: Transaction) => Promise<void> | void
@@ -101,36 +89,36 @@ export const transaction = (
     } finally {
       locks[dbName]!.inProgress = false
       isFinalized = false
-      startNextTransaction(dbName)
+      startNextOperation(dbName)
     }
   }
 
   return new Promise((resolve, reject) => {
-    const tx: PendingTransaction = {
+    const queuedTransaction: QueuedOperation = {
       start: () => {
         run().then(resolve).catch(reject)
       },
     }
 
-    locks[dbName]?.queue.push(tx)
-    startNextTransaction(dbName)
+    locks[dbName]?.queue.push(queuedTransaction)
+    startNextOperation(dbName)
   })
 }
 
-function startNextTransaction(dbName: string) {
+export function startNextOperation(dbName: string) {
   if (locks[dbName] == null) throw Error(`Lock not found for db: ${dbName}`)
 
   if (locks[dbName].inProgress) {
-    // Transaction is already in process bail out
+    // Operation is already in process bail out
     return
   }
 
   if (locks[dbName].queue.length > 0) {
     locks[dbName].inProgress = true
 
-    const tx = locks[dbName].queue.shift()!
+    const operation = locks[dbName].queue.shift()!
     setImmediate(() => {
-      tx.start()
+      operation.start()
     })
   }
 }