@op-engineering/op-sqlite 0.0.0-resolution-test

package/cpp/DBHostObject.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "OPThreadPool.h"
+#include "types.h"
+#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>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+struct PendingReactiveInvocation {
+    std::string db_name;
+    std::string table;
+    std::string rowid;
+};
+
+struct TableRowDiscriminator {
+    std::string table;
+    std::vector<int> ids;
+};
+
+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:
+    // 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 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);
+#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;
+
+  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;
+#ifdef OP_SQLITE_USE_LIBSQL
+    DB db;
+#else
+    sqlite3 *db;
+#endif
+};
+
+} // namespace opsqlite

package/cpp/DumbHostObject.cpp

@@ -0,0 +1,72 @@
+#include "DumbHostObject.h"
+#include "SmartHostObject.h"
+#include "utils.h"
+#include <iostream>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+
+DumbHostObject::DumbHostObject(
+    std::shared_ptr<std::vector<SmartHostObject>> metadata) {
+    this->metadata = metadata;
+};
+
+std::vector<jsi::PropNameID>
+DumbHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> keys;
+
+    for (auto field : *metadata) {
+        // TODO improve this by generating the propName once on metadata
+        // creation
+        keys.push_back(jsi::PropNameID::forAscii(
+            rt, std::get<std::string>(field.fields[0].second)));
+    }
+
+    return keys;
+}
+
+jsi::Value DumbHostObject::get(jsi::Runtime &rt,
+                               const jsi::PropNameID &propNameID) {
+
+    auto name = propNameID.utf8(rt);
+    auto fields = metadata.get();
+    for (int i = 0; i < fields->size(); i++) {
+        auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
+        if (fieldName == name) {
+            return to_jsi(rt, values.at(i));
+        }
+    }
+
+    for (auto pairField : ownValues) {
+        if (name == pairField.first) {
+            return to_jsi(rt, pairField.second);
+        }
+    }
+
+    return {};
+}
+
+void DumbHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
+                         const jsi::Value &value) {
+    auto key = name.utf8(rt);
+    auto fields = metadata.get();
+    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] = to_variant(rt, value);
+            return;
+        }
+    }
+
+    for (auto pairField : ownValues) {
+        if (key == pairField.first) {
+            pairField.second = to_variant(rt, value);
+            return;
+        }
+    }
+
+    ownValues.push_back(std::make_pair(key, to_variant(rt, value)));
+}
+
+} // namespace opsqlite

package/cpp/DumbHostObject.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "SmartHostObject.h"
+#include "types.h"
+#include <any>
+#include <jsi/jsi.h>
+#include <stdio.h>
+#include <vector>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+
+class JSI_EXPORT DumbHostObject : public jsi::HostObject {
+  public:
+    DumbHostObject() = default;
+
+    explicit DumbHostObject(
+        std::shared_ptr<std::vector<SmartHostObject>> metadata);
+
+    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;
+
+    std::vector<JSVariant> values;
+
+    std::shared_ptr<std::vector<SmartHostObject>> metadata;
+
+    std::vector<std::pair<std::string, JSVariant>> ownValues;
+};
+
+} // namespace opsqlite

package/cpp/OPThreadPool.cpp

@@ -0,0 +1,120 @@
+#include "OPThreadPool.h"
+
+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);
+    }
+}
+
+// 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;
+
+    // Wake up all the threads, so they can finish and be joined
+    workQueueConditionVariable.notify_all();
+
+    for (auto &thread : threads) {
+        if (thread.joinable()) {
+            thread.join();
+        }
+    }
+
+    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);
+
+    // Push the request to the queue
+    workQueue.push(task);
+
+    // 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;
+    }
+}
+
+void ThreadPool::waitFinished() {
+    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;
+
+    // Wake up all the threads, so they can finish and be joined
+    workQueueConditionVariable.notify_all();
+
+    for (auto &thread : threads) {
+        if (thread.joinable()) {
+            thread.join();
+        }
+    }
+
+    threads.clear();
+
+    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);
+    }
+
+    done = false;
+}
+} // namespace opsqlite

package/cpp/OPThreadPool.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <condition_variable>
+#include <exception>
+#include <mutex>
+#include <queue>
+#include <stdio.h>
+#include <thread>
+#include <vector>
+
+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();
+};
+
+} // namespace opsqlite

package/cpp/PreparedStatementHostObject.cpp

@@ -0,0 +1,151 @@
+#include "PreparedStatementHostObject.h"
+#if OP_SQLITE_USE_LIBSQL
+#include "libsql/bridge.h"
+#else
+#include "bridge.h"
+#endif
+#include "macros.h"
+#include "utils.h"
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+
+std::vector<jsi::PropNameID>
+PreparedStatementHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> keys;
+
+    return keys;
+}
+
+jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
+                                            const jsi::PropNameID &propNameID) {
+    auto name = propNameID.utf8(rt);
+
+    if (name == "bind") {
+        return HOSTFN("bind") {
+            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);
+
+            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);
+#else
+                        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 == "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 {
+#ifdef OP_SQLITE_USE_LIBSQL
+                        auto status =
+                            opsqlite_libsql_execute_prepared_statement(
+                                _db, _stmt, &results, metadata);
+#else
+                        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 {};
+}
+
+PreparedStatementHostObject::~PreparedStatementHostObject() {
+#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

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+#ifdef OP_SQLITE_USE_LIBSQL
+#include "libsql.h"
+#include "libsql/bridge.h"
+#else
+#include <sqlite3.h>
+#endif
+#include "OPThreadPool.h"
+#include <string>
+#include <utility>
+
+namespace opsqlite {
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+class PreparedStatementHostObject : public jsi::HostObject {
+  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) {};
+#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)) {};
+#endif
+    ~PreparedStatementHostObject() override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    jsi::Value get(jsi::Runtime &rt,
+                   const jsi::PropNameID &propNameID) override;
+
+  private:
+    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

@@ -0,0 +1,34 @@
+#include "SmartHostObject.h"
+#include "utils.h"
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+
+std::vector<jsi::PropNameID>
+SmartHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> keys;
+
+    keys.reserve(fields.size());
+    for (const auto &field : fields) {
+        keys.emplace_back(jsi::PropNameID::forAscii(rt, field.first));
+    }
+
+    return keys;
+}
+
+jsi::Value SmartHostObject::get(jsi::Runtime &rt,
+                                const jsi::PropNameID &propNameID) {
+    auto name = propNameID.utf8(rt);
+
+    for (const auto &field : fields) {
+        auto fieldName = field.first;
+        if (fieldName == name) {
+            return to_jsi(rt, field.second);
+        }
+    }
+
+    return {};
+}
+
+} // namespace opsqlite

package/cpp/SmartHostObject.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "types.h"
+#include <any>
+#include <jsi/jsi.h>
+#include <vector>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+
+class JSI_EXPORT SmartHostObject : public jsi::HostObject {
+  public:
+    SmartHostObject() = default;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    jsi::Value get(jsi::Runtime &rt,
+                   const jsi::PropNameID &propNameID) override;
+
+    std::vector<std::pair<std::string, JSVariant>> fields;
+};
+
+} // namespace opsqlite