@op-engineering/op-sqlite 11.2.13 → 11.2.15

package/cpp/DBHostObject.cpp

@@ -19,110 +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();
+    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>>();
+        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);
+        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);
-        });
-  }
+        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();
+    pending_reactive_queries.clear();
 
-  invoker->invokeAsync(
-      [this, resolve]() { resolve->asObject(rt).asFunction(rt).call(rt, {}); });
+    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);
-        });
-  }
-
-  for (const auto &query_ptr : reactive_queries) {
-    auto query = query_ptr.get();
-    if (query->discriminators.empty()) {
-      continue;
+    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);
+            });
     }
 
-    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;
+    for (const auto &query_ptr : reactive_queries) {
+        auto query = query_ptr.get();
+        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;
+                }
+            }
         }
-      }
-    }
 
-    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
 
@@ -135,13 +142,11 @@ void DBHostObject::auto_register_update_hook() {
 #ifdef OP_SQLITE_USE_LIBSQL
 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) {
-  db = opsqlite_libsql_open_remote(url, auth_token);
+                           std::shared_ptr<react::CallInvoker> invoker)
+    : db_name(url), invoker(std::move(invoker)), rt(rt) {
+    db = opsqlite_libsql_open_remote(url, auth_token);
 
-  create_jsi_functions();
+    create_jsi_functions();
 }
 
 DBHostObject::DBHostObject(jsi::Runtime &rt,
@@ -149,13 +154,11 @@ DBHostObject::DBHostObject(jsi::Runtime &rt,
                            std::string &db_name, std::string &path,
                            std::string &url, std::string &auth_token,
                            int sync_interval)
-    : db_name(db_name), invoker(std::move(invoker)),
-      rt(rt) {
-  db =
-      opsqlite_libsql_open_sync(db_name, path, url, auth_token, sync_interval);
+    : db_name(db_name), invoker(std::move(invoker)), rt(rt) {
+    db = opsqlite_libsql_open_sync(db_name, path, url, auth_token,
+                                   sync_interval);
 
-
-  create_jsi_functions();
+    create_jsi_functions();
 }
 
 #endif
@@ -168,655 +171,688 @@ 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") {
-    if (count < 3) {
-      throw std::runtime_error(
-          "[op-sqlite][attach] Incorrect number of arguments");
-    }
-    if (!args[0].isString() || !args[1].isString() || !args[2].isString()) {
-      throw std::runtime_error(
-          "[op-sqlite] name, database to attach and alias must be strings");
-    }
+    function_map["attach"] = HOSTFN("attach") {
+        if (count < 3) {
+            throw std::runtime_error(
+                "[op-sqlite][attach] Incorrect number of arguments");
+        }
+        if (!args[0].isString() || !args[1].isString() || !args[2].isString()) {
+            throw std::runtime_error("[op-sqlite] name, database to attach and "
+                                     "alias must be strings");
+        }
 
-    std::string secondary_db_path = std::string(base_path);
-    if (count > 3) {
-      if (!args[3].isString()) {
-        throw std::runtime_error(
-            "[op-sqlite][attach] database location must be a string");
-      }
+        std::string secondary_db_path = std::string(base_path);
+        if (count > 3) {
+            if (!args[3].isString()) {
+                throw std::runtime_error(
+                    "[op-sqlite][attach] database location must be a string");
+            }
 
-      secondary_db_path += "/" + args[3].asString(rt).utf8(rt);
-    }
+            secondary_db_path += "/" + args[3].asString(rt).utf8(rt);
+        }
 
-    std::string main_db_name = args[0].asString(rt).utf8(rt);
-    std::string secondary_db_name = args[1].asString(rt).utf8(rt);
-    std::string alias = args[2].asString(rt).utf8(rt);
+        std::string main_db_name = args[0].asString(rt).utf8(rt);
+        std::string secondary_db_name = args[1].asString(rt).utf8(rt);
+        std::string alias = args[2].asString(rt).utf8(rt);
 #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, main_db_name, secondary_db_path, secondary_db_name,
-                    alias);
+        opsqlite_attach(db, main_db_name, secondary_db_path, secondary_db_name,
+                        alias);
 #endif
 
-    return {};
-  });
+        return {};
+    });
 
-  function_map["detach"] = HOSTFN("detach") {
-    if (count < 2) {
-      throw std::runtime_error(
-          "[op-sqlite][detach] Incorrect number of arguments");
-    }
-    if (!args[0].isString() || !args[1].isString()) {
-      throw std::runtime_error(
-          "[op-sqlite] database name and alias must be a strings");
-    }
+    function_map["detach"] = HOSTFN("detach") {
+        if (count < 2) {
+            throw std::runtime_error(
+                "[op-sqlite][detach] Incorrect number of arguments");
+        }
+        if (!args[0].isString() || !args[1].isString()) {
+            throw std::runtime_error(
+                "[op-sqlite] database name and alias must be a strings");
+        }
 
-    std::string dbName = args[0].asString(rt).utf8(rt);
-    std::string alias = args[1].asString(rt).utf8(rt);
+        std::string dbName = args[0].asString(rt).utf8(rt);
+        std::string alias = args[1].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
-    opsqlite_libsql_detach(db, alias);
+        opsqlite_libsql_detach(db, alias);
 #else
-    opsqlite_detach(db, dbName, alias);
+        opsqlite_detach(db, dbName, alias);
 #endif
 
-    return {};
-  });
+        return {};
+    });
+
+    function_map["close"] = HOSTFN("close") {
+        invalidated = true;
 
-  function_map["close"] = HOSTFN("close") {
 #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") {
-    std::string path = std::string(base_path);
+    function_map["delete"] = HOSTFN("delete") {
+        invalidated = true;
 
-    if (count == 1) {
-      if (!args[1].isString()) {
-        throw std::runtime_error(
-            "[op-sqlite][open] database location must be a string");
-      }
+        std::string path = std::string(base_path);
 
-      std::string location = args[1].asString(rt).utf8(rt);
+        if (count == 1) {
+            if (!args[1].isString()) {
+                throw std::runtime_error(
+                    "[op-sqlite][open] database location must be a string");
+            }
 
-      if (!location.empty()) {
-        if (location == ":memory:") {
-          path = ":memory:";
-        } else if (location.rfind('/', 0) == 0) {
-          path = location;
-        } else {
-          path = path + "/" + location;
+            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;
+                }
+            }
         }
-      }
-    }
 
 #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 {};
-  });
+        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>();
+    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>();
 
-    auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        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 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;
+            auto task = [this, &rt, query, params, resolve, reject]() {
+                try {
+                    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
 
-          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 {};
+                    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"] = HOSTFN("executeSync") {
+        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["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>();
+    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 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 {
+            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 {
 #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 {};
+                    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;
+    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);
-    }
+        if (count == 2) {
+            const jsi::Value &originalParams = args[1];
+            params = to_variant_vec(rt, originalParams);
+        }
 
-    auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        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>>();
+            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>>();
 #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
 
-          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 {};
+                    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");
-      return {};
-    }
+    function_map["executeBatch"] = HOSTFN("executeBatch") {
+        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");
-      return {};
-    }
+        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);
+        const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
 
-    std::vector<BatchArguments> commands;
-    to_batch_arguments(rt, batchParams, &commands);
+        std::vector<BatchArguments> commands;
+        to_batch_arguments(rt, batchParams, &commands);
 
-    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,
-                   commands =
-                       std::make_shared<std::vector<BatchArguments>>(commands),
-                   resolve, reject]() {
-        try {
+        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, commands, resolve, reject]() {
+                try {
 #ifdef OP_SQLITE_USE_LIBSQL
-          auto batchResult =
-              opsqlite_libsql_execute_batch(db, commands.get());
+                    auto batchResult =
+                        opsqlite_libsql_execute_batch(db, &commands);
 #else
-          auto batchResult = opsqlite_execute_batch(db, commands.get());
+                    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 {};
+                    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 promise;
+    });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  function_map["sync"] = HOSTFN("sync") {
-    opsqlite_libsql_sync(db);
-    return {};
-  });
+    function_map["sync"] = HOSTFN("sync") {
+        opsqlite_libsql_sync(db);
+        return {};
+    });
 #else
-  function_map["loadFile"] = HOSTFN("loadFile") {
-    if (count < 1) {
-      throw std::runtime_error(
-          "[op-sqlite][loadFile] Incorrect parameter count");
-      return {};
-    }
+    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);
+        const std::string sqlFileName = args[0].asString(rt).utf8(rt);
 
-    auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        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 {};
+            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 {};
     }));
 
     return promise;
-  });
+    });
 
-  function_map["updateHook"] = HOSTFN("updateHook") {
-    auto callback = std::make_shared<jsi::Value>(rt, args[0]);
+    function_map["updateHook"] = HOSTFN("updateHook") {
+        auto callback = std::make_shared<jsi::Value>(rt, args[0]);
 
-    if (callback->isUndefined() || callback->isNull()) {
-      update_hook_callback = nullptr;
-    } else {
-      update_hook_callback = callback;
-    }
+        if (callback->isUndefined() || callback->isNull()) {
+            update_hook_callback = nullptr;
+        } else {
+            update_hook_callback = callback;
+        }
 
-    auto_register_update_hook();
-    return {};
-  });
+        auto_register_update_hook();
+        return {};
+    });
 
-  function_map["commitHook"] = HOSTFN("commitHook") {
-    if (count < 1) {
-      throw std::runtime_error("[op-sqlite][commitHook] callback needed");
-    }
+    function_map["commitHook"] = HOSTFN("commitHook") {
+        if (count < 1) {
+            throw std::runtime_error("[op-sqlite][commitHook] callback needed");
+        }
 
-    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);
+        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);
 
-    return {};
-  });
+        return {};
+    });
 
-  function_map["rollbackHook"] = HOSTFN("rollbackHook") {
-    if (count < 1) {
-      throw std::runtime_error("[op-sqlite][rollbackHook] callback needed");
-    }
+    function_map["rollbackHook"] = HOSTFN("rollbackHook") {
+        if (count < 1) {
+            throw std::runtime_error(
+                "[op-sqlite][rollbackHook] callback needed");
+        }
 
-    auto callback = std::make_shared<jsi::Value>(rt, args[0]);
+        auto callback = std::make_shared<jsi::Value>(rt, args[0]);
 
-    if (callback->isUndefined() || callback->isNull()) {
-      opsqlite_deregister_rollback_hook(db);
-      return {};
-    }
-    rollback_hook_callback = callback;
+        if (callback->isUndefined() || callback->isNull()) {
+            opsqlite_deregister_rollback_hook(db);
+            return {};
+        }
+        rollback_hook_callback = callback;
+
+        opsqlite_register_rollback_hook(db, this);
+        return {};
+    });
 
-    opsqlite_register_rollback_hook(db, this);
-    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["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_load_extension(db, path, entry_point);
+        return {};
+    });
 
-    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()));
+    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});
         }
-      }
-      discriminators.push_back({table, ids});
-    }
 
-    std::shared_ptr<ReactiveQuery> reactiveQuery =
-        std::make_shared<ReactiveQuery>(
-            ReactiveQuery{stmt, discriminators, callback});
+        std::shared_ptr<ReactiveQuery> reactiveQuery =
+            std::make_shared<ReactiveQuery>(
+                ReactiveQuery{stmt, discriminators, callback});
 
-    reactive_queries.push_back(reactiveQuery);
+        reactive_queries.push_back(reactiveQuery);
 
-    auto_register_update_hook();
+        auto_register_update_hook();
 
-    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 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;
-  });
+        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, db_name, statement, invoker, _thread_pool);
+
+        return jsi::Object::createFromHostObject(rt,
+                                                 preparedStatementHostObject);
+    });
 
-    auto result = opsqlite_get_db_path(db_name, path);
-    return jsi::String::createFromUtf8(rt, result);
-  });
+    function_map["getDbPath"] = HOSTFN("getDbPath") {
+        std::string path = std::string(base_path);
 
-  function_map["flushPendingReactiveQueries"] =
-      HOSTFN("flushPendingReactiveQueries") {
-    auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        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);
+    });
+
+    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() {
-  invalidated = true;
-  _thread_pool->restartPool();
+    if (invalidated) {
+        return;
+    }
+
+    invalidated = true;
+    _thread_pool->restartPool();
 #ifdef OP_SQLITE_USE_LIBSQL
     opsqlite_libsql_close(db);
 #else
-  if (db != nullptr) {
-    opsqlite_close(db);
-    db = nullptr;
-  }
+    if (db != nullptr) {
+        opsqlite_close(db);
+        db = nullptr;
+    }
 #endif
 }