@op-engineering/op-sqlite 15.0.7 → 15.1.1

package/cpp/DBHostObject.cpp

@@ -1,13 +1,13 @@
 #include "DBHostObject.h"
 #include "PreparedStatementHostObject.h"
 #if OP_SQLITE_USE_LIBSQL
-#include "libsql/bridge.h"
+#include "libsql/bridge.hpp"
 #else
 #include "bridge.h"
 #endif
 #include "logs.h"
-#include "macros.h"
-#include "utils.h"
+#include "macros.hpp"
+#include "utils.hpp"
 #include <iostream>
 #include <utility>
 
@@ -19,125 +19,117 @@ namespace react = facebook::react;
 #ifdef OP_SQLITE_USE_LIBSQL
 void DBHostObject::flush_pending_reactive_queries(
     const std::shared_ptr<jsi::Value> &resolve) {
-    invoker->invokeAsync([this, resolve]() {
-        resolve->asObject(rt).asFunction(rt).call(rt, {});
-    });
+  invoker->invokeAsync(
+      [this, resolve]() { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
 }
 #else
 void DBHostObject::flush_pending_reactive_queries(
     const std::shared_ptr<jsi::Value> &resolve) {
-    for (const auto &query_ptr : pending_reactive_queries) {
-        auto query = query_ptr.get();
-
-        std::vector<DumbHostObject> results;
-        std::shared_ptr<std::vector<SmartHostObject>> metadata =
-            std::make_shared<std::vector<SmartHostObject>>();
-
-        auto status = opsqlite_execute_prepared_statement(db, query->stmt,
-                                                          &results, metadata);
-
-        invoker->invokeAsync(
-            [this,
-             results = std::make_shared<std::vector<DumbHostObject>>(results),
-             callback = query->callback, metadata, status = std::move(status)] {
-                auto jsiResult =
-                    create_result(rt, status, results.get(), metadata);
-                callback->asObject(rt).asFunction(rt).call(rt, jsiResult);
-            });
-    }
+  for (const auto &query_ptr : pending_reactive_queries) {
+    auto query = query_ptr.get();
 
-    pending_reactive_queries.clear();
+    std::vector<DumbHostObject> results;
+    std::shared_ptr<std::vector<SmartHostObject>> metadata =
+        std::make_shared<std::vector<SmartHostObject>>();
 
-    invoker->invokeAsync([this, resolve]() {
-        resolve->asObject(rt).asFunction(rt).call(rt, {});
-    });
+    auto status = opsqlite_execute_prepared_statement(db, query->stmt, &results,
+                                                      metadata);
+
+    invoker->invokeAsync(
+        [this, results = std::make_shared<std::vector<DumbHostObject>>(results),
+         callback = query->callback, metadata, status = std::move(status)] {
+          auto jsiResult = create_result(rt, status, results.get(), metadata);
+          callback->asObject(rt).asFunction(rt).call(rt, jsiResult);
+        });
+  }
+
+  pending_reactive_queries.clear();
+
+  invoker->invokeAsync(
+      [this, resolve]() { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
 }
 
 void DBHostObject::on_commit() {
-    invoker->invokeAsync(
-        [this] { commit_hook_callback->asObject(rt).asFunction(rt).call(rt); });
+  invoker->invokeAsync(
+      [this] { 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);
-    });
+  invoker->invokeAsync(
+      [this] { 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] {
-                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);
-            });
-    }
+  if (update_hook_callback != nullptr) {
+    invoker->invokeAsync(
+        [this, callback = update_hook_callback, table, operation, row_id] {
+          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) {
-        auto query = query_ptr.get();
+  for (const auto &query_ptr : reactive_queries) {
+    auto query = query_ptr.get();
 
-        // The JS environment might have cleared the query while the update was queued
-        // For now this seems to prevent a EXC_BAD_ACCESS
-        if (query == nullptr) {
-            continue;
-        }
+    // The JS environment might have cleared the query while the update was
+    // queued For now this seems to prevent a EXC_BAD_ACCESS
+    if (query == nullptr) {
+      continue;
+    }
 
-        
-        if (query->discriminators.empty()) {
-            continue;
-        }
+    if (query->discriminators.empty()) {
+      continue;
+    }
 
-        bool shouldFire = false;
-
-        for (const auto &discriminator : query->discriminators) {
-            // Tables don't match then skip
-            if (discriminator.table != table) {
-                continue;
-            }
-
-            // If no ids are specified, then we should fire
-            if (discriminator.ids.empty()) {
-                shouldFire = true;
-                break;
-            }
-
-            // If ids are specified, then we should check if the rowId matches
-            for (const auto &discrimator_id : discriminator.ids) {
-                if (row_id == discrimator_id) {
-                    shouldFire = true;
-                    break;
-                }
-            }
+    bool shouldFire = false;
+
+    for (const auto &discriminator : query->discriminators) {
+      // Tables don't match then skip
+      if (discriminator.table != table) {
+        continue;
+      }
+
+      // If no ids are specified, then we should fire
+      if (discriminator.ids.empty()) {
+        shouldFire = true;
+        break;
+      }
+
+      // If ids are specified, then we should check if the rowId matches
+      for (const auto &discrimator_id : discriminator.ids) {
+        if (row_id == discrimator_id) {
+          shouldFire = true;
+          break;
         }
+      }
+    }
 
-        if (shouldFire) {
-            pending_reactive_queries.insert(query_ptr);
-        }
+    if (shouldFire) {
+      pending_reactive_queries.insert(query_ptr);
     }
+  }
 }
 
 void DBHostObject::auto_register_update_hook() {
-    if (update_hook_callback == nullptr && reactive_queries.empty() &&
-        is_update_hook_registered) {
-        opsqlite_deregister_update_hook(db);
-        is_update_hook_registered = false;
-        return;
-    }
-
-    if (is_update_hook_registered) {
-        return;
-    }
-
-    opsqlite_register_update_hook(db, this);
-    is_update_hook_registered = true;
+  if (update_hook_callback == nullptr && reactive_queries.empty() &&
+      is_update_hook_registered) {
+    opsqlite_deregister_update_hook(db);
+    is_update_hook_registered = false;
+    return;
+  }
+
+  if (is_update_hook_registered) {
+    return;
+  }
+
+  opsqlite_register_update_hook(db, this);
+  is_update_hook_registered = true;
 }
 #endif
 
@@ -153,10 +145,10 @@ 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) {
-    _thread_pool = std::make_shared<ThreadPool>();
-    db = opsqlite_libsql_open_remote(url, auth_token);
+  _thread_pool = std::make_shared<ThreadPool>();
+  db = opsqlite_libsql_open_remote(url, auth_token);
 
-    create_jsi_functions();
+  create_jsi_functions();
 }
 
 // Sync connection constructor
@@ -169,13 +161,13 @@ DBHostObject::DBHostObject(jsi::Runtime &rt,
                            std::string &remote_encryption_key)
     : db_name(db_name), invoker(std::move(invoker)), rt(rt) {
 
-    _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, offline, encryption_key,
-                                   remote_encryption_key);
+  db =
+      opsqlite_libsql_open_sync(db_name, path, url, auth_token, sync_interval,
+                                offline, encryption_key, remote_encryption_key);
 
-    create_jsi_functions();
+  create_jsi_functions();
 }
 
 #endif
@@ -188,704 +180,504 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
                            std::string &encryption_key)
     : base_path(base_path), invoker(std::move(invoker)), db_name(db_name),
       rt(rt) {
-    _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,
-                       encryption_key);
+  db = opsqlite_open(db_name, path, crsqlite_path, sqlite_vec_path,
+                     encryption_key);
 #elif OP_SQLITE_USE_LIBSQL
-    db = opsqlite_libsql_open(db_name, path, crsqlite_path);
+  db = opsqlite_libsql_open(db_name, path, crsqlite_path);
 #else
-    db = opsqlite_open(db_name, path, crsqlite_path, sqlite_vec_path);
+  db = opsqlite_open(db_name, path, crsqlite_path, sqlite_vec_path);
 #endif
-    create_jsi_functions();
+  create_jsi_functions();
 };
 
 void DBHostObject::create_jsi_functions() {
-    function_map["attach"] = HOSTFN("attach") {
-        std::string secondary_db_path = std::string(base_path);
-
-        auto obj_params = args[0].asObject(rt);
-
-        std::string secondary_db_name =
-            obj_params.getProperty(rt, "secondaryDbFileName")
-                .asString(rt)
-                .utf8(rt);
-        std::string alias =
-            obj_params.getProperty(rt, "alias").asString(rt).utf8(rt);
-
-        if (obj_params.hasProperty(rt, "location")) {
-            std::string location =
-                obj_params.getProperty(rt, "location").asString(rt).utf8(rt);
-            secondary_db_path = secondary_db_path + location;
-        }
+  function_map["attach"] = HFN(this) {
+    std::string secondary_db_path = std::string(base_path);
+
+    auto obj_params = args[0].asObject(rt);
+
+    std::string secondary_db_name =
+        obj_params.getProperty(rt, "secondaryDbFileName").asString(rt).utf8(rt);
+    std::string alias =
+        obj_params.getProperty(rt, "alias").asString(rt).utf8(rt);
+
+    if (obj_params.hasProperty(rt, "location")) {
+      std::string location =
+          obj_params.getProperty(rt, "location").asString(rt).utf8(rt);
+      secondary_db_path = secondary_db_path + location;
+    }
 
 #ifdef OP_SQLITE_USE_LIBSQL
-        opsqlite_libsql_attach(db, secondary_db_path, secondary_db_name, alias);
+    opsqlite_libsql_attach(db, secondary_db_path, secondary_db_name, alias);
 #else
-        opsqlite_attach(db, secondary_db_path, secondary_db_name, alias);
+    opsqlite_attach(db, secondary_db_path, secondary_db_name, alias);
 #endif
 
-        return {};
-    });
-
-    function_map["detach"] = HOSTFN("detach") {
+    return {};
+  });
 
-        if (!args[0].isString()) {
-            throw std::runtime_error("[op-sqlite] alias must be a strings");
-        }
+  function_map["detach"] = HFN(this) {
+    if (!args[0].isString()) {
+      throw std::runtime_error("[op-sqlite] alias must be a strings");
+    }
 
-        std::string alias = args[0].asString(rt).utf8(rt);
+    std::string alias = args[0].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
-        opsqlite_libsql_detach(db, alias);
+    opsqlite_libsql_detach(db, alias);
 #else
-        opsqlite_detach(db, alias);
+    opsqlite_detach(db, alias);
 #endif
 
-        return {};
-    });
+    return {};
+  });
 
-    function_map["close"] = HOSTFN("close") {
-        invalidated = true;
+  function_map["close"] = HFN(this) {
+    invalidated = true;
 
 #ifdef OP_SQLITE_USE_LIBSQL
-        opsqlite_libsql_close(db);
+    opsqlite_libsql_close(db);
 #else
-        opsqlite_close(db);
+    opsqlite_close(db);
 #endif
 
-        return {};
-    });
+    return {};
+  });
 
-    function_map["delete"] = HOSTFN("delete") {
-        invalidated = true;
+  function_map["delete"] = HFN(this) {
+    invalidated = true;
 
-        std::string path = std::string(base_path);
+    std::string path = std::string(base_path);
 
-        if (count == 1) {
-            if (!args[1].isString()) {
-                throw std::runtime_error(
-                    "[op-sqlite][open] database location must be a string");
-            }
+    if (count == 1) {
+      if (!args[1].isString()) {
+        throw std::runtime_error(
+            "[op-sqlite][open] database location must be a string");
+      }
 
-            std::string location = args[1].asString(rt).utf8(rt);
+      std::string location = args[1].asString(rt).utf8(rt);
 
-            if (!location.empty()) {
-                if (location == ":memory:") {
-                    path = ":memory:";
-                } else if (location.rfind('/', 0) == 0) {
-                    path = location;
-                } else {
-                    path = path + "/" + location;
-                }
-            }
+      if (!location.empty()) {
+        if (location == ":memory:") {
+          path = ":memory:";
+        } else if (location.rfind('/', 0) == 0) {
+          path = location;
+        } else {
+          path = path + "/" + location;
         }
+      }
+    }
 
 #ifdef OP_SQLITE_USE_LIBSQL
-        opsqlite_libsql_remove(db, db_name, path);
+    opsqlite_libsql_remove(db, db_name, path);
 #else
-        opsqlite_remove(db, db_name, path);
+    opsqlite_remove(db, db_name, path);
 #endif
 
-        return {};
-    });
-
-    function_map["executeRaw"] = HOSTFN("executeRaw") {
-        const std::string query = args[0].asString(rt).utf8(rt);
-        std::vector<JSVariant> params = count == 2 && args[1].isObject()
-                                            ? to_variant_vec(rt, args[1])
-                                            : std::vector<JSVariant>();
+    return {};
+  });
 
-        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 = [this, &rt, query, params, resolve, reject]() {
-                try {
-                    std::vector<std::vector<JSVariant>> results;
+  function_map["executeRaw"] = HFN(this) {
+    const std::string query = args[0].asString(rt).utf8(rt);
+    const std::vector<JSVariant> params = count == 2 && args[1].isObject()
+                                              ? to_variant_vec(rt, args[1])
+                                              : std::vector<JSVariant>();
 
+    return promisify(
+        rt,
+        [this, query, params]() {
+          std::vector<std::vector<JSVariant>> results;
 #ifdef OP_SQLITE_USE_LIBSQL
-                    auto status = opsqlite_libsql_execute_raw(
-                        db, query, &params, &results);
+          auto status =
+              opsqlite_libsql_execute_raw(db, query, &params, &results);
 #else
-                    auto status =
-                        opsqlite_execute_raw(db, query, &params, &results);
+          auto status = opsqlite_execute_raw(db, query, &params, &results);
 #endif
+          return std::make_tuple(status, results);
+        },
+        [](jsi::Runtime &rt, std::any prev) {
+          auto tuple = std::any_cast<
+              std::tuple<BridgeResult, std::vector<std::vector<JSVariant>>>>(
+              prev);
+
+          return create_raw_result(rt, std::get<0>(tuple), &std::get<1>(tuple));
+        });
+  });
 
-                    if (invalidated) {
-                        return;
-                    }
-
-                    invoker->invokeAsync([&rt, results = std::move(results),
-                                          status = std::move(status), resolve,
-                                          reject] {
-                        auto jsiResult =
-                            create_raw_result(rt, status, &results);
-                        resolve->asObject(rt).asFunction(rt).call(
-                            rt, std::move(jsiResult));
-                    });
-                } catch (std::runtime_error &e) {
-                    auto what = e.what();
-                    invoker->invokeAsync([&rt, what, reject] {
-                        auto errorCtr =
-                            rt.global().getPropertyAsFunction(rt, "Error");
-                        auto error = errorCtr.callAsConstructor(
-                            rt, jsi::String::createFromAscii(rt, what));
-                        reject->asObject(rt).asFunction(rt).call(rt, error);
-                    });
-                } catch (std::exception &exc) {
-                    auto what = exc.what();
-                    invoker->invokeAsync([&rt, what, reject] {
-                        auto errorCtr =
-                            rt.global().getPropertyAsFunction(rt, "Error");
-                        auto error = errorCtr.callAsConstructor(
-                            rt, jsi::String::createFromAscii(rt, what));
-                        reject->asObject(rt).asFunction(rt).call(rt, error);
-                    });
-                }
-            };
-
-            _thread_pool->queueWork(task);
-
-            return {};
-     }));
-
-    return promise;
-    });
-
-    function_map["executeSync"] = HOSTFN("executeSync") {
-        std::string query = args[0].asString(rt).utf8(rt);
-        std::vector<JSVariant> params;
+  function_map["executeSync"] = HFN(this) {
+    std::string query = args[0].asString(rt).utf8(rt);
+    std::vector<JSVariant> params;
 
-        if (count == 2) {
-            params = to_variant_vec(rt, args[1]);
-        }
+    if (count == 2) {
+      params = to_variant_vec(rt, args[1]);
+    }
 #ifdef OP_SQLITE_USE_LIBSQL
-        auto status = opsqlite_libsql_execute(db, query, &params);
+    auto status = opsqlite_libsql_execute(db, query, &params);
 #else
-        auto status = opsqlite_execute(db, query, &params);
+    auto status = opsqlite_execute(db, query, &params);
 #endif
 
-        return create_js_rows(rt, status);
-    });
+    return create_js_rows(rt, status);
+  });
 
-    function_map["executeRawSync"] = HOSTFN("executeRawSync") {
-        const std::string query = args[0].asString(rt).utf8(rt);
-        std::vector<JSVariant> params = count == 2 && args[1].isObject()
-                                            ? to_variant_vec(rt, args[1])
-                                            : std::vector<JSVariant>();
+  function_map["executeRawSync"] = HFN(this) {
+    const std::string query = args[0].asString(rt).utf8(rt);
+    std::vector<JSVariant> params = count == 2 && args[1].isObject()
+                                        ? to_variant_vec(rt, args[1])
+                                        : std::vector<JSVariant>();
 
-        std::vector<std::vector<JSVariant>> results;
+    std::vector<std::vector<JSVariant>> results;
 
 #ifdef OP_SQLITE_USE_LIBSQL
-        auto status = opsqlite_libsql_execute_raw(db, query, &params, &results);
+    auto status = opsqlite_libsql_execute_raw(db, query, &params, &results);
 #else
-        auto status = opsqlite_execute_raw(db, query, &params, &results);
+    auto status = opsqlite_execute_raw(db, query, &params, &results);
 #endif
 
-        return create_raw_result(rt, status, &results);
-    });
+    return create_raw_result(rt, status, &results);
+  });
 
-    function_map["execute"] = HOSTFN("execute") {
-        const std::string query = args[0].asString(rt).utf8(rt);
-        std::vector<JSVariant> params = count == 2 && args[1].isObject()
-                                            ? to_variant_vec(rt, args[1])
-                                            : std::vector<JSVariant>();
-
-        auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-            auto promise = promiseCtr.callAsConstructor(rt,
- HOSTFN("executor") {
-            auto task = [this, &rt, query, params,
-                         resolve = std::make_shared<jsi::Value>(rt, args[0]),
-                         reject = std::make_shared<jsi::Value>(rt, args[1])]() {
-                try {
+  function_map["execute"] = HFN(this) {
+    const std::string query = args[0].asString(rt).utf8(rt);
+    std::vector<JSVariant> params = count == 2 && args[1].isObject()
+                                        ? to_variant_vec(rt, args[1])
+                                        : std::vector<JSVariant>();
+
+    return promisify(
+        rt,
+        [this, query, params]() {
 #ifdef OP_SQLITE_USE_LIBSQL
-                    auto status = opsqlite_libsql_execute(db, query, &params);
+          auto status = opsqlite_libsql_execute(db, query, &params);
 #else
-                    auto status = opsqlite_execute(db, query, &params);
+          auto status = opsqlite_execute(db, query, &params);
 #endif
-
-                    if (invalidated) {
-                        return;
-                    }
-
-                    invoker->invokeAsync(
-                        [&rt, status = std::move(status), resolve, reject] {
-                            auto jsiResult = create_js_rows(rt, status);
-                            resolve->asObject(rt).asFunction(rt).call(
-                                rt, std::move(jsiResult));
-                        });
-                    // On Android RN is broken and does not correctly match
-                    // runtime_error to the generic exception We have to
-                    // explicitly catch it
-                    // https://github.com/facebook/react-native/issues/48027
-                } catch (std::runtime_error &e) {
-                    auto what = e.what();
-                    invoker->invokeAsync(
-                        [&rt, what = std::string(what), reject] {
-                            auto errorCtr =
-                                rt.global().getPropertyAsFunction(rt, "Error");
-                            auto error = errorCtr.callAsConstructor(
-                                rt, jsi::String::createFromAscii(rt, what));
-                            reject->asObject(rt).asFunction(rt).call(rt, error);
-                        });
-                } catch (std::exception &exc) {
-                    auto what = exc.what();
-                    invoker->invokeAsync(
-                        [&rt, what = std::string(what), reject] {
-                            auto errorCtr =
-                                rt.global().getPropertyAsFunction(rt, "Error");
-                            auto error = errorCtr.callAsConstructor(
-                                rt, jsi::String::createFromAscii(rt, what));
-                            reject->asObject(rt).asFunction(rt).call(rt, error);
-                        });
-                }
-            };
-
-            _thread_pool->queueWork(task);
-
-            return {};
-    }));
-
-            return promise;
-    });
-
-    function_map["executeWithHostObjects"] = HOSTFN("executeWithHostObjects") {
-        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);
-        }
-
-        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, resolve, reject]() {
-                try {
-                    std::vector<DumbHostObject> results;
-                    std::shared_ptr<std::vector<SmartHostObject>> metadata =
-                        std::make_shared<std::vector<SmartHostObject>>();
+          return status;
+        },
+        [](jsi::Runtime &rt, std::any prev) {
+          auto status = std::any_cast<BridgeResult>(prev);
+          return create_js_rows(rt, status);
+        });
+  });
+
+  function_map["executeWithHostObjects"] = HFN(this) {
+    const std::string query = args[0].asString(rt).utf8(rt);
+    std::vector<JSVariant> params = count == 2 && args[1].isObject()
+                                        ? to_variant_vec(rt, args[1])
+                                        : std::vector<JSVariant>();
+
+    return promisify(
+        rt,
+        [this, query, params]() {
+          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_with_host_objects(
-                        db, query, &params, &results, metadata);
+          auto status = opsqlite_libsql_execute_with_host_objects(
+              db, query, &params, &results, metadata);
 #else
-                    auto status = opsqlite_execute_host_objects(
-                        db, query, &params, &results, metadata);
+          auto status = opsqlite_execute_host_objects(db, query, &params,
+                                                      &results, metadata);
 #endif
+          return std::make_tuple(status, results, metadata);
+        },
+        [](jsi::Runtime &rt, std::any prev) {
+          auto tuple = std::any_cast<
+              std::tuple<BridgeResult, std::vector<DumbHostObject>,
+                         std::shared_ptr<std::vector<SmartHostObject>>>>(prev);
+          auto results =
+              std::make_shared<std::vector<DumbHostObject>>(std::get<1>(tuple));
+          return create_result(rt, std::get<0>(tuple), results.get(),
+                               std::get<2>(tuple));
+        });
+  });
 
-                    if (invalidated) {
-                        return;
-                    }
-
-                    invoker->invokeAsync(
-                        [&rt,
-                         results =
-                             std::make_shared<std::vector<DumbHostObject>>(
-                                 results),
-                         metadata, status = std::move(status), resolve,
-                         reject] {
-                            auto jsiResult = create_result(
-                                rt, status, results.get(), metadata);
-                            resolve->asObject(rt).asFunction(rt).call(
-                                rt, std::move(jsiResult));
-                        });
-                } catch (std::runtime_error &e) {
-                    auto what = e.what();
-                    invoker->invokeAsync(
-                        [&rt, what = std::string(what), reject] {
-                            auto errorCtr =
-                                rt.global().getPropertyAsFunction(rt, "Error");
-                            auto error = errorCtr.callAsConstructor(
-                                rt, jsi::String::createFromAscii(rt, what));
-                            reject->asObject(rt).asFunction(rt).call(rt, error);
-                        });
-                } catch (std::exception &exc) {
-                    auto what = exc.what();
-                    invoker->invokeAsync([&rt, what, reject] {
-                        auto errorCtr =
-                            rt.global().getPropertyAsFunction(rt, "Error");
-                        auto error = errorCtr.callAsConstructor(
-                            rt, jsi::String::createFromAscii(rt, what));
-                        reject->asObject(rt).asFunction(rt).call(rt, error);
-                    });
-                }
-            };
-
-            _thread_pool->queueWork(task);
-
-            return {};
-      }));
-
-    return promise;
-    });
-
-    function_map["executeBatch"] = HOSTFN("executeBatch") {
-        if (count < 1) {
-            throw std::runtime_error(
-                "[op-sqlite][executeAsyncBatch] Incorrect parameter count");
-        }
+  function_map["executeBatch"] = HFN(this) {
+    if (count < 1) {
+      throw std::runtime_error(
+          "[op-sqlite][executeAsyncBatch] Incorrect parameter count");
+    }
 
-        const jsi::Value &params = args[0];
+    const jsi::Value &params = args[0];
 
-        if (params.isNull() || params.isUndefined()) {
-            throw std::runtime_error(
-                "[op-sqlite][executeAsyncBatch] - An array of SQL "
-                "commands or parameters is needed");
-        }
-
-        const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
+    if (params.isNull() || params.isUndefined()) {
+      throw std::runtime_error(
+          "[op-sqlite][executeAsyncBatch] - An array of SQL "
+          "commands or parameters is needed");
+    }
 
-        std::vector<BatchArguments> commands;
-        to_batch_arguments(rt, batchParams, &commands);
+    const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
 
-        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]);
+    std::vector<BatchArguments> commands;
+    to_batch_arguments(rt, batchParams, &commands);
 
-            auto task = [this, &rt, commands, resolve, reject]() {
-                try {
+    return promisify(
+        rt,
+        [this, commands]() {
 #ifdef OP_SQLITE_USE_LIBSQL
-                    auto batchResult =
-                        opsqlite_libsql_execute_batch(db, &commands);
+          auto batchResult = opsqlite_libsql_execute_batch(db, &commands);
 #else
-                    auto batchResult = opsqlite_execute_batch(db, &commands);
+          auto batchResult = opsqlite_execute_batch(db, &commands);
 #endif
-
-                    if (invalidated) {
-                        return;
-                    }
-
-                    invoker->invokeAsync([&rt,
-                                          batchResult = std::move(batchResult),
-                                          resolve] {
-                        auto res = jsi::Object(rt);
-                        res.setProperty(rt, "rowsAffected",
-                                        jsi::Value(batchResult.affectedRows));
-                        resolve->asObject(rt).asFunction(rt).call(
-                            rt, std::move(res));
-                    });
-                } catch (std::runtime_error &e) {
-                    auto what = e.what();
-                    invoker->invokeAsync([&rt, what, reject] {
-                        auto errorCtr =
-                            rt.global().getPropertyAsFunction(rt, "Error");
-                        auto error = errorCtr.callAsConstructor(
-                            rt, jsi::String::createFromAscii(rt, what));
-                        reject->asObject(rt).asFunction(rt).call(rt, error);
-                    });
-                } catch (std::exception &exc) {
-                    auto what = exc.what();
-                    invoker->invokeAsync([&rt, what, reject] {
-                        auto errorCtr =
-                            rt.global().getPropertyAsFunction(rt, "Error");
-                        auto error = errorCtr.callAsConstructor(
-                            rt, jsi::String::createFromAscii(rt, what));
-                        reject->asObject(rt).asFunction(rt).call(rt, error);
-                    });
-                }
-            };
-            _thread_pool->queueWork(task);
-
-            return {};
-    }));
-
-            return promise;
-    });
+          return batchResult;
+        },
+        [](jsi::Runtime &rt, std::any prev) {
+          auto batchResult = std::any_cast<BatchResult>(prev);
+          auto res = jsi::Object(rt);
+          res.setProperty(rt, "rowsAffected",
+                          jsi::Value(batchResult.affectedRows));
+          return res;
+        });
+  });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-    function_map["sync"] = HOSTFN("sync") {
-        opsqlite_libsql_sync(db);
-        return {};
-    });
-
-    function_map["setReservedBytes"] = HOSTFN("setReservedBytes") {
-        int32_t 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["sync"] = HOSTFN("sync") {
+    opsqlite_libsql_sync(db);
+    return {};
+  });
+
+  function_map["setReservedBytes"] = HOSTFN("setReservedBytes") {
+    int32_t 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));
+  });
 #else
-    function_map["loadFile"] = HOSTFN("loadFile") {
-        if (count < 1) {
-            throw std::runtime_error(
-                "[op-sqlite][loadFile] Incorrect parameter count");
-            return {};
-        }
-
-        const std::string sqlFileName = args[0].asString(rt).utf8(rt);
-
-        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, sqlFileName, resolve, reject]() {
-                try {
-                    const auto result = import_sql_file(db, sqlFileName);
-
-                    invoker->invokeAsync([&rt, result, resolve] {
-                        auto res = jsi::Object(rt);
-                        res.setProperty(rt, "rowsAffected",
-                                        jsi::Value(result.affectedRows));
-                        res.setProperty(rt, "commands",
-                                        jsi::Value(result.commands));
-                        resolve->asObject(rt).asFunction(rt).call(
-                            rt, std::move(res));
-                    });
-                } catch (std::runtime_error &e) {
-                    auto what = e.what();
-                    invoker->invokeAsync(
-                        [&rt, what = std::string(what), reject] {
-                            auto errorCtr =
-                                rt.global().getPropertyAsFunction(rt, "Error");
-                            auto error = errorCtr.callAsConstructor(
-                                rt, jsi::String::createFromAscii(rt, what));
-                            reject->asObject(rt).asFunction(rt).call(rt, error);
-                        });
-                } catch (std::exception &exc) {
-                    auto what = exc.what();
-                    invoker->invokeAsync(
-                        [&rt, what = std::string(what), reject] {
-                            auto errorCtr =
-                                rt.global().getPropertyAsFunction(rt, "Error");
-                            auto error = errorCtr.callAsConstructor(
-                                rt, jsi::String::createFromAscii(rt, what));
-                            reject->asObject(rt).asFunction(rt).call(rt, error);
-                        });
-                }
-            };
-            _thread_pool->queueWork(task);
-            return {};
-    }));
+  function_map["loadFile"] = HFN(this) {
+    if (count < 1) {
+      throw std::runtime_error(
+          "[op-sqlite][loadFile] Incorrect parameter count");
+    }
 
-    return promise;
-    });
+    const std::string sqlFileName = args[0].asString(rt).utf8(rt);
 
-    function_map["updateHook"] = HOSTFN("updateHook") {
-        auto callback = std::make_shared<jsi::Value>(rt, args[0]);
+    return promisify(
+        rt, [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);
+          res.setProperty(rt, "rowsAffected", jsi::Value(result.affectedRows));
+          res.setProperty(rt, "commands", jsi::Value(result.commands));
+          return res;
+        });
+  });
 
-        if (callback->isUndefined() || callback->isNull()) {
-            update_hook_callback = nullptr;
-        } else {
-            update_hook_callback = callback;
-        }
+  function_map["updateHook"] = HOSTFN("updateHook") {
+    auto callback = std::make_shared<jsi::Value>(rt, args[0]);
 
-        auto_register_update_hook();
-        return {};
-    });
+    if (callback->isUndefined() || callback->isNull()) {
+      update_hook_callback = nullptr;
+    } else {
+      update_hook_callback = callback;
+    }
 
-    function_map["commitHook"] = HOSTFN("commitHook") {
-        if (count < 1) {
-            throw std::runtime_error("[op-sqlite][commitHook] callback needed");
-        }
+    auto_register_update_hook();
+    return {};
+  });
 
-        auto callback = std::make_shared<jsi::Value>(rt, args[0]);
-        if (callback->isUndefined() || callback->isNull()) {
-            opsqlite_deregister_commit_hook(db);
-            return {};
-        }
-        commit_hook_callback = callback;
-        opsqlite_register_commit_hook(db, this);
+  function_map["commitHook"] = HOSTFN("commitHook") {
+    if (count < 1) {
+      throw std::runtime_error("[op-sqlite][commitHook] callback needed");
+    }
 
-        return {};
-    });
+    auto callback = std::make_shared<jsi::Value>(rt, args[0]);
+    if (callback->isUndefined() || callback->isNull()) {
+      opsqlite_deregister_commit_hook(db);
+      return {};
+    }
+    commit_hook_callback = callback;
+    opsqlite_register_commit_hook(db, this);
 
-    function_map["rollbackHook"] = HOSTFN("rollbackHook") {
-        if (count < 1) {
-            throw std::runtime_error(
-                "[op-sqlite][rollbackHook] callback needed");
-        }
+    return {};
+  });
 
-        auto callback = std::make_shared<jsi::Value>(rt, args[0]);
+  function_map["rollbackHook"] = HOSTFN("rollbackHook") {
+    if (count < 1) {
+      throw std::runtime_error("[op-sqlite][rollbackHook] callback needed");
+    }
 
-        if (callback->isUndefined() || callback->isNull()) {
-            opsqlite_deregister_rollback_hook(db);
-            return {};
-        }
-        rollback_hook_callback = callback;
+    auto callback = std::make_shared<jsi::Value>(rt, args[0]);
 
-        opsqlite_register_rollback_hook(db, this);
-        return {};
-    });
+    if (callback->isUndefined() || callback->isNull()) {
+      opsqlite_deregister_rollback_hook(db);
+      return {};
+    }
+    rollback_hook_callback = callback;
 
-    function_map["loadExtension"] = HOSTFN("loadExtension") {
-        auto path = args[0].asString(rt).utf8(rt);
-        std::string entry_point;
-        if (count > 1 && args[1].isString()) {
-            entry_point = args[1].asString(rt).utf8(rt);
-        }
+    opsqlite_register_rollback_hook(db, this);
+    return {};
+  });
 
-        opsqlite_load_extension(db, path, entry_point);
-        return {};
-    });
+  function_map["loadExtension"] = HOSTFN("loadExtension") {
+    auto path = args[0].asString(rt).utf8(rt);
+    std::string entry_point;
+    if (count > 1 && args[1].isString()) {
+      entry_point = args[1].asString(rt).utf8(rt);
+    }
 
-    function_map["reactiveExecute"] = HOSTFN("reactiveExecute") {
-        auto query = args[0].asObject(rt);
-
-        const std::string query_str =
-            query.getProperty(rt, "query").asString(rt).utf8(rt);
-        auto js_args = query.getProperty(rt, "arguments");
-        auto js_discriminators =
-            query.getProperty(rt, "fireOn").asObject(rt).asArray(rt);
-        auto variant_args = to_variant_vec(rt, js_args);
-
-        sqlite3_stmt *stmt = opsqlite_prepare_statement(db, query_str);
-        opsqlite_bind_statement(stmt, &variant_args);
-
-        auto callback =
-            std::make_shared<jsi::Value>(query.getProperty(rt, "callback"));
-
-        std::vector<TableRowDiscriminator> discriminators;
-
-        for (size_t i = 0; i < js_discriminators.length(rt); i++) {
-            auto js_discriminator =
-                js_discriminators.getValueAtIndex(rt, i).asObject(rt);
-            std::string table =
-                js_discriminator.getProperty(rt, "table").asString(rt).utf8(rt);
-            std::vector<int> ids;
-            if (js_discriminator.hasProperty(rt, "ids")) {
-                auto js_ids = js_discriminator.getProperty(rt, "ids")
-                                  .asObject(rt)
-                                  .asArray(rt);
-                for (size_t j = 0; j < js_ids.length(rt); j++) {
-                    ids.push_back(static_cast<int>(
-                        js_ids.getValueAtIndex(rt, j).asNumber()));
-                }
-            }
-            discriminators.push_back({table, ids});
+    opsqlite_load_extension(db, path, entry_point);
+    return {};
+  });
+
+  function_map["reactiveExecute"] = HOSTFN("reactiveExecute") {
+    auto query = args[0].asObject(rt);
+
+    const std::string query_str =
+        query.getProperty(rt, "query").asString(rt).utf8(rt);
+    auto js_args = query.getProperty(rt, "arguments");
+    auto js_discriminators =
+        query.getProperty(rt, "fireOn").asObject(rt).asArray(rt);
+    auto variant_args = to_variant_vec(rt, js_args);
+
+    sqlite3_stmt *stmt = opsqlite_prepare_statement(db, query_str);
+    opsqlite_bind_statement(stmt, &variant_args);
+
+    auto callback =
+        std::make_shared<jsi::Value>(query.getProperty(rt, "callback"));
+
+    std::vector<TableRowDiscriminator> discriminators;
+
+    for (size_t i = 0; i < js_discriminators.length(rt); i++) {
+      auto js_discriminator =
+          js_discriminators.getValueAtIndex(rt, i).asObject(rt);
+      std::string table =
+          js_discriminator.getProperty(rt, "table").asString(rt).utf8(rt);
+      std::vector<int> ids;
+      if (js_discriminator.hasProperty(rt, "ids")) {
+        auto js_ids =
+            js_discriminator.getProperty(rt, "ids").asObject(rt).asArray(rt);
+        for (size_t j = 0; j < js_ids.length(rt); j++) {
+          ids.push_back(
+              static_cast<int>(js_ids.getValueAtIndex(rt, j).asNumber()));
         }
+      }
+      discriminators.push_back({table, ids});
+    }
 
-        std::shared_ptr<ReactiveQuery> reactiveQuery =
-            std::make_shared<ReactiveQuery>(
-                ReactiveQuery{stmt, discriminators, callback});
-
-        reactive_queries.push_back(reactiveQuery);
+    std::shared_ptr<ReactiveQuery> reactiveQuery =
+        std::make_shared<ReactiveQuery>(
+            ReactiveQuery{stmt, discriminators, callback});
 
-        auto_register_update_hook();
+    reactive_queries.push_back(reactiveQuery);
 
-        auto unsubscribe = HOSTFN("unsubscribe") {
-            auto it = std::find(reactive_queries.begin(),
-                                reactive_queries.end(), reactiveQuery);
-            if (it != reactive_queries.end()) {
-                reactive_queries.erase(it);
-            }
-            auto_register_update_hook();
-            return {};
-        });
+    auto_register_update_hook();
 
-        return unsubscribe;
+    auto unsubscribe = HOSTFN("unsubscribe") {
+      auto it = std::find(reactive_queries.begin(), reactive_queries.end(),
+                          reactiveQuery);
+      if (it != reactive_queries.end()) {
+        reactive_queries.erase(it);
+      }
+      auto_register_update_hook();
+      return {};
     });
+
+    return unsubscribe;
+  });
 #endif
 
-    function_map["prepareStatement"] = HOSTFN("prepareStatement") {
-        auto query = args[0].asString(rt).utf8(rt);
+  function_map["prepareStatement"] = HOSTFN("prepareStatement") {
+    auto query = args[0].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
-        libsql_stmt_t statement = opsqlite_libsql_prepare_statement(db, query);
+    libsql_stmt_t statement = opsqlite_libsql_prepare_statement(db, query);
 #else
-        sqlite3_stmt *statement = opsqlite_prepare_statement(db, query);
+    sqlite3_stmt *statement = opsqlite_prepare_statement(db, query);
 #endif
-        auto preparedStatementHostObject =
-            std::make_shared<PreparedStatementHostObject>(
-                db, db_name, statement, invoker, _thread_pool);
-
-        return jsi::Object::createFromHostObject(rt,
-                                                 preparedStatementHostObject);
-    });
-
-    function_map["getDbPath"] = HOSTFN("getDbPath") {
-        std::string path = std::string(base_path);
-
-        if (count == 1) {
-            if (!args[0].isString()) {
-                throw std::runtime_error(
-                    "[op-sqlite][open] database location must be a string");
-            }
-
-            std::string last_path = args[0].asString(rt).utf8(rt);
-
-            if (last_path == ":memory:") {
-                path = ":memory:";
-            } else if (last_path.rfind('/', 0) == 0) {
-                path = last_path;
-            } else {
-                path = path + "/" + last_path;
-            }
-        }
+    auto preparedStatementHostObject =
+        std::make_shared<PreparedStatementHostObject>(db, statement);
+
+    return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
+  });
+
+  function_map["getDbPath"] = HOSTFN("getDbPath") {
+    std::string path = std::string(base_path);
+
+    if (count == 1) {
+      if (!args[0].isString()) {
+        throw std::runtime_error(
+            "[op-sqlite][open] database location must be a string");
+      }
+
+      std::string last_path = args[0].asString(rt).utf8(rt);
+
+      if (last_path == ":memory:") {
+        path = ":memory:";
+      } else if (last_path.rfind('/', 0) == 0) {
+        path = last_path;
+      } else {
+        path = path + "/" + last_path;
+      }
+    }
 
-        auto result = opsqlite_get_db_path(db_name, path);
-        return jsi::String::createFromUtf8(rt, result);
-    });
+    auto result = opsqlite_get_db_path(db_name, path);
+    return jsi::String::createFromUtf8(rt, result);
+  });
 
-    function_map["flushPendingReactiveQueries"] =
-        HOSTFN("flushPendingReactiveQueries") {
-        auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+  function_map["flushPendingReactiveQueries"] =
+      HOSTFN("flushPendingReactiveQueries") {
+    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 resolve = std::make_shared<jsi::Value>(rt, args[0]);
 
-            auto task = [&rt, this, resolve]() {
-                flush_pending_reactive_queries(resolve);
-            };
+      auto task = [&rt, this, resolve]() {
+        flush_pending_reactive_queries(resolve);
+      };
 
-            _thread_pool->queueWork(task);
+      _thread_pool->queueWork(task);
 
-            return {};
+      return {};
     }));
 
     return promise;
-    });
+  });
 }
 
 std::vector<jsi::PropNameID> DBHostObject::getPropertyNames(jsi::Runtime &_rt) {
-    std::vector<jsi::PropNameID> keys;
-    keys.reserve(function_map.size());
-    for (const auto &pair : function_map) {
-        keys.emplace_back(jsi::PropNameID::forUtf8(_rt, pair.first));
-    }
-    return keys;
+  std::vector<jsi::PropNameID> keys;
+  keys.reserve(function_map.size());
+  for (const auto &pair : function_map) {
+    keys.emplace_back(jsi::PropNameID::forUtf8(_rt, pair.first));
+  }
+  return keys;
 }
 
 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()) {
-            throw std::runtime_error(
-                "[op-sqlite] Function " + name +
-                " not implemented for current backend (libsql or sqlcipher)");
-        });
-    }
+  auto name = propNameID.utf8(rt);
+  if (function_map.count(name) != 1) {
+    return HOST_STATIC_FN(name.c_str()) {
+      throw std::runtime_error(
+          "[op-sqlite] Function " + name +
+          " not implemented for current backend (libsql or sqlcipher)");
+    });
+  }
 
-    return {rt, function_map[name]};
+  return {rt, function_map[name]};
 }
 
 void DBHostObject::set(jsi::Runtime &_rt, const jsi::PropNameID &name,
                        const jsi::Value &value) {
-    throw std::runtime_error("You cannot write to this object!");
+  throw std::runtime_error("You cannot write to this object!");
 }
 
 void DBHostObject::invalidate() {
-    if (invalidated) {
-        return;
-    }
+  if (invalidated) {
+    return;
+  }
 
-    invalidated = true;
-    _thread_pool->restartPool();
+  invalidated = true;
+  _thread_pool->restartPool();
 #ifdef OP_SQLITE_USE_LIBSQL
-    opsqlite_libsql_close(db);
+  opsqlite_libsql_close(db);
 #else
-    if (db != nullptr) {
-        opsqlite_close(db);
-        db = nullptr;
-    }
+  if (db != nullptr) {
+    opsqlite_close(db);
+    db = nullptr;
+  }
 #endif
 }