OP-Engineering · ospfranco · Dec 19, 2025 · Dec 19, 2025
diff --git a/cpp/DBHostObject.cpp b/cpp/DBHostObject.cpp
@@ -19,8 +19,9 @@ namespace react = facebook::react;
 #ifdef OP_SQLITE_USE_LIBSQL
 void DBHostObject::flush_pending_reactive_queries(
     const std::shared_ptr<jsi::Value> &resolve) {
-  invoker->invokeAsync(
-      [resolve](jsi::Runtime &rt) { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
+  invoker->invokeAsync([resolve](jsi::Runtime &rt) {
+    resolve->asObject(rt).asFunction(rt).call(rt, {});
+  });
 }
 #else
 void DBHostObject::flush_pending_reactive_queries(
@@ -37,41 +38,45 @@ void DBHostObject::flush_pending_reactive_queries(
 
     invoker->invokeAsync(
         [results = std::make_shared<std::vector<DumbHostObject>>(results),
-         callback = query->callback, metadata, status = std::move(status)](jsi::Runtime &rt) {
+         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);
         });
   }
 
   pending_reactive_queries.clear();
 
-  invoker->invokeAsync(
-      [resolve](jsi::Runtime &rt) { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
+  invoker->invokeAsync([resolve](jsi::Runtime &rt) {
+    resolve->asObject(rt).asFunction(rt).call(rt, {});
+  });
 }
 
 void DBHostObject::on_commit() {
-  invoker->invokeAsync(
-      [this](jsi::Runtime &rt) { commit_hook_callback->asObject(rt).asFunction(rt).call(rt); });
+  invoker->invokeAsync([this](jsi::Runtime &rt) {
+    commit_hook_callback->asObject(rt).asFunction(rt).call(rt);
+  });
 }
 
 void DBHostObject::on_rollback() {
-  invoker->invokeAsync(
-      [this](jsi::Runtime &rt) { rollback_hook_callback->asObject(rt).asFunction(rt).call(rt); });
+  invoker->invokeAsync([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(
-        [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",
-                          jsi::String::createFromUtf8(rt, operation));
-          res.setProperty(rt, "rowId", jsi::Value(static_cast<double>(row_id)));
-
-          callback->asObject(rt).asFunction(rt).call(rt, res);
-        });
+    invoker->invokeAsync([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",
+                      jsi::String::createFromUtf8(rt, operation));
+      res.setProperty(rt, "rowId", jsi::Value(static_cast<double>(row_id)));
+
+      callback->asObject(rt).asFunction(rt).call(rt, res);
+    });
   }
 
   for (const auto &query_ptr : reactive_queries) {
@@ -144,7 +149,7 @@ void DBHostObject::auto_register_update_hook() {
 DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &url,
                            std::string &auth_token)
     : db_name(url) {
-  _thread_pool = std::make_shared<ThreadPool>();
+  thread_pool = std::make_shared<ThreadPool>();
   db = opsqlite_libsql_open_remote(url, auth_token);
 
   create_jsi_functions(rt);
@@ -158,7 +163,7 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &db_name,
                            std::string &remote_encryption_key)
     : db_name(db_name) {
 
-  _thread_pool = std::make_shared<ThreadPool>();
+  thread_pool = std::make_shared<ThreadPool>();
 
   db =
       opsqlite_libsql_open_sync(db_name, path, url, auth_token, sync_interval,
@@ -175,7 +180,7 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
                            std::string &sqlite_vec_path,
                            std::string &encryption_key)
     : base_path(base_path), db_name(db_name) {
-  _thread_pool = std::make_shared<ThreadPool>();
+  thread_pool = std::make_shared<ThreadPool>();
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
   db = opsqlite_open(db_name, path, crsqlite_path, sqlite_vec_path,
@@ -281,7 +286,7 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
                                               : std::vector<JSVariant>();
 
     return promisify(
-        rt,
+        rt, thread_pool,
         [this, query, params]() {
           std::vector<std::vector<JSVariant>> results;
 #ifdef OP_SQLITE_USE_LIBSQL
@@ -341,7 +346,7 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
                                         : std::vector<JSVariant>();
 
     return promisify(
-        rt,
+        rt, thread_pool,
         [this, query, params]() {
 #ifdef OP_SQLITE_USE_LIBSQL
           auto status = opsqlite_libsql_execute(db, query, &params);
@@ -363,7 +368,7 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
                                         : std::vector<JSVariant>();
 
     return promisify(
-        rt,
+        rt, thread_pool,
         [this, query, params]() {
           std::vector<DumbHostObject> results;
           std::shared_ptr<std::vector<SmartHostObject>> metadata =
@@ -408,7 +413,7 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
     to_batch_arguments(rt, batchParams, &commands);
 
     return promisify(
-        rt,
+        rt, thread_pool,
         [this, commands]() {
 #ifdef OP_SQLITE_USE_LIBSQL
           auto batchResult = opsqlite_libsql_execute_batch(db, &commands);
@@ -432,7 +437,7 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
     return {};
   });
 
-  function_map["setReservedBytes"] =HFN(this) {
+  function_map["setReservedBytes"] = HFN(this) {
     auto reserved_bytes = static_cast<int32_t>(args[0].asNumber());
     opsqlite_libsql_set_reserved_bytes(db, reserved_bytes);
     return {};
@@ -451,7 +456,8 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
     const std::string sqlFileName = args[0].asString(rt).utf8(rt);
 
     return promisify(
-        rt, [this, sqlFileName]() { return import_sql_file(db, sqlFileName); },
+        rt, thread_pool,
+        [this, sqlFileName]() { return import_sql_file(db, sqlFileName); },
         [](jsi::Runtime &rt, std::any prev) {
           auto result = std::any_cast<BatchResult>(prev);
           auto res = jsi::Object(rt);
@@ -583,7 +589,8 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
     sqlite3_stmt *statement = opsqlite_prepare_statement(db, query);
 #endif
     auto preparedStatementHostObject =
-        std::make_shared<PreparedStatementHostObject>(db, statement);
+        std::make_shared<PreparedStatementHostObject>(db, statement,
+                                                      thread_pool);
 
     return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
   });
@@ -621,7 +628,7 @@ void DBHostObject::create_jsi_functions(jsi::Runtime &rt) {
         flush_pending_reactive_queries(resolve);
       };
 
-      _thread_pool->queueWork(task);
+      thread_pool->queueWork(task);
 
       return {};
     }));
@@ -664,7 +671,7 @@ void DBHostObject::invalidate() {
   }
 
   invalidated = true;
-  _thread_pool->restartPool();
+  thread_pool->restartPool();
 #ifdef OP_SQLITE_USE_LIBSQL
   opsqlite_libsql_close(db);
 #else

diff --git a/cpp/DBHostObject.h b/cpp/DBHostObject.h
@@ -78,7 +78,7 @@ class JSI_EXPORT DBHostObject : public jsi::HostObject {
 
   std::unordered_map<std::string, jsi::Value> function_map;
   std::string base_path;
-  std::shared_ptr<ThreadPool> _thread_pool;
+  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;

diff --git a/cpp/PreparedStatementHostObject.cpp b/cpp/PreparedStatementHostObject.cpp
@@ -32,7 +32,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
       std::vector<JSVariant> params = to_variant_vec(rt, js_params);
 
       return promisify(
-          rt,
+          rt, _thread_pool,
           [this, params]() {
 #ifdef OP_SQLITE_USE_LIBSQL
             opsqlite_libsql_bind_statement(_stmt, &params);
@@ -77,7 +77,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
       }
 
       return promisify(
-          rt,
+          rt, _thread_pool,
           [this]() {
             std::vector<DumbHostObject> results;
             auto metadata = std::make_shared<std::vector<SmartHostObject>>();

diff --git a/cpp/PreparedStatementHostObject.h b/cpp/PreparedStatementHostObject.h
@@ -24,20 +24,23 @@ namespace react = facebook::react;
 class PreparedStatementHostObject : public jsi::HostObject {
 public:
 #ifdef OP_SQLITE_USE_LIBSQL
-  PreparedStatementHostObject(
-      DB const &db, libsql_stmt_t stmt)
-      : _db(db), _stmt(stmt) {};
+  PreparedStatementHostObject(DB const &db, libsql_stmt_t stmt,
+                              std::shared_ptr<ThreadPool> thread_pool)
+      : _db(db), _stmt(stmt), _thread_pool(thread_pool) {};
 #else
-  PreparedStatementHostObject(sqlite3 *db, sqlite3_stmt *stmt)
-      : _db(db), _stmt(stmt) {};
+  PreparedStatementHostObject(sqlite3 *db, sqlite3_stmt *stmt,
+                              std::shared_ptr<ThreadPool> thread_pool)
+      : _db(db), _stmt(stmt), _thread_pool(thread_pool) {};
 #endif
+
   ~PreparedStatementHostObject() override;
 
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
 
 private:
+  std::shared_ptr<ThreadPool> _thread_pool;
 #ifdef OP_SQLITE_USE_LIBSQL
   DB _db;
   libsql_stmt_t _stmt;

diff --git a/cpp/utils.cpp b/cpp/utils.cpp
@@ -5,18 +5,16 @@
 #include "bridge.h"
 #endif
 #include "OPThreadPool.h"
+#include "macros.hpp"
 #include <fstream>
 #include <sys/stat.h>
 #include <utility>
-#include "macros.hpp"
 
 namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
-auto __thread_pool = std::make_shared<ThreadPool>();
-
 inline jsi::Value to_jsi(jsi::Runtime &rt, const JSVariant &value) {
   if (std::holds_alternative<bool>(value)) {
     return std::get<bool>(value);
@@ -324,17 +322,20 @@ void log_to_console(jsi::Runtime &runtime, const std::string &message) {
 }
 
 jsi::Value
-promisify(jsi::Runtime &rt, std::function<std::any()> lambda,
+promisify(jsi::Runtime &rt, std::shared_ptr<ThreadPool> thread_pool,
+          std::function<std::any()> lambda,
           std::function<jsi::Value(jsi::Runtime &rt, std::any result)>
               resolve_callback) {
   auto promise_constructor = rt.global().getPropertyAsFunction(rt, "Promise");
 
-  auto executor = HFN2(lambda = std::move(lambda),
-                       resolve_callback = std::move(resolve_callback)) {
+  auto executor =
+      HFN3(lambda = std::move(lambda),
+           resolve_callback = std::move(resolve_callback), thread_pool) {
     auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
     auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
-    auto task = [lambda = lambda, resolve_callback = resolve_callback,
+    auto task = [lambda = lambda, thread_pool,
+                 resolve_callback = resolve_callback,
                  resolve = std::move(resolve), reject = std::move(reject)]() {
       try {
         std::any result = lambda();
@@ -374,7 +375,7 @@ promisify(jsi::Runtime &rt, std::function<std::any()> lambda,
       }
     };
 
-    __thread_pool->queueWork(task);
+    thread_pool->queueWork(task);
 
     return jsi::Value(nullptr);
   });

diff --git a/cpp/utils.hpp b/cpp/utils.hpp
@@ -12,6 +12,7 @@
 #include <ReactCommon/CallInvoker.h>
 #include <string>
 #include <vector>
+#include "OPThreadPool.h"
 
 namespace opsqlite {
 
@@ -51,7 +52,7 @@ bool file_exists(const std::string &path);
 void log_to_console(jsi::Runtime &rt, const std::string &message);
 
 jsi::Value
-promisify(jsi::Runtime &rt, std::function<std::any()> lambda,
+promisify(jsi::Runtime &rt, std::shared_ptr<ThreadPool> thread_pool, std::function<std::any()> lambda,
           std::function<jsi::Value(jsi::Runtime &rt, std::any result)>
               resolve_callback);
 

diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
@@ -2027,7 +2027,7 @@ EXTERNAL SOURCES:
 SPEC CHECKSUMS:
   FBLazyVector: 2e5b5553df729e080483373db6f045201ff4e6db
   hermes-engine: 273e30e7fb618279934b0b95ffab60ecedb7acf5
-  op-sqlite: 44765a0bf429dbb8cc5e301b81114faa080df893
+  op-sqlite: 4651f571998e9739cd4fe16f033bd8a159279da6
   OpServer: 9b3ebdeeb095950e760e3c39853cd06849421b35
   RCTDeprecation: c6b36da89aa26090c8684d29c2868dcca2cd4554
   RCTRequired: 1413a0844770d00fa1f1bb2da4680adfa8698065

diff --git a/op-sqlite.podspec b/op-sqlite.podspec
@@ -147,7 +147,7 @@ Pod::Spec.new do |s|
   end
 
   other_cflags = '$(inherited) -DSQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION=1 -DHAVE_USLEEP=1 -DSQLITE_ENABLE_LOCKING_STYLE=0'
-  optimizedCflags = ' -DSQLITE_DQS=0 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1 -DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1 -DSQLITE_MAX_EXPR_DEPTH=0 -DSQLITE_OMIT_DEPRECATED=1 -DSQLITE_OMIT_PROGRESS_CALLBACK=1 -DSQLITE_OMIT_SHARED_CACHE=1 -DSQLITE_USE_ALLOCA=1 -DSQLITE_STRICT_SUBTYPE=1'
+  optimizedCflags = ' -DSQLITE_DQS=0 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1 -DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1 -DSQLITE_MAX_EXPR_DEPTH=0 -DSQLITE_OMIT_DEPRECATED=1 -DSQLITE_OMIT_PROGRESS_CALLBACK=1 -DSQLITE_OMIT_SHARED_CACHE=1 -DSQLITE_USE_ALLOCA=1 -DSQLITE_STRICT_SUBTYPE=1 -DSQLITE_THREADSAFE=2'
   frameworks = []
 
   if fts5 then