@op-engineering/op-sqlite 15.0.0 → 15.0.2

package/src/index.ts

@@ -1,5 +1,7 @@
-import { NativeModules, Platform } from 'react-native';
+import { NativeModules } from 'react-native';
+
 export { Storage } from './Storage';
+export * from './functions';
 
 export type Scalar =
   | string
@@ -55,7 +57,8 @@ export type ColumnMetadata = {
  */
 export type SQLBatchTuple =
   | [string]
-  | [string, Array<Scalar> | Array<Array<Scalar>>];
+  | [string, Scalar[]]
+  | [string, Scalar[][]];
 
 export type UpdateHookOperation = 'INSERT' | 'DELETE' | 'UPDATE';
 
@@ -82,7 +85,7 @@ export type Transaction = {
   rollback: () => QueryResult;
 };
 
-type PendingTransaction = {
+export type _PendingTransaction = {
   /*
    * The start function should not throw or return a promise because the
    * queue just calls it and does not monitor for failures or completions.
@@ -101,7 +104,7 @@ export type PreparedStatement = {
   execute: () => Promise<QueryResult>;
 };
 
-type InternalDB = {
+export type _InternalDB = {
   close: () => void;
   delete: (location?: string) => void;
   attach: (params: {
@@ -307,44 +310,14 @@ export type OPSQLiteProxy = {
     name: string;
     location?: string;
     encryptionKey?: string;
-  }) => InternalDB;
-  openRemote: (options: { url: string; authToken: string }) => InternalDB;
-  openSync: (options: DBParams) => InternalDB;
+  }) => _InternalDB;
+  openRemote: (options: { url: string; authToken: string }) => _InternalDB;
+  openSync: (options: DBParams) => _InternalDB;
   isSQLCipher: () => boolean;
   isLibsql: () => boolean;
   isIOSEmbedded: () => boolean;
 };
 
-declare global {
-  var __OPSQLiteProxy: object | undefined;
-}
-
-if (global.__OPSQLiteProxy == null) {
-  if (NativeModules.OPSQLite == null) {
-    throw new Error(
-      'Base module not found. Did you do a pod install/clear the gradle cache?'
-    );
-  }
-
-  // Call the synchronous blocking install() function
-  const installed = NativeModules.OPSQLite.install();
-  if (!installed) {
-    throw new Error(
-      `Failed to install op-sqlite: The native OPSQLite Module could not be installed! Looks like something went wrong when installing JSI bindings, check the native logs for more info`
-    );
-  }
-
-  // Check again if the constructor now exists. If not, throw an error.
-  if (global.__OPSQLiteProxy == null) {
-    throw new Error(
-      'OPSqlite native object is not available. Something is wrong. Check the native logs for more information.'
-    );
-  }
-}
-
-const proxy = global.__OPSQLiteProxy;
-const OPSQLite = proxy as OPSQLiteProxy;
-
 export const {
   IOS_DOCUMENT_PATH,
   IOS_LIBRARY_PATH,
@@ -354,417 +327,3 @@ export const {
 } = !!NativeModules.OPSQLite.getConstants
   ? NativeModules.OPSQLite.getConstants()
   : NativeModules.OPSQLite;
-
-function enhanceDB(db: InternalDB, options: DBParams): DB {
-  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();
-      });
-    }
-  };
-
-  function sanitizeArrayBuffersInArray(
-    params?: any[] | any[][]
-  ): any[] | undefined {
-    if (!params) {
-      return params;
-    }
-
-    return params.map((p) => {
-      if (Array.isArray(p)) {
-        return sanitizeArrayBuffersInArray(p);
-      }
-
-      if (ArrayBuffer.isView(p)) {
-        return p.buffer;
-      }
-
-      return p;
-    });
-  }
-
-  // spreading the object does not work with HostObjects (db)
-  // We need to manually assign the fields
-  let enhancedDb = {
-    delete: db.delete,
-    attach: db.attach,
-    detach: db.detach,
-    executeBatch: async (
-      commands: SQLBatchTuple[]
-    ): Promise<BatchQueryResult> => {
-      const sanitizedCommands = commands.map(([query, params]) => {
-        if (params) {
-          return [query, sanitizeArrayBuffersInArray(params)];
-        }
-
-        return [query];
-      });
-
-      async function run() {
-        try {
-          enhancedDb.executeSync('BEGIN TRANSACTION;');
-
-          let res = await db.executeBatch(sanitizedCommands as any[]);
-
-          enhancedDb.executeSync('COMMIT;');
-
-          return res;
-        } catch (executionError) {
-          try {
-            enhancedDb.executeSync('ROLLBACK;');
-          } catch (rollbackError) {
-            throw rollbackError;
-          }
-
-          throw executionError;
-        } finally {
-          lock.inProgress = false;
-          startNextTransaction();
-        }
-      }
-
-      return await new Promise((resolve, reject) => {
-        const tx: PendingTransaction = {
-          start: () => {
-            run().then(resolve).catch(reject);
-          },
-        };
-
-        lock.queue.push(tx);
-        startNextTransaction();
-      });
-    },
-    loadFile: db.loadFile,
-    updateHook: db.updateHook,
-    commitHook: db.commitHook,
-    rollbackHook: db.rollbackHook,
-    loadExtension: db.loadExtension,
-    getDbPath: db.getDbPath,
-    reactiveExecute: db.reactiveExecute,
-    sync: db.sync,
-    close: db.close,
-    executeWithHostObjects: async (
-      query: string,
-      params?: Scalar[]
-    ): Promise<QueryResult> => {
-      const sanitizedParams = sanitizeArrayBuffersInArray(params);
-
-      return sanitizedParams
-        ? await db.executeWithHostObjects(query, sanitizedParams as Scalar[])
-        : await db.executeWithHostObjects(query);
-    },
-    executeRaw: async (query: string, params?: Scalar[]) => {
-      const sanitizedParams = sanitizeArrayBuffersInArray(params);
-
-      return db.executeRaw(query, sanitizedParams as Scalar[]);
-    },
-    // Wrapper for executeRaw, drizzleORM uses this function
-    // at some point I changed the API but they did not pin their dependency to a specific version
-    // so re-inserting this so it starts working again
-    executeRawAsync: async (query: string, params?: Scalar[]) => {
-      const sanitizedParams = sanitizeArrayBuffersInArray(params);
-
-      return db.executeRaw(query, sanitizedParams as Scalar[]);
-    },
-    executeRawSync: (query: string, params?: Scalar[]) => {
-      const sanitizedParams = sanitizeArrayBuffersInArray(params);
-      return db.executeRawSync(query, sanitizedParams as Scalar[]);
-    },
-    executeSync: (query: string, params?: Scalar[]): QueryResult => {
-      const sanitizedParams = sanitizeArrayBuffersInArray(params);
-
-      let intermediateResult = sanitizedParams
-        ? db.executeSync(query, sanitizedParams as Scalar[])
-        : db.executeSync(query);
-
-      let rows: Record<string, Scalar>[] = [];
-      for (let i = 0; i < (intermediateResult.rawRows?.length ?? 0); i++) {
-        let row: Record<string, Scalar> = {};
-        let rawRow = intermediateResult.rawRows![i]!;
-        for (let j = 0; j < intermediateResult.columnNames!.length; j++) {
-          let columnName = intermediateResult.columnNames![j]!;
-          let value = rawRow[j]!;
-
-          row[columnName] = value;
-        }
-        rows.push(row);
-      }
-
-      let res = {
-        ...intermediateResult,
-        rows,
-      };
-
-      delete res.rawRows;
-
-      return res;
-    },
-    executeAsync: async (
-      query: string,
-      params?: Scalar[] | undefined
-    ): Promise<QueryResult> => {
-      return db.execute(query, params);
-    },
-    execute: async (
-      query: string,
-      params?: Scalar[] | undefined
-    ): Promise<QueryResult> => {
-      const sanitizedParams = sanitizeArrayBuffersInArray(params);
-
-      let intermediateResult = await db.execute(
-        query,
-        sanitizedParams as Scalar[]
-      );
-
-      let rows: Record<string, Scalar>[] = [];
-      for (let i = 0; i < (intermediateResult.rawRows?.length ?? 0); i++) {
-        let row: Record<string, Scalar> = {};
-        let rawRow = intermediateResult.rawRows![i]!;
-        for (let j = 0; j < intermediateResult.columnNames!.length; j++) {
-          let columnName = intermediateResult.columnNames![j]!;
-          let value = rawRow[j]!;
-
-          row[columnName] = value;
-        }
-        rows.push(row);
-      }
-
-      let res = {
-        ...intermediateResult,
-        rows,
-      };
-
-      delete res.rawRows;
-
-      return res;
-    },
-    prepareStatement: (query: string) => {
-      const stmt = db.prepareStatement(query);
-
-      return {
-        bindSync: (params: Scalar[]) => {
-          const sanitizedParams = sanitizeArrayBuffersInArray(params);
-
-          stmt.bindSync(sanitizedParams!);
-        },
-        bind: async (params: Scalar[]) => {
-          const sanitizedParams = sanitizeArrayBuffersInArray(params);
-
-          await stmt.bind(sanitizedParams!);
-        },
-        execute: stmt.execute,
-      };
-    },
-    transaction: async (
-      fn: (tx: Transaction) => Promise<void>
-    ): Promise<void> => {
-      let isFinalized = false;
-
-      const execute = async (query: string, params?: Scalar[]) => {
-        if (isFinalized) {
-          throw Error(
-            `OP-Sqlite Error: Database: ${
-              options.name || options.url
-            }. Cannot execute query on finalized transaction`
-          );
-        }
-        return await enhancedDb.execute(query, params);
-      };
-
-      const commit = async (): Promise<QueryResult> => {
-        if (isFinalized) {
-          throw Error(
-            `OP-Sqlite Error: Database: ${
-              options.name || options.url
-            }. Cannot execute query on finalized transaction`
-          );
-        }
-        const result = enhancedDb.executeSync('COMMIT;');
-
-        await db.flushPendingReactiveQueries();
-
-        isFinalized = true;
-        return result;
-      };
-
-      const rollback = (): QueryResult => {
-        if (isFinalized) {
-          throw Error(
-            `OP-Sqlite Error: Database: ${
-              options.name || options.url
-            }. Cannot execute query on finalized transaction`
-          );
-        }
-        const result = enhancedDb.executeSync('ROLLBACK;');
-        isFinalized = true;
-        return result;
-      };
-
-      async function run() {
-        try {
-          enhancedDb.executeSync('BEGIN TRANSACTION;');
-
-          await fn({
-            commit,
-            execute,
-            rollback,
-          });
-
-          if (!isFinalized) {
-            commit();
-          }
-        } catch (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;
-}
-
-/**
- * Open a replicating connection via libsql to a turso db
- * libsql needs to be enabled on your package.json
- */
-export const openSync = (params: {
-  url: string;
-  authToken: string;
-  name: string;
-  location?: string;
-  libsqlSyncInterval?: number;
-  libsqlOffline?: boolean;
-  encryptionKey?: string;
-  remoteEncryptionKey?: string;
-}): DB => {
-  if (!isLibsql()) {
-    throw new Error('This function is only available for libsql');
-  }
-
-  const db = OPSQLite.openSync(params);
-  const enhancedDb = enhanceDB(db, params);
-
-  return enhancedDb;
-};
-
-/**
- * Open a remote connection via libsql to a turso db
- * libsql needs to be enabled on your package.json
- */
-export const openRemote = (params: { url: string; authToken: string }): DB => {
-  if (!isLibsql()) {
-    throw new Error('This function is only available for libsql');
-  }
-
-  const db = OPSQLite.openRemote(params);
-  const enhancedDb = enhanceDB(db, params);
-
-  return enhancedDb;
-};
-
-/**
- * Open a connection to a local sqlite, sqlcipher or libsql database.
- *
- * If you want libsql remote or sync connections, use openSync or openRemote.
- */
-export const open = (params: {
-  name: string;
-  location?: string;
-  encryptionKey?: string;
-}): DB => {
-  if (params.location?.startsWith('file://')) {
-    console.warn(
-      "[op-sqlite] You are passing a path with 'file://' prefix, it's automatically removed"
-    );
-    params.location = params.location.substring(7);
-  }
-
-  const db = OPSQLite.open(params);
-  const enhancedDb = enhanceDB(db, params);
-
-  return enhancedDb;
-};
-
-/**
- * Moves the database from the assets folder to the default path (check the docs) or to a custom path
- * It DOES NOT OVERWRITE the database if it already exists in the destination path
- * if you want to overwrite the database, you need to pass the overwrite flag as true
- * @param args object with the parameters for the operaiton
- * @returns promise, rejects if failed to move the database, resolves if the operation was successful
- */
-export const moveAssetsDatabase = async (args: {
-  filename: string;
-  path?: string;
-  overwrite?: boolean;
-}): Promise<boolean> => {
-  return NativeModules.OPSQLite.moveAssetsDatabase(args);
-};
-
-/**
- * Used to load a dylib file that contains a sqlite 3 extension/plugin
- * It returns the raw path to the actual file which then needs to be passed to the loadExtension function
- * Check the docs for more information
- * @param bundle the iOS bundle identifier of the .framework
- * @param name the file name of the dylib file
- * @returns
- */
-export const getDylibPath = (bundle: string, name: string): string => {
-  return NativeModules.OPSQLite.getDylibPath(bundle, name);
-};
-
-export const isSQLCipher = (): boolean => {
-  return OPSQLite.isSQLCipher();
-};
-
-export const isLibsql = (): boolean => {
-  return OPSQLite.isLibsql();
-};
-
-export const isIOSEmbeeded = (): boolean => {
-  if (Platform.OS !== 'ios') {
-    return false;
-  }
-
-  return OPSQLite.isIOSEmbedded();
-};