@op-engineering/op-sqlite 11.2.5 → 11.2.6

package/cpp/DBHostObject.h

@@ -5,7 +5,11 @@
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <set>
+#ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
 #include <sqlite3.h>
+#endif
 #include <unordered_map>
 #include <vector>
 
@@ -26,51 +30,55 @@ struct TableRowDiscriminator {
 };
 
 struct ReactiveQuery {
+#ifndef OP_SQLITE_USE_LIBSQL
   sqlite3_stmt *stmt;
+#endif
   std::vector<TableRowDiscriminator> discriminators;
   std::shared_ptr<jsi::Value> callback;
 };
 
 class JSI_EXPORT DBHostObject : public jsi::HostObject {
 public:
-  // Constructor for local databases
+  // Normal constructor shared between all backends
   DBHostObject(jsi::Runtime &rt, std::string &base_path,
                std::shared_ptr<react::CallInvoker> invoker,
-               std::shared_ptr<ThreadPool> thread_pool, std::string &db_name,
-               std::string &path, std::string &crsqlite_path,
-               std::string &sqlite_vec_path, std::string &encryption_key);
+               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,
-               std::shared_ptr<ThreadPool> thread_pool);
+               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::shared_ptr<ThreadPool> thread_pool, std::string &db_name,
-               std::string &path, std::string &url, std::string &auth_token,
-               int sync_interval);
+               std::string &db_name, std::string &path, std::string &url,
+               std::string &auth_token, int sync_interval);
 #endif
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
+  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);
+           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();
+  ~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(std::shared_ptr<jsi::Value> resolve);
+  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<jsi::Value> update_hook;
   std::shared_ptr<react::CallInvoker> invoker;
-  std::shared_ptr<ThreadPool> thread_pool;
+  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;
@@ -80,6 +88,11 @@ private:
   std::vector<PendingReactiveInvocation> pending_reactive_invocations;
   bool is_update_hook_registered = false;
   bool invalidated = false;
+#ifdef OP_SQLITE_USE_LIBSQL
+  DB db;
+#else
+  sqlite3 *db;
+#endif
 };
 
 } // namespace opsqlite

package/cpp/DumbHostObject.cpp

@@ -33,13 +33,13 @@ jsi::Value DumbHostObject::get(jsi::Runtime &rt,
   for (int i = 0; i < fields->size(); i++) {
     auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
     if (fieldName == name) {
-      return toJSI(rt, values.at(i));
+      return to_jsi(rt, values.at(i));
     }
   }
 
   for (auto pairField : ownValues) {
     if (name == pairField.first) {
-      return toJSI(rt, pairField.second);
+      return to_jsi(rt, pairField.second);
     }
   }
 
@@ -53,19 +53,19 @@ void DumbHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
   for (int i = 0; i < fields->size(); i++) {
     auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
     if (fieldName == key) {
-      values[i] = toVariant(rt, value);
+      values[i] = to_variant(rt, value);
       return;
     }
   }
 
   for (auto pairField : ownValues) {
     if (key == pairField.first) {
-      pairField.second = toVariant(rt, value);
+      pairField.second = to_variant(rt, value);
       return;
     }
   }
 
-  ownValues.push_back(std::make_pair(key, toVariant(rt, value)));
+  ownValues.push_back(std::make_pair(key, to_variant(rt, value)));
 }
 
 } // namespace opsqlite

package/cpp/DumbHostObject.h

@@ -1,12 +1,10 @@
-#ifndef DumbHostObject_h
-#define DumbHostObject_h
-
-#include <stdio.h>
+#pragma once
 
 #include "SmartHostObject.h"
 #include "types.h"
 #include <any>
 #include <jsi/jsi.h>
+#include <stdio.h>
 #include <vector>
 
 namespace opsqlite {
@@ -15,16 +13,17 @@ namespace jsi = facebook::jsi;
 
 class JSI_EXPORT DumbHostObject : public jsi::HostObject {
 public:
-  DumbHostObject(){};
+  DumbHostObject() = default;
 
-  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);
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
 
   void set(jsi::Runtime &rt, const jsi::PropNameID &name,
-           const jsi::Value &value);
+           const jsi::Value &value) override;
 
   std::vector<JSVariant> values;
 
@@ -34,5 +33,3 @@ public:
 };
 
 } // namespace opsqlite
-
-#endif /* DumbHostObject_h */

package/cpp/PreparedStatementHostObject.cpp

@@ -30,13 +30,45 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
 
       const jsi::Value &js_params = args[0];
       std::vector<JSVariant> params = to_variant_vec(rt, js_params);
+
+      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, resolve, reject,
+                     invoker = this->_js_call_invoker, params]() {
+          try {
 #ifdef OP_SQLITE_USE_LIBSQL
-      opsqlite_libsql_bind_statement(_stmt, &params);
+            opsqlite_libsql_bind_statement(_stmt, &params);
 #else
-      opsqlite_bind_statement(_stmt, &params);
+            opsqlite_bind_statement(_stmt, &params);
 #endif
+            invoker->invokeAsync([&rt, resolve] {
+              resolve->asObject(rt).asFunction(rt).call(rt, {});
+            });
+          } catch (const std::runtime_error &e) {
+            invoker->invokeAsync([&rt, e, reject] {
+              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+              auto error = errorCtr.callAsConstructor(
+                  rt, jsi::String::createFromUtf8(rt, e.what()));
+              reject->asObject(rt).asFunction(rt).call(rt, error);
+            });
+          } catch (const std::exception &e) {
+            invoker->invokeAsync([&rt, e, reject] {
+              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+              auto error = errorCtr.callAsConstructor(
+                  rt, jsi::String::createFromUtf8(rt, e.what()));
+              reject->asObject(rt).asFunction(rt).call(rt, error);
+            });
+          }
+        };
+
+        _thread_pool->queueWork(task);
 
-      return {};
+        return {};
+          }));
+      return promise;
     });
   }
 
@@ -56,30 +88,32 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
           std::vector<DumbHostObject> results;
           std::shared_ptr<std::vector<SmartHostObject>> metadata =
               std::make_shared<std::vector<SmartHostObject>>();
+          try {
 #ifdef OP_SQLITE_USE_LIBSQL
-          auto status = opsqlite_libsql_execute_prepared_statement(
-              _name, _stmt, &results, metadata);
+            auto status = opsqlite_libsql_execute_prepared_statement(
+                _db, _stmt, &results, metadata);
 #else
-          auto status = opsqlite_execute_prepared_statement(_name, _stmt,
-                                                            &results, metadata);
+            auto status = opsqlite_execute_prepared_statement(
+                _db, _stmt, &results, metadata);
 #endif
-          invoker->invokeAsync(
-              [&rt, status = std::move(status),
-               results = std::make_shared<std::vector<DumbHostObject>>(results),
-               metadata, resolve, reject] {
-                if (status.type == SQLiteOk) {
+            invoker->invokeAsync(
+                [&rt, status = std::move(status),
+                 results =
+                     std::make_shared<std::vector<DumbHostObject>>(results),
+                 metadata, resolve] {
                   auto jsiResult =
                       create_result(rt, status, results.get(), metadata);
                   resolve->asObject(rt).asFunction(rt).call(
                       rt, std::move(jsiResult));
-                } else {
-                  auto errorCtr =
-                      rt.global().getPropertyAsFunction(rt, "Error");
-                  auto error = errorCtr.callAsConstructor(
-                      rt, jsi::String::createFromUtf8(rt, status.message));
-                  reject->asObject(rt).asFunction(rt).call(rt, error);
-                }
-              });
+                });
+          } catch (std::exception &exc) {
+            invoker->invokeAsync([&rt, &exc, reject] {
+              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+              auto error = errorCtr.callAsConstructor(
+                  rt, jsi::String::createFromUtf8(rt, exc.what()));
+              reject->asObject(rt).asFunction(rt).call(rt, error);
+            });
+          }
         };
 
         _thread_pool->queueWork(task);

package/cpp/PreparedStatementHostObject.h

@@ -4,12 +4,14 @@
 #include <jsi/jsi.h>
 #include <memory>
 #ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
 #include "libsql.h"
 #else
 #include <sqlite3.h>
 #endif
 #include "ThreadPool.h"
 #include <string>
+#include <utility>
 
 namespace opsqlite {
 namespace jsi = facebook::jsi;
@@ -19,35 +21,37 @@ class PreparedStatementHostObject : public jsi::HostObject {
 public:
 #ifdef OP_SQLITE_USE_LIBSQL
   PreparedStatementHostObject(
-      std::string name, libsql_stmt_t stmt,
+      DB const &db, std::string name, libsql_stmt_t stmt,
       std::shared_ptr<react::CallInvoker> js_call_invoker,
       std::shared_ptr<ThreadPool> thread_pool)
-      : _name(name), _stmt(stmt), _js_call_invoker(js_call_invoker),
-        _thread_pool(thread_pool){};
+      : _db(db), _name(std::move(name)), _stmt(stmt), _js_call_invoker(js_call_invoker),
+        _thread_pool(thread_pool) {};
 #else
   PreparedStatementHostObject(
-      std::string name, sqlite3_stmt *stmt,
+      sqlite3 *db, std::string name, sqlite3_stmt *stmt,
       std::shared_ptr<react::CallInvoker> js_call_invoker,
       std::shared_ptr<ThreadPool> thread_pool)
-      : _name(name), _stmt(stmt), _js_call_invoker(js_call_invoker),
-        _thread_pool(thread_pool){};
+      : _db(db), _name(std::move(name)), _stmt(stmt), _js_call_invoker(std::move(js_call_invoker)),
+        _thread_pool(std::move(thread_pool)) {};
 #endif
-  virtual ~PreparedStatementHostObject();
+  ~PreparedStatementHostObject() override;
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
 
 private:
-  std::shared_ptr<react::CallInvoker> _js_call_invoker;
-  std::shared_ptr<ThreadPool> _thread_pool;
   std::string _name;
 #ifdef OP_SQLITE_USE_LIBSQL
+  DB _db;
   libsql_stmt_t _stmt;
 #else
+  sqlite3 *_db;
   // This shouldn't be de-allocated until sqlite3_finalize is called on it
   sqlite3_stmt *_stmt;
 #endif
+  std::shared_ptr<react::CallInvoker> _js_call_invoker;
+  std::shared_ptr<ThreadPool> _thread_pool;
 };
 
 } // namespace opsqlite

package/cpp/SmartHostObject.cpp

@@ -9,8 +9,9 @@ std::vector<jsi::PropNameID>
 SmartHostObject::getPropertyNames(jsi::Runtime &rt) {
   std::vector<jsi::PropNameID> keys;
 
-  for (auto field : fields) {
-    keys.push_back(jsi::PropNameID::forAscii(rt, field.first));
+  keys.reserve(fields.size());
+for (const auto& field : fields) {
+    keys.emplace_back(jsi::PropNameID::forAscii(rt, field.first));
   }
 
   return keys;
@@ -20,10 +21,10 @@ jsi::Value SmartHostObject::get(jsi::Runtime &rt,
                                 const jsi::PropNameID &propNameID) {
   auto name = propNameID.utf8(rt);
 
-  for (auto field : fields) {
+  for (const auto& field : fields) {
     auto fieldName = field.first;
     if (fieldName == name) {
-      return toJSI(rt, field.second);
+      return to_jsi(rt, field.second);
     }
   }
 

package/cpp/SmartHostObject.h

@@ -1,5 +1,4 @@
-#ifndef SmartHostObject_h
-#define SmartHostObject_h
+#pragma once
 
 #include "types.h"
 #include <any>
@@ -12,15 +11,13 @@ namespace jsi = facebook::jsi;
 
 class JSI_EXPORT SmartHostObject : public jsi::HostObject {
 public:
-  SmartHostObject(){};
+  SmartHostObject() = default;
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
 
   std::vector<std::pair<std::string, JSVariant>> fields;
 };
 
 } // namespace opsqlite
-
-#endif /* SmartHostObject_h */

package/cpp/ThreadPool.cpp

@@ -6,16 +6,17 @@ 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 = 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.push_back(std::thread(&ThreadPool::doWork, this));
+    threads.emplace_back(&ThreadPool::doWork, this);
   }
 }
 
@@ -39,7 +40,7 @@ ThreadPool::~ThreadPool() {
 
 // 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(std::function<void(void)> task) {
+void ThreadPool::queueWork(const std::function<void(void)>& task) {
   // Grab the mutex
   std::lock_guard<std::mutex> g(workQueueMutex);
 
@@ -65,7 +66,7 @@ void ThreadPool::doWork() {
         return !workQueue.empty() || done;
       });
 
-      // If we are shutting down exit witout trying to process more work
+      // If we are shutting down exit without trying to process more work
       if (done) {
         break;
       }
@@ -109,7 +110,7 @@ void ThreadPool::restartPool() {
     // 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.push_back(std::thread(&ThreadPool::doWork, this));
+    threads.emplace_back(&ThreadPool::doWork, this);
   }
 
   done = false;

package/cpp/ThreadPool.h

@@ -1,5 +1,4 @@
-#ifndef ThreadPool_h
-#define ThreadPool_h
+#pragma once
 
 #include <condition_variable>
 #include <exception>
@@ -15,12 +14,12 @@ class ThreadPool {
 public:
   ThreadPool();
   ~ThreadPool();
-  void queueWork(std::function<void(void)> task);
+  void queueWork(const std::function<void(void)>& task);
   void waitFinished();
   void restartPool();
 
 private:
-  unsigned int busy;
+  unsigned int busy{};
   // This condition variable is used for the threads to wait until there is work
   // to do
   std::condition_variable_any workQueueConditionVariable;
@@ -42,6 +41,4 @@ private:
   void doWork();
 };
 
-} // namespace opsqlite
-
-#endif /* ThreadPool_h */
+} // namespace opsqlite

package/cpp/bindings.cpp

@@ -22,40 +22,29 @@ namespace jsi = facebook::jsi;
 std::string _base_path;
 std::string _crsqlite_path;
 std::string _sqlite_vec_path;
-std::shared_ptr<ThreadPool> thread_pool = std::make_shared<ThreadPool>();
 std::vector<std::shared_ptr<DBHostObject>> dbs;
 
 // 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
-// to prevent any ongoing operations from continuing work and can return early
-bool invalidated = false;
-
-void clearState() {
+// (CodePush/Hot Reload) The clearState function is called
+void invalidate() {
   for (const auto &db : dbs) {
     db->invalidate();
   }
-  invalidated = true;
-
-#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();
+  // 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) {
-  invalidated = false;
   _base_path = std::string(base_path);
   _crsqlite_path = std::string(crsqlite_path);
   _sqlite_vec_path = std::string(sqlite_vec_path);
 
-  auto open = HOSTFN("open") {
+  auto open = HOST_STATIC_FN("open") {
     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);
@@ -89,13 +78,13 @@ void install(jsi::Runtime &rt,
     }
 
     std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, path, invoker, thread_pool, name, path, _crsqlite_path,
-        _sqlite_vec_path, encryptionKey);
+        rt, path, invoker, name, path, _crsqlite_path, _sqlite_vec_path,
+        encryptionKey);
     dbs.emplace_back(db);
     return jsi::Object::createFromHostObject(rt, db);
   });
 
-  auto is_sqlcipher = HOSTFN("isSQLCipher") {
+  auto is_sqlcipher = HOST_STATIC_FN("isSQLCipher") {
 #ifdef OP_SQLITE_USE_SQLCIPHER
     return true;
 #else
@@ -103,7 +92,7 @@ void install(jsi::Runtime &rt,
 #endif
   });
 
-  auto is_libsql = HOSTFN("isLibsql") {
+  auto is_libsql = HOST_STATIC_FN("isLibsql") {
 #ifdef OP_SQLITE_USE_LIBSQL
     return true;
 #else
@@ -112,18 +101,18 @@ void install(jsi::Runtime &rt,
   });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  auto open_remote = HOSTFN("openRemote") {
+  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, thread_pool);
+        rt, url, auth_token, invoker);
     return jsi::Object::createFromHostObject(rt, db);
   });
 
-  auto open_sync = HOSTFN("openSync") {
+  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);
@@ -152,7 +141,7 @@ void install(jsi::Runtime &rt,
     }
 
     std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, invoker, thread_pool, name, path, url, auth_token, sync_interval);
+        rt, invoker, name, path, url, auth_token, sync_interval);
     return jsi::Object::createFromHostObject(rt, db);
   });
 #endif

package/cpp/bindings.h

@@ -9,9 +9,10 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
-void install(jsi::Runtime &rt, const std::shared_ptr<react::CallInvoker>& invoker,
+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);
-void clearState();
+void invalidate();
 
 } // namespace opsqlite