@op-engineering/op-sqlite 1.0.0

package/cpp/DynamicHostObject.h

@@ -0,0 +1,30 @@
+#ifndef DynamicHostObject_h
+#define DynamicHostObject_h
+
+#include <jsi/jsi.h>
+#include <any>
+#include <vector>
+#include <unordered_map>
+
+namespace osp {
+
+    namespace jsi = facebook::jsi;
+
+    class JSI_EXPORT DynamicHostObject: public jsi::HostObject {
+    public:
+        DynamicHostObject() {};
+
+        virtual ~DynamicHostObject() {};
+
+        std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
+
+        jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
+
+        std::unordered_map<std::string, std::any> fields;
+
+
+    };
+
+}
+
+#endif /* DynamicHostObject_h */

package/cpp/ThreadPool.cpp

@@ -0,0 +1,95 @@
+#include "ThreadPool.h"
+
+namespace osp {
+
+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;
+  }
+
+  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));
+  }
+}
+
+// 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();
+    }
+  }
+}
+
+// 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)
+{
+  // 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 witout 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); });
+}
+
+
+}

package/cpp/ThreadPool.h

@@ -0,0 +1,46 @@
+#ifndef ThreadPool_h
+#define ThreadPool_h
+
+#include <condition_variable>
+#include <exception>
+#include <mutex>
+#include <queue>
+#include <stdio.h>
+#include <thread>
+#include <vector>
+
+namespace osp {
+
+class ThreadPool {
+public:
+  ThreadPool();
+  ~ThreadPool();
+  void queueWork(std::function<void(void)> task);
+  void waitFinished();
+
+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();
+};
+
+}
+
+#endif /* ThreadPool_h */

package/cpp/bindings.cpp

@@ -0,0 +1,430 @@
+#include "bindings.h"
+#include "bridge.h"
+#include "logs.h"
+#include "utils.h"
+#include "ThreadPool.h"
+#include "sqlbatchexecutor.h"
+#include <vector>
+#include <string>
+#include "macros.h"
+#include <iostream>
+
+namespace osp {
+
+namespace jsi = facebook::jsi;
+
+std::string basePath;
+std::shared_ptr<react::CallInvoker> invoker;
+std::shared_ptr<ThreadPool> pool;
+
+void clearState() {
+    sqliteCloseAll();
+}
+
+void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker, const char *docPath)
+{
+    basePath = std::string(docPath);
+    pool = std::make_shared<ThreadPool>();
+    invoker = jsCallInvoker;
+    
+    auto open = HOSTFN("open", 2) {
+        if (count == 0)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][open] database name is required");
+        }
+        
+        if (!args[0].isString())
+        {
+            throw jsi::JSError(rt, "[op-sqlite][open] database name must be a string");
+        }
+        
+        std::string dbName = args[0].asString(rt).utf8(rt);
+        std::string tempDocPath = std::string(basePath);
+        
+        if (count > 1 && !args[1].isUndefined() && !args[1].isNull())
+        {
+            if (!args[1].isString())
+            {
+                throw jsi::JSError(rt, "[op-sqlite][open] database location must be a string");
+            }
+            
+            tempDocPath = tempDocPath + "/" + args[1].asString(rt).utf8(rt);
+        }
+        
+        BridgeResult result = sqliteOpenDb(dbName, tempDocPath);
+        
+        if (result.type == SQLiteError)
+        {
+            throw jsi::JSError(rt, result.message.c_str());
+        }
+        
+        return {};
+    });
+    
+    auto attach = HOSTFN("attach", 4) {
+        if(count < 3) {
+            throw jsi::JSError(rt, "[op-sqlite][attach] Incorrect number of arguments");
+        }
+        if (!args[0].isString() || !args[1].isString() || !args[2].isString())
+        {
+            throw jsi::JSError(rt, "dbName, databaseToAttach and alias must be a strings");
+            return {};
+        }
+        
+        std::string tempDocPath = std::string(basePath);
+        if (count > 3 && !args[3].isUndefined() && !args[3].isNull())
+        {
+            if (!args[3].isString())
+            {
+                throw jsi::JSError(rt, "[op-sqlite][attach] database location must be a string");
+            }
+            
+            tempDocPath = tempDocPath + "/" + args[3].asString(rt).utf8(rt);
+        }
+        
+        std::string dbName = args[0].asString(rt).utf8(rt);
+        std::string databaseToAttach = args[1].asString(rt).utf8(rt);
+        std::string alias = args[2].asString(rt).utf8(rt);
+        BridgeResult result = sqliteAttachDb(dbName, tempDocPath, databaseToAttach, alias);
+        
+        if (result.type == SQLiteError)
+        {
+            throw jsi::JSError(rt, result.message.c_str());
+        }
+        
+        return {};
+    });
+    
+    auto detach = HOSTFN("detach", 2) {
+        if(count < 2) {
+            throw jsi::JSError(rt, "[op-sqlite][detach] Incorrect number of arguments");
+        }
+        if (!args[0].isString() || !args[1].isString())
+        {
+            throw jsi::JSError(rt, "dbName, databaseToAttach and alias must be a strings");
+            return {};
+        }
+        
+        std::string dbName = args[0].asString(rt).utf8(rt);
+        std::string alias = args[1].asString(rt).utf8(rt);
+        BridgeResult result = sqliteDetachDb(dbName, alias);
+        
+        if (result.type == SQLiteError)
+        {
+            throw jsi::JSError(rt, result.message.c_str());
+        }
+        
+        return {};
+    });
+    
+    auto close = HOSTFN("close", 1)
+    {
+        if (count == 0)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][close] database name is required");
+        }
+        
+        if (!args[0].isString())
+        {
+            throw jsi::JSError(rt, "[op-sqlite][close] database name must be a string");
+        }
+        
+        std::string dbName = args[0].asString(rt).utf8(rt);
+        
+        BridgeResult result = sqliteCloseDb(dbName);
+        
+        if (result.type == SQLiteError)
+        {
+            throw jsi::JSError(rt, result.message.c_str());
+        }
+        
+        return {};
+    });
+    
+    auto remove = HOSTFN("delete", 2)
+    {
+        if (count == 0)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][open] database name is required");
+        }
+        
+        if (!args[0].isString())
+        {
+            throw jsi::JSError(rt, "[op-sqlite][open] database name must be a string");
+        }
+        
+        std::string dbName = args[0].asString(rt).utf8(rt);
+        
+        std::string tempDocPath = std::string(basePath);
+        
+        if (count > 1 && !args[1].isUndefined() && !args[1].isNull())
+        {
+            if (!args[1].isString())
+            {
+                throw jsi::JSError(rt, "[op-sqlite][open] database location must be a string");
+            }
+            
+            tempDocPath = tempDocPath + "/" + args[1].asString(rt).utf8(rt);
+        }
+        
+        
+        BridgeResult result = sqliteRemoveDb(dbName, tempDocPath);
+        
+        if (result.type == SQLiteError)
+        {
+            throw jsi::JSError(rt, result.message.c_str());
+        }
+        
+        return {};
+    });
+    
+    auto execute = HOSTFN("execute", 3)
+    {
+        const std::string dbName = args[0].asString(rt).utf8(rt);
+        const std::string query = args[1].asString(rt).utf8(rt);
+        std::vector<std::any> params;
+        if(count == 3) {
+            const jsi::Value &originalParams = args[2];
+            params = toAnyVec(rt, originalParams);
+        }
+        
+        std::vector<std::shared_ptr<DynamicHostObject>> results;
+        std::vector<std::shared_ptr<DynamicHostObject>> metadata;
+        
+        try {
+            auto status = sqliteExecute(dbName, query, &params, &results, &metadata);
+            
+            if(status.type == SQLiteError) {
+                throw jsi::JSError(rt, status.message);
+            }
+            
+            auto jsiResult = createResult(rt, status, &results, &metadata);
+            return jsiResult;
+        } catch(std::exception &e) {
+            throw jsi::JSError(rt, e.what());
+        }
+    });
+    
+    auto executeAsync = HOSTFN("executeAsync", 3)
+    {
+        if (count < 3)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][executeAsync] Incorrect arguments for executeAsync");
+        }
+        
+        const std::string dbName = args[0].asString(rt).utf8(rt);
+        const std::string query = args[1].asString(rt).utf8(rt);
+        const jsi::Value &originalParams = args[2];
+        
+        std::vector<std::any> params = toAnyVec(rt, originalParams);
+        
+        auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+            auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+            auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+            
+            auto task =
+            [&rt, dbName, query, params = std::make_shared<std::vector<std::any>>(params), resolve, reject]()
+            {
+                try
+                {
+                    std::vector<std::shared_ptr<DynamicHostObject>> results;
+                    std::vector<std::shared_ptr<DynamicHostObject>> metadata;
+                    
+                    auto status = sqliteExecute(dbName, query, params.get(), &results, &metadata);
+                    
+                    invoker->invokeAsync([&rt,
+                                           results = std::make_shared<std::vector<std::shared_ptr<DynamicHostObject>>>(results),
+                                           metadata = std::make_shared<std::vector<std::shared_ptr<DynamicHostObject>>>(metadata),
+                                           status = std::move(status),
+                                           resolve,
+                                           reject] {
+                        if(status.type == SQLiteOk) {
+                            auto jsiResult = createResult(rt, status, results.get(), metadata.get());
+                            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] {
+                        jsi::JSError(rt, exc.what());
+                    });
+                }
+            };
+            
+            pool->queueWork(task);
+            
+            return {};
+        }));
+        
+        return promise;
+    });
+    
+    // Execute a batch of SQL queries in a transaction
+    // Parameters can be: [[sql: string, arguments: any[] | arguments: any[][] ]]
+    auto executeBatch = HOSTFN("executeBatch", 2)
+    {
+        if (sizeof(args) < 2)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][executeBatch] - Incorrect parameter count");
+        }
+        
+        const jsi::Value &params = args[1];
+        if (params.isNull() || params.isUndefined())
+        {
+            throw jsi::JSError(rt, "[op-sqlite][executeBatch] - An array of SQL commands or parameters is needed");
+        }
+        const std::string dbName = args[0].asString(rt).utf8(rt);
+        const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
+        std::vector<BatchArguments> commands;
+        toBatchArguments(rt, batchParams, &commands);
+        
+        auto batchResult = sqliteExecuteBatch(dbName, &commands);
+        if (batchResult.type == SQLiteOk)
+        {
+            auto res = jsi::Object(rt);
+            res.setProperty(rt, "rowsAffected", jsi::Value(batchResult.affectedRows));
+            return std::move(res);
+        }
+        else
+        {
+            throw jsi::JSError(rt, batchResult.message);
+        }
+    });
+    
+    auto executeBatchAsync = HOSTFN("executeBatchAsync", 2)
+    {
+        if (sizeof(args) < 2)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][executeAsyncBatch] Incorrect parameter count");
+            return {};
+        }
+        
+        const jsi::Value &params = args[1];
+        
+        if (params.isNull() || params.isUndefined())
+        {
+            throw jsi::JSError(rt, "[op-sqlite][executeAsyncBatch] - An array of SQL commands or parameters is needed");
+            return {};
+        }
+        
+        const std::string dbName = args[0].asString(rt).utf8(rt);
+        const jsi::Array &batchParams = params.asObject(rt).asArray(rt);
+        
+        std::vector<BatchArguments> commands;
+        toBatchArguments(rt, batchParams, &commands);
+        
+        auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+            auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+            auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+            
+            auto task =
+            [&rt, dbName, commands = std::make_shared<std::vector<BatchArguments>>(commands), resolve, reject]()
+            {
+                try
+                {
+                    auto batchResult = sqliteExecuteBatch(dbName, commands.get());
+                    invoker->invokeAsync([&rt, batchResult = std::move(batchResult), resolve, reject]
+                                         {
+                        if(batchResult.type == SQLiteOk)
+                        {
+                            auto res = jsi::Object(rt);
+                            res.setProperty(rt, "rowsAffected", jsi::Value(batchResult.affectedRows));
+                            resolve->asObject(rt).asFunction(rt).call(rt, std::move(res));
+                        } else
+                        {
+                            throw jsi::JSError(rt, batchResult.message);
+                        } });
+                }
+                catch (std::exception &exc)
+                {
+                    invoker->invokeAsync([&rt, reject, &exc]
+                                         {
+                        throw jsi::JSError(rt, exc.what());
+                    });
+                }
+            };
+            pool->queueWork(task);
+            
+            return {};
+        }));
+        
+        return promise;
+    });
+    
+    auto loadFile = HOSTFN("loadFile", 2)
+    {
+        if (sizeof(args) < 2)
+        {
+            throw jsi::JSError(rt, "[op-sqlite][loadFileAsync] Incorrect parameter count");
+            return {};
+        }
+        
+        const std::string dbName = args[0].asString(rt).utf8(rt);
+        const std::string sqlFileName = args[1].asString(rt).utf8(rt);
+        
+        auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+        auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
+            auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+            auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+            
+            auto task =
+            [&rt, dbName, sqlFileName, resolve, reject]()
+            {
+                try
+                {
+                    const auto importResult = importSQLFile(dbName, sqlFileName);
+                    
+                    invoker->invokeAsync([&rt, result = std::move(importResult), resolve, reject]
+                                         {
+                        if(result.type == SQLiteOk)
+                        {
+                            auto res = jsi::Object(rt);
+                            res.setProperty(rt, "rowsAffected", jsi::Value(result.affectedRows));
+                            res.setProperty(rt, "commands", jsi::Value(result.commands));
+                            resolve->asObject(rt).asFunction(rt).call(rt, std::move(res));
+                        } else {
+                            throw jsi::JSError(rt, result.message);
+                        } });
+                }
+                catch (std::exception &exc)
+                {
+                    invoker->invokeAsync([&rt, err = exc.what(), reject]
+                                         {
+                        throw jsi::JSError(rt, err);
+                    });
+                }
+            };
+            pool->queueWork(task);
+            return {};
+        }));
+        
+        return promise;
+    });
+    
+    
+    
+    jsi::Object module = jsi::Object(rt);
+    
+    module.setProperty(rt, "open", std::move(open));
+    module.setProperty(rt, "close", std::move(close));
+    module.setProperty(rt, "attach", std::move(attach));
+    module.setProperty(rt, "detach", std::move(detach));
+    module.setProperty(rt, "delete", std::move(remove));
+    module.setProperty(rt, "execute", std::move(execute));
+    module.setProperty(rt, "executeAsync", std::move(executeAsync));
+    module.setProperty(rt, "executeBatch", std::move(executeBatch));
+    module.setProperty(rt, "executeBatchAsync", std::move(executeBatchAsync));
+    module.setProperty(rt, "loadFile", std::move(loadFile));
+    
+    rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
+}
+
+}

package/cpp/bindings.h

@@ -0,0 +1,13 @@
+#include <jsi/jsilib.h>
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+
+using namespace facebook;
+
+namespace osp {
+
+void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker, const char *docPath);
+void clearState();
+
+}
+