@op-engineering/op-sqlite 6.0.2-beta1 → 6.0.2-beta4

package/cpp/DBHostObject.cpp

@@ -1,8 +1,11 @@
 #include "DBHostObject.h"
 #include "PreparedStatementHostObject.h"
+#if OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
 #include "bridge.h"
+#endif
 #include "macros.h"
-#include "sqlbatchexecutor.h"
 #include "utils.h"
 #include <iostream>
 
@@ -11,6 +14,7 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
+#ifndef OP_SQLITE_USE_LIBSQL
 void DBHostObject::auto_register_update_hook() {
   if (update_hook_callback == nullptr && reactive_queries.size() == 0 &&
       has_update_hook_registered) {
@@ -61,18 +65,35 @@ void DBHostObject::auto_register_update_hook() {
     for (const auto &query_ptr : reactive_queries) {
 
       auto query = query_ptr.get();
-      if (query->tables.size() == 0) {
+      if (query->discriminators.size() == 0) {
         continue;
       }
 
-      if (std::find(query->tables.begin(), query->tables.end(), table_name) ==
-          query->tables.end()) {
-        continue;
+      bool shouldFire = false;
+
+      for (const auto &discriminator : query->discriminators) {
+        if (discriminator.table != table_name) {
+          continue;
+        }
+
+        // Table has matched
+
+        // If no ids are specified, then we should fire
+        if (discriminator.ids.size() == 0) {
+          shouldFire = true;
+          break;
+        } else { // If ids are specified, then we should check if the rowId
+                 // matches
+          for (const auto &discrimator_id : discriminator.ids) {
+            if (rowId == discrimator_id) {
+              shouldFire = true;
+              break;
+            }
+          }
+        }
       }
 
-      if (query->rowIds.size() > 0 &&
-          std::find(query->rowIds.begin(), query->rowIds.end(), rowId) ==
-              query->rowIds.end()) {
+      if (!shouldFire) {
         continue;
       }
 
@@ -80,8 +101,8 @@ void DBHostObject::auto_register_update_hook() {
       std::shared_ptr<std::vector<SmartHostObject>> metadata =
           std::make_shared<std::vector<SmartHostObject>>();
 
-      auto status = opsqlite_execute(dbName, query->query, &query->args,
-                                     &results, metadata);
+      auto status = opsqlite_execute_prepared_statement(db_name, query->stmt,
+                                                        &results, metadata);
 
       if (status.type == SQLiteError) {
         jsCallInvoker->invokeAsync(
@@ -114,6 +135,24 @@ void DBHostObject::auto_register_update_hook() {
   opsqlite_register_update_hook(db_name, std::move(hook));
   has_update_hook_registered = true;
 }
+#endif
+
+#ifdef OP_SQLITE_USE_LIBSQL
+DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &url,
+                           std::string &auth_token,
+                           std::shared_ptr<react::CallInvoker> js_call_invoker,
+                           std::shared_ptr<ThreadPool> thread_pool)
+    : db_name(url), jsCallInvoker(js_call_invoker), thread_pool(thread_pool),
+      rt(rt) {
+  BridgeResult result = opsqlite_libsql_open_remote(url, auth_token);
+
+  if (result.type == SQLiteError) {
+    throw std::runtime_error(result.message);
+  }
+
+  create_jsi_functions();
+}
+#endif
 
 DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
                            std::shared_ptr<react::CallInvoker> jsCallInvoker,
@@ -127,6 +166,8 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 #ifdef OP_SQLITE_USE_SQLCIPHER
   BridgeResult result =
       opsqlite_open(db_name, path, crsqlite_path, encryption_key);
+#elif OP_SQLITE_USE_LIBSQL
+  BridgeResult result = opsqlite_libsql_open(db_name, path);
 #else
   BridgeResult result = opsqlite_open(db_name, path, crsqlite_path);
 #endif
@@ -135,6 +176,10 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     throw std::runtime_error(result.message);
   }
 
+  create_jsi_functions();
+};
+
+void DBHostObject::create_jsi_functions() {
   auto attach = HOSTFN("attach", 4) {
     if (count < 3) {
       throw jsi::JSError(rt,
@@ -159,9 +204,13 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     std::string dbName = args[0].asString(rt).utf8(rt);
     std::string databaseToAttach = args[1].asString(rt).utf8(rt);
     std::string alias = args[2].asString(rt).utf8(rt);
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result =
+        opsqlite_libsql_attach(dbName, tempDocPath, databaseToAttach, alias);
+#else
     BridgeResult result =
         opsqlite_attach(dbName, tempDocPath, databaseToAttach, alias);
-
+#endif
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
     }
@@ -182,7 +231,11 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 
     std::string dbName = args[0].asString(rt).utf8(rt);
     std::string alias = args[1].asString(rt).utf8(rt);
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result = opsqlite_libsql_detach(dbName, alias);
+#else
     BridgeResult result = opsqlite_detach(dbName, alias);
+#endif
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -192,7 +245,11 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
   });
 
   auto close = HOSTFN("close", 0) {
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result = opsqlite_libsql_close(db_name);
+#else
     BridgeResult result = opsqlite_close(db_name);
+#endif
 
     if (result.type == SQLiteError) {
       throw jsi::JSError(rt, result.message.c_str());
@@ -224,7 +281,11 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       }
     }
 
+#ifdef OP_SQLITE_USE_LIBSQL
+    BridgeResult result = opsqlite_libsql_remove(db_name, path);
+#else
     BridgeResult result = opsqlite_remove(db_name, path);
+#endif
 
     if (result.type == SQLiteError) {
       throw std::runtime_error(result.message);
@@ -246,7 +307,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     std::shared_ptr<std::vector<SmartHostObject>> metadata =
         std::make_shared<std::vector<SmartHostObject>>();
 
+#ifdef OP_SQLITE_USE_LIBSQL
+    auto status =
+        opsqlite_libsql_execute(db_name, query, &params, &results, metadata);
+#else
     auto status = opsqlite_execute(db_name, query, &params, &results, metadata);
+#endif
 
     if (status.type == SQLiteError) {
       throw std::runtime_error(status.message);
@@ -270,12 +336,17 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
-      auto task = [&rt, db_name, query, params = std::move(params), resolve,
+      auto task = [&rt, this, query, params = std::move(params), resolve,
                    reject, invoker = this->jsCallInvoker]() {
         try {
           std::vector<std::vector<JSVariant>> results;
 
+#ifdef OP_SQLITE_USE_LIBSQL
+          auto status =
+              opsqlite_libsql_execute_raw(db_name, query, &params, &results);
+#else
           auto status = opsqlite_execute_raw(db_name, query, &params, &results);
+#endif
           //
           //            if (invalidated) {
           //              return;
@@ -308,13 +379,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       thread_pool->queueWork(task);
 
       return {};
-    }));
+     }));
 
     return promise;
   });
 
   auto execute_async = HOSTFN("executeAsync", 2) {
-
     const std::string query = args[0].asString(rt).utf8(rt);
     std::vector<JSVariant> params;
 
@@ -328,15 +398,19 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
-      auto task = [&rt, &db_name, query, params = std::move(params), resolve,
+      auto task = [&rt, this, query, params = std::move(params), resolve,
                    reject, invoker = this->jsCallInvoker]() {
         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(db_name, query, &params,
+                                                &results, metadata);
+#else
           auto status =
               opsqlite_execute(db_name, query, &params, &results, metadata);
+#endif
 
           //            if (invalidated) {
           //              return;
@@ -391,9 +465,13 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     }
     const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
     std::vector<BatchArguments> commands;
-    toBatchArguments(rt, batchParams, &commands);
+    to_batch_arguments(rt, batchParams, &commands);
 
-    auto batchResult = sqliteExecuteBatch(db_name, &commands);
+#ifdef OP_SQLITE_USE_LIBSQL
+    auto batchResult = opsqlite_libsql_execute_batch(db_name, &commands);
+#else
+    auto batchResult = opsqlite_execute_batch(db_name, &commands);
+#endif
     if (batchResult.type == SQLiteOk) {
       auto res = jsi::Object(rt);
       res.setProperty(rt, "rowsAffected", jsi::Value(batchResult.affectedRows));
@@ -422,19 +500,24 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
 
     std::vector<BatchArguments> commands;
-    toBatchArguments(rt, batchParams, &commands);
+    to_batch_arguments(rt, batchParams, &commands);
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+     auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
-      auto task = [&rt, &db_name, &jsCallInvoker,
+      auto task = [&rt, this,
                    commands =
                        std::make_shared<std::vector<BatchArguments>>(commands),
                    resolve, reject]() {
         try {
-          auto batchResult = sqliteExecuteBatch(db_name, commands.get());
+#ifdef OP_SQLITE_USE_LIBSQL
+          auto batchResult =
+              opsqlite_libsql_execute_batch(db_name, commands.get());
+#else
+          auto batchResult = opsqlite_execute_batch(db_name, commands.get());
+#endif
           jsCallInvoker->invokeAsync([&rt, batchResult = std::move(batchResult),
                                       resolve, reject] {
             if (batchResult.type == SQLiteOk) {
@@ -457,11 +540,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       thread_pool->queueWork(task);
 
       return {};
-           }));
+            }));
 
-    return promise;
+     return promise;
   });
 
+#ifndef OP_SQLITE_USE_LIBSQL
   auto load_file = HOSTFN("loadFile", 1) {
     if (sizeof(args) < 1) {
       throw std::runtime_error(
@@ -472,12 +556,12 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     const std::string sqlFileName = args[0].asString(rt).utf8(rt);
 
     auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
-    auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2)
+        {
       auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
       auto reject = std::make_shared<jsi::Value>(rt, args[1]);
 
-      auto task = [&rt, &db_name, &jsCallInvoker, sqlFileName, resolve,
-                   reject]() {
+      auto task = [&rt, this, sqlFileName, resolve, reject]() {
         try {
           const auto importResult = importSQLFile(db_name, sqlFileName);
 
@@ -503,9 +587,9 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
       };
       thread_pool->queueWork(task);
       return {};
-           }));
+               }));
 
-    return promise;
+        return promise;
   });
 
   auto update_hook = HOSTFN("updateHook", 1) {
@@ -533,7 +617,7 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     }
     commit_hook_callback = callback;
 
-    auto hook = [&rt, jsCallInvoker, callback](std::string dbName) {
+    auto hook = [&rt, this, callback](std::string dbName) {
       jsCallInvoker->invokeAsync(
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
@@ -557,7 +641,7 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     }
     rollback_hook_callback = callback;
 
-    auto hook = [&rt, jsCallInvoker, callback](std::string db_name) {
+    auto hook = [&rt, this, callback](std::string db_name) {
       jsCallInvoker->invokeAsync(
           [&rt, callback] { callback->asObject(rt).asFunction(rt).call(rt); });
     };
@@ -566,17 +650,6 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     return {};
   });
 
-  auto prepare_statement = HOSTFN("prepareStatement", 1) {
-    auto query = args[0].asString(rt).utf8(rt);
-
-    sqlite3_stmt *statement = opsqlite_prepare_statement(db_name, query);
-
-    auto preparedStatementHostObject =
-        std::make_shared<PreparedStatementHostObject>(db_name, statement);
-
-    return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
-  });
-
   auto load_extension = HOSTFN("loadExtension", 1) {
     auto path = args[0].asString(rt).utf8(rt);
     std::string entry_point = "";
@@ -591,29 +664,6 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     return {};
   });
 
-  auto get_db_path = HOSTFN("getDbPath", 1) {
-    std::string path = std::string(base_path);
-    if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
-      if (!args[0].isString()) {
-        throw std::runtime_error(
-            "[op-sqlite][open] database location must be a string");
-      }
-
-      std::string lastPath = args[0].asString(rt).utf8(rt);
-
-      if (lastPath == ":memory:") {
-        path = ":memory:";
-      } else if (lastPath.rfind("/", 0) == 0) {
-        path = lastPath;
-      } else {
-        path = path + "/" + lastPath;
-      }
-    }
-
-    auto result = opsqlite_get_db_path(db_name, path);
-    return jsi::String::createFromUtf8(rt, result);
-  });
-
   auto reactive_execute = HOSTFN("reactiveExecute", 0) {
     auto query = args[0].asObject(rt);
     // if (!query.hasProperty(rt, "query") || !query.hasProperty(rt, "args")
@@ -628,23 +678,47 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 
     const std::string query_str =
         query.getProperty(rt, "query").asString(rt).utf8(rt);
-    auto argsArray = query.getProperty(rt, "args");
-    auto tablesArray = query.getProperty(rt, "tables");
+    auto js_args = query.getProperty(rt, "args");
+    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_name, query_str);
+    opsqlite_bind_statement(stmt, &variant_args);
 
     auto callback =
         std::make_shared<jsi::Value>(query.getProperty(rt, "callback"));
 
-    std::vector<JSVariant> query_args = to_variant_vec(rt, argsArray);
-    std::vector<std::string> tables = to_string_vec(rt, tablesArray);
-    std::vector<int> rowIds;
-    if (query.hasProperty(rt, "rowIds")) {
-      auto rowIdsArray = query.getProperty(rt, "rowIds");
-      rowIds = to_int_vec(rt, rowIdsArray);
+    // std::vector<JSVariant> query_args = to_variant_vec(rt, argsArray);
+    // std::vector<std::string> tables = to_string_vec(rt, tablesArray);
+    // std::vector<int> rowIds;
+    // if (query.hasProperty(rt, "rowIds")) {
+    //   auto rowIdsArray = query.getProperty(rt, "rowIds");
+    //   rowIds = to_int_vec(rt, rowIdsArray);
+    // }
+
+    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{query_str, query_args, tables, rowIds, callback});
+            ReactiveQuery{stmt, discriminators, callback});
 
     reactive_queries.push_back(reactiveQuery);
 
@@ -663,6 +737,44 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
     return unsubscribe;
   });
 
+#endif
+
+  auto prepare_statement = HOSTFN("prepareStatement", 1) {
+    auto query = args[0].asString(rt).utf8(rt);
+#ifdef OP_SQLITE_USE_LIBSQL
+    libsql_stmt_t statement = opsqlite_libsql_prepare_statement(db_name, query);
+#else
+    sqlite3_stmt *statement = opsqlite_prepare_statement(db_name, query);
+#endif
+    auto preparedStatementHostObject =
+        std::make_shared<PreparedStatementHostObject>(db_name, statement);
+
+    return jsi::Object::createFromHostObject(rt, preparedStatementHostObject);
+  });
+
+  auto get_db_path = HOSTFN("getDbPath", 1) {
+    std::string path = std::string(base_path);
+    if (count == 1 && !args[0].isUndefined() && !args[0].isNull()) {
+      if (!args[0].isString()) {
+        throw std::runtime_error(
+            "[op-sqlite][open] database location must be a string");
+      }
+
+      std::string lastPath = args[0].asString(rt).utf8(rt);
+
+      if (lastPath == ":memory:") {
+        path = ":memory:";
+      } else if (lastPath.rfind("/", 0) == 0) {
+        path = lastPath;
+      } else {
+        path = path + "/" + lastPath;
+      }
+    }
+
+    auto result = opsqlite_get_db_path(db_name, path);
+    return jsi::String::createFromUtf8(rt, result);
+  });
+
   function_map["attach"] = std::move(attach);
   function_map["detach"] = std::move(detach);
   function_map["close"] = std::move(close);
@@ -672,15 +784,17 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
   function_map["delete"] = std::move(remove);
   function_map["executeBatch"] = std::move(execute_batch);
   function_map["executeBatchAsync"] = std::move(execute_batch_async);
+  function_map["prepareStatement"] = std::move(prepare_statement);
+  function_map["getDbPath"] = std::move(get_db_path);
+#ifndef OP_SQLITE_USE_LIBSQL
   function_map["loadFile"] = std::move(load_file);
   function_map["updateHook"] = std::move(update_hook);
   function_map["commitHook"] = std::move(commit_hook);
   function_map["rollbackHook"] = std::move(rollback_hook);
-  function_map["prepareStatement"] = std::move(prepare_statement);
   function_map["loadExtension"] = std::move(load_extension);
-  function_map["getDbPath"] = std::move(get_db_path);
   function_map["reactiveExecute"] = std::move(reactive_execute);
-};
+#endif
+}
 
 std::vector<jsi::PropNameID> DBHostObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> keys;
@@ -719,6 +833,44 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "executeBatchAsync") {
     return jsi::Value(rt, function_map["executeBatchAsync"]);
   }
+  if (name == "prepareStatement") {
+    return jsi::Value(rt, function_map["prepareStatement"]);
+  }
+  if (name == "getDbPath") {
+    return jsi::Value(rt, function_map["getDbPath"]);
+  }
+#ifdef OP_SQLITE_USE_LIBSQL
+  if (name == "loadFile") {
+    return HOSTFN("loadFile", 0) {
+      throw std::runtime_error("[op-sqlite] Load file not implemented");
+    });
+  }
+  if (name == "updateHook") {
+    return HOSTFN("updateHook", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "commitHook") {
+    return HOSTFN("commitHook", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "rollbackHook") {
+    return HOSTFN("rollbackHook", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "loadExtension") {
+    return HOSTFN("loadExtension", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+  if (name == "reactiveExecute") {
+    return HOSTFN("reactiveExecute", 0) {
+      throw std::runtime_error("[op-sqlite] Hooks not supported in libsql");
+    });
+  }
+#else
   if (name == "loadFile") {
     return jsi::Value(rt, function_map["loadFile"]);
   }
@@ -731,25 +883,20 @@ jsi::Value DBHostObject::get(jsi::Runtime &rt,
   if (name == "rollbackHook") {
     return jsi::Value(rt, function_map["rollbackHook"]);
   }
-  if (name == "prepareStatement") {
-    return jsi::Value(rt, function_map["prepareStatement"]);
-  }
   if (name == "loadExtension") {
     return jsi::Value(rt, function_map["loadExtension"]);
   }
-  if (name == "getDbPath") {
-    return jsi::Value(rt, function_map["getDbPath"]);
-  }
   if (name == "reactiveExecute") {
     return jsi::Value(rt, function_map["reactiveExecute"]);
   }
+#endif
 
   return {};
 }
 
-// void DBHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
-//                        const jsi::Value &value) {
-//   throw std::runtime_error("You cannot write to this object!");
-// }
+void DBHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
+                       const jsi::Value &value) {
+  throw std::runtime_error("You cannot write to this object!");
+}
 
 } // namespace opsqlite

package/cpp/DBHostObject.h

@@ -1,7 +1,7 @@
-#ifndef DBHostObject_h
-#define DBHostObject_h
+#pragma once
 
 #include "ThreadPool.h"
+#include "sqlite3.h"
 #include "types.h"
 #include <ReactCommon/CallInvoker.h>
 #include <any>
@@ -14,11 +14,14 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
+struct TableRowDiscriminator {
+  std::string table;
+  std::vector<int> ids;
+};
+
 struct ReactiveQuery {
-  std::string query;
-  std::vector<JSVariant> args;
-  std::vector<std::string> tables;
-  std::vector<int> rowIds;
+  sqlite3_stmt *stmt;
+  std::vector<TableRowDiscriminator> discriminators;
   std::shared_ptr<jsi::Value> callback;
 };
 
@@ -30,15 +33,23 @@ public:
                std::string &path, std::string &crsqlite_path,
                std::string &encryption_key);
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
+#ifdef OP_SQLITE_USE_LIBSQL
+  DBHostObject(jsi::Runtime &rt, std::string &url, std::string &auth_token,
+               std::shared_ptr<react::CallInvoker> js_call_invoker,
+               std::shared_ptr<ThreadPool> thread_pool);
+#endif
 
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value);
 
+private:
   void auto_register_update_hook();
+  void create_jsi_functions();
 
   std::unordered_map<std::string, jsi::Value> function_map;
   std::string base_path;
-
   std::shared_ptr<jsi::Value> update_hook;
   std::shared_ptr<react::CallInvoker> jsCallInvoker;
   std::shared_ptr<ThreadPool> thread_pool;
@@ -52,5 +63,3 @@ public:
 };
 
 } // namespace opsqlite
-
-#endif /* DBHostObject_h */