Added support commit and rollbacks hooks

ospfranco · ospfranco · commit 1af8d7f2bcf7 · 2023-11-17T17:50:42.000+01:00
diff --git a/cpp/bindings.cpp b/cpp/bindings.cpp
@@ -19,6 +19,8 @@ std::string basePath;
 std::shared_ptr<react::CallInvoker> invoker;
 ThreadPool pool;
 std::unordered_map<std::string, std::shared_ptr<jsi::Value>> updateHooks = std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
+std::unordered_map<std::string, std::shared_ptr<jsi::Value>> commitHooks = std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
+std::unordered_map<std::string, std::shared_ptr<jsi::Value>> rollbackHooks = std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
 
 
 // React native will try to clean the module on JS context invalidation (CodePush/Hot Reload)
@@ -479,6 +481,55 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
         return {};
     });
     
+    auto commitHook = HOSTFN("commitHook", 2)
+    {
+        if (sizeof(args) < 2)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][loadFileAsync] Incorrect parameters: dbName and callback needed");
+            return {};
+        }
+        
+        auto dbName = args[0].asString(rt).utf8(rt);
+        auto callback = std::make_shared<jsi::Value>(rt, args[1]);
+        commitHooks[dbName] = callback;
+        
+        auto hook = [&rt, callback](std::string dbName) {
+            invoker->invokeAsync([&rt, callback]
+                                 {
+                callback->asObject(rt).asFunction(rt).call(rt);
+            });
+        };
+        
+        registerCommitHook(dbName, std::move(hook));
+        
+        return {};
+    });
+    
+    auto rollbackHook = HOSTFN("rollbackHook", 2)
+    {
+        if (sizeof(args) < 2)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][loadFileAsync] Incorrect parameters: dbName and callback needed");
+            return {};
+        }
+        
+        auto dbName = args[0].asString(rt).utf8(rt);
+        auto callback = std::make_shared<jsi::Value>(rt, args[1]);
+        rollbackHooks[dbName] = callback;
+        
+        auto hook = [&rt, callback](std::string dbName) {
+            
+            invoker->invokeAsync([&rt, callback] {
+                callback->asObject(rt).asFunction(rt).call(rt);
+                
+            });
+        };
+        
+        registerRollbackHook(dbName, std::move(hook));
+        
+        return {};
+    });
+    
     jsi::Object module = jsi::Object(rt);
     
     module.setProperty(rt, "open", std::move(open));
@@ -492,6 +543,8 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
     module.setProperty(rt, "executeBatchAsync", std::move(executeBatchAsync));
     module.setProperty(rt, "loadFile", std::move(loadFile));
     module.setProperty(rt, "updateHook", std::move(updateHook));
+    module.setProperty(rt, "commitHook", std::move(commitHook));
+    module.setProperty(rt, "rollbackHook", std::move(rollbackHook));
     
     rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
 }
diff --git a/cpp/bridge.cpp b/cpp/bridge.cpp
@@ -16,10 +16,20 @@ namespace opsqlite {
     std::unordered_map<std::string, sqlite3 *> dbMap = std::unordered_map<std::string, sqlite3 *>();
     std::unordered_map<
         std::string,
-        std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)>> callbackMap =
+        std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)>> updateCallbackMap =
             std::unordered_map<
                 std::string,
                 std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)>>();
+    
+    std::unordered_map<
+        std::string,
+        std::function<void (std::string dbName)>> commitCallbackMap =
+            std::unordered_map<std::string, std::function<void (std::string dbName)>>();
+
+    std::unordered_map<
+        std::string,
+        std::function<void (std::string dbName)>> rollbackCallbackMap =
+            std::unordered_map<std::string, std::function<void (std::string dbName)>>();
 
     bool folder_exists(const std::string &foldername)
     {
@@ -490,32 +500,34 @@ namespace opsqlite {
         dbMap.clear();
     }
 
-std::string operationToString(int operation_type) {
-    switch (operation_type) {
-        case SQLITE_INSERT:
-            return "INSERT";
-        
-        case SQLITE_DELETE:
-            return "DELETE";
+    std::string operationToString(int operation_type) {
+        switch (operation_type) {
+            case SQLITE_INSERT:
+                return "INSERT";
             
-        case SQLITE_UPDATE:
-            return "UPDATE";
-            
-        default:
-            throw std::invalid_argument("Uknown SQLite operation on hook");
+            case SQLITE_DELETE:
+                return "DELETE";
+                
+            case SQLITE_UPDATE:
+                return "UPDATE";
+                
+            default:
+                throw std::invalid_argument("Uknown SQLite operation on hook");
+        }
     }
-}
 
-void update_callback ( void *dbName, int operation_type,
-    char const *database, char const *table,
-    sqlite3_int64 rowid)
-    {
-    std::string &strDbName = *(static_cast<std::string*>(dbName));
-    auto callback = callbackMap[strDbName];
-    callback(strDbName, std::string(table), operationToString(operation_type), static_cast<int>(rowid));
+    void update_callback(void *dbName,
+                         int operation_type,
+                         char const *database,
+                         char const *table,
+                         sqlite3_int64 rowid) {
+        std::string &strDbName = *(static_cast<std::string*>(dbName));
+        auto callback = updateCallbackMap[strDbName];
+        callback(strDbName, std::string(table), operationToString(operation_type), static_cast<int>(rowid));
     }
     
-    BridgeResult registerUpdateHook(std::string const dbName, std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)> const callback) {
+    BridgeResult registerUpdateHook(std::string const dbName,
+                                    std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)> const callback) {
         if (dbMap.count(dbName) == 0)
         {
             return {
@@ -525,7 +537,7 @@ void update_callback ( void *dbName, int operation_type,
         }
         
         sqlite3 *db = dbMap[dbName];
-        callbackMap[dbName] = callback;
+        updateCallbackMap[dbName] = callback;
         const std::string *key = nullptr;
         
         // TODO find a more elegant way to retrieve a reference to the key
@@ -544,4 +556,80 @@ void update_callback ( void *dbName, int operation_type,
             SQLiteOk
         };
     }
+
+    int commit_callback(void *dbName) {
+        std::string &strDbName = *(static_cast<std::string*>(dbName));
+        auto callback = commitCallbackMap[strDbName];
+        callback(strDbName);
+        // You need to return 0 to allow commits to continue
+        return 0;
+    }
+
+    BridgeResult registerCommitHook(std::string const dbName,
+                                    std::function<void (std::string dbName)> const callback) {
+        if (dbMap.count(dbName) == 0)
+        {
+            return {
+                SQLiteError,
+                "[op-sqlite] Database not opened: " + dbName
+            };
+        }
+        
+        sqlite3 *db = dbMap[dbName];
+        commitCallbackMap[dbName] = callback;
+        const std::string *key = nullptr;
+        
+        // TODO find a more elegant way to retrieve a reference to the key
+        for (auto const& element : dbMap) {
+            if(element.first == dbName) {
+                key = &element.first;
+            }
+        }
+        
+        sqlite3_commit_hook(
+          db,
+          &commit_callback,
+          (void *)key);
+        
+        return {
+            SQLiteOk
+        };
+    }
+
+    void rollback_callback(void *dbName) {
+        std::string &strDbName = *(static_cast<std::string*>(dbName));
+        auto callback = rollbackCallbackMap[strDbName];
+        callback(strDbName);
+    }
+
+    BridgeResult registerRollbackHook(std::string const dbName,
+                                    std::function<void (std::string dbName)> const callback) {
+        if (dbMap.count(dbName) == 0)
+        {
+            return {
+                SQLiteError,
+                "[op-sqlite] Database not opened: " + dbName
+            };
+        }
+        
+        sqlite3 *db = dbMap[dbName];
+        rollbackCallbackMap[dbName] = callback;
+        const std::string *key = nullptr;
+        
+        // TODO find a more elegant way to retrieve a reference to the key
+        for (auto const& element : dbMap) {
+            if(element.first == dbName) {
+                key = &element.first;
+            }
+        }
+        
+        sqlite3_rollback_hook(
+          db,
+          &rollback_callback,
+          (void *)key);
+        
+        return {
+            SQLiteOk
+        };
+    }
 }
diff --git a/cpp/bridge.h b/cpp/bridge.h
@@ -31,7 +31,12 @@ BridgeResult sqliteExecuteLiteral(std::string const dbName, std::string const &q
 
 void sqliteCloseAll();
 
-BridgeResult registerUpdateHook(std::string const dbName, std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)> const callback);
+BridgeResult registerUpdateHook(std::string const dbName, 
+                                std::function<void (std::string dbName, std::string tableName, std::string operation, int rowId)> const callback);
+BridgeResult registerCommitHook(std::string const dbName,
+                                std::function<void (std::string dbName)> const callback);
+BridgeResult registerRollbackHook(std::string const dbName,
+                                  std::function<void (std::string dbName)> const callback);
 
 }
 
diff --git a/example/src/App.tsx b/example/src/App.tsx
@@ -14,7 +14,7 @@ import {dbSetupTests, queriesTests, runTests, blobTests} from './tests/index';
 import pak from '../package.json';
 import {styled} from 'nativewind';
 import RNRestart from 'react-native-restart';
-import {updateHookTests} from './tests/updateHook.spec';
+import {registerHooksTests} from './tests/hooks';
 
 const StyledScrollView = styled(ScrollView, {
   props: {
@@ -30,7 +30,7 @@ export default function App() {
 
   useEffect(() => {
     setResults([]);
-    runTests(dbSetupTests, queriesTests, blobTests, updateHookTests).then(
+    runTests(dbSetupTests, queriesTests, blobTests, registerHooksTests).then(
       setResults,
     );
   }, []);
diff --git a/example/src/tests/hooks.ts b/example/src/tests/hooks.ts
@@ -12,13 +12,13 @@ async function sleep(ms: number): Promise<void> {
 
 const expect = chai.expect;
 const DB_CONFIG = {
-  name: 'updateHookDb',
+  name: 'hooksDb',
 };
 const chance = new Chance();
 
 let db: OPSQLiteConnection;
 
-export function updateHookTests() {
+export function registerHooksTests() {
   beforeEach(() => {
     try {
       if (db) {
@@ -37,8 +37,8 @@ export function updateHookTests() {
     }
   });
 
-  describe('Update hook', () => {
-    it('Should register an update hook', async () => {
+  describe('Hooks', () => {
+    it('update hook', async () => {
       let promiseResolve: any;
       let promise = new Promise(resolve => {
         promiseResolve = resolve;
@@ -64,5 +64,56 @@ export function updateHookTests() {
 
       expect(operation).to.equal('INSERT');
     });
+
+    it('commit hook', async () => {
+      let promiseResolve: any;
+      let promise = new Promise(resolve => {
+        promiseResolve = resolve;
+      });
+
+      db.commitHook(() => {
+        promiseResolve?.();
+      });
+
+      const id = chance.integer();
+      const name = chance.name();
+      const age = chance.integer();
+      const networth = chance.floating();
+      await db.transaction(async tx => {
+        tx.execute(
+          'INSERT INTO "User" (id, name, age, networth) VALUES(?, ?, ?, ?)',
+          [id, name, age, networth],
+        );
+      });
+
+      await promise;
+    });
+
+    it('rollback hook', async () => {
+      let promiseResolve: any;
+      let promise = new Promise(resolve => {
+        promiseResolve = resolve;
+      });
+
+      db.rollbackHook(() => {
+        promiseResolve?.();
+      });
+
+      const id = chance.integer();
+      const name = chance.name();
+      const age = chance.integer();
+      const networth = chance.floating();
+      console.warn('1');
+      try {
+        await db.transaction(async tx => {
+          throw new Error('Blah');
+        });
+      } catch (e) {
+        // intentionally left blank
+      }
+
+      console.warn('2');
+      await promise;
+    });
   });
 }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
diff --git a/src/index.ts b/src/index.ts
@@ -168,6 +168,8 @@ interface ISQLite {
       rowId: number;
     }) => void
   ) => void;
+  commitHook: (dbName: string, callback: () => void) => void;
+  rollbackHook: (dbName: string, callback: () => void) => void;
 }
 
 const locks: Record<
@@ -382,6 +384,8 @@ export type OPSQLiteConnection = {
       rowId: number;
     }) => void
   ) => void;
+  commitHook: (callback: () => void) => void;
+  rollbackHook: (callback: () => void) => void;
 };
 
 export const open = (options: {
@@ -412,5 +416,7 @@ export const open = (options: {
       OPSQLite.executeBatchAsync(options.name, commands),
     loadFile: (location: string) => OPSQLite.loadFile(options.name, location),
     updateHook: (callback) => OPSQLite.updateHook(options.name, callback),
+    commitHook: (callback) => OPSQLite.commitHook(options.name, callback),
+    rollbackHook: (callback) => OPSQLite.rollbackHook(options.name, callback),
   };
 };

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@op-engineering/op-sqlite",`
`3`		`- "version": "1.0.12",`
	`3`	`+ "version": "1.0.13",`
`4`	`4`	`"description": "Next generation SQLite for React Native",`
`5`	`5`	`"main": "lib/commonjs/index",`
`6`	`6`	`"module": "lib/module/index",`