@op-engineering/op-sqlite 15.1.2 → 15.1.3

package/cpp/DBHostObject.cpp

@@ -20,7 +20,7 @@ namespace react = facebook::react;
 void DBHostObject::flush_pending_reactive_queries(
     const std::shared_ptr<jsi::Value> &resolve) {
   invoker->invokeAsync(
-      [this, resolve]() { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
+      [resolve](jsi::Runtime &rt) { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
 }
 #else
 void DBHostObject::flush_pending_reactive_queries(
@@ -36,8 +36,8 @@ void DBHostObject::flush_pending_reactive_queries(
                                                       metadata);
 
     invoker->invokeAsync(
-        [this, results = std::make_shared<std::vector<DumbHostObject>>(results),
-         callback = query->callback, metadata, status = std::move(status)] {
+        [results = std::make_shared<std::vector<DumbHostObject>>(results),
+         callback = query->callback, metadata, status = std::move(status)](jsi::Runtime &rt) {
           auto jsiResult = create_result(rt, status, results.get(), metadata);
           callback->asObject(rt).asFunction(rt).call(rt, jsiResult);
         });
@@ -46,24 +46,24 @@ void DBHostObject::flush_pending_reactive_queries(
   pending_reactive_queries.clear();
 
   invoker->invokeAsync(
-      [this, resolve]() { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
+      [resolve](jsi::Runtime &rt) { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
 }
 
 void DBHostObject::on_commit() {
   invoker->invokeAsync(
-      [this] { commit_hook_callback->asObject(rt).asFunction(rt).call(rt); });
+      [this](jsi::Runtime &rt) { commit_hook_callback->asObject(rt).asFunction(rt).call(rt); });
 }
 
 void DBHostObject::on_rollback() {
   invoker->invokeAsync(
-      [this] { rollback_hook_callback->asObject(rt).asFunction(rt).call(rt); });
+      [this](jsi::Runtime &rt) { rollback_hook_callback->asObject(rt).asFunction(rt).call(rt); });
 }
 
 void DBHostObject::on_update(const std::string &table,
                              const std::string &operation, long long row_id) {
   if (update_hook_callback != nullptr) {
     invoker->invokeAsync(
-        [this, callback = update_hook_callback, table, operation, row_id] {
+        [callback = update_hook_callback, table, operation, row_id](jsi::Runtime &rt) {
           auto res = jsi::Object(rt);
           res.setProperty(rt, "table", jsi::String::createFromUtf8(rt, table));
           res.setProperty(rt, "operation",
@@ -142,24 +142,21 @@ void DBHostObject::auto_register_update_hook() {
 #ifdef OP_SQLITE_USE_LIBSQL
 // Remote connection constructor
 DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &url,
-                           std::string &auth_token,
-                           std::shared_ptr<react::CallInvoker> invoker)
-    : db_name(url), invoker(std::move(invoker)), rt(rt) {
+                           std::string &auth_token)
+    : db_name(url) {
   _thread_pool = std::make_shared<ThreadPool>();
   db = opsqlite_libsql_open_remote(url, auth_token);
 
-  create_jsi_functions();
+  create_jsi_functions(rt);
 }
 
 // Sync connection constructor
-DBHostObject::DBHostObject(jsi::Runtime &rt,
-                           std::shared_ptr<react::CallInvoker> invoker,
-                           std::string &db_name, std::string &path,
-                           std::string &url, std::string &auth_token,
-                           int sync_interval, bool offline,
-                           std::string &encryption_key,
+DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &db_name,
+                           std::string &path, std::string &url,
+                           std::string &auth_token, int sync_interval,
+                           bool offline, std::string &encryption_key,
                            std::string &remote_encryption_key)
-    : db_name(db_name), invoker(std::move(invoker)), rt(rt) {
+    : db_name(db_name) {
 
   _thread_pool = std::make_shared<ThreadPool>();
 
@@ -167,19 +164,17 @@ DBHostObject::DBHostObject(jsi::Runtime &rt,
       opsqlite_libsql_open_sync(db_name, path, url, auth_token, sync_interval,
                                 offline, encryption_key, remote_encryption_key);
 
-  create_jsi_functions();
+  create_jsi_functions(rt);
 }
 
 #endif
 
 DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
-                           std::shared_ptr<react::CallInvoker> invoker,
                            std::string &db_name, std::string &path,
                            std::string &crsqlite_path,
                            std::string &sqlite_vec_path,
                            std::string &encryption_key)
-    : base_path(base_path), invoker(std::move(invoker)), db_name(db_name),
-      rt(rt) {
+    : base_path(base_path), db_name(db_name) {
   _thread_pool = std::make_shared<ThreadPool>();
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
@@ -190,10 +185,10 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 #else
   db = opsqlite_open(db_name, path, crsqlite_path, sqlite_vec_path);
 #endif
-  create_jsi_functions();
+  create_jsi_functions(rt);
 };
 
-void DBHostObject::create_jsi_functions() {
+void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
   function_map["attach"] = HFN(this) {
     std::string secondary_db_path = std::string(base_path);
 
@@ -432,19 +427,19 @@ void DBHostObject::create_jsi_functions() {
   });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  function_map["sync"] = HOSTFN("sync") {
+  function_map["sync"] = HFN(this) {
     opsqlite_libsql_sync(db);
     return {};
   });
 
-  function_map["setReservedBytes"] = HOSTFN("setReservedBytes") {
-    int32_t reserved_bytes = static_cast<int32_t>(args[0].asNumber());
+  function_map["setReservedBytes"] =HFN(this) {
+    auto reserved_bytes = static_cast<int32_t>(args[0].asNumber());
     opsqlite_libsql_set_reserved_bytes(db, reserved_bytes);
     return {};
   });
 
-  function_map["getReservedBytes"] = HOSTFN("getReservedBytes") {
-    return jsi::Value(opsqlite_libsql_get_reserved_bytes(db));
+  function_map["getReservedBytes"] = HFN(this) {
+    return {opsqlite_libsql_get_reserved_bytes(db)};
   });
 #else
   function_map["loadFile"] = HFN(this) {
@@ -466,7 +461,7 @@ void DBHostObject::create_jsi_functions() {
         });
   });
 
-  function_map["updateHook"] = HOSTFN("updateHook") {
+  function_map["updateHook"] = HFN(this) {
     auto callback = std::make_shared<jsi::Value>(rt, args[0]);
 
     if (callback->isUndefined() || callback->isNull()) {
@@ -479,7 +474,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  function_map["commitHook"] = HOSTFN("commitHook") {
+  function_map["commitHook"] = HFN(this) {
     if (count < 1) {
       throw std::runtime_error("[op-sqlite][commitHook] callback needed");
     }
@@ -495,7 +490,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  function_map["rollbackHook"] = HOSTFN("rollbackHook") {
+  function_map["rollbackHook"] = HFN(this) {
     if (count < 1) {
       throw std::runtime_error("[op-sqlite][rollbackHook] callback needed");
     }
@@ -512,7 +507,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  function_map["loadExtension"] = HOSTFN("loadExtension") {
+  function_map["loadExtension"] = HFN(this) {
     auto path = args[0].asString(rt).utf8(rt);
     std::string entry_point;
     if (count > 1 && args[1].isString()) {
@@ -523,7 +518,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  function_map["reactiveExecute"] = HOSTFN("reactiveExecute") {
+  function_map["reactiveExecute"] = HFN(this) {
     auto query = args[0].asObject(rt);
 
     const std::string query_str =
@@ -566,7 +561,7 @@ void DBHostObject::create_jsi_functions() {
 
     auto_register_update_hook();
 
-    auto unsubscribe = HOSTFN("unsubscribe") {
+    auto unsubscribe = HFN2(this, reactiveQuery) {
       auto it = std::find(reactive_queries.begin(), reactive_queries.end(),
                           reactiveQuery);
       if (it != reactive_queries.end()) {
@@ -580,7 +575,7 @@ void DBHostObject::create_jsi_functions() {
   });
 #endif
 
-  function_map["prepareStatement"] = HOSTFN("prepareStatement") {
+  function_map["prepareStatement"] = HFN(this) {
     auto query = args[0].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
     libsql_stmt_t statement = opsqlite_libsql_prepare_statement(db, query);
@@ -593,7 +588,7 @@ void DBHostObject::create_jsi_functions() {
     return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
   });
 
-  function_map["getDbPath"] = HOSTFN("getDbPath") {
+  function_map["getDbPath"] = HFN(this) {
     std::string path = std::string(base_path);
 
     if (count == 1) {
@@ -617,13 +612,12 @@ void DBHostObject::create_jsi_functions() {
     return jsi::String::createFromUtf8(rt, result);
   });
 
-  function_map["flushPendingReactiveQueries"] =
-      HOSTFN("flushPendingReactiveQueries") {
+  function_map["flushPendingReactiveQueries"] = HFN(this) {
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
+    auto promise = promiseCtr.callAsConstructor(rt, HFN(this) {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
 
-      auto task = [&rt, this, resolve]() {
+      auto task = [this, resolve]() {
         flush_pending_reactive_queries(resolve);
       };
 
@@ -645,11 +639,11 @@ std::vector<jsi::PropNameID> DBHostObject::getPropertyNames(jsi::Runtime &_rt) {
   return keys;
 }
 
-jsi::Value DBHostObject::get(jsi::Runtime &_rt,
+jsi::Value DBHostObject::get(jsi::Runtime &rt,
                              const jsi::PropNameID &propNameID) {
   auto name = propNameID.utf8(rt);
   if (function_map.count(name) != 1) {
-    return HOST_STATIC_FN(name.c_str()) {
+    return HFN(name) {
       throw std::runtime_error(
           "[op-sqlite] Function " + name +
           " not implemented for current backend (libsql or sqlcipher)");

package/cpp/DBHostObject.h

@@ -44,22 +44,19 @@ struct ReactiveQuery {
 class JSI_EXPORT DBHostObject : public jsi::HostObject {
 public:
   // Normal constructor shared between all backends
-  DBHostObject(jsi::Runtime &rt, std::string &base_path,
-               std::shared_ptr<react::CallInvoker> invoker,
-               std::string &db_name, std::string &path,
-               std::string &crsqlite_path, std::string &sqlite_vec_path,
-               std::string &encryption_key);
+  DBHostObject(jsi::Runtime &rt, std::string &base_path, std::string &db_name,
+               std::string &path, std::string &crsqlite_path,
+               std::string &sqlite_vec_path, std::string &encryption_key);
 
 #ifdef OP_SQLITE_USE_LIBSQL
   // Constructor for remoteOpen, purely for remote databases
-  DBHostObject(jsi::Runtime &rt, std::string &url, std::string &auth_token,
-               std::shared_ptr<react::CallInvoker> invoker);
+  DBHostObject(jsi::Runtime &rt, std::string &url, std::string &auth_token);
 
   // Constructor for a local database with remote sync
-  DBHostObject(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
-               std::string &db_name, std::string &path, std::string &url,
-               std::string &auth_token, int sync_interval, bool offline,
-               std::string &encryption_key, std::string &remote_encryption_key);
+  DBHostObject(jsi::Runtime &rt, std::string &db_name, std::string &path,
+               std::string &url, std::string &auth_token, int sync_interval,
+               bool offline, std::string &encryption_key,
+               std::string &remote_encryption_key);
 #endif
 
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
@@ -76,19 +73,16 @@ public:
 private:
   std::set<std::shared_ptr<ReactiveQuery>> pending_reactive_queries;
   void auto_register_update_hook();
-  void create_jsi_functions();
-  void
-  flush_pending_reactive_queries(const std::shared_ptr<jsi::Value> &resolve);
+  void create_jsi_functions(jsi::Runtime &rt);
+  void flush_pending_reactive_queries(const std::shared_ptr<jsi::Value> &resolve);
 
   std::unordered_map<std::string, jsi::Value> function_map;
   std::string base_path;
-  std::shared_ptr<react::CallInvoker> invoker;
   std::shared_ptr<ThreadPool> _thread_pool;
   std::string db_name;
   std::shared_ptr<jsi::Value> update_hook_callback;
   std::shared_ptr<jsi::Value> commit_hook_callback;
   std::shared_ptr<jsi::Value> rollback_hook_callback;
-  jsi::Runtime &rt;
   std::vector<std::shared_ptr<ReactiveQuery>> reactive_queries;
   std::vector<PendingReactiveInvocation> pending_reactive_invocations;
   bool is_update_hook_registered = false;

package/cpp/OPSqlite.cpp

@@ -43,14 +43,14 @@ void invalidate() {
 }
 
 void install(jsi::Runtime &rt,
-             const std::shared_ptr<react::CallInvoker> &invoker,
+             const std::shared_ptr<react::CallInvoker> &_invoker,
              const char *base_path, const char *crsqlite_path,
              const char *sqlite_vec_path) {
 
   _base_path = std::string(base_path);
   _crsqlite_path = std::string(crsqlite_path);
   _sqlite_vec_path = std::string(sqlite_vec_path);
-  opsqlite::invoker = invoker;
+  opsqlite::invoker = _invoker;
   opsqlite::invalidated = false;
 
   auto open = HFN0 {
@@ -69,12 +69,6 @@ void install(jsi::Runtime &rt,
           options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt);
     }
 
-#ifdef OP_SQLITE_USE_SQLCIPHER
-    if (encryption_key.empty()) {
-      log_to_console(rt, "Encryption key is missing for SQLCipher");
-    }
-#endif
-
     if (!location.empty()) {
       if (location == ":memory:") {
         path = ":memory:";
@@ -86,13 +80,12 @@ void install(jsi::Runtime &rt,
     }
 
     std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, path, opsqlite::invoker, name, path, _crsqlite_path,
-        _sqlite_vec_path, encryption_key);
+        rt, path, name, path, _crsqlite_path, _sqlite_vec_path, encryption_key);
     dbs.emplace_back(db);
     return jsi::Object::createFromHostObject(rt, db);
   });
 
-  auto is_sqlcipher = HOST_STATIC_FN("isSQLCipher") {
+  auto is_sqlcipher = HFN(=) {
 #ifdef OP_SQLITE_USE_SQLCIPHER
     return true;
 #else
@@ -100,7 +93,7 @@ void install(jsi::Runtime &rt,
 #endif
   });
 
-  auto is_ios_embedded = HOST_STATIC_FN("isIOSEmbedded") {
+  auto is_ios_embedded = HFN(=) {
 #ifdef OP_SQLITE_USE_PHONE_VERSION
     return true;
 #else
@@ -108,7 +101,7 @@ void install(jsi::Runtime &rt,
 #endif
   });
 
-  auto is_libsql = HOST_STATIC_FN("isLibsql") {
+  auto is_libsql = HFN(=) {
 #ifdef OP_SQLITE_USE_LIBSQL
     return true;
 #else
@@ -117,7 +110,7 @@ void install(jsi::Runtime &rt,
   });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  auto open_remote = HOST_STATIC_FN("openRemote") {
+  auto open_remote = HFN(=) {
     jsi::Object options = args[0].asObject(rt);
 
     std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
@@ -126,12 +119,12 @@ void install(jsi::Runtime &rt,
         options.getProperty(rt, "authToken").asString(rt).utf8(rt);
 
     std::shared_ptr<DBHostObject> db =
-        std::make_shared<DBHostObject>(rt, url, auth_token, invoker);
+        std::make_shared<DBHostObject>(rt, url, auth_token);
 
     return jsi::Object::createFromHostObject(rt, db);
   });
 
-  auto open_sync = HOST_STATIC_FN("openSync") {
+  auto open_sync = HFN(=) {
     jsi::Object options = args[0].asObject(rt);
     std::string name = options.getProperty(rt, "name").asString(rt).utf8(rt);
     std::string path = std::string(_base_path);
@@ -169,7 +162,7 @@ void install(jsi::Runtime &rt,
     if (!location.empty()) {
       if (location == ":memory:") {
         path = ":memory:";
-      } else if (location.rfind("/", 0) == 0) {
+      } else if (location.rfind('/', 0) == 0) {
         path = location;
       } else {
         path = path + "/" + location;
@@ -177,8 +170,8 @@ void install(jsi::Runtime &rt,
     }
 
     std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, invoker, name, path, url, auth_token, sync_interval, offline,
-        encryption_key, remote_encryption_key);
+        rt, name, path, url, auth_token, sync_interval, offline, encryption_key,
+        remote_encryption_key);
     return jsi::Object::createFromHostObject(rt, db);
   });
 #endif

package/cpp/PreparedStatementHostObject.cpp

@@ -48,7 +48,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
   }
 
   if (name == "bindSync") {
-    return HOSTFN("bindSync") {
+    return HFN(this) {
       if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
@@ -71,7 +71,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
   }
 
   if (name == "execute") {
-    return HOSTFN("execute") {
+    return HFN(this) {
       if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }

package/cpp/macros.hpp

@@ -1,19 +1,5 @@
 #pragma once
 
-#define HOSTFN(name)                                                           \
-jsi::Function::createFromHostFunction( \
-rt, \
-jsi::PropNameID::forAscii(rt, name), \
-0, \
-[=, this](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value
-
-#define HOST_STATIC_FN(name)                                                   \
-jsi::Function::createFromHostFunction( \
-rt, \
-jsi::PropNameID::forAscii(rt, name), \
-0, \
-[=](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value
-
 // Do not unroll into multi lines to avoid Xcode reporting the wrong lines
 #define HFN0 jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, ""), 0, [](jsi::Runtime &rt, const jsi::Value &that, const jsi::Value *args, size_t count) -> jsi::Value
 #define HFN(c1) jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, ""), 0, [c1](jsi::Runtime &rt, const jsi::Value &that, const jsi::Value *args, size_t count) -> jsi::Value

package/op-sqlite.podspec

@@ -33,8 +33,8 @@ if is_user_app
   raise "package.json not found" if package_json_path.nil?
   
   app_package = JSON.parse(File.read(package_json_path))
-# When running on the example app
 else
+  # When running on the example app
   package_json_path = File.join(__dir__, "example", "package.json")
   app_package = JSON.parse(File.read(File.join(__dir__, "example", "package.json")))
 end
@@ -90,7 +90,7 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => "13.0", :tvos => "13.0", :osx => "10.15", :visionos => "1.0" }
+  s.platforms    = { :ios => min_ios_version_supported, :tvos => "13.0", :osx => "10.15", :visionos => "1.0" }
   s.source       = { :git => "https://github.com/op-engineering/op-sqlite.git", :tag => "#{s.version}" }
 
   install_modules_dependencies(s)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "15.1.2",
+  "version": "15.1.3",
   "description": "Fastest SQLite for React Native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",