@op-engineering/op-sqlite 15.0.7 → 15.1.1

package/cpp/PreparedStatementHostObject.cpp

@@ -1,11 +1,11 @@
 #include "PreparedStatementHostObject.h"
 #if OP_SQLITE_USE_LIBSQL
-#include "libsql/bridge.h"
+#include "libsql/bridge.hpp"
 #else
 #include "bridge.h"
 #endif
-#include "macros.h"
-#include "utils.h"
+#include "macros.hpp"
+#include "utils.hpp"
 
 namespace opsqlite {
 
@@ -13,161 +13,112 @@ namespace jsi = facebook::jsi;
 
 std::vector<jsi::PropNameID>
 PreparedStatementHostObject::getPropertyNames(jsi::Runtime &rt) {
-    std::vector<jsi::PropNameID> keys;
+  std::vector<jsi::PropNameID> keys;
 
-    return keys;
+  return keys;
 }
 
 jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
                                             const jsi::PropNameID &propNameID) {
-    auto name = propNameID.utf8(rt);
+  auto name = propNameID.utf8(rt);
 
-    if (name == "bind") {
-        return HOSTFN("bind") {
-            if (_stmt == nullptr) {
-                throw std::runtime_error("statement has been freed");
-            }
+  if (name == "bind") {
+    return HFN(this) {
+      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);
+      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 {
+      return promisify(
+          rt,
+          [this, params]() {
 #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 promise;
-        });
-    }
-
-    if (name == "bindSync") {
-      return HOSTFN("bindSync") {
-        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);
-        try {
+            return nullptr;
+          },
+          [](jsi::Runtime &rt, std::any result) {
+            return jsi::Value::undefined;
+          });
+    });
+  }
+
+  if (name == "bindSync") {
+    return HOSTFN("bindSync") {
+      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);
+      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
-        } catch (const std::runtime_error &e) {
-          throw std::runtime_error(e.what());
-        } catch (const std::exception &e) {
-          throw std::runtime_error(e.what());
-        }
-        return {};
-      });
-    }
-
-    if (name == "execute") {
-        return HOSTFN("execute") {
-            if (_stmt == nullptr) {
-                throw std::runtime_error("statement has been freed");
-            }
-
-            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>>();
-                    try {
+      } catch (const std::runtime_error &e) {
+        throw std::runtime_error(e.what());
+      } catch (const std::exception &e) {
+        throw std::runtime_error(e.what());
+      }
+      return {};
+    });
+  }
+
+  if (name == "execute") {
+    return HOSTFN("execute") {
+      if (_stmt == nullptr) {
+        throw std::runtime_error("statement has been freed");
+      }
+
+      return promisify(
+          rt,
+          [this]() {
+            std::vector<DumbHostObject> results;
+            auto metadata = std::make_shared<std::vector<SmartHostObject>>();
 #ifdef OP_SQLITE_USE_LIBSQL
-                        auto status =
-                            opsqlite_libsql_execute_prepared_statement(
-                                _db, _stmt, &results, metadata);
+            auto status = opsqlite_libsql_execute_prepared_statement(
+                _db, _stmt, &results, metadata);
 #else
-                        auto status = opsqlite_execute_prepared_statement(
-                            _db, _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] {
-                                auto jsiResult = create_result(
-                                    rt, status, results.get(), metadata);
-                                resolve->asObject(rt).asFunction(rt).call(
-                                    rt, std::move(jsiResult));
-                            });
-                    } 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);
-
-                return {};
-          }));
-
-        return promise;
-        });
-    }
-
-    return {};
+            return std::make_tuple(results, *metadata, status);
+          },
+          [](jsi::Runtime &rt, std::any result) {
+            auto tuple = std::any_cast<
+                std::tuple<std::vector<DumbHostObject>,
+                           std::vector<SmartHostObject>, BridgeResult>>(result);
+            const auto &results = std::get<0>(tuple);
+            const auto &metadata = std::get<1>(tuple);
+            BridgeResult status = std::get<2>(tuple);
+            auto results_ptr =
+                std::make_shared<std::vector<DumbHostObject>>(results);
+            auto metadata_ptr =
+                std::make_shared<std::vector<SmartHostObject>>(metadata);
+            return create_result(rt, status, results_ptr.get(), metadata_ptr);
+          });
+    });
+  }
+  return {};
 }
 
 PreparedStatementHostObject::~PreparedStatementHostObject() {
 #ifdef OP_SQLITE_USE_LIBSQL
-    if (_stmt != nullptr) {
-        libsql_free_stmt(_stmt);
-        _stmt = nullptr;
-    }
+  if (_stmt != nullptr) {
+    libsql_free_stmt(_stmt);
+    _stmt = nullptr;
+  }
 #else
-    if (_stmt != nullptr) {
-        //    sqlite3_finalize(_stmt);
-        _stmt = nullptr;
-    }
+  if (_stmt != nullptr) {
+    //    sqlite3_finalize(_stmt);
+    _stmt = nullptr;
+  }
 #endif
 }
 

package/cpp/PreparedStatementHostObject.h

@@ -5,7 +5,7 @@
 #include <memory>
 #ifdef OP_SQLITE_USE_LIBSQL
 #include "libsql.h"
-#include "libsql/bridge.h"
+#include "libsql/bridge.hpp"
 #else
 #ifdef __ANDROID__
 #include "sqlite3.h"
@@ -22,42 +22,30 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
 class PreparedStatementHostObject : public jsi::HostObject {
-  public:
+public:
 #ifdef OP_SQLITE_USE_LIBSQL
-    PreparedStatementHostObject(
-        DB const &db, std::string name, libsql_stmt_t stmt,
-        std::shared_ptr<react::CallInvoker> js_call_invoker,
-        std::shared_ptr<ThreadPool> thread_pool)
-        : _db(db), _name(std::move(name)), _stmt(stmt),
-          _js_call_invoker(js_call_invoker), _thread_pool(thread_pool) {};
+  PreparedStatementHostObject(
+      DB const &db, libsql_stmt_t stmt)
+      : _db(db), _stmt(stmt) {};
 #else
-    PreparedStatementHostObject(
-        sqlite3 *db, std::string name, sqlite3_stmt *stmt,
-        std::shared_ptr<react::CallInvoker> js_call_invoker,
-        std::shared_ptr<ThreadPool> thread_pool)
-        : _db(db), _name(std::move(name)), _stmt(stmt),
-          _js_call_invoker(std::move(js_call_invoker)),
-          _thread_pool(std::move(thread_pool)) {};
+  PreparedStatementHostObject(sqlite3 *db, sqlite3_stmt *stmt)
+      : _db(db), _stmt(stmt) {};
 #endif
-    ~PreparedStatementHostObject() override;
+  ~PreparedStatementHostObject() override;
 
-    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;
 
-  private:
-    std::string _name;
+private:
 #ifdef OP_SQLITE_USE_LIBSQL
-    DB _db;
-    libsql_stmt_t _stmt;
+  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;
+  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

@@ -1,5 +1,5 @@
 #include "SmartHostObject.h"
-#include "utils.h"
+#include "utils.hpp"
 
 namespace opsqlite {
 

package/cpp/SmartHostObject.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "types.h"
+#include "types.hpp"
 #include <any>
 #include <jsi/jsi.h>
 #include <vector>
@@ -10,15 +10,14 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 
 class JSI_EXPORT SmartHostObject : public jsi::HostObject {
-  public:
-    SmartHostObject() = default;
+public:
+  SmartHostObject() = default;
 
-    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;
 
-    std::vector<std::pair<std::string, JSVariant>> fields;
+  std::vector<std::pair<std::string, JSVariant>> fields;
 };
 
 } // namespace opsqlite