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

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 = to_variant_vec(rt, js_params);
-
-      opsqlite_bind_statement(_statement, &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 */

package/cpp/bindings.cpp

@@ -1,12 +1,14 @@
 #include "bindings.h"
 #include "DBHostObject.h"
 #include "DumbHostObject.h"
-#include "PreparedStatementHostObject.h"
 #include "ThreadPool.h"
+#ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
 #include "bridge.h"
+#endif
 #include "logs.h"
 #include "macros.h"
-#include "sqlbatchexecutor.h"
 #include "utils.h"
 #include <iostream>
 #include <string>
@@ -17,16 +19,10 @@ namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
-std::string basePath;
-std::string crsqlitePath;
-std::shared_ptr<react::CallInvoker> invoker;
+std::string _base_path;
+std::string _crsqlite_path;
+std::shared_ptr<react::CallInvoker> _invoker;
 std::shared_ptr<ThreadPool> thread_pool = std::make_shared<ThreadPool>();
-// std::unordered_map<std::string, std::shared_ptr<jsi::Value>> updateHooks =
-//     std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
-// std::unordered_map<std::string, std::shared_ptr<jsi::Value>> commitHooks =
-//     std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
-// std::unordered_map<std::string, std::shared_ptr<jsi::Value>> rollbackHooks =
-//     std::unordered_map<std::string, std::shared_ptr<jsi::Value>>();
 
 // React native will try to clean the module on JS context invalidation
 // (CodePush/Hot Reload) The clearState function is called and we use this flag
@@ -35,32 +31,28 @@ bool invalidated = false;
 
 void clearState() {
   invalidated = true;
-  // Will terminate all operations and database connections
+
+#ifdef OP_SQLITE_USE_LIBSQL
+  opsqlite_libsql_close_all();
+#else
   opsqlite_close_all();
+#endif
+
   // We then join all the threads before the context gets invalidated
   thread_pool->restartPool();
-  //  updateHooks.clear();
-  //  commitHooks.clear();
-  //  rollbackHooks.clear();
 }
 
-void install(jsi::Runtime &rt,
-             std::shared_ptr<react::CallInvoker> js_call_invoker,
-             const char *doc_path, const char *_crsqlitePath) {
-
+void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
+             const char *base_path, const char *crsqlite_path) {
   invalidated = false;
-  basePath = std::string(doc_path);
-  crsqlitePath = std::string(_crsqlitePath);
-  invoker = js_call_invoker;
-
-  auto open = HOSTFN("open", 3) {
-    if (count == 0) {
-      throw std::runtime_error("[op-sqlite][open] database name is required");
-    }
+  _base_path = std::string(base_path);
+  _crsqlite_path = std::string(crsqlite_path);
+  _invoker = invoker;
 
+  auto open = HOSTFN("open", 1) {
     jsi::Object options = args[0].asObject(rt);
-    std::string dbName = options.getProperty(rt, "name").asString(rt).utf8(rt);
-    std::string path = std::string(basePath);
+    std::string name = options.getProperty(rt, "name").asString(rt).utf8(rt);
+    std::string path = std::string(_base_path);
     std::string location;
     std::string encryptionKey;
 
@@ -90,9 +82,9 @@ void install(jsi::Runtime &rt,
       }
     }
 
-    std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, basePath, invoker, thread_pool, dbName, path, crsqlitePath,
-        encryptionKey);
+    std::shared_ptr<DBHostObject> db =
+        std::make_shared<DBHostObject>(rt, path, invoker, thread_pool, name,
+                                       path, _crsqlite_path, encryptionKey);
     return jsi::Object::createFromHostObject(rt, db);
   });
 
@@ -104,9 +96,34 @@ void install(jsi::Runtime &rt,
 #endif
   });
 
+  auto is_libsql = HOSTFN("isLibsql", 0) {
+#ifdef OP_SQLITE_USE_LIBSQL
+    return true;
+#else
+    return false;
+#endif
+  });
+
+#ifdef OP_SQLITE_USE_LIBSQL
+  auto open_remote = HOSTFN("openRemote", 1) {
+    jsi::Object options = args[0].asObject(rt);
+    std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
+    std::string auth_token =
+        options.getProperty(rt, "authToken").asString(rt).utf8(rt);
+
+    std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
+        rt, url, auth_token, invoker, thread_pool);
+    return jsi::Object::createFromHostObject(rt, db);
+  });
+#endif
+
   jsi::Object module = jsi::Object(rt);
   module.setProperty(rt, "open", std::move(open));
   module.setProperty(rt, "isSQLCipher", std::move(is_sqlcipher));
+  module.setProperty(rt, "isLibsql", std::move(is_libsql));
+#ifdef OP_SQLITE_USE_LIBSQL
+  module.setProperty(rt, "openRemote", std::move(open_remote));
+#endif
 
   rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
 }

package/cpp/bindings.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <jsi/jsilib.h>
@@ -7,9 +9,8 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
-void install(jsi::Runtime &rt,
-             std::shared_ptr<react::CallInvoker> jsCallInvoker,
-             const char *docPath, const char *crsqlitePath);
+void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
+             const char *base_path, const char *crsqlite_path);
 void clearState();
 
 } // namespace opsqlite

package/cpp/bridge.cpp

@@ -867,4 +867,49 @@ BridgeResult opsqlite_load_extension(std::string const &db_name,
 #endif
 }
 
+BatchResult opsqlite_execute_batch(std::string dbName,
+                                   std::vector<BatchArguments> *commands) {
+  size_t commandCount = commands->size();
+  if (commandCount <= 0) {
+    return BatchResult{
+        .type = SQLiteError,
+        .message = "No SQL commands provided",
+    };
+  }
+
+  try {
+    int affectedRows = 0;
+    opsqlite_execute(dbName, "BEGIN EXCLUSIVE TRANSACTION", nullptr, nullptr,
+                     nullptr);
+    for (int i = 0; i < commandCount; i++) {
+      auto command = commands->at(i);
+      // We do not provide a datastructure to receive query data because we
+      // don't need/want to handle this results in a batch execution
+      auto result = opsqlite_execute(dbName, command.sql, command.params.get(),
+                                     nullptr, nullptr);
+      if (result.type == SQLiteError) {
+        opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
+        return BatchResult{
+            .type = SQLiteError,
+            .message = result.message,
+        };
+      } else {
+        affectedRows += result.affectedRows;
+      }
+    }
+    opsqlite_execute(dbName, "COMMIT", nullptr, nullptr, nullptr);
+    return BatchResult{
+        .type = SQLiteOk,
+        .affectedRows = affectedRows,
+        .commands = static_cast<int>(commandCount),
+    };
+  } catch (std::exception &exc) {
+    opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
+    return BatchResult{
+        .type = SQLiteError,
+        .message = exc.what(),
+    };
+  }
+}
+
 } // namespace opsqlite

package/cpp/bridge.h

@@ -50,6 +50,9 @@ opsqlite_execute(std::string const &dbName, std::string const &query,
                  std::vector<DumbHostObject> *results,
                  std::shared_ptr<std::vector<SmartHostObject>> metadatas);
 
+BatchResult opsqlite_execute_batch(std::string dbName,
+                                   std::vector<BatchArguments> *commands);
+
 BridgeResult opsqlite_execute_raw(std::string const &dbName,
                                   std::string const &query,
                                   const std::vector<JSVariant> *params,