@op-engineering/op-sqlite 6.0.2-beta1 → 6.0.2-beta4

package/src/index.ts

@@ -180,8 +180,10 @@ export type DB = {
   reactiveExecute: (params: {
     query: string;
     arguments: any[];
-    tables: string[];
-    rowIds?: number[];
+    fireOn: {
+      table: string;
+      ids?: number[];
+    }[];
     callback: (response: any) => void;
   }) => () => void;
 };
@@ -192,7 +194,9 @@ type OPSQLiteProxy = {
     location?: string;
     encryptionKey?: string;
   }) => DB;
+  openRemote: (options: { url: string; authToken: string }) => DB;
   isSQLCipher: () => boolean;
+  isLibsql: () => boolean;
 };
 
 const locks: Record<
@@ -216,6 +220,204 @@ function enhanceQueryResult(result: QueryResult): void {
   }
 }
 
+// TODO de-dupe this function with open
+export const openRemote = (options: { url: string; authToken: string }): DB => {
+  if (!isLibsql()) {
+    throw new Error('This function is only available for libsql');
+  }
+
+  const db = OPSQLite.openRemote(options);
+
+  const lock = {
+    queue: [] as PendingTransaction[],
+    inProgress: false,
+  };
+
+  const startNextTransaction = () => {
+    if (lock.inProgress) {
+      // Transaction is already in process bail out
+      return;
+    }
+
+    if (lock.queue.length) {
+      lock.inProgress = true;
+      const tx = lock.queue.shift();
+
+      if (!tx) {
+        throw new Error('Could not get a operation on database');
+      }
+
+      setImmediate(() => {
+        tx.start();
+      });
+    }
+  };
+
+  // spreading the object is not working, so we need to do it manually
+  let enhancedDb = {
+    delete: db.delete,
+    attach: db.attach,
+    detach: db.detach,
+    executeBatch: db.executeBatch,
+    executeBatchAsync: db.executeBatchAsync,
+
+    loadFile: db.loadFile,
+    updateHook: db.updateHook,
+    commitHook: db.commitHook,
+    rollbackHook: db.rollbackHook,
+    loadExtension: db.loadExtension,
+    executeRawAsync: db.executeRawAsync,
+    getDbPath: db.getDbPath,
+    reactiveExecute: db.reactiveExecute,
+    close: () => {
+      db.close();
+      delete locks[options.url];
+    },
+    execute: (query: string, params?: any[] | undefined): QueryResult => {
+      const sanitizedParams = params?.map((p) => {
+        if (ArrayBuffer.isView(p)) {
+          return p.buffer;
+        }
+
+        return p;
+      });
+
+      const result = db.execute(query, sanitizedParams);
+      enhanceQueryResult(result);
+      return result;
+    },
+    executeAsync: async (
+      query: string,
+      params?: any[] | undefined
+    ): Promise<QueryResult> => {
+      const sanitizedParams = params?.map((p) => {
+        if (ArrayBuffer.isView(p)) {
+          return p.buffer;
+        }
+
+        return p;
+      });
+
+      const result = await db.executeAsync(query, sanitizedParams);
+      enhanceQueryResult(result);
+      return result;
+    },
+    prepareStatement: (query: string) => {
+      const stmt = db.prepareStatement(query);
+
+      return {
+        bind: (params: any[]) => {
+          const sanitizedParams = params.map((p) => {
+            if (ArrayBuffer.isView(p)) {
+              return p.buffer;
+            }
+
+            return p;
+          });
+
+          stmt.bind(sanitizedParams);
+        },
+        execute: () => {
+          const res = stmt.execute();
+          enhanceQueryResult(res);
+          return res;
+        },
+      };
+    },
+    transaction: async (
+      fn: (tx: Transaction) => Promise<void>
+    ): Promise<void> => {
+      let isFinalized = false;
+
+      // Local transaction context object implementation
+      const execute = (query: string, params?: any[]): QueryResult => {
+        if (isFinalized) {
+          throw Error(
+            `OP-Sqlite Error: Database: ${options.url}. Cannot execute query on finalized transaction`
+          );
+        }
+        return enhancedDb.execute(query, params);
+      };
+
+      const executeAsync = (query: string, params?: any[] | undefined) => {
+        if (isFinalized) {
+          throw Error(
+            `OP-Sqlite Error: Database: ${options.url}. Cannot execute query on finalized transaction`
+          );
+        }
+        return enhancedDb.executeAsync(query, params);
+      };
+
+      const commit = () => {
+        if (isFinalized) {
+          throw Error(
+            `OP-Sqlite Error: Database: ${options.url}. Cannot execute query on finalized transaction`
+          );
+        }
+        const result = enhancedDb.execute('COMMIT;');
+        isFinalized = true;
+        return result;
+      };
+
+      const rollback = () => {
+        if (isFinalized) {
+          throw Error(
+            `OP-Sqlite Error: Database: ${options.url}. Cannot execute query on finalized transaction`
+          );
+        }
+        const result = enhancedDb.execute('ROLLBACK;');
+        isFinalized = true;
+        return result;
+      };
+
+      async function run() {
+        try {
+          await enhancedDb.executeAsync('BEGIN TRANSACTION;');
+
+          await fn({
+            commit,
+            execute,
+            executeAsync,
+            rollback,
+          });
+
+          if (!isFinalized) {
+            commit();
+          }
+        } catch (executionError) {
+          console.warn('transaction error', executionError);
+          if (!isFinalized) {
+            try {
+              rollback();
+            } catch (rollbackError) {
+              throw rollbackError;
+            }
+          }
+
+          throw executionError;
+        } finally {
+          lock.inProgress = false;
+          isFinalized = false;
+          startNextTransaction();
+        }
+      }
+
+      return await new Promise((resolve, reject) => {
+        const tx: PendingTransaction = {
+          start: () => {
+            run().then(resolve).catch(reject);
+          },
+        };
+
+        lock.queue.push(tx);
+        startNextTransaction();
+      });
+    },
+  };
+
+  return enhancedDb;
+};
+
 export const open = (options: {
   name: string;
   location?: string;
@@ -375,7 +577,7 @@ export const open = (options: {
             executeAsync,
             rollback,
           });
-          console.warn('finished executing user function for transaction');
+
           if (!isFinalized) {
             commit();
           }
@@ -424,3 +626,7 @@ export const moveAssetsDatabase = async (args: {
 export const isSQLCipher = (): boolean => {
   return OPSQLite.isSQLCipher();
 };
+
+export const isLibsql = (): boolean => {
+  return OPSQLite.isLibsql();
+};

package/cpp/sqlbatchexecutor.cpp

@@ -1,93 +0,0 @@
-#include "sqlbatchexecutor.h"
-
-namespace opsqlite {
-
-/**
- * Batch execution implementation
- */
-
-void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams,
-                      std::vector<BatchArguments> *commands) {
-  for (int i = 0; i < batchParams.length(rt); i++) {
-    const jsi::Array &command =
-        batchParams.getValueAtIndex(rt, i).asObject(rt).asArray(rt);
-    if (command.length(rt) == 0) {
-      continue;
-    }
-
-    const std::string query =
-        command.getValueAtIndex(rt, 0).asString(rt).utf8(rt);
-    const jsi::Value &commandParams = command.length(rt) > 1
-                                          ? command.getValueAtIndex(rt, 1)
-                                          : jsi::Value::undefined();
-    if (!commandParams.isUndefined() &&
-        commandParams.asObject(rt).isArray(rt) &&
-        commandParams.asObject(rt).asArray(rt).length(rt) > 0 &&
-        commandParams.asObject(rt)
-            .asArray(rt)
-            .getValueAtIndex(rt, 0)
-            .isObject()) {
-      // This arguments is an array of arrays, like a batch update of a single
-      // sql command.
-      const jsi::Array &batchUpdateParams =
-          commandParams.asObject(rt).asArray(rt);
-      for (int x = 0; x < batchUpdateParams.length(rt); x++) {
-        const jsi::Value &p = batchUpdateParams.getValueAtIndex(rt, x);
-        auto params =
-            std::make_shared<std::vector<JSVariant>>(to_variant_vec(rt, p));
-        commands->push_back({query, params});
-      }
-    } else {
-      auto params = std::make_shared<std::vector<JSVariant>>(
-          to_variant_vec(rt, commandParams));
-      commands->push_back({query, params});
-    }
-  }
-}
-
-BatchResult sqliteExecuteBatch(std::string dbName,
-                               std::vector<BatchArguments> *commands) {
-  size_t commandCount = commands->size();
-  if (commandCount <= 0) {
-    return BatchResult{
-        .type = SQLiteError,
-        .message = "No SQL commands provided",
-    };
-  }
-
-  try {
-    int affectedRows = 0;
-    opsqlite_execute(dbName, "BEGIN EXCLUSIVE TRANSACTION", nullptr, nullptr,
-                     nullptr);
-    for (int i = 0; i < commandCount; i++) {
-      auto command = commands->at(i);
-      // We do not provide a datastructure to receive query data because we
-      // don't need/want to handle this results in a batch execution
-      auto result = opsqlite_execute(dbName, command.sql, command.params.get(),
-                                     nullptr, nullptr);
-      if (result.type == SQLiteError) {
-        opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
-        return BatchResult{
-            .type = SQLiteError,
-            .message = result.message,
-        };
-      } else {
-        affectedRows += result.affectedRows;
-      }
-    }
-    opsqlite_execute(dbName, "COMMIT", nullptr, nullptr, nullptr);
-    return BatchResult{
-        .type = SQLiteOk,
-        .affectedRows = affectedRows,
-        .commands = static_cast<int>(commandCount),
-    };
-  } catch (std::exception &exc) {
-    opsqlite_execute(dbName, "ROLLBACK", nullptr, nullptr, nullptr);
-    return BatchResult{
-        .type = SQLiteError,
-        .message = exc.what(),
-    };
-  }
-}
-
-} // namespace opsqlite

package/cpp/sqlbatchexecutor.h

@@ -1,30 +0,0 @@
-/**
- * SQL Batch execution implementation using default sqliteBridge implementation
- */
-#include "bridge.h"
-#include "types.h"
-#include "utils.h"
-
-namespace opsqlite {
-
-namespace jsi = facebook::jsi;
-
-struct BatchArguments {
-  std::string sql;
-  std::shared_ptr<std::vector<JSVariant>> params;
-};
-
-/**
- * Local Helper method to translate JSI objects BatchArguments data structure
- * MUST be called in the JavaScript Thread
- */
-void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams,
-                      std::vector<BatchArguments> *commands);
-
-/**
- * Execute a batch of commands in a exclusive transaction
- */
-BatchResult sqliteExecuteBatch(std::string dbName,
-                               std::vector<BatchArguments> *commands);
-
-} // namespace opsqlite