@op-engineering/op-sqlite 7.3.0 → 8.0.0-beta0

package/cpp/PreparedStatementHostObject.cpp

@@ -23,7 +23,7 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
   auto name = propNameID.utf8(rt);
 
   if (name == "bind") {
-    return HOSTFN("bind", 1) {
+    return HOSTFN("bind") {
       if (_stmt == nullptr) {
         throw std::runtime_error("statement has been freed");
       }
@@ -41,28 +41,53 @@ jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
   }
 
   if (name == "execute") {
-    return HOSTFN("execute", 1) {
+    return HOSTFN("execute") {
       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 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]() {
+          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_prepared_statement(
-          _name, _stmt, &results, metadata);
+          auto status = opsqlite_libsql_execute_prepared_statement(
+              _name, _stmt, &results, metadata);
 #else
-      auto status =
-          opsqlite_execute_prepared_statement(_name, _stmt, &results, metadata);
+          auto status = opsqlite_execute_prepared_statement(_name, _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) {
+                  auto jsiResult =
+                      createResult(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);
+                }
+              });
+        };
 
-      if (status.type == SQLiteError) {
-        throw std::runtime_error(status.message);
-      }
+        _thread_pool->queueWork(task);
+
+        return {};
+          }));
 
-      auto jsiResult = createResult(rt, status, &results, metadata);
-      return jsiResult;
+        return promise;
     });
   }
 

package/cpp/PreparedStatementHostObject.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
 #include <memory>
 #ifdef OP_SQLITE_USE_LIBSQL
@@ -7,19 +8,29 @@
 #else
 #include <sqlite3.h>
 #endif
+#include "ThreadPool.h"
 #include <string>
 
 namespace opsqlite {
 namespace jsi = facebook::jsi;
+namespace react = facebook::react;
 
 class PreparedStatementHostObject : public jsi::HostObject {
 public:
 #ifdef OP_SQLITE_USE_LIBSQL
-  PreparedStatementHostObject(std::string name, libsql_stmt_t stmt)
-      : _name(name), _stmt(stmt){};
+  PreparedStatementHostObject(
+      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){};
 #else
-  PreparedStatementHostObject(std::string name, sqlite3_stmt *stmt)
-      : _name(name), _stmt(stmt){};
+  PreparedStatementHostObject(
+      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){};
 #endif
   virtual ~PreparedStatementHostObject();
 
@@ -28,6 +39,8 @@ public:
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
 private:
+  std::shared_ptr<react::CallInvoker> _js_call_invoker;
+  std::shared_ptr<ThreadPool> _thread_pool;
   std::string _name;
 #ifdef OP_SQLITE_USE_LIBSQL
   libsql_stmt_t _stmt;

package/cpp/bindings.cpp

@@ -21,6 +21,7 @@ namespace jsi = facebook::jsi;
 
 std::string _base_path;
 std::string _crsqlite_path;
+std::string _sqlite_vec_path;
 std::shared_ptr<react::CallInvoker> _invoker;
 std::shared_ptr<ThreadPool> thread_pool = std::make_shared<ThreadPool>();
 
@@ -43,13 +44,15 @@ void clearState() {
 }
 
 void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
-             const char *base_path, const char *crsqlite_path) {
+             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);
   _invoker = invoker;
 
-  auto open = HOSTFN("open", 1) {
+  auto open = HOSTFN("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);
@@ -82,13 +85,13 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
       }
     }
 
-    std::shared_ptr<DBHostObject> db =
-        std::make_shared<DBHostObject>(rt, path, invoker, thread_pool, name,
-                                       path, _crsqlite_path, encryptionKey);
+    std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
+        rt, path, invoker, thread_pool, name, path, _crsqlite_path,
+        _sqlite_vec_path, encryptionKey);
     return jsi::Object::createFromHostObject(rt, db);
   });
 
-  auto is_sqlcipher = HOSTFN("isSQLCipher", 0) {
+  auto is_sqlcipher = HOSTFN("isSQLCipher") {
 #ifdef OP_SQLITE_USE_SQLCIPHER
     return true;
 #else
@@ -96,7 +99,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
 #endif
   });
 
-  auto is_libsql = HOSTFN("isLibsql", 0) {
+  auto is_libsql = HOSTFN("isLibsql") {
 #ifdef OP_SQLITE_USE_LIBSQL
     return true;
 #else
@@ -105,7 +108,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
   });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  auto open_remote = HOSTFN("openRemote", 1) {
+  auto open_remote = HOSTFN("openRemote") {
     jsi::Object options = args[0].asObject(rt);
     std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
     std::string auth_token =
@@ -116,7 +119,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
     return jsi::Object::createFromHostObject(rt, db);
   });
 
-  auto open_sync = HOSTFN("openSync", 1) {
+  auto open_sync = HOSTFN("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);

package/cpp/bindings.h

@@ -10,7 +10,8 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
 void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
-             const char *base_path, const char *crsqlite_path);
+             const char *base_path, const char *crsqlite_path,
+             const char *sqlite_vec_path);
 void clearState();
 
 } // namespace opsqlite