@op-engineering/op-sqlite 15.0.7 → 15.1.1

package/cpp/DBHostObject.h

@@ -1,12 +1,12 @@
 #pragma once
 
 #include "OPThreadPool.h"
-#include "types.h"
+#include "types.hpp"
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <set>
 #ifdef OP_SQLITE_USE_LIBSQL
-#include "libsql/bridge.h"
+#include "libsql/bridge.hpp"
 #else
 #ifdef __ANDROID__
 #include "sqlite3.h"
@@ -23,82 +23,80 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
 struct PendingReactiveInvocation {
-    std::string db_name;
-    std::string table;
-    std::string rowid;
+  std::string db_name;
+  std::string table;
+  std::string rowid;
 };
 
 struct TableRowDiscriminator {
-    std::string table;
-    std::vector<int> ids;
+  std::string table;
+  std::vector<int> ids;
 };
 
 struct ReactiveQuery {
 #ifndef OP_SQLITE_USE_LIBSQL
-    sqlite3_stmt *stmt;
+  sqlite3_stmt *stmt;
 #endif
-    std::vector<TableRowDiscriminator> discriminators;
-    std::shared_ptr<jsi::Value> callback;
+  std::vector<TableRowDiscriminator> discriminators;
+  std::shared_ptr<jsi::Value> callback;
 };
 
 class JSI_EXPORT DBHostObject : public jsi::HostObject {
-  public:
-    // Normal constructor shared between all backends
-    DBHostObject(jsi::Runtime &rt, std::string &base_path,
-                 std::shared_ptr<react::CallInvoker> invoker,
-                 std::string &db_name, std::string &path,
-                 std::string &crsqlite_path, std::string &sqlite_vec_path,
-                 std::string &encryption_key);
+public:
+  // Normal constructor shared between all backends
+  DBHostObject(jsi::Runtime &rt, std::string &base_path,
+               std::shared_ptr<react::CallInvoker> invoker,
+               std::string &db_name, std::string &path,
+               std::string &crsqlite_path, std::string &sqlite_vec_path,
+               std::string &encryption_key);
 
 #ifdef OP_SQLITE_USE_LIBSQL
-    // Constructor for remoteOpen, purely for remote databases
-    DBHostObject(jsi::Runtime &rt, std::string &url, std::string &auth_token,
-                 std::shared_ptr<react::CallInvoker> invoker);
+  // Constructor for remoteOpen, purely for remote databases
+  DBHostObject(jsi::Runtime &rt, std::string &url, std::string &auth_token,
+               std::shared_ptr<react::CallInvoker> invoker);
 
-    // Constructor for a local database with remote sync
-    DBHostObject(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
-                 std::string &db_name, std::string &path, std::string &url,
-                 std::string &auth_token, int sync_interval, bool offline,
-                 std::string &encryption_key,
-                 std::string &remote_encryption_key);
+  // Constructor for a local database with remote sync
+  DBHostObject(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
+               std::string &db_name, std::string &path, std::string &url,
+               std::string &auth_token, int sync_interval, bool offline,
+               std::string &encryption_key, std::string &remote_encryption_key);
 #endif
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-    jsi::Value get(jsi::Runtime &rt,
-                   const jsi::PropNameID &propNameID) override;
-    void set(jsi::Runtime &rt, const jsi::PropNameID &name,
-             const jsi::Value &value) override;
-    void on_update(const std::string &table, const std::string &operation,
-                   long long row_id);
-    void on_commit();
-    void on_rollback();
-    void invalidate();
-    ~DBHostObject() override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value) override;
+  void on_update(const std::string &table, const std::string &operation,
+                 long long row_id);
+  void on_commit();
+  void on_rollback();
+  void invalidate();
+  ~DBHostObject() override;
 
-  private:
-    std::set<std::shared_ptr<ReactiveQuery>> pending_reactive_queries;
-    void auto_register_update_hook();
-    void create_jsi_functions();
-    void
-    flush_pending_reactive_queries(const std::shared_ptr<jsi::Value> &resolve);
+private:
+  std::set<std::shared_ptr<ReactiveQuery>> pending_reactive_queries;
+  void auto_register_update_hook();
+  void create_jsi_functions();
+  void
+  flush_pending_reactive_queries(const std::shared_ptr<jsi::Value> &resolve);
 
-    std::unordered_map<std::string, jsi::Value> function_map;
-    std::string base_path;
-    std::shared_ptr<react::CallInvoker> invoker;
-    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;
-    std::vector<PendingReactiveInvocation> pending_reactive_invocations;
-    bool is_update_hook_registered = false;
-    bool invalidated = false;
+  std::unordered_map<std::string, jsi::Value> function_map;
+  std::string base_path;
+  std::shared_ptr<react::CallInvoker> invoker;
+  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;
+  std::vector<PendingReactiveInvocation> pending_reactive_invocations;
+  bool is_update_hook_registered = false;
+  bool invalidated = false;
 #ifdef OP_SQLITE_USE_LIBSQL
-    DB db;
+  DB db;
 #else
-    sqlite3 *db;
+  sqlite3 *db;
 #endif
 };
 

package/cpp/DumbHostObject.cpp

@@ -1,6 +1,6 @@
 #include "DumbHostObject.h"
 #include "SmartHostObject.h"
-#include "utils.h"
+#include "utils.hpp"
 #include <iostream>
 
 namespace opsqlite {

package/cpp/DumbHostObject.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "SmartHostObject.h"
-#include "types.h"
+#include "types.hpp"
 #include <any>
 #include <jsi/jsi.h>
 #include <stdio.h>
@@ -12,25 +12,24 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 
 class JSI_EXPORT DumbHostObject : public jsi::HostObject {
-  public:
-    DumbHostObject() = default;
+public:
+  DumbHostObject() = default;
 
-    explicit DumbHostObject(
-        std::shared_ptr<std::vector<SmartHostObject>> metadata);
+  explicit DumbHostObject(
+      std::shared_ptr<std::vector<SmartHostObject>> metadata);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
-    jsi::Value get(jsi::Runtime &rt,
-                   const jsi::PropNameID &propNameID) override;
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
 
-    void set(jsi::Runtime &rt, const jsi::PropNameID &name,
-             const jsi::Value &value) override;
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value) override;
 
-    std::vector<JSVariant> values;
+  std::vector<JSVariant> values;
 
-    std::shared_ptr<std::vector<SmartHostObject>> metadata;
+  std::shared_ptr<std::vector<SmartHostObject>> metadata;
 
-    std::vector<std::pair<std::string, JSVariant>> ownValues;
+  std::vector<std::pair<std::string, JSVariant>> ownValues;
 };
 
 } // namespace opsqlite

package/cpp/OPSqlite.cpp

@@ -0,0 +1,207 @@
+#include "OPSqlite.hpp"
+#include "DBHostObject.h"
+#include "DumbHostObject.h"
+#include "OPThreadPool.h"
+#ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.hpp"
+#else
+#include "bridge.h"
+#endif
+#include "logs.h"
+#include "macros.hpp"
+#include "utils.hpp"
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+std::string _base_path;
+std::string _crsqlite_path;
+std::string _sqlite_vec_path;
+std::vector<std::shared_ptr<DBHostObject>> dbs;
+bool invalidated = false;
+std::shared_ptr<react::CallInvoker> invoker;
+
+// React native will try to clean the module on JS context invalidation
+// (CodePush/Hot Reload) The clearState function is called
+void invalidate() {
+  // Global flag used by the threads to stop work
+  invalidated = true;
+
+  for (const auto &db : dbs) {
+    db->invalidate();
+  }
+
+  // Clear our existing vector of shared pointers so they can be garbage
+  // collected
+  dbs.clear();
+}
+
+void install(jsi::Runtime &rt,
+             const std::shared_ptr<react::CallInvoker> &invoker,
+             const char *base_path, const char *crsqlite_path,
+             const char *sqlite_vec_path) {
+
+  _base_path = std::string(base_path);
+  _crsqlite_path = std::string(crsqlite_path);
+  _sqlite_vec_path = std::string(sqlite_vec_path);
+  opsqlite::invoker = invoker;
+
+  auto open = HFN0 {
+    jsi::Object options = args[0].asObject(rt);
+    std::string name = options.getProperty(rt, "name").asString(rt).utf8(rt);
+    std::string path = std::string(_base_path);
+    std::string location;
+    std::string encryption_key;
+
+    if (options.hasProperty(rt, "location")) {
+      location = options.getProperty(rt, "location").asString(rt).utf8(rt);
+    }
+
+    if (options.hasProperty(rt, "encryptionKey")) {
+      encryption_key =
+          options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt);
+    }
+
+#ifdef OP_SQLITE_USE_SQLCIPHER
+    if (encryption_key.empty()) {
+      log_to_console(rt, "Encryption key is missing for SQLCipher");
+    }
+#endif
+
+    if (!location.empty()) {
+      if (location == ":memory:") {
+        path = ":memory:";
+      } else if (location.rfind('/', 0) == 0) {
+        path = location;
+      } else {
+        path = path + "/" + location;
+      }
+    }
+
+    std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
+        rt, path, opsqlite::invoker, name, path, _crsqlite_path,
+        _sqlite_vec_path, encryption_key);
+    dbs.emplace_back(db);
+    return jsi::Object::createFromHostObject(rt, db);
+  });
+
+  auto is_sqlcipher = HOST_STATIC_FN("isSQLCipher") {
+#ifdef OP_SQLITE_USE_SQLCIPHER
+    return true;
+#else
+    return false;
+#endif
+  });
+
+  auto is_ios_embedded = HOST_STATIC_FN("isIOSEmbedded") {
+#ifdef OP_SQLITE_USE_PHONE_VERSION
+    return true;
+#else
+    return false;
+#endif
+  });
+
+  auto is_libsql = HOST_STATIC_FN("isLibsql") {
+#ifdef OP_SQLITE_USE_LIBSQL
+    return true;
+#else
+    return false;
+#endif
+  });
+
+#ifdef OP_SQLITE_USE_LIBSQL
+  auto open_remote = HOST_STATIC_FN("openRemote") {
+    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);
+
+    return jsi::Object::createFromHostObject(rt, db);
+  });
+
+  auto open_sync = HOST_STATIC_FN("openSync") {
+    jsi::Object options = args[0].asObject(rt);
+    std::string name = options.getProperty(rt, "name").asString(rt).utf8(rt);
+    std::string path = std::string(_base_path);
+    std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
+    std::string auth_token =
+        options.getProperty(rt, "authToken").asString(rt).utf8(rt);
+
+    int sync_interval = 0;
+    if (options.hasProperty(rt, "libsqlSyncInterval")) {
+      sync_interval = static_cast<int>(
+          options.getProperty(rt, "libsqlSyncInterval").asNumber());
+    }
+
+    bool offline = false;
+    if (options.hasProperty(rt, "libsqlOffline")) {
+      offline = options.getProperty(rt, "libsqlOffline").asBool();
+    }
+
+    std::string encryption_key;
+    if (options.hasProperty(rt, "encryptionKey")) {
+      encryption_key =
+          options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt);
+    }
+
+    std::string remote_encryption_key;
+    if (options.hasProperty(rt, "remoteEncryptionKey")) {
+      remote_encryption_key =
+          options.getProperty(rt, "remoteEncryptionKey").asString(rt).utf8(rt);
+    }
+
+    std::string location;
+    if (options.hasProperty(rt, "location")) {
+      location = options.getProperty(rt, "location").asString(rt).utf8(rt);
+    }
+    if (!location.empty()) {
+      if (location == ":memory:") {
+        path = ":memory:";
+      } else if (location.rfind("/", 0) == 0) {
+        path = location;
+      } else {
+        path = path + "/" + location;
+      }
+    }
+
+    std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
+        rt, invoker, name, path, url, auth_token, sync_interval, offline,
+        encryption_key, remote_encryption_key);
+    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));
+  module.setProperty(rt, "isIOSEmbedded", std::move(is_ios_embedded));
+#ifdef OP_SQLITE_USE_LIBSQL
+  module.setProperty(rt, "openRemote", std::move(open_remote));
+  module.setProperty(rt, "openSync", std::move(open_sync));
+#endif
+
+  rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
+}
+
+void expoUpdatesWorkaround(const char *base_path) {
+#ifdef OP_SQLITE_USE_LIBSQL
+  std::string path = std::string(base_path);
+  // Open a DB before anything else so that expo-updates does not mess up the
+  // configuration
+  opsqlite_libsql_open("__dummy", path, "");
+#endif
+}
+
+} // namespace opsqlite

package/cpp/OPThreadPool.cpp

@@ -3,118 +3,118 @@
 namespace opsqlite {
 
 ThreadPool::ThreadPool() : done(false) {
-    // This returns the number of threads supported by the system. If the
-    // function can't figure out this information, it returns 0. 0 is not good,
-    // so we create at least 1
-    //  auto numberOfThreads = std::thread::hardware_concurrency();
-    //  if (numberOfThreads == 0) {
-    //    numberOfThreads = 1;
-    //  }
-
-    auto numberOfThreads = 1;
-    for (unsigned i = 0; i < numberOfThreads; ++i) {
-        // The threads will execute the private member `doWork`. Note that we
-        // need to pass a reference to the function (namespaced with the class
-        // name) as the first argument, and the current object as second
-        // argument
-        threads.emplace_back(&ThreadPool::doWork, this);
-    }
+  // This returns the number of threads supported by the system. If the
+  // function can't figure out this information, it returns 0. 0 is not good,
+  // so we create at least 1
+  //  auto numberOfThreads = std::thread::hardware_concurrency();
+  //  if (numberOfThreads == 0) {
+  //    numberOfThreads = 1;
+  //  }
+
+  auto numberOfThreads = 1;
+  for (unsigned i = 0; i < numberOfThreads; ++i) {
+    // The threads will execute the private member `doWork`. Note that we
+    // need to pass a reference to the function (namespaced with the class
+    // name) as the first argument, and the current object as second
+    // argument
+    threads.emplace_back(&ThreadPool::doWork, this);
+  }
 }
 
 // The destructor joins all the threads so the program can exit gracefully.
 // This will be executed if there is any exception (e.g. creating the threads)
 ThreadPool::~ThreadPool() {
-    // So threads know it's time to shut down
-    done = true;
+  // So threads know it's time to shut down
+  done = true;
 
-    // Wake up all the threads, so they can finish and be joined
-    workQueueConditionVariable.notify_all();
+  // Wake up all the threads, so they can finish and be joined
+  workQueueConditionVariable.notify_all();
 
-    for (auto &thread : threads) {
-        if (thread.joinable()) {
-            thread.join();
-        }
+  for (auto &thread : threads) {
+    if (thread.joinable()) {
+      thread.join();
     }
+  }
 
-    threads.clear();
+  threads.clear();
 }
 
 // This function will be called by the server every time there is a request
 // that needs to be processed by the thread pool
 void ThreadPool::queueWork(const std::function<void(void)> &task) {
-    // Grab the mutex
-    std::lock_guard<std::mutex> g(workQueueMutex);
+  // Grab the mutex
+  std::lock_guard<std::mutex> g(workQueueMutex);
 
-    // Push the request to the queue
-    workQueue.push(task);
+  // Push the request to the queue
+  workQueue.push(task);
 
-    // Notify one thread that there are requests to process
-    workQueueConditionVariable.notify_one();
+  // Notify one thread that there are requests to process
+  workQueueConditionVariable.notify_one();
 }
 
 // Function used by the threads to grab work from the queue
 void ThreadPool::doWork() {
-    // Loop while the queue is not destructing
-    while (!done) {
-        std::function<void(void)> task;
-
-        // Create a scope, so we don't lock the queue for longer than necessary
-        {
-            std::unique_lock<std::mutex> g(workQueueMutex);
-            workQueueConditionVariable.wait(g, [&] {
-                // Only wake up if there are elements in the queue or the
-                // program is shutting down
-                return !workQueue.empty() || done;
-            });
-
-            // If we are shutting down exit without trying to process more work
-            if (done) {
-                break;
-            }
-
-            task = workQueue.front();
-            workQueue.pop();
-        }
-        ++busy;
-        task();
-        --busy;
+  // Loop while the queue is not destructing
+  while (!done) {
+    std::function<void(void)> task;
+
+    // Create a scope, so we don't lock the queue for longer than necessary
+    {
+      std::unique_lock<std::mutex> g(workQueueMutex);
+      workQueueConditionVariable.wait(g, [&] {
+        // Only wake up if there are elements in the queue or the
+        // program is shutting down
+        return !workQueue.empty() || done;
+      });
+
+      // If we are shutting down exit without trying to process more work
+      if (done) {
+        break;
+      }
+
+      task = workQueue.front();
+      workQueue.pop();
     }
+    ++busy;
+    task();
+    --busy;
+  }
 }
 
 void ThreadPool::waitFinished() {
-    std::unique_lock<std::mutex> g(workQueueMutex);
-    workQueueConditionVariable.wait(
-        g, [&] { return workQueue.empty() && (busy == 0); });
+  std::unique_lock<std::mutex> g(workQueueMutex);
+  workQueueConditionVariable.wait(
+      g, [&] { return workQueue.empty() && (busy == 0); });
 }
 
 void ThreadPool::restartPool() {
-    // So threads know it's time to shut down
-    done = true;
+  // So threads know it's time to shut down
+  done = true;
 
-    // Wake up all the threads, so they can finish and be joined
-    workQueueConditionVariable.notify_all();
+  // Wake up all the threads, so they can finish and be joined
+  workQueueConditionVariable.notify_all();
 
-    for (auto &thread : threads) {
-        if (thread.joinable()) {
-            thread.join();
-        }
+  for (auto &thread : threads) {
+    if (thread.joinable()) {
+      thread.join();
     }
+  }
 
-    threads.clear();
+  threads.clear();
 
-    auto numberOfThreads = std::thread::hardware_concurrency();
-    if (numberOfThreads == 0) {
-        numberOfThreads = 1;
-    }
+  auto numberOfThreads = std::thread::hardware_concurrency();
+  if (numberOfThreads == 0) {
+    numberOfThreads = 1;
+  }
 
-    for (unsigned i = 0; i < numberOfThreads; ++i) {
-        // The threads will execute the private member `doWork`. Note that we
-        // need to pass a reference to the function (namespaced with the class
-        // name) as the first argument, and the current object as second
-        // argument
-        threads.emplace_back(&ThreadPool::doWork, this);
-    }
+  for (unsigned i = 0; i < numberOfThreads; ++i) {
+    // The threads will execute the private member `doWork`. Note that we
+    // need to pass a reference to the function (namespaced with the class
+    // name) as the first argument, and the current object as second
+    // argument
+    threads.emplace_back(&ThreadPool::doWork, this);
+  }
 
-    done = false;
+  done = false;
 }
 } // namespace opsqlite

package/cpp/OPThreadPool.h

@@ -11,34 +11,34 @@
 namespace opsqlite {
 
 class ThreadPool {
-  public:
-    ThreadPool();
-    ~ThreadPool();
-    void queueWork(const std::function<void(void)> &task);
-    void waitFinished();
-    void restartPool();
-
-  private:
-    unsigned int busy{};
-    // This condition variable is used for the threads to wait until there is
-    // work to do
-    std::condition_variable_any workQueueConditionVariable;
-
-    // We store the threads in a vector, so we can later stop them gracefully
-    std::vector<std::thread> threads;
-
-    // Mutex to protect workQueue
-    std::mutex workQueueMutex;
-
-    // Queue of requests waiting to be processed
-    std::queue<std::function<void(void)>> workQueue;
-
-    // This will be set to true when the thread pool is shutting down. This
-    // tells the threads to stop looping and finish
-    bool done;
-
-    // Function used by the threads to grab work from the queue
-    void doWork();
+public:
+  ThreadPool();
+  ~ThreadPool();
+  void queueWork(const std::function<void(void)> &task);
+  void waitFinished();
+  void restartPool();
+
+private:
+  unsigned int busy{};
+  // This condition variable is used for the threads to wait until there is
+  // work to do
+  std::condition_variable_any workQueueConditionVariable;
+
+  // We store the threads in a vector, so we can later stop them gracefully
+  std::vector<std::thread> threads;
+
+  // Mutex to protect workQueue
+  std::mutex workQueueMutex;
+
+  // Queue of requests waiting to be processed
+  std::queue<std::function<void(void)>> workQueue;
+
+  // This will be set to true when the thread pool is shutting down. This
+  // tells the threads to stop looping and finish
+  bool done;
+
+  // Function used by the threads to grab work from the queue
+  void doWork();
 };
 
 } // namespace opsqlite