@op-engineering/op-sqlite 3.0.1 → 3.0.2

package/cpp/bindings.cpp

@@ -511,8 +511,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      opsqlite_deregister_update_hook(dbName);
-      return {};
+      throw std::runtime_error("[op-sqlite][updateHook] callback is required");
     }
 
     updateHooks[dbName] = callback;
@@ -552,9 +551,13 @@ void install(jsi::Runtime &rt,
           });
     };
 
-    opsqlite_register_update_hook(dbName, std::move(hook));
+    auto register_result =
+        opsqlite_register_update_hook(dbName, std::move(hook));
 
-    return {};
+    return HOSTFN("remove", 0) {
+      opsqlite_deregister_update_hook(dbName, register_result.identifier);
+      return {};
+    });
   });
 
   auto commit_hook = HOSTFN("commitHook", 2) {
@@ -567,8 +570,7 @@ void install(jsi::Runtime &rt,
     auto dbName = args[0].asString(rt).utf8(rt);
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
     if (callback->isUndefined() || callback->isNull()) {
-      opsqlite_deregister_commit_hook(dbName);
-      return {};
+      throw std::runtime_error("Callback is needed");
     }
     commitHooks[dbName] = callback;
 
@@ -577,9 +579,13 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    opsqlite_register_commit_hook(dbName, std::move(hook));
+    auto register_result =
+        opsqlite_register_commit_hook(dbName, std::move(hook));
 
-    return {};
+    return HOSTFN("remove", 0) {
+      opsqlite_deregister_commit_hook(dbName, register_result.identifier);
+      return {};
+    });
   });
 
   auto rollback_hook = HOSTFN("rollbackHook", 2) {
@@ -594,7 +600,7 @@ void install(jsi::Runtime &rt,
     auto callback = std::make_shared<jsi::Value>(rt, args[1]);
 
     if (callback->isUndefined() || callback->isNull()) {
-      opsqlite_deregister_rollback_hook(dbName);
+      throw std::runtime_error("Callback is needed");
       return {};
     }
     rollbackHooks[dbName] = callback;
@@ -604,8 +610,13 @@ void install(jsi::Runtime &rt,
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
 
-    opsqlite_register_rollback_hook(dbName, std::move(hook));
-    return {};
+    auto register_result =
+        opsqlite_register_rollback_hook(dbName, std::move(hook));
+
+    return HOSTFN("remove", 0) {
+      opsqlite_deregister_rollback_hook(dbName, register_result.identifier);
+      return {};
+    });
   });
 
   auto prepare_statement = HOSTFN("prepareStatement", 1) {

package/cpp/bridge.cpp

@@ -8,17 +8,25 @@
 
 namespace opsqlite {
 
+// TODO this has gotten unweildy, using a HostObject abstraction would be better
 /// Maps to hold the different objects
 std::unordered_map<std::string, sqlite3 *> dbMap =
     std::unordered_map<std::string, sqlite3 *>();
-std::unordered_map<std::string, UpdateCallback> updateCallbackMap =
-    std::unordered_map<std::string, UpdateCallback>();
-
-std::unordered_map<std::string, CommitCallback> commitCallbackMap =
-    std::unordered_map<std::string, CommitCallback>();
-
-std::unordered_map<std::string, RollbackCallback> rollbackCallbackMap =
-    std::unordered_map<std::string, RollbackCallback>();
+std::unordered_map<std::string, std::unordered_map<std::string, UpdateCallback>>
+    updateCallbackMap =
+        std::unordered_map<std::string,
+                           std::unordered_map<std::string, UpdateCallback>>();
+
+std::unordered_map<std::string, std::unordered_map<std::string, CommitCallback>>
+    commitCallbackMap =
+        std::unordered_map<std::string,
+                           std::unordered_map<std::string, CommitCallback>>();
+
+std::unordered_map<std::string,
+                   std::unordered_map<std::string, RollbackCallback>>
+    rollbackCallbackMap =
+        std::unordered_map<std::string,
+                           std::unordered_map<std::string, RollbackCallback>>();
 
 inline void check_db_open(std::string const &db_name) {
   if (dbMap.count(db_name) == 0) {
@@ -26,6 +34,38 @@ inline void check_db_open(std::string const &db_name) {
   }
 }
 
+// Hook native callbacks
+void update_callback(void *user_data, int operation_type, char const *database,
+                     char const *table, sqlite3_int64 rowid) {
+  std::string db_name(database);
+  auto callbacks = updateCallbackMap[db_name];
+  // iterate over the callback map and call them
+
+  for (auto &cb : callbacks) {
+    cb.second(db_name, std::string(table),
+              sqlite_operation_to_string(operation_type),
+              static_cast<long long>(rowid));
+  }
+}
+
+int commit_callback(void *database) {
+  std::string db_name(static_cast<char const *>(database));
+  auto callbacks = commitCallbackMap[db_name];
+  for (auto &cb : callbacks) {
+    cb.second(db_name);
+  }
+  // You need to return 0 to allow commits to continue
+  return 0;
+}
+
+void rollback_callback(void *database) {
+  std::string db_name(static_cast<char const *>(database));
+  auto callbacks = rollbackCallbackMap[db_name];
+  for (auto &cb : callbacks) {
+    cb.second(db_name);
+  }
+}
+
 /// Start of api
 
 /// Returns the completely formed db path, but it also creates any sub-folders
@@ -69,6 +109,12 @@ BridgeResult opsqlite_open(std::string const &dbName,
                    nullptr, nullptr);
 #endif
 
+  // On connection we register the native hooks, so on JS people can create
+  // reactive queries and their own hooks
+  sqlite3_update_hook(db, &update_callback, nullptr);
+  sqlite3_commit_hook(db, &commit_callback, nullptr);
+  sqlite3_rollback_hook(db, &rollback_callback, nullptr);
+
   return BridgeResult{.type = SQLiteOk, .affectedRows = 0};
 }
 
@@ -684,132 +730,83 @@ void opsqlite_close_all() {
   commitCallbackMap.clear();
 }
 
-std::string operation_to_string(int operation_type) {
-  switch (operation_type) {
-  case SQLITE_INSERT:
-    return "INSERT";
-
-  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 = updateCallbackMap[strDbName];
-  callback(strDbName, std::string(table), operation_to_string(operation_type),
-           static_cast<int>(rowid));
-}
-
-BridgeResult opsqlite_register_update_hook(std::string const &dbName,
+BridgeResult opsqlite_register_update_hook(std::string const &db_name,
                                            UpdateCallback const callback) {
-  check_db_open(dbName);
+  check_db_open(db_name);
 
-  sqlite3 *db = dbMap[dbName];
-  updateCallbackMap[dbName] = callback;
-  const std::string *key = nullptr;
+  sqlite3 *db = dbMap[db_name];
+  std::string id = get_uuid();
 
-  // 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;
-    }
+  if (!updateCallbackMap.count(db_name)) {
+    updateCallbackMap[db_name] =
+        std::unordered_map<std::string, UpdateCallback>();
   }
 
-  sqlite3_update_hook(db, &update_callback, (void *)key);
+  updateCallbackMap[db_name][id] = callback;
 
-  return {SQLiteOk};
+  return {.type = SQLiteOk, .identifier = id};
 }
 
-BridgeResult opsqlite_deregister_update_hook(std::string const &dbName) {
-  check_db_open(dbName);
-
-  sqlite3 *db = dbMap[dbName];
-  updateCallbackMap.erase(dbName);
-
-  sqlite3_update_hook(db, NULL, NULL);
+BridgeResult opsqlite_deregister_update_hook(std::string const &db_name,
+                                             std::string const &id) {
+  check_db_open(db_name);
+  updateCallbackMap[db_name].erase(id);
 
   return {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 opsqlite_register_commit_hook(std::string const &dbName,
+BridgeResult opsqlite_register_commit_hook(std::string const &db_name,
                                            CommitCallback const callback) {
-  check_db_open(dbName);
+  check_db_open(db_name);
 
-  sqlite3 *db = dbMap[dbName];
-  commitCallbackMap[dbName] = callback;
-  const std::string *key = nullptr;
+  sqlite3 *db = dbMap[db_name];
+  std::string id = get_uuid();
 
-  // 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;
-    }
+  if (!commitCallbackMap.count(db_name)) {
+    commitCallbackMap[db_name] =
+        std::unordered_map<std::string, CommitCallback>();
   }
 
-  sqlite3_commit_hook(db, &commit_callback, (void *)key);
+  commitCallbackMap[db_name][id] = callback;
 
-  return {SQLiteOk};
+  return {.type = SQLiteOk, .identifier = id};
 }
 
-BridgeResult opsqlite_deregister_commit_hook(std::string const &dbName) {
-  check_db_open(dbName);
+BridgeResult opsqlite_deregister_commit_hook(std::string const &db_name,
+                                             std::string const &id) {
+  check_db_open(db_name);
 
-  sqlite3 *db = dbMap[dbName];
-  commitCallbackMap.erase(dbName);
+  sqlite3 *db = dbMap[db_name];
+  commitCallbackMap[db_name].erase(id);
   sqlite3_commit_hook(db, NULL, NULL);
 
   return {SQLiteOk};
 }
 
-void rollback_callback(void *dbName) {
-  std::string &strDbName = *(static_cast<std::string *>(dbName));
-  auto callback = rollbackCallbackMap[strDbName];
-  callback(strDbName);
-}
-
-BridgeResult opsqlite_register_rollback_hook(std::string const &dbName,
+BridgeResult opsqlite_register_rollback_hook(std::string const &db_name,
                                              RollbackCallback const callback) {
-  check_db_open(dbName);
+  check_db_open(db_name);
 
-  sqlite3 *db = dbMap[dbName];
-  rollbackCallbackMap[dbName] = callback;
-  const std::string *key = nullptr;
+  sqlite3 *db = dbMap[db_name];
+  std::string id = get_uuid();
 
-  // 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;
-    }
+  if (!rollbackCallbackMap.count(db_name)) {
+    rollbackCallbackMap[db_name] =
+        std::unordered_map<std::string, RollbackCallback>();
   }
 
-  sqlite3_rollback_hook(db, &rollback_callback, (void *)key);
+  rollbackCallbackMap[db_name][id] = callback;
 
-  return {SQLiteOk};
+  return {.type = SQLiteOk, .identifier = id};
 }
 
-BridgeResult opsqlite_deregister_rollback_hook(std::string const &dbName) {
-  check_db_open(dbName);
-
-  sqlite3 *db = dbMap[dbName];
-  rollbackCallbackMap.erase(dbName);
+BridgeResult opsqlite_deregister_rollback_hook(std::string const &db_name,
+                                               std::string const &id) {
+  check_db_open(db_name);
 
-  sqlite3_rollback_hook(db, NULL, NULL);
+  sqlite3 *db = dbMap[db_name];
+  rollbackCallbackMap[db_name].erase(id);
+  sqlite3_commit_hook(db, NULL, NULL);
 
   return {SQLiteOk};
 }

package/cpp/bridge.h

@@ -58,13 +58,16 @@ void opsqlite_close_all();
 
 BridgeResult opsqlite_register_update_hook(std::string const &dbName,
                                            UpdateCallback const callback);
-BridgeResult opsqlite_deregister_update_hook(std::string const &dbName);
+BridgeResult opsqlite_deregister_update_hook(std::string const &dbName,
+                                             std::string const &id);
 BridgeResult opsqlite_register_commit_hook(std::string const &dbName,
                                            CommitCallback const callback);
-BridgeResult opsqlite_deregister_commit_hook(std::string const &dbName);
+BridgeResult opsqlite_deregister_commit_hook(std::string const &dbName,
+                                             std::string const &id);
 BridgeResult opsqlite_register_rollback_hook(std::string const &dbName,
                                              RollbackCallback const callback);
-BridgeResult opsqlite_deregister_rollback_hook(std::string const &dbName);
+BridgeResult opsqlite_deregister_rollback_hook(std::string const &dbName,
+                                               std::string const &id);
 
 sqlite3_stmt *opsqlite_prepare_statement(std::string const &dbName,
                                          std::string const &query);

package/cpp/types.h

@@ -12,6 +12,7 @@ struct BridgeResult {
   std::string message;
   int affectedRows;
   double insertId;
+  std::string identifier;
 };
 
 struct BatchResult {

package/cpp/utils.cpp

@@ -3,6 +3,7 @@
 #include "bridge.h"
 #include <fstream>
 #include <iostream>
+#include <random>
 #include <sstream>
 #include <sys/stat.h>
 #include <unistd.h>
@@ -252,4 +253,40 @@ int mkdir(std::string const &path) {
   return 0;
 }
 
+// Semi random function, more than enough for our purposes
+std::string get_uuid() {
+  static std::random_device dev;
+  static std::mt19937 rng(dev());
+
+  std::uniform_int_distribution<int> dist(0, 15);
+
+  const char *v = "0123456789abcdef";
+  const bool dash[] = {0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0};
+
+  std::string res;
+  for (int i = 0; i < 16; i++) {
+    if (dash[i])
+      res += "-";
+    res += v[dist(rng)];
+    res += v[dist(rng)];
+  }
+  return res;
+}
+
+std::string sqlite_operation_to_string(int operation_type) {
+  switch (operation_type) {
+  case SQLITE_INSERT:
+    return "INSERT";
+
+  case SQLITE_DELETE:
+    return "DELETE";
+
+  case SQLITE_UPDATE:
+    return "UPDATE";
+
+  default:
+    throw std::invalid_argument("Uknown SQLite operation on hook");
+  }
+}
+
 } // namespace opsqlite

package/cpp/utils.h

@@ -37,6 +37,10 @@ bool folder_exists(const std::string &foldername);
 
 bool file_exists(const std::string &path);
 
+std::string get_uuid();
+
+std::string sqlite_operation_to_string(int operation_type);
+
 } // namespace opsqlite
 
 #endif /* utils_h */

package/op-sqlite.podspec

@@ -28,7 +28,7 @@ Pod::Spec.new do |s|
   if ENV['OP_SQLITE_USE_SQLCIPHER'] == '1' then
     puts "OP-SQLITE using SQLCipher! 🔒\n"
     s.exclude_files = "cpp/sqlite3.c", "cpp/sqlite3.h"
-    xcconfig[:GCC_PREPROCESSOR_DEFINITIONS] += " OP_SQLITE_USE_SQLCIPHER=1"
+    xcconfig[:GCC_PREPROCESSOR_DEFINITIONS] += " OP_SQLITE_USE_SQLCIPHER=1 SQLITE_HAS_CODEC SQLITE_TEMP_STORE=2"
   else
     puts "OP-SQLITE using SQLite! 📦\n"
     s.exclude_files = "cpp/sqlcipher/sqlite3.c", "cpp/sqlcipher/sqlite3.h"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",