react-native-nitro-sqlite 9.0.2 → 9.1.0

package/cpp/NitroSQLiteException.hpp

@@ -34,7 +34,7 @@ public:
   explicit NitroSQLiteException(const std::string& message): NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, message) {}
   NitroSQLiteException(const NitroSQLiteExceptionType& type, const char* message) : NitroSQLiteException(type, std::string(message)) {}
   NitroSQLiteException(const NitroSQLiteExceptionType& type, const std::string& message)
-    : _exceptionString("[react-native-nitro-sqlite] " + typeToString(type) + ": " + message) {}
+    : _exceptionString("[" + typeToString(type) + "] " + message) {}
 
 private:
   const std::string _exceptionString;

package/cpp/specs/HybridNativeQueryResult.cpp

@@ -5,6 +5,7 @@ namespace margelo::nitro::rnnitrosqlite {
 std::optional<double> HybridNativeQueryResult::getInsertId() {
   return this->_insertId;
 }
+
 double HybridNativeQueryResult::getRowsAffected() {
   return this->_rowsAffected;
 }

package/cpp/specs/HybridNativeQueryResult.hpp

@@ -27,8 +27,11 @@ private:
 public:
   // Properties
   std::optional<double> getInsertId() override;
+  
   double getRowsAffected() override;
+  
   SQLiteQueryResults getResults() override;
+  
   std::optional<SQLiteQueryTableMetadata> getMetadata() override;
 };
 

package/cpp/specs/HybridNitroSQLite.cpp

@@ -1,6 +1,5 @@
 #include "HybridNitroSQLite.hpp"
 #include "HybridNativeQueryResult.hpp"
-#include "ThreadPool.hpp"
 #include "NitroSQLiteException.hpp"
 #include "logs.hpp"
 #include "macros.hpp"
@@ -14,8 +13,6 @@
 
 namespace margelo::nitro::rnnitrosqlite {
 
-auto pool = std::make_shared<margelo::rnnitrosqlite::ThreadPool>();
-
 const std::string getDocPath(const std::optional<std::string>& location) {
   std::string tempDocPath = std::string(HybridNitroSQLite::docPath);
   if (location) {
@@ -61,23 +58,12 @@ ExecuteQueryResult HybridNitroSQLite::execute(const std::string& dbName, const s
   return std::make_shared<HybridNativeQueryResult>(result.insertId, result.rowsAffected, *result.results, *result.metadata);
 };
 
-std::future<ExecuteQueryResult> HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& query,
-                                                               const std::optional<SQLiteQueryParams>& params) {
-  auto promise = std::make_shared<std::promise<ExecuteQueryResult>>();
-  auto future = promise->get_future();
-
-  auto task = [this, promise, dbName, query, params]() {
-    try {
-      auto result = execute(dbName, query, params);
-      promise->set_value(result);
-    } catch (...) {
-      promise->set_exception(std::current_exception());
-    }
-  };
-
-  pool->queueWork(std::move(task));
-
-  return future;
+std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>> HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& query,
+                                                                                                       const std::optional<SQLiteQueryParams>& params) {
+  return Promise<std::shared_ptr<HybridNativeQueryResultSpec>>::async([=, this]() -> std::shared_ptr<HybridNativeQueryResultSpec> {
+    auto result = execute(dbName, query, params);
+    return result;
+  });
 };
 
 BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& batchParams) {
@@ -87,23 +73,12 @@ BatchQueryResult HybridNitroSQLite::executeBatch(const std::string& dbName, cons
   return BatchQueryResult(result.rowsAffected);
 };
 
-std::future<BatchQueryResult> HybridNitroSQLite::executeBatchAsync(const std::string& dbName,
-                                                                   const std::vector<BatchQueryCommand>& batchParams) {
-  auto promise = std::make_shared<std::promise<BatchQueryResult>>();
-  auto future = promise->get_future();
-
-  auto task = [this, promise, dbName, batchParams]() {
-    try {
-      auto result = executeBatch(dbName, batchParams);
-      promise->set_value(result);
-    } catch (...) {
-      promise->set_exception(std::current_exception());
-    }
-  };
-
-  pool->queueWork(std::move(task));
-
-  return future;
+std::shared_ptr<Promise<BatchQueryResult>> HybridNitroSQLite::executeBatchAsync(const std::string& dbName,
+                                                                                const std::vector<BatchQueryCommand>& batchParams) {
+  return Promise<BatchQueryResult>::async([=, this]() -> BatchQueryResult {
+    auto result = executeBatch(dbName, batchParams);
+    return result;
+  });
 };
 
 FileLoadResult HybridNitroSQLite::loadFile(const std::string& dbName, const std::string& location) {
@@ -111,22 +86,11 @@ FileLoadResult HybridNitroSQLite::loadFile(const std::string& dbName, const std:
   return FileLoadResult(result.commands, result.rowsAffected);
 };
 
-std::future<FileLoadResult> HybridNitroSQLite::loadFileAsync(const std::string& dbName, const std::string& location) {
-  auto promise = std::make_shared<std::promise<FileLoadResult>>();
-  auto future = promise->get_future();
-
-  auto task = [this, promise, dbName, location]() {
-    try {
-      auto result = loadFile(dbName, location);
-      promise->set_value(result);
-    } catch (...) {
-      promise->set_exception(std::current_exception());
-    }
-  };
-
-  pool->queueWork(std::move(task));
-
-  return future;
+std::shared_ptr<Promise<FileLoadResult>> HybridNitroSQLite::loadFileAsync(const std::string& dbName, const std::string& location) {
+  return Promise<FileLoadResult>::async([=, this]() -> FileLoadResult {
+    auto result = loadFile(dbName, location);
+    return result;
+  });
 };
 
 } // namespace margelo::nitro::rnnitrosqlite

package/cpp/specs/HybridNitroSQLite.hpp

@@ -18,17 +18,25 @@ public:
 public:
   // Methods
   void open(const std::string& dbName, const std::optional<std::string>& location) override;
+  
   void close(const std::string& dbName) override;
+  
   void drop(const std::string& dbName, const std::optional<std::string>& location) override;
+  
   void attach(const std::string& mainDbName, const std::string& dbNameToAttach, const std::string& alias,
               const std::optional<std::string>& location) override;
+  
   void detach(const std::string& mainDbName, const std::string& alias) override;
+  
   std::shared_ptr<HybridNativeQueryResultSpec> execute(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
-  std::future<std::shared_ptr<HybridNativeQueryResultSpec>> executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
+  
+  std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>> executeAsync(const std::string& dbName, const std::string& query, const std::optional<SQLiteQueryParams>& params) override;
+  
   BatchQueryResult executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) override;
-  std::future<BatchQueryResult> executeBatchAsync(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) override;
+  std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) override;
+  
   FileLoadResult loadFile(const std::string& dbName, const std::string& location) override;
-  std::future<FileLoadResult> loadFileAsync(const std::string& dbName, const std::string& location) override;
+  std::shared_ptr<Promise<FileLoadResult>> loadFileAsync(const std::string& dbName, const std::string& location) override;
 };
 
 inline std::string HybridNitroSQLite::docPath = "";

package/ios/NitroSQLite.xcodeproj/project.pbxproj

@@ -19,7 +19,6 @@
 		83BC6E792C8F78A200B954D2 /* sqlfileloader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 83BC6E682C8F78A200B954D2 /* sqlfileloader.cpp */; };
 		83BC6E7A2C8F78A200B954D2 /* sqlite3.c in Sources */ = {isa = PBXBuildFile; fileRef = 83BC6E6A2C8F78A200B954D2 /* sqlite3.c */; };
 		83BC6E7B2C8F78A200B954D2 /* sqliteBridge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 83BC6E6C2C8F78A200B954D2 /* sqliteBridge.cpp */; };
-		83BC6E7C2C8F78A200B954D2 /* ThreadPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 83BC6E6E2C8F78A200B954D2 /* ThreadPool.cpp */; };
 		83BC6E7F2C8F7BDD00B954D2 /* Empty.swift in Sources */ = {isa = PBXBuildFile; fileRef = 83BC6E7E2C8F7BDD00B954D2 /* Empty.swift */; };
 /* End PBXBuildFile section */
 
@@ -75,8 +74,6 @@
 		83BC6E6B2C8F78A200B954D2 /* sqlite3.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sqlite3.h; sourceTree = "<group>"; };
 		83BC6E6C2C8F78A200B954D2 /* sqliteBridge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sqliteBridge.cpp; sourceTree = "<group>"; };
 		83BC6E6D2C8F78A200B954D2 /* sqliteBridge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sqliteBridge.h; sourceTree = "<group>"; };
-		83BC6E6E2C8F78A200B954D2 /* ThreadPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ThreadPool.cpp; sourceTree = "<group>"; };
-		83BC6E6F2C8F78A200B954D2 /* ThreadPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadPool.h; sourceTree = "<group>"; };
 		83BC6E7E2C8F7BDD00B954D2 /* Empty.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Empty.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
@@ -206,8 +203,6 @@
 				83BC6E6B2C8F78A200B954D2 /* sqlite3.h */,
 				83BC6E6C2C8F78A200B954D2 /* sqliteBridge.cpp */,
 				83BC6E6D2C8F78A200B954D2 /* sqliteBridge.h */,
-				83BC6E6E2C8F78A200B954D2 /* ThreadPool.cpp */,
-				83BC6E6F2C8F78A200B954D2 /* ThreadPool.h */,
 			);
 			name = cpp;
 			path = ../cpp;
@@ -272,7 +267,6 @@
 			files = (
 				83BC6E772C8F78A200B954D2 /* OnLoad.cpp in Sources */,
 				83BC6E792C8F78A200B954D2 /* sqlfileloader.cpp in Sources */,
-				83BC6E7C2C8F78A200B954D2 /* ThreadPool.cpp in Sources */,
 				83BC6E712C8F78A200B954D2 /* RNNitroSQLite-Swift-Cxx-Bridge.cpp in Sources */,
 				83BC6E762C8F78A200B954D2 /* JSIHelper.cpp in Sources */,
 				83BC6E7F2C8F7BDD00B954D2 /* Empty.swift in Sources */,

package/nitrogen/generated/ios/RNNitroSQLite-Swift-Cxx-Umbrella.hpp

@@ -20,7 +20,7 @@
 #include <NitroModules/ArrayBufferHolder.hpp>
 #include <NitroModules/AnyMapHolder.hpp>
 #include <NitroModules/HybridContext.hpp>
-#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/RuntimeError.hpp>
 
 // Forward declarations of Swift defined types
 

package/nitrogen/generated/shared/c++/HybridNitroSQLiteSpec.hpp

@@ -31,7 +31,7 @@ namespace margelo::nitro::rnnitrosqlite { struct FileLoadResult; }
 #include <vector>
 #include <variant>
 #include <NitroModules/ArrayBuffer.hpp>
-#include <future>
+#include <NitroModules/Promise.hpp>
 #include "BatchQueryResult.hpp"
 #include "BatchQueryCommand.hpp"
 #include "FileLoadResult.hpp"
@@ -73,11 +73,11 @@ namespace margelo::nitro::rnnitrosqlite {
       virtual void attach(const std::string& mainDbName, const std::string& dbNameToAttach, const std::string& alias, const std::optional<std::string>& location) = 0;
       virtual void detach(const std::string& mainDbName, const std::string& alias) = 0;
       virtual std::shared_ptr<margelo::nitro::rnnitrosqlite::HybridNativeQueryResultSpec> execute(const std::string& dbName, const std::string& query, const std::optional<std::vector<std::variant<std::string, double, int64_t, bool, std::shared_ptr<ArrayBuffer>>>>& params) = 0;
-      virtual std::future<std::shared_ptr<margelo::nitro::rnnitrosqlite::HybridNativeQueryResultSpec>> executeAsync(const std::string& dbName, const std::string& query, const std::optional<std::vector<std::variant<std::string, double, int64_t, bool, std::shared_ptr<ArrayBuffer>>>>& params) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::rnnitrosqlite::HybridNativeQueryResultSpec>>> executeAsync(const std::string& dbName, const std::string& query, const std::optional<std::vector<std::variant<std::string, double, int64_t, bool, std::shared_ptr<ArrayBuffer>>>>& params) = 0;
       virtual BatchQueryResult executeBatch(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) = 0;
-      virtual std::future<BatchQueryResult> executeBatchAsync(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) = 0;
+      virtual std::shared_ptr<Promise<BatchQueryResult>> executeBatchAsync(const std::string& dbName, const std::vector<BatchQueryCommand>& commands) = 0;
       virtual FileLoadResult loadFile(const std::string& dbName, const std::string& location) = 0;
-      virtual std::future<FileLoadResult> loadFileAsync(const std::string& dbName, const std::string& location) = 0;
+      virtual std::shared_ptr<Promise<FileLoadResult>> loadFileAsync(const std::string& dbName, const std::string& location) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-sqlite",
-  "version": "9.0.2",
+  "version": "9.1.0",
   "description": "Fast SQLite library for React Native built using Nitro Modules",
   "source": "./src/index.ts",
   "main": "./lib/commonjs/index",
@@ -79,7 +79,7 @@
   "peerDependencies": {
     "react": ">=17.0.0",
     "react-native": ">=0.74.0",
-    "react-native-nitro-modules": "0.16.2"
+    "react-native-nitro-modules": ">=0.17.0"
   },
   "resolutions": {
     "@types/react": "^18.2.44"

package/cpp/ThreadPool.cpp

@@ -1,91 +0,0 @@
-//
-//  ThreadPool.cpp
-//  react-native-nitro-sqlite
-//
-//  Created by Oscar on 13.03.22.
-//
-
-#include "ThreadPool.hpp"
-
-namespace margelo::rnnitrosqlite {
-
-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); });
-}
-
-} // namespace margelo::rnnitrosqlite

package/cpp/ThreadPool.hpp

@@ -1,50 +0,0 @@
-//
-//  ThreadPool.hpp
-//  react-native-nitro-sqlite
-//
-//  Created by Oscar on 13.03.22.
-//
-
-#pragma once
-
-#include <condition_variable>
-#include <exception>
-#include <mutex>
-#include <queue>
-#include <stdio.h>
-#include <thread>
-#include <vector>
-
-namespace margelo::rnnitrosqlite {
-
-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();
-};
-
-} // namespace margelo::rnnitrosqlite