@op-engineering/op-sqlite 6.0.1 → 6.0.2-beta3

package/cpp/DBHostObject.h

@@ -0,0 +1,61 @@
+#ifndef DBHostObject_h
+#define DBHostObject_h
+
+#include "ThreadPool.h"
+#include "sqlite3.h"
+#include "types.h"
+#include <ReactCommon/CallInvoker.h>
+#include <any>
+#include <jsi/jsi.h>
+#include <unordered_map>
+#include <vector>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+struct TableRowDiscriminator {
+  std::string table;
+  std::vector<int> ids;
+};
+
+struct ReactiveQuery {
+  sqlite3_stmt *stmt;
+  std::vector<TableRowDiscriminator> discriminators;
+  std::shared_ptr<jsi::Value> callback;
+};
+
+class JSI_EXPORT DBHostObject : public jsi::HostObject {
+public:
+  DBHostObject(jsi::Runtime &rt, std::string &base_path,
+               std::shared_ptr<react::CallInvoker> js_call_invoker,
+               std::shared_ptr<ThreadPool> thread_pool, std::string &db_name,
+               std::string &path, std::string &crsqlite_path,
+               std::string &encryption_key);
+
+  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);
+
+  void auto_register_update_hook();
+
+  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;
+  std::string db_name;
+  std::shared_ptr<jsi::Value> update_hook_callback;
+  std::shared_ptr<jsi::Value> commit_hook_callback;
+  std::shared_ptr<jsi::Value> rollback_hook_callback;
+  jsi::Runtime &rt;
+  std::vector<std::shared_ptr<ReactiveQuery>> reactive_queries;
+  bool has_update_hook_registered = false;
+};
+
+} // namespace opsqlite
+
+#endif /* DBHostObject_h */

package/cpp/PreparedStatementHostObject.cpp

@@ -1,5 +1,9 @@
 #include "PreparedStatementHostObject.h"
+#if OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
 #include "bridge.h"
+#endif
 #include "macros.h"
 #include "utils.h"
 
@@ -7,10 +11,6 @@ namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
-PreparedStatementHostObject::PreparedStatementHostObject(
-    std::string dbName, sqlite3_stmt *statementPtr)
-    : _dbName(dbName), _statement(statementPtr) {}
-
 std::vector<jsi::PropNameID>
 PreparedStatementHostObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> keys;
@@ -24,14 +24,17 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 
   if (name == "bind") {
     return HOSTFN("bind", 1) {
-      if (_statement == nullptr) {
+      if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
 
       const jsi::Value &js_params = args[0];
-      std::vector<JSVariant> params = toVariantVec(rt, js_params);
-
-      opsqlite_bind_statement(_statement, &params);
+      std::vector<JSVariant> params = to_variant_vec(rt, js_params);
+#ifdef OP_SQLITE_USE_LIBSQL
+      opsqlite_libsql_bind_statement(_stmt, &params);
+#else
+      opsqlite_bind_statement(_stmt, &params);
+#endif
 
       return {};
     });
@@ -39,16 +42,20 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 
   if (name == "execute") {
     return HOSTFN("execute", 1) {
-      if (_statement == nullptr) {
+      if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
 
       std::vector<DumbHostObject> results;
       std::shared_ptr<std::vector<SmartHostObject>> metadata =
           std::make_shared<std::vector<SmartHostObject>>();
-
-      auto status = opsqlite_execute_prepared_statement(_dbName, _statement,
-                                                        &results, metadata);
+#ifdef OP_SQLITE_USE_LIBSQL
+      auto status = opsqlite_libsql_execute_prepared_statement(
+          _name, _stmt, &results, metadata);
+#else
+      auto status =
+          opsqlite_execute_prepared_statement(_name, _stmt, &results, metadata);
+#endif
 
       if (status.type == SQLiteError) {
         throw std::runtime_error(status.message);
@@ -63,10 +70,17 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 }
 
 PreparedStatementHostObject::~PreparedStatementHostObject() {
-  if (_statement != nullptr) {
-    sqlite3_finalize(_statement);
-    _statement = nullptr;
+#ifdef OP_SQLITE_USE_LIBSQL
+  if (_stmt != nullptr) {
+    libsql_free_stmt(_stmt);
+    _stmt = nullptr;
+  }
+#else
+  if (_stmt != nullptr) {
+    sqlite3_finalize(_stmt);
+    _stmt = nullptr;
   }
+#endif
 }
 
 } // namespace opsqlite

package/cpp/PreparedStatementHostObject.h

@@ -1,16 +1,12 @@
-//
-//  PreparedStatementHostObject.hpp
-//  op-sqlite
-//
-//  Created by Oscar Franco on 5/12/23.
-//
-
-#ifndef PreparedStatementHostObject_h
-#define PreparedStatementHostObject_h
+#pragma once
 
 #include <jsi/jsi.h>
 #include <memory>
+#ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql.h"
+#else
 #include <sqlite3.h>
+#endif
 #include <string>
 
 namespace opsqlite {
@@ -18,7 +14,13 @@ namespace jsi = facebook::jsi;
 
 class PreparedStatementHostObject : public jsi::HostObject {
 public:
-  PreparedStatementHostObject(std::string dbName, sqlite3_stmt *statement);
+#ifdef OP_SQLITE_USE_LIBSQL
+  PreparedStatementHostObject(std::string name, libsql_stmt_t stmt)
+      : _name(name), _stmt(stmt){};
+#else
+  PreparedStatementHostObject(std::string name, sqlite3_stmt *stmt)
+      : _name(name), _stmt(stmt){};
+#endif
   virtual ~PreparedStatementHostObject();
 
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
@@ -26,11 +28,13 @@ public:
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
 private:
-  std::string _dbName;
+  std::string _name;
+#ifdef OP_SQLITE_USE_LIBSQL
+  libsql_stmt_t _stmt;
+#else
   // This shouldn't be de-allocated until sqlite3_finalize is called on it
-  sqlite3_stmt *_statement;
+  sqlite3_stmt *_stmt;
+#endif
 };
 
 } // namespace opsqlite
-
-#endif /* PreparedStatementHostObject_hpp */