Merge pull request #64 from ospfranco/async-transaction

Add an async version of transactions

Author: Oscar Franco

README.md

@@ -195,6 +195,20 @@ QuickSQLite.transaction('myDatabase', (tx) => {
 });
 ```
 
+Async transactions are also possible, but the API is based on promises and/or a boolean response:
+
+```ts
+QuickSQLite.asyncTransaction('myDatabase', async (tx) => {
+  // If the function throws (rejects) the transaction will be rolled back
+  const res = tx.promiseExecuteSql(
+    'UPDATE sometable SET somecolumn = ? where somekey = ?',
+    [0, 1]
+  );
+  // You must also return true to signal a correct transaction
+  return true;
+});
+```
+
 ### Batch operation
 
 Batch execution allows transactional execution of a set of commands

src/index.ts

@@ -1,5 +1,3 @@
-/* eslint-disable no-shadow */
-/* eslint-disable no-undef */
 import { NativeModules } from 'react-native';
 
 declare global {
@@ -129,6 +127,19 @@ export interface Transaction {
   executeSql: (query: string, params?: any[]) => QueryResult;
 }
 
+export interface AsyncTransaction {
+  executeSql: (query: string, params?: any[]) => QueryResult;
+  asyncExecuteSql: (
+    query: string,
+    params: any[] | undefined,
+    cb: (res: QueryResult) => void
+  ) => void;
+  promiseExecuteSql: (
+    query: string,
+    params: any[] | undefined
+  ) => Promise<QueryResult>;
+}
+
 export interface PendingTransaction {
   start: () => void;
 }
@@ -141,9 +152,7 @@ interface ISQLite {
     status: 0 | 1;
     message?: string;
   };
-  close: (
-    dbName: string
-  ) => {
+  close: (dbName: string) => {
     status: 0 | 1;
     message?: string;
   };
@@ -156,6 +165,10 @@ interface ISQLite {
   ) => StatementResult;
   detach: (mainDbName: string, alias: string) => StatementResult;
   transaction: (dbName: string, fn: (tx: Transaction) => boolean) => void;
+  asyncTransaction: (
+    dbName: string,
+    fn: (tx: AsyncTransaction) => Promise<boolean>
+  ) => void;
   executeSql: (
     dbName: string,
     query: string,
@@ -298,6 +311,70 @@ QuickSQLite.transaction = (
   startNextTransaction(dbName);
 };
 
+QuickSQLite.asyncTransaction = (
+  dbName: string,
+  callback: (tx: AsyncTransaction) => Promise<boolean>
+) => {
+  if (!locks[dbName]) {
+    throw Error(`Quick SQLite Error: No lock found on db: ${dbName}`);
+  }
+
+  // Local transaction context object implementation
+  const executeSql = (query: string, params?: any[]): QueryResult => {
+    return QuickSQLite.executeSql(dbName, query, params);
+  };
+
+  const asyncExecuteSql = (
+    query: string,
+    params: any[] | undefined,
+    cb: (res: QueryResult) => void
+  ) => {
+    return QuickSQLite.asyncExecuteSql(dbName, query, params, cb);
+  };
+
+  const promiseExecuteSql = (
+    query: string,
+    params: any[] | undefined
+  ): Promise<QueryResult> => {
+    return new Promise((resolve, reject) => {
+      QuickSQLite.asyncExecuteSql(dbName, query, params, (res) => {
+        if (res.status) {
+          reject(res);
+        } else {
+          resolve(res);
+        }
+      });
+    });
+  };
+
+  const tx: PendingTransaction = {
+    start: async () => {
+      try {
+        QuickSQLite.executeSql(dbName, 'BEGIN TRANSACTION', null);
+        const result = await callback({
+          executeSql,
+          asyncExecuteSql,
+          promiseExecuteSql,
+        });
+        if (result === true) {
+          QuickSQLite.executeSql(dbName, 'COMMIT', null);
+        } else {
+          QuickSQLite.executeSql(dbName, 'ROLLBACK', null);
+        }
+      } catch (e: any) {
+        QuickSQLite.executeSql(dbName, 'ROLLBACK', null);
+        throw e;
+      } finally {
+        locks[dbName].inProgress = false;
+        startNextTransaction(dbName);
+      }
+    },
+  };
+
+  locks[dbName].queue.push(tx);
+  startNextTransaction(dbName);
+};
+
 const startNextTransaction = (dbName: string) => {
   if (locks[dbName].inProgress) {
     // Transaction is already in process bail out
@@ -358,6 +435,7 @@ interface IDBConnection {
   ) => void;
   detach: (alias: string, callback: (result: StatementResult) => void) => void;
   transaction: (fn: (tx: Transaction) => boolean) => void;
+  asyncTransaction: (fn: (tx: AsyncTransaction) => Promise<boolean>) => void
   loadSqlFile: (
     location: string,
     callback: (result: FileLoadResult) => void
@@ -430,6 +508,9 @@ export const openDatabase = (
       transaction: (fn: (tx: Transaction) => boolean): void => {
         QuickSQLite.transaction(options.name, fn);
       },
+      asyncTransaction: (fn: (tx: AsyncTransaction) => Promise<boolean>): void => {
+        return QuickSQLite.asyncTransaction(options.name, fn);
+      },
       close: (ok: any, fail: any) => {
         try {
           QuickSQLite.close(options.name);