@op-engineering/op-sqlite 7.4.0 → 8.0.0-beta0

package/README.md

@@ -1,13 +1,21 @@
 ![benchmark](benchmark.png)
 
-**Current SQLite version: 3.45.1**
-
 Created by [@ospfranco](https://twitter.com/ospfranco). **Please consider sponsoring!**.
 
-# Docs
+OP-SQLite has grown large to cover a lot of plugins, sqlite versions and APIs. Please read the full documentation before opening an issue.
 
 [See the docs](https://ospfranco.notion.site/OP-SQLite-Documentation-a279a52102464d0cb13c3fa230d2f2dc?pvs=4)
 
+Some of the big and external (back-ends, out-of-tree features, plugins) supported features:
+
+- Vanilla sqlite ofc
+- Libsql is supported as a sqlite backend
+- SQLCipher is supported as a sqlite backend
+- FTS5 plugin
+- cr-sqlite plugin
+- sqlite-vec plugin
+- Reactive queries (currently with some issues, please donate)
+
 # License
 
 MIT License.

package/android/build.gradle

@@ -225,4 +225,12 @@ tasks.whenTaskAdded { task ->
       task.dependsOn(it)
     }
   }
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "opsqlite"
+    codegenJavaPackageName = "com.op.sqlite.example"
+  }
 }

package/cpp/DBHostObject.cpp

@@ -39,7 +39,7 @@ void DBHostObject::auto_register_update_hook() {
       if (operation != "DELETE") {
         std::string query = "SELECT * FROM " + table_name +
                             " where rowid = " + std::to_string(rowId) + ";";
-        opsqlite_execute(name, query, &params, &results, metadata);
+        opsqlite_execute_host_objects(name, query, &params, &results, metadata);
       }
 
       jsCallInvoker->invokeAsync(
@@ -57,7 +57,7 @@ void DBHostObject::auto_register_update_hook() {
               res.setProperty(
                   rt, "row",
                   jsi::Object::createFromHostObject(
-                      rt, std::make_shared<DumbHostObject>(results->at(0))));
+                      rt, std::make_shared<HostObject>(results->at(0))));
             }
 
             callback->asObject(rt).asFunction(rt).call(rt, res);
@@ -177,8 +177,8 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       thread_pool(thread_pool), db_name(db_name), rt(rt) {
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
-  BridgeResult result =
-      opsqlite_open(db_name, path, crsqlite_path, sqlite_vec_path, encryption_key);
+  BridgeResult result = opsqlite_open(db_name, path, crsqlite_path,
+                                      sqlite_vec_path, encryption_key);
 #elif OP_SQLITE_USE_LIBSQL
   BridgeResult result = opsqlite_libsql_open(db_name, path, crsqlite_path);
 #else
@@ -194,7 +194,7 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 };
 
 void DBHostObject::create_jsi_functions() {
-  auto attach = HOSTFN("attach", 4) {
+  auto attach = HOSTFN("attach") {
     if (count < 3) {
       throw jsi::JSError(rt,
                          "[op-sqlite][attach] Incorrect number of arguments");
@@ -232,7 +232,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto detach = HOSTFN("detach", 2) {
+  auto detach = HOSTFN("detach") {
     if (count < 2) {
       throw std::runtime_error(
           "[op-sqlite][detach] Incorrect number of arguments");
@@ -258,7 +258,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto close = HOSTFN("close", 0) {
+  auto close = HOSTFN("close") {
 #ifdef OP_SQLITE_USE_LIBSQL
     BridgeResult result = opsqlite_libsql_close(db_name);
 #else
@@ -272,8 +272,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto remove = HOSTFN("delete", 1) {
-
+  auto remove = HOSTFN("delete") {
     std::string path = std::string(base_path);
 
     if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
@@ -308,7 +307,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto execute = HOSTFN("execute", 2) {
+  auto execute_raw = HOSTFN("executeRaw") {
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
@@ -317,59 +316,86 @@ void DBHostObject::create_jsi_functions() {
       params = to_variant_vec(rt, originalParams);
     }
 
-    std::vector<DumbHostObject> results;
-    std::shared_ptr<std::vector<SmartHostObject>> metadata =
-        std::make_shared<std::vector<SmartHostObject>>();
+    auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
+      auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+      auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+
+      auto task = [&rt, this, query, params = std::move(params), resolve,
+                   reject, invoker = this->jsCallInvoker]() {
+        try {
+          std::vector<std::vector<JSVariant>> results;
 
 #ifdef OP_SQLITE_USE_LIBSQL
-    auto status =
-        opsqlite_libsql_execute(db_name, query, &params, &results, metadata);
+          auto status =
+              opsqlite_libsql_execute_raw(db_name, query, &params, &results);
 #else
-    auto status = opsqlite_execute(db_name, query, &params, &results, metadata);
+          auto status = opsqlite_execute_raw(db_name, query, &params, &results);
 #endif
 
-    if (status.type == SQLiteError) {
-      throw std::runtime_error(status.message);
-    }
+          invoker->invokeAsync([&rt, results = std::move(results),
+                                status = std::move(status), resolve, reject] {
+            if (status.type == SQLiteOk) {
+              auto jsiResult = create_raw_result(rt, status, &results);
+              resolve->asObject(rt).asFunction(rt).call(rt,
+                                                        std::move(jsiResult));
+            } else {
+              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+              auto error = errorCtr.callAsConstructor(
+                  rt, jsi::String::createFromUtf8(rt, status.message));
+              reject->asObject(rt).asFunction(rt).call(rt, error);
+            }
+          });
+
+        } catch (std::exception &exc) {
+          invoker->invokeAsync([&rt, exc = std::move(exc), reject] {
+            auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+            auto error = errorCtr.callAsConstructor(
+                rt, jsi::String::createFromAscii(rt, exc.what()));
+            reject->asObject(rt).asFunction(rt).call(rt, error);
+          });
+        }
+      };
+
+      thread_pool->queueWork(task);
 
-    auto jsiResult = createResult(rt, status, &results, metadata);
-    return jsiResult;
+      return {};
+     }));
+
+    return promise;
   });
 
-  auto execute_raw_async = HOSTFN("executeRawAsync", 2) {
+  auto execute = HOSTFN("execute") {
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
     if (count == 2) {
-      const jsi::Value &originalParams = args[1];
-      params = to_variant_vec(rt, originalParams);
+      params = to_variant_vec(rt, args[1]);
     }
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
       auto task = [&rt, this, query, params = std::move(params), resolve,
                    reject, invoker = this->jsCallInvoker]() {
         try {
-          std::vector<std::vector<JSVariant>> results;
 
 #ifdef OP_SQLITE_USE_LIBSQL
-          auto status =
-              opsqlite_libsql_execute_raw(db_name, query, &params, &results);
+          auto status = opsqlite_libsql_execute(db_name, query, &params);
 #else
-          auto status = opsqlite_execute_raw(db_name, query, &params, &results);
+          auto status = opsqlite_execute(db_name, query, &params);
 #endif
-          //
+
           //            if (invalidated) {
           //              return;
           //            }
 
-          invoker->invokeAsync([&rt, results = std::move(results),
-                                status = std::move(status), resolve, reject] {
+          invoker->invokeAsync([&rt, status = std::move(status), resolve,
+                                reject] {
             if (status.type == SQLiteOk) {
-              auto jsiResult = create_raw_result(rt, status, &results);
+              auto jsiResult = create_js_rows(rt, status);
               resolve->asObject(rt).asFunction(rt).call(rt,
                                                         std::move(jsiResult));
             } else {
@@ -381,8 +407,11 @@ void DBHostObject::create_jsi_functions() {
           });
 
         } catch (std::exception &exc) {
+          std::cout << "Exception executing function" << exc.what()
+                    << std::endl;
           invoker->invokeAsync([&rt, exc = std::move(exc), reject] {
             auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+            auto what = exc.what();
             auto error = errorCtr.callAsConstructor(
                 rt, jsi::String::createFromAscii(rt, exc.what()));
             reject->asObject(rt).asFunction(rt).call(rt, error);
@@ -393,12 +422,12 @@ void DBHostObject::create_jsi_functions() {
       thread_pool->queueWork(task);
 
       return {};
-     }));
+        }));
 
-    return promise;
+        return promise;
   });
 
-  auto execute_async = HOSTFN("executeAsync", 2) {
+  auto execute_with_host_objects = HOSTFN("executeWithHostObjects") {
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
@@ -408,7 +437,7 @@ void DBHostObject::create_jsi_functions() {
     }
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
@@ -419,11 +448,11 @@ void DBHostObject::create_jsi_functions() {
           std::shared_ptr<std::vector<SmartHostObject>> metadata =
               std::make_shared<std::vector<SmartHostObject>>();
 #ifdef OP_SQLITE_USE_LIBSQL
-          auto status = opsqlite_libsql_execute(db_name, query, &params,
-                                                &results, metadata);
+          auto status = opsqlite_libsql_execute_with_host_objects(
+              db_name, query, &params, &results, metadata);
 #else
-          auto status =
-              opsqlite_execute(db_name, query, &params, &results, metadata);
+          auto status = opsqlite_execute_host_objects(db_name, query, &params,
+                                                      &results, metadata);
 #endif
 
           //            if (invalidated) {
@@ -466,36 +495,7 @@ void DBHostObject::create_jsi_functions() {
     return promise;
   });
 
-  auto execute_batch = HOSTFN("executeBatch", 1) {
-    if (sizeof(args) < 1) {
-      throw std::runtime_error(
-          "[op-sqlite][executeBatch] - Incorrect parameter count");
-    }
-
-    const jsi::Value &params = args[0];
-    if (params.isNull() || params.isUndefined()) {
-      throw std::runtime_error("[op-sqlite][executeBatch] - An array of SQL "
-                               "commands or parameters is needed");
-    }
-    const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
-    std::vector<BatchArguments> commands;
-    to_batch_arguments(rt, batchParams, &commands);
-
-#ifdef OP_SQLITE_USE_LIBSQL
-    auto batchResult = opsqlite_libsql_execute_batch(db_name, &commands);
-#else
-    auto batchResult = opsqlite_execute_batch(db_name, &commands);
-#endif
-    if (batchResult.type == SQLiteOk) {
-      auto res = jsi::Object(rt);
-      res.setProperty(rt, "rowsAffected", jsi::Value(batchResult.affectedRows));
-      return std::move(res);
-    } else {
-      throw std::runtime_error(batchResult.message);
-    }
-  });
-
-  auto execute_batch_async = HOSTFN("executeBatchAsync", 1) {
+  auto execute_batch = HOSTFN("executeBatch") {
     if (sizeof(args) < 1) {
       throw std::runtime_error(
           "[op-sqlite][executeAsyncBatch] Incorrect parameter count");
@@ -517,7 +517,7 @@ void DBHostObject::create_jsi_functions() {
     to_batch_arguments(rt, batchParams, &commands);
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-     auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+     auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
@@ -560,17 +560,15 @@ void DBHostObject::create_jsi_functions() {
   });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  auto sync = HOSTFN("sync", 0) {
+  auto sync = HOSTFN("sync") {
     BridgeResult result = opsqlite_libsql_sync(db_name);
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
     }
     return {};
   });
-#endif
-
-#ifndef OP_SQLITE_USE_LIBSQL
-  auto load_file = HOSTFN("loadFile", 1) {
+#else
+  auto load_file = HOSTFN("loadFile") {
     if (sizeof(args) < 1) {
       throw std::runtime_error(
           "[op-sqlite][loadFile] Incorrect parameter count");
@@ -580,17 +578,17 @@ void DBHostObject::create_jsi_functions() {
     const std::string sqlFileName = args[0].asString(rt).utf8(rt);
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2)
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor")
         {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
       auto task = [&rt, this, sqlFileName, resolve, reject]() {
         try {
-          const auto importResult = importSQLFile(db_name, sqlFileName);
+          const auto result = importSQLFile(db_name, sqlFileName);
 
-          jsCallInvoker->invokeAsync([&rt, result = std::move(importResult),
-                                      resolve, reject] {
+          jsCallInvoker->invokeAsync([&rt, result = std::move(result), resolve,
+                                      reject] {
             if (result.type == SQLiteOk) {
               auto res = jsi::Object(rt);
               res.setProperty(rt, "rowsAffected",
@@ -616,7 +614,7 @@ void DBHostObject::create_jsi_functions() {
         return promise;
   });
 
-  auto update_hook = HOSTFN("updateHook", 1) {
+  auto update_hook = HOSTFN("updateHook") {
     auto callback = std::make_shared<jsi::Value>(rt, args[0]);
 
     if (callback->isUndefined() || callback->isNull()) {
@@ -628,7 +626,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto commit_hook = HOSTFN("commitHook", 1) {
+  auto commit_hook = HOSTFN("commitHook") {
     if (sizeof(args) < 1) {
       throw std::runtime_error("[op-sqlite][commitHook] callback needed");
       return {};
@@ -651,7 +649,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto rollback_hook = HOSTFN("rollbackHook", 1) {
+  auto rollback_hook = HOSTFN("rollbackHook") {
     if (sizeof(args) < 1) {
       throw std::runtime_error("[op-sqlite][rollbackHook] callback needed");
       return {};
@@ -674,7 +672,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto load_extension = HOSTFN("loadExtension", 1) {
+  auto load_extension = HOSTFN("loadExtension") {
     auto path = args[0].asString(rt).utf8(rt);
     std::string entry_point = "";
     if (count > 1 && args[1].isString()) {
@@ -688,7 +686,7 @@ void DBHostObject::create_jsi_functions() {
     return {};
   });
 
-  auto reactive_execute = HOSTFN("reactiveExecute", 0) {
+  auto reactive_execute = HOSTFN("reactiveExecute") {
     auto query = args[0].asObject(rt);
     // if (!query.hasProperty(rt, "query") || !query.hasProperty(rt, "args")
     // ||
@@ -748,7 +746,7 @@ void DBHostObject::create_jsi_functions() {
 
     auto_register_update_hook();
 
-    auto unsubscribe = HOSTFN("unsubscribe", 0) {
+    auto unsubscribe = HOSTFN("unsubscribe") {
       auto it = std::find(reactive_queries.begin(), reactive_queries.end(),
                           reactiveQuery);
       if (it != reactive_queries.end()) {
@@ -763,7 +761,7 @@ void DBHostObject::create_jsi_functions() {
 
 #endif
 
-  auto prepare_statement = HOSTFN("prepareStatement", 1) {
+  auto prepare_statement = HOSTFN("prepareStatement") {
     auto query = args[0].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
     libsql_stmt_t statement = opsqlite_libsql_prepare_statement(db_name, query);
@@ -771,12 +769,13 @@ void DBHostObject::create_jsi_functions() {
     sqlite3_stmt *statement = opsqlite_prepare_statement(db_name, query);
 #endif
     auto preparedStatementHostObject =
-        std::make_shared<PreparedStatementHostObject>(db_name, statement);
+        std::make_shared<PreparedStatementHostObject>(
+            db_name, statement, jsCallInvoker, thread_pool);
 
     return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
   });
 
-  auto get_db_path = HOSTFN("getDbPath", 1) {
+  auto get_db_path = HOSTFN("getDbPath") {
     std::string path = std::string(base_path);
     if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
       if (!args[0].isString()) {
@@ -802,12 +801,11 @@ void DBHostObject::create_jsi_functions() {
   function_map["attach"] = std::move(attach);
   function_map["detach"] = std::move(detach);
   function_map["close"] = std::move(close);
-  function_map["executeRawAsync"] = std::move(execute_raw_async);
   function_map["execute"] = std::move(execute);
-  function_map["executeAsync"] = std::move(execute_async);
+  function_map["executeRaw"] = std::move(execute_raw);
+  function_map["executeWithHostObjects"] = std::move(execute_with_host_objects);
   function_map["delete"] = std::move(remove);
   function_map["executeBatch"] = std::move(execute_batch);
-  function_map["executeBatchAsync"] = std::move(execute_batch_async);
   function_map["prepareStatement"] = std::move(prepare_statement);
   function_map["getDbPath"] = std::move(get_db_path);
 #ifdef OP_SQLITE_USE_LIBSQL
@@ -841,14 +839,14 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "close") {
     return jsi::Value(rt, function_map["close"]);
   }
-  if (name == "executeRawAsync") {
-    return jsi::Value(rt, function_map["executeRawAsync"]);
+  if (name == "executeRaw") {
+    return jsi::Value(rt, function_map["executeRaw"]);
   }
   if (name == "execute") {
     return jsi::Value(rt, function_map["execute"]);
   }
-  if (name == "executeAsync") {
-    return jsi::Value(rt, function_map["executeAsync"]);
+  if (name == "executeWithHostObjects") {
+    return jsi::Value(rt, function_map["executeWithHostObjects"]);
   }
   if (name == "delete") {
     return jsi::Value(rt, function_map["delete"]);
@@ -856,9 +854,6 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "executeBatch") {
     return jsi::Value(rt, function_map["executeBatch"]);
   }
-  if (name == "executeBatchAsync") {
-    return jsi::Value(rt, function_map["executeBatchAsync"]);
-  }
   if (name == "prepareStatement") {
     return jsi::Value(rt, function_map["prepareStatement"]);
   }
@@ -870,32 +865,32 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   }
 #ifdef OP_SQLITE_USE_LIBSQL
   if (name == "loadFile") {
-    return HOSTFN("loadFile", 0) {
+    return HOSTFN("loadFile") {
       throw std::runtime_error("[op-sqlite] Load file not implemented");
     });
   }
   if (name == "updateHook") {
-    return HOSTFN("updateHook", 0) {
+    return HOSTFN("updateHook") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "commitHook") {
-    return HOSTFN("commitHook", 0) {
+    return HOSTFN("commitHook") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "rollbackHook") {
-    return HOSTFN("rollbackHook", 0) {
+    return HOSTFN("rollbackHook") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "loadExtension") {
-    return HOSTFN("loadExtension", 0) {
+    return HOSTFN("loadExtension") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }
   if (name == "reactiveExecute") {
-    return HOSTFN("reactiveExecute", 0) {
+    return HOSTFN("reactiveExecute") {
       throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
     });
   }

package/cpp/PreparedStatementHostObject.cpp

@@ -23,7 +23,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
   auto name = propNameID.utf8(rt);
 
   if (name == "bind") {
-    return HOSTFN("bind", 1) {
+    return HOSTFN("bind") {
       if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
@@ -41,28 +41,53 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
   }
 
   if (name == "execute") {
-    return HOSTFN("execute", 1) {
+    return HOSTFN("execute") {
       if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
 
-      std::vector<DumbHostObject> results;
-      std::shared_ptr<std::vector<SmartHostObject>> metadata =
-          std::make_shared<std::vector<SmartHostObject>>();
+      auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
+        auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+        auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+
+        auto task = [&rt, this, resolve, reject,
+                     invoker = this->_js_call_invoker]() {
+          std::vector<DumbHostObject> results;
+          std::shared_ptr<std::vector<SmartHostObject>> metadata =
+              std::make_shared<std::vector<SmartHostObject>>();
 #ifdef OP_SQLITE_USE_LIBSQL
-      auto status = opsqlite_libsql_execute_prepared_statement(
-          _name, _stmt, &results, metadata);
+          auto status = opsqlite_libsql_execute_prepared_statement(
+              _name, _stmt, &results, metadata);
 #else
-      auto status =
-          opsqlite_execute_prepared_statement(_name, _stmt, &results, metadata);
+          auto status = opsqlite_execute_prepared_statement(_name, _stmt,
+                                                            &results, metadata);
 #endif
+          invoker->invokeAsync(
+              [&rt, status = std::move(status),
+               results = std::make_shared<std::vector<DumbHostObject>>(results),
+               metadata, resolve, reject] {
+                if (status.type == SQLiteOk) {
+                  auto jsiResult =
+                      createResult(rt, status, results.get(), metadata);
+                  resolve->asObject(rt).asFunction(rt).call(
+                      rt, std::move(jsiResult));
+                } else {
+                  auto errorCtr =
+                      rt.global().getPropertyAsFunction(rt, "Error");
+                  auto error = errorCtr.callAsConstructor(
+                      rt, jsi::String::createFromUtf8(rt, status.message));
+                  reject->asObject(rt).asFunction(rt).call(rt, error);
+                }
+              });
+        };
 
-      if (status.type == SQLiteError) {
-        throw std::runtime_error(status.message);
-      }
+        _thread_pool->queueWork(task);
+
+        return {};
+          }));
 
-      auto jsiResult = createResult(rt, status, &results, metadata);
-      return jsiResult;
+        return promise;
     });
   }
 

package/cpp/PreparedStatementHostObject.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <memory>
 #ifdef OP_SQLITE_USE_LIBSQL
@@ -7,19 +8,29 @@
 #else
 #include <sqlite3.h>
 #endif
+#include "ThreadPool.h"
 #include <string>
 
 namespace opsqlite {
 namespace jsi = facebook::jsi;
+namespace react = facebook::react;
 
 class PreparedStatementHostObject : public jsi::HostObject {
 public:
 #ifdef OP_SQLITE_USE_LIBSQL
-  PreparedStatementHostObject(std::string name, libsql_stmt_t stmt)
-      : _name(name), _stmt(stmt){};
+  PreparedStatementHostObject(
+      std::string name, libsql_stmt_t stmt,
+      std::shared_ptr<react::CallInvoker> js_call_invoker,
+      std::shared_ptr<ThreadPool> thread_pool)
+      : _name(name), _stmt(stmt), _js_call_invoker(js_call_invoker),
+        _thread_pool(thread_pool){};
 #else
-  PreparedStatementHostObject(std::string name, sqlite3_stmt *stmt)
-      : _name(name), _stmt(stmt){};
+  PreparedStatementHostObject(
+      std::string name, sqlite3_stmt *stmt,
+      std::shared_ptr<react::CallInvoker> js_call_invoker,
+      std::shared_ptr<ThreadPool> thread_pool)
+      : _name(name), _stmt(stmt), _js_call_invoker(js_call_invoker),
+        _thread_pool(thread_pool){};
 #endif
   virtual ~PreparedStatementHostObject();
 
@@ -28,6 +39,8 @@ public:
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
 private:
+  std::shared_ptr<react::CallInvoker> _js_call_invoker;
+  std::shared_ptr<ThreadPool> _thread_pool;
   std::string _name;
 #ifdef OP_SQLITE_USE_LIBSQL
   libsql_stmt_t _stmt;