react-native-nitro-sqlite 9.1.11 → 9.2.0

package/src/operations/transaction.ts

@@ -1,4 +1,4 @@
-import { locks, HybridNitroSQLite } from '../nitro'
+import { queueOperationAsync, throwIfDatabaseIsNotOpen } from '../DatabaseQueue'
 import type {
   QueryResult,
   Transaction,
@@ -6,131 +6,88 @@ import type {
   QueryResultRow,
 } from '../types'
 import { execute, executeAsync } from './execute'
+import NitroSQLiteError from '../NitroSQLiteError'
 
-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 = (
+export const transaction = async <Result = void>(
   dbName: string,
-  fn: (tx: Transaction) => Promise<void> | void
-): Promise<void> => {
-  if (locks[dbName] == null)
-    throw Error(`Nitro SQLite Error: No lock found on db: ${dbName}`)
+  transactionCallback: (tx: Transaction) => Promise<Result>,
+  isExclusive = false,
+) => {
+  throwIfDatabaseIsNotOpen(dbName)
 
-  let isFinalized = false
+  let isFinished = false
 
-  // Local transaction context object implementation
-  const executeOnTransaction = <Data extends QueryResultRow = never>(
+  const executeOnTransaction = <Row extends QueryResultRow = never>(
     query: string,
-    params?: SQLiteQueryParams
-  ): QueryResult<Data> => {
-    if (isFinalized) {
-      throw Error(
-        `Nitro SQLite Error: Cannot execute query on finalized transaction: ${dbName}`
+    params?: SQLiteQueryParams,
+  ): QueryResult<Row> => {
+    if (isFinished) {
+      throw new NitroSQLiteError(
+        `Cannot execute query on finalized transaction: ${dbName}`,
       )
     }
     return execute(dbName, query, params)
   }
 
-  const executeAsyncOnTransaction = <Data extends QueryResultRow = never>(
+  const executeAsyncOnTransaction = <Row extends QueryResultRow = never>(
     query: string,
-    params?: SQLiteQueryParams
-  ): Promise<QueryResult<Data>> => {
-    if (isFinalized) {
-      throw Error(
-        `Nitro SQLite Error: Cannot execute query on finalized transaction: ${dbName}`
+    params?: SQLiteQueryParams,
+  ): Promise<QueryResult<Row>> => {
+    if (isFinished) {
+      throw new NitroSQLiteError(
+        `Cannot execute query on finalized transaction: ${dbName}`,
       )
     }
     return executeAsync(dbName, query, params)
   }
 
   const commit = () => {
-    if (isFinalized) {
-      throw Error(
-        `Nitro SQLite Error: Cannot execute commit on finalized transaction: ${dbName}`
+    if (isFinished) {
+      throw new NitroSQLiteError(
+        `Cannot execute commit on finalized transaction: ${dbName}`,
       )
     }
-    const result = HybridNitroSQLite.execute(dbName, 'COMMIT')
-    isFinalized = true
-    return result
+    isFinished = true
+    return execute(dbName, 'COMMIT')
   }
 
   const rollback = () => {
-    if (isFinalized) {
-      throw Error(
-        `Nitro SQLite Error: Cannot execute rollback on finalized transaction: ${dbName}`
+    if (isFinished) {
+      throw new NitroSQLiteError(
+        `Cannot execute rollback on finalized transaction: ${dbName}`,
       )
     }
-    const result = HybridNitroSQLite.execute(dbName, 'ROLLBACK')
-    isFinalized = true
-    return result
+    isFinished = true
+    return execute(dbName, 'ROLLBACK')
   }
 
-  async function run() {
+  return await queueOperationAsync(dbName, async () => {
     try {
-      await HybridNitroSQLite.executeAsync(dbName, 'BEGIN TRANSACTION')
+      await executeAsync(
+        dbName,
+        isExclusive ? 'BEGIN EXCLUSIVE TRANSACTION' : 'BEGIN TRANSACTION',
+      )
 
-      await fn({
+      const result = await transactionCallback({
         commit,
         execute: executeOnTransaction,
         executeAsync: executeAsyncOnTransaction,
         rollback,
       })
 
-      if (!isFinalized) commit()
+      if (!isFinished) commit()
+
+      return result
     } catch (executionError) {
-      if (!isFinalized) {
+      if (!isFinished) {
         try {
           rollback()
         } catch (rollbackError) {
-          throw rollbackError
+          throw NitroSQLiteError.fromError(rollbackError)
         }
       }
 
-      throw executionError
-    } finally {
-      locks[dbName]!.inProgress = false
-      isFinalized = false
-      startNextTransaction(dbName)
+      throw NitroSQLiteError.fromError(executionError)
     }
-  }
-
-  return new Promise((resolve, reject) => {
-    const tx: PendingTransaction = {
-      start: () => {
-        run().then(resolve).catch(reject)
-      },
-    }
-
-    locks[dbName]?.queue.push(tx)
-    startNextTransaction(dbName)
   })
 }
-
-function startNextTransaction(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
-    return
-  }
-
-  if (locks[dbName].queue.length > 0) {
-    locks[dbName].inProgress = true
-
-    const tx = locks[dbName].queue.shift()!
-    setImmediate(() => {
-      tx.start()
-    })
-  }
-}

package/src/specs/NitroSQLite.nitro.ts

@@ -16,26 +16,26 @@ export interface NitroSQLite
     mainDbName: string,
     dbNameToAttach: string,
     alias: string,
-    location?: string
+    location?: string,
   ): void
   detach(mainDbName: string, alias: string): void
   execute(
     dbName: string,
     query: string,
-    params?: NativeSQLiteQueryParams
+    params?: NativeSQLiteQueryParams,
   ): NativeQueryResult
   executeAsync(
     dbName: string,
     query: string,
-    params?: NativeSQLiteQueryParams
+    params?: NativeSQLiteQueryParams,
   ): Promise<NativeQueryResult>
   executeBatch(
     dbName: string,
-    commands: NativeBatchQueryCommand[]
+    commands: NativeBatchQueryCommand[],
   ): BatchQueryResult
   executeBatchAsync(
     dbName: string,
-    commands: NativeBatchQueryCommand[]
+    commands: NativeBatchQueryCommand[],
   ): Promise<BatchQueryResult>
   loadFile(dbName: string, location: string): FileLoadResult
   loadFileAsync(dbName: string, location: string): Promise<FileLoadResult>

package/src/typeORM.ts

@@ -18,7 +18,7 @@ interface TypeOrmNitroSQLiteConnection {
     sql: string,
     params: SQLiteQueryParams | undefined,
     okExecute: (res: QueryResult<RowData>) => void,
-    failExecute: (msg: string) => void
+    failExecute: (msg: string) => void,
   ) => Promise<void>
   transaction: (fn: (tx: Transaction) => Promise<void>) => Promise<void>
   close: (okClose: () => void, failClose: (e: unknown) => void) => void
@@ -26,7 +26,7 @@ interface TypeOrmNitroSQLiteConnection {
     dbNameToAttach: string,
     alias: string,
     location: string | undefined,
-    callback: () => void
+    callback: () => void,
   ) => void
   detach: (alias: string, callback: () => void) => void
 }
@@ -42,7 +42,7 @@ export const typeORMDriver = {
       location?: string
     },
     ok: (db: TypeOrmNitroSQLiteConnection) => void,
-    fail: (msg: string) => void
+    fail: (msg: string) => void,
   ): TypeOrmNitroSQLiteConnection | null => {
     try {
       const db = Operations.open(options)
@@ -52,7 +52,7 @@ export const typeORMDriver = {
           sql: string,
           params: SQLiteQueryParams | undefined,
           okExecute: (res: QueryResult<RowData>) => void,
-          failExecute: (msg: string) => void
+          failExecute: (msg: string) => void,
         ) => {
           try {
             const result = await db.executeAsync<RowData>(sql, params)
@@ -62,7 +62,7 @@ export const typeORMDriver = {
           }
         },
         transaction: (
-          fn: (tx: Transaction) => Promise<void>
+          fn: (tx: Transaction) => Promise<void>,
         ): Promise<void> => {
           return db.transaction(fn)
         },
@@ -78,7 +78,7 @@ export const typeORMDriver = {
           dbNameToAttach: string,
           alias: string,
           location: string | undefined,
-          callback: () => void
+          callback: () => void,
         ) => {
           db.attach(dbNameToAttach, alias, location)
           callback()

package/src/types.ts

@@ -8,7 +8,9 @@ export interface NitroSQLiteConnection {
   delete(): void
   attach(dbNameToAttach: string, alias: string, location?: string): void
   detach(alias: string): void
-  transaction(fn: (tx: Transaction) => Promise<void> | void): Promise<void>
+  transaction: <Result = void>(
+    transactionCallback: (tx: Transaction) => Promise<Result>,
+  ) => Promise<Result>
   execute: ExecuteQuery
   executeAsync: ExecuteAsyncQuery
   executeBatch(commands: BatchQueryCommand[]): BatchQueryResult
@@ -67,12 +69,12 @@ export interface QueryResult<Row extends QueryResultRow = QueryResultRow> {
 
 export type ExecuteQuery = <Row extends QueryResultRow = QueryResultRow>(
   query: string,
-  params?: SQLiteQueryParams
+  params?: SQLiteQueryParams,
 ) => QueryResult<Row>
 
 export type ExecuteAsyncQuery = <Row extends QueryResultRow = QueryResultRow>(
   query: string,
-  params?: SQLiteQueryParams
+  params?: SQLiteQueryParams,
 ) => Promise<QueryResult<Row>>
 
 export interface Transaction {