Changing refreshSchema to return a promise.

Author: Chriztiaan

cpp/ConnectionPool.cpp

@@ -168,12 +168,23 @@ void ConnectionPool::closeAll() {
   }
 }
 
-void ConnectionPool::refreshSchema() {
-  writeConnection.refreshSchema();
+std::future<void> ConnectionPool::refreshSchema() {
+    std::vector<std::future<void>> futures;
 
-  for (unsigned int i = 0; i < maxReads; i++) {
-    readConnections[i]->refreshSchema();
-  }
+    // Collect the future from the write connection
+    futures.push_back(writeConnection.refreshSchema());
+
+    // Collect the futures from the read connections
+    for (unsigned int i = 0; i < maxReads; i++) {
+        futures.push_back(readConnections[i]->refreshSchema());
+    }
+
+    // Return a future that completes when all collected futures are done
+    return std::async(std::launch::async, [futures = std::move(futures)]() mutable {
+        for (auto& fut : futures) {
+            fut.get(); // This will block until the future is ready and rethrow exceptions if any
+        }
+    });
 }
 
 SQLiteOPResult ConnectionPool::attachDatabase(std::string const dbFileName,

cpp/ConnectionPool.h

@@ -3,6 +3,7 @@
 #include "sqlite3.h"
 #include <string>
 #include <vector>
+#include <future>
 
 #ifndef ConnectionPool_h
 #define ConnectionPool_h
@@ -129,7 +130,7 @@ class ConnectionPool {
   /**
    * Refreshes the schema for all connections.
    */
-  void refreshSchema();
+  std::future<void> ConnectionPool::refreshSchema();
 
   /**
    * Attaches another database to all connections

cpp/ConnectionState.cpp

@@ -2,6 +2,8 @@
 #include "fileUtils.h"
 #include "sqlite3.h"
 
+
+
 const std::string EMPTY_LOCK_ID = "";
 
 SQLiteOPResult genericSqliteOpenDb(string const dbName, string const docPath,
@@ -44,12 +46,26 @@ bool ConnectionState::matchesLock(const ConnectionLockId &lockId) {
 
 bool ConnectionState::isEmptyLock() { return _currentLockId == EMPTY_LOCK_ID; }
 
-void ConnectionState::refreshSchema() {
-  queueWork([this](sqlite3* db) {
-    sqlite3_exec(db, "PRAGMA table_info('sqlite_master')", nullptr, nullptr, nullptr);
-  });
+std::future<void> ConnectionState::refreshSchema() {
+    auto promise = std::make_shared<std::promise<void>>();
+    auto future = promise->get_future();
+
+    queueWork([promise](sqlite3* db) {
+        try {
+            int rc = sqlite3_exec(db, "PRAGMA table_info('sqlite_master')", nullptr, nullptr, nullptr);
+            if (rc != SQLITE_OK) {
+                throw std::runtime_error("Failed to refresh schema");
+            }
+            promise->set_value();
+        } catch (...) {
+            promise->set_exception(std::current_exception());
+        }
+    });
+
+    return future;
 }
 
+
 void ConnectionState::close() {
   waitFinished();
   // So that the thread can stop (if not already)

cpp/ConnectionState.h

@@ -6,6 +6,7 @@
 #include <string>
 #include <thread>
 #include <vector>
+#include <future>
 
 #ifndef ConnectionState_h
 #define ConnectionState_h
@@ -41,7 +42,7 @@ class ConnectionState {
   bool matchesLock(const ConnectionLockId &lockId);
   bool isEmptyLock();
 
-  void refreshSchema();
+  std::future<void> refreshSchema();
   void close();
   void queueWork(std::function<void(sqlite3 *)> task);
 

cpp/bindings.cpp

@@ -286,20 +286,52 @@ void osp::install(jsi::Runtime &rt,
     return {};
   });
 
+  
   auto refreshSchema = HOSTFN("refreshSchema", 1) {
-      if (count == 0) {
-          throw jsi::JSError(rt, "[react-native-quick-sqlite][refreshSchema] database name is required");
-      }
+    if (count == 0) {
+        throw jsi::JSError(rt, "[react-native-quick-sqlite][refreshSchema] database name is required");
+    }
 
-      if (!args[0].isString()) {
-          throw jsi::JSError(rt, "[react-native-quick-sqlite][refreshSchema] database name must be a string");
-      }
+    if (!args[0].isString()) {
+        throw jsi::JSError(rt, "[react-native-quick-sqlite][refreshSchema] database name must be a string");
+    }
 
-      string dbName = args[0].asString(rt).utf8(rt);
+    std::string dbName = args[0].asString(rt).utf8(rt);
 
-      sqliteRefreshSchema(dbName);
+    auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+    auto jsPromise = 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]);
 
-      return {};
+        try {
+            auto future = sqliteRefreshSchema(dbName);
+
+            // Waiting for the future to complete in a separate thread
+            std::thread([future = std::move(future), &rt, resolve, reject]() mutable {
+                try {
+                    future.get(); 
+                    invoker->invokeAsync([&rt, resolve] {
+                        resolve->asObject(rt).asFunction(rt).call(rt);
+                    });
+                } catch (const std::exception& exc) {
+                    invoker->invokeAsync([&rt, reject, exc] {
+                        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);
+                    });
+                }
+            }).detach();
+
+        } catch (const std::exception& exc) {
+            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);
+        }
+
+        return {};
+    }));
+
+    return jsPromise;
   });
 
   auto executeInContext = HOSTFN("executeInContext", 3) {

cpp/sqliteBridge.cpp

@@ -60,14 +60,17 @@ sqliteOpenDb(string const dbName, string const docPath,
   };
 }
 
-void sqliteRefreshSchema(string const dbName) {
-  if (dbMap.count(dbName) == 0) {
-   // Do nothing 
-    return;
-  }
 
-  ConnectionPool *connection = dbMap[dbName];
-  connection->refreshSchema();
+std::future<void> sqliteRefreshSchema(const std::string& dbName) {
+    if (dbMap.count(dbName) == 0) {
+        // Database not found, return a future that's already set
+        std::promise<void> promise;
+        promise.set_value();
+        return promise.get_future();
+    }
+
+    ConnectionPool* connection = dbMap[dbName];
+    return connection->refreshSchema();
 }
 
 

cpp/sqliteBridge.h

@@ -11,6 +11,7 @@
 #include "JSIHelper.h"
 #include "sqlite3.h"
 #include <vector>
+#include <future>
 
 #ifndef SQLiteBridge_h
 #define SQLiteBridge_h
@@ -33,7 +34,7 @@ sqliteOpenDb(std::string const dbName, std::string const docPath,
                  const TransactionCallbackPayload *event),
              uint32_t numReadConnections);
 
-void sqliteRefreshSchema(string const dbName);
+std::future<void> sqliteRefreshSchema(const std::string& dbName);
 
 SQLiteOPResult sqliteCloseDb(string const dbName);
 

src/types.ts

@@ -124,7 +124,7 @@ export interface ISQLite {
   open: Open;
   close: (dbName: string) => void;
   delete: (dbName: string, location?: string) => void;
-  refreshSchema: (dbName: string) => void;
+  refreshSchema: (dbName: string) => Promise<void>;
 
   requestLock: (dbName: string, id: ContextLockID, type: ConcurrentLockType) => QueryResult;
   releaseLock(dbName: string, id: ContextLockID): void;
@@ -152,7 +152,7 @@ export interface TransactionContext extends LockContext {
 
 export type QuickSQLiteConnection = {
   close: () => void;
-  refreshSchema: () => void;
+  refreshSchema: () => Promise<void>;
   execute: (sql: string, args?: any[]) => Promise<QueryResult>;
   readLock: <T>(callback: (context: LockContext) => Promise<T>, options?: LockOptions) => Promise<T>;
   readTransaction: <T>(callback: (context: TransactionContext) => Promise<T>, options?: LockOptions) => Promise<T>;