@op-engineering/op-sqlite 6.0.1 → 6.0.2-beta3

package/src/index.ts

@@ -34,7 +34,7 @@ if (global.__OPSQLiteProxy == null) {
 }
 
 const proxy = global.__OPSQLiteProxy;
-export const OPSQLite = proxy as ISQLite;
+export const OPSQLite = proxy as OPSQLiteProxy;
 
 export const {
   IOS_DOCUMENT_PATH,
@@ -145,14 +145,9 @@ export type PreparedStatementObj = {
   execute: () => QueryResult;
 };
 
-interface ISQLite {
-  open: (options: {
-    name: string;
-    location?: string;
-    encryptionKey?: string;
-  }) => void;
-  close: (dbName: string) => void;
-  delete: (dbName: string, location?: string) => void;
+export type DB = {
+  close: () => void;
+  delete: (location?: string) => void;
   attach: (
     mainDbName: string,
     dbNameToAttach: string,
@@ -160,24 +155,13 @@ interface ISQLite {
     location?: string
   ) => void;
   detach: (mainDbName: string, alias: string) => void;
-  transaction: (
-    dbName: string,
-    fn: (tx: Transaction) => Promise<void>
-  ) => Promise<void>;
-  execute: (dbName: string, query: string, params?: any[]) => QueryResult;
-  executeAsync: (
-    dbName: string,
-    query: string,
-    params?: any[]
-  ) => Promise<QueryResult>;
-  executeBatch: (dbName: string, commands: SQLBatchTuple[]) => BatchQueryResult;
-  executeBatchAsync: (
-    dbName: string,
-    commands: SQLBatchTuple[]
-  ) => Promise<BatchQueryResult>;
-  loadFile: (dbName: string, location: string) => Promise<FileLoadResult>;
+  transaction: (fn: (tx: Transaction) => Promise<void>) => Promise<void>;
+  execute: (query: string, params?: any[]) => QueryResult;
+  executeAsync: (query: string, params?: any[]) => Promise<QueryResult>;
+  executeBatch: (commands: SQLBatchTuple[]) => BatchQueryResult;
+  executeBatchAsync: (commands: SQLBatchTuple[]) => Promise<BatchQueryResult>;
+  loadFile: (location: string) => Promise<FileLoadResult>;
   updateHook: (
-    dbName: string,
     callback?:
       | ((params: {
           table: string;
@@ -187,18 +171,32 @@ interface ISQLite {
         }) => void)
       | null
   ) => void;
-  commitHook: (dbName: string, callback?: (() => void) | null) => void;
-  rollbackHook: (dbName: string, callback?: (() => void) | null) => void;
-  prepareStatement: (dbName: string, query: string) => PreparedStatementObj;
-  loadExtension: (dbName: string, path: string, entryPoint?: string) => void;
-  executeRawAsync: (
-    dbName: string,
-    query: string,
-    params?: any[]
-  ) => Promise<any[]>;
-  getDbPath: (dbName: string, location?: string) => string;
+  commitHook: (callback?: (() => void) | null) => void;
+  rollbackHook: (callback?: (() => void) | null) => void;
+  prepareStatement: (query: string) => PreparedStatementObj;
+  loadExtension: (path: string, entryPoint?: string) => void;
+  executeRawAsync: (query: string, params?: any[]) => Promise<any[]>;
+  getDbPath: (location?: string) => string;
+  reactiveExecute: (params: {
+    query: string;
+    arguments: any[];
+    fireOn: {
+      table: string;
+      ids?: number[];
+    }[];
+    callback: (response: any) => void;
+  }) => () => void;
+};
+
+type OPSQLiteProxy = {
+  open: (options: {
+    name: string;
+    location?: string;
+    encryptionKey?: string;
+  }) => DB;
   isSQLCipher: () => boolean;
-}
+  isLibsql: () => boolean;
+};
 
 const locks: Record<
   string,
@@ -221,71 +219,76 @@ function enhanceQueryResult(result: QueryResult): void {
   }
 }
 
-const _open = OPSQLite.open;
-OPSQLite.open = (options: {
+export const open = (options: {
   name: string;
   location?: string;
   encryptionKey?: string;
-}) => {
-  _open(options);
+}): DB => {
+  const db = OPSQLite.open(options);
 
-  locks[options.name] = {
-    queue: [],
+  const lock = {
+    queue: [] as PendingTransaction[],
     inProgress: false,
   };
-};
-
-const _close = OPSQLite.close;
-OPSQLite.close = (dbName: string) => {
-  _close(dbName);
-  delete locks[dbName];
-};
 
-const _execute = OPSQLite.execute;
-OPSQLite.execute = (
-  dbName: string,
-  query: string,
-  params?: any[] | undefined
-): QueryResult => {
-  const sanitizedParams = params?.map((p) => {
-    if (ArrayBuffer.isView(p)) {
-      return p.buffer;
+  const startNextTransaction = () => {
+    if (lock.inProgress) {
+      // Transaction is already in process bail out
+      return;
     }
 
-    return p;
-  });
+    if (lock.queue.length) {
+      lock.inProgress = true;
+      const tx = lock.queue.shift();
 
-  const result = _execute(dbName, query, sanitizedParams);
-  enhanceQueryResult(result);
-  return result;
-};
+      if (!tx) {
+        throw new Error('Could not get a operation on database');
+      }
 
-const _executeAsync = OPSQLite.executeAsync;
-OPSQLite.executeAsync = async (
-  dbName: string,
-  query: string,
-  params?: any[] | undefined
-): Promise<QueryResult> => {
-  const sanitizedParams = params?.map((p) => {
-    if (ArrayBuffer.isView(p)) {
-      return p.buffer;
+      setImmediate(() => {
+        tx.start();
+      });
     }
+  };
 
-    return p;
-  });
-
-  const res = await _executeAsync(dbName, query, sanitizedParams);
-  enhanceQueryResult(res);
-  return res;
-};
+  // 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.name];
+    },
+    execute: (query: string, params?: any[] | undefined): QueryResult => {
+      const sanitizedParams = params?.map((p) => {
+        if (ArrayBuffer.isView(p)) {
+          return p.buffer;
+        }
 
-const _prepareStatement = OPSQLite.prepareStatement;
-OPSQLite.prepareStatement = (dbName: string, query: string) => {
-  const stmt = _prepareStatement(dbName, query);
+        return p;
+      });
 
-  return {
-    bind: (params: any[]) => {
-      const sanitizedParams = params.map((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;
         }
@@ -293,200 +296,124 @@ OPSQLite.prepareStatement = (dbName: string, query: string) => {
         return p;
       });
 
-      stmt.bind(sanitizedParams);
+      const result = await db.executeAsync(query, sanitizedParams);
+      enhanceQueryResult(result);
+      return result;
     },
-    execute: () => {
-      const res = stmt.execute();
-      enhanceQueryResult(res);
-      return res;
+    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;
+        },
+      };
     },
-  };
-};
-
-OPSQLite.transaction = async (
-  dbName: string,
-  fn: (tx: Transaction) => Promise<void>
-): Promise<void> => {
-  if (!locks[dbName]) {
-    throw Error(`SQLite Error: No lock found on db: ${dbName}`);
-  }
-
-  let isFinalized = false;
-
-  // Local transaction context object implementation
-  const execute = (query: string, params?: any[]): QueryResult => {
-    if (isFinalized) {
-      throw Error(
-        `SQLite Error: Cannot execute query on finalized transaction: ${dbName}`
-      );
-    }
-    return OPSQLite.execute(dbName, query, params);
-  };
-
-  const executeAsync = (query: string, params?: any[] | undefined) => {
-    if (isFinalized) {
-      throw Error(
-        `SQLite Error: Cannot execute query on finalized transaction: ${dbName}`
-      );
-    }
-    return OPSQLite.executeAsync(dbName, query, params);
-  };
-
-  const commit = () => {
-    if (isFinalized) {
-      throw Error(
-        `SQLite Error: Cannot execute commit on finalized transaction: ${dbName}`
-      );
-    }
-    const result = OPSQLite.execute(dbName, 'COMMIT');
-    isFinalized = true;
-    return result;
-  };
-
-  const rollback = () => {
-    if (isFinalized) {
-      throw Error(
-        `SQLite Error: Cannot execute rollback on finalized transaction: ${dbName}`
-      );
-    }
-    const result = OPSQLite.execute(dbName, 'ROLLBACK');
-    isFinalized = true;
-    return result;
-  };
-
-  async function run() {
-    try {
-      await OPSQLite.executeAsync(dbName, 'BEGIN TRANSACTION');
-
-      await fn({
-        commit,
-        execute,
-        executeAsync,
-        rollback,
-      });
+    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.name}. 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.name}. Cannot execute query on finalized transaction`
+          );
+        }
+        return enhancedDb.executeAsync(query, params);
+      };
+
+      const commit = () => {
+        if (isFinalized) {
+          throw Error(
+            `OP-Sqlite Error: Database: ${options.name}. 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.name}. Cannot execute query on finalized transaction`
+          );
+        }
+        const result = enhancedDb.execute('ROLLBACK;');
+        isFinalized = true;
+        return result;
+      };
 
-      if (!isFinalized) {
-        commit();
-      }
-    } catch (executionError) {
-      if (!isFinalized) {
+      async function run() {
         try {
-          rollback();
-        } catch (rollbackError) {
-          throw rollbackError;
+          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();
         }
       }
 
-      throw executionError;
-    } finally {
-      locks[dbName]!.inProgress = false;
-      isFinalized = false;
-      startNextTransaction(dbName);
-    }
-  }
-
-  return await new Promise((resolve, reject) => {
-    const tx: PendingTransaction = {
-      start: () => {
-        run().then(resolve).catch(reject);
-      },
-    };
-
-    locks[dbName]!.queue.push(tx);
-    startNextTransaction(dbName);
-  });
-};
-
-const startNextTransaction = (dbName: string) => {
-  if (!locks[dbName]) {
-    throw Error(`Lock not found for db: ${dbName}`);
-  }
-
-  if (locks[dbName]!.inProgress) {
-    // Transaction is already in process bail out
-    return;
-  }
-
-  if (locks[dbName]!.queue.length) {
-    locks[dbName]!.inProgress = true;
-    const tx = locks[dbName]!.queue.shift();
+      return await new Promise((resolve, reject) => {
+        const tx: PendingTransaction = {
+          start: () => {
+            run().then(resolve).catch(reject);
+          },
+        };
 
-    if (!tx) {
-      throw new Error('Could not get a operation on datebase');
-    }
-
-    setImmediate(() => {
-      tx.start();
-    });
-  }
-};
-
-export type OPSQLiteConnection = {
-  close: () => void;
-  delete: () => void;
-  attach: (dbNameToAttach: string, alias: string, location?: string) => void;
-  detach: (alias: string) => void;
-  transaction: (fn: (tx: Transaction) => Promise<void>) => Promise<void>;
-  execute: (query: string, params?: any[]) => QueryResult;
-  executeAsync: (query: string, params?: any[]) => Promise<QueryResult>;
-  executeBatch: (commands: SQLBatchTuple[]) => BatchQueryResult;
-  executeBatchAsync: (commands: SQLBatchTuple[]) => Promise<BatchQueryResult>;
-  loadFile: (location: string) => Promise<FileLoadResult>;
-  updateHook: (
-    callback:
-      | ((params: {
-          table: string;
-          operation: UpdateHookOperation;
-          row?: any;
-          rowId: number;
-        }) => void)
-      | null
-  ) => void;
-  commitHook: (callback: (() => void) | null) => void;
-  rollbackHook: (callback: (() => void) | null) => void;
-  prepareStatement: (query: string) => PreparedStatementObj;
-  loadExtension: (path: string, entryPoint?: string) => void;
-  executeRawAsync: (query: string, params?: any[]) => Promise<any[]>;
-  getDbPath: () => string;
-};
-
-export const open = (options: {
-  name: string;
-  location?: string;
-  encryptionKey?: string;
-}): OPSQLiteConnection => {
-  OPSQLite.open(options);
-
-  return {
-    close: () => OPSQLite.close(options.name),
-    delete: () => OPSQLite.delete(options.name, options.location),
-    attach: (dbNameToAttach: string, alias: string, location?: string) =>
-      OPSQLite.attach(options.name, dbNameToAttach, alias, location),
-    detach: (alias: string) => OPSQLite.detach(options.name, alias),
-    transaction: (fn: (tx: Transaction) => Promise<void>) =>
-      OPSQLite.transaction(options.name, fn),
-    execute: (query: string, params?: any[] | undefined): QueryResult =>
-      OPSQLite.execute(options.name, query, params),
-    executeAsync: (
-      query: string,
-      params?: any[] | undefined
-    ): Promise<QueryResult> =>
-      OPSQLite.executeAsync(options.name, query, params),
-    executeBatch: (commands: SQLBatchTuple[]) =>
-      OPSQLite.executeBatch(options.name, commands),
-    executeBatchAsync: (commands: SQLBatchTuple[]) =>
-      OPSQLite.executeBatchAsync(options.name, commands),
-    loadFile: (location: string) => OPSQLite.loadFile(options.name, location),
-    updateHook: (callback) => OPSQLite.updateHook(options.name, callback),
-    commitHook: (callback) => OPSQLite.commitHook(options.name, callback),
-    rollbackHook: (callback) => OPSQLite.rollbackHook(options.name, callback),
-    prepareStatement: (query) => OPSQLite.prepareStatement(options.name, query),
-    loadExtension: (path, entryPoint) =>
-      OPSQLite.loadExtension(options.name, path, entryPoint),
-    executeRawAsync: (query, params) =>
-      OPSQLite.executeRawAsync(options.name, query, params),
-    getDbPath: () => OPSQLite.getDbPath(options.name, options.location),
+        lock.queue.push(tx);
+        startNextTransaction();
+      });
+    },
   };
+
+  return enhancedDb;
 };
 
 export const moveAssetsDatabase = async (args: {
@@ -500,3 +427,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>>(toVariantVec(rt, p));
-        commands->push_back({query, params});
-      }
-    } else {
-      auto params = std::make_shared<std::vector<JSVariant>>(
-          toVariantVec(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