react-native-nitro-sqlite 8.2.1-nitro.1

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "react-native-nitro-sqlite",
+  "version": "8.2.1-nitro.1",
+  "description": "Fast SQLite for react-native",
+  "main": "lib/commonjs/index",
+  "module": "lib/module/index",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/margelo/react-native-nitro-sqlite.git"
+  },
+  "author": "Margelo <hello@margelo.com> (https://github.com/margelo)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/margelo/react-native-nitro-sqlite/issues"
+  },
+  "homepage": "https://github.com/margelo/react-native-nitro-sqlite#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src",
+    "lib",
+    "nitrogen",
+    "android",
+    "ios",
+    "cpp",
+    "nitrogen",
+    "RNNitroSQLite.podspec",
+    "!lib/typescript/example",
+    "!android/build",
+    "!android/.cxx",
+    "!ios/build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "scripts": {
+    "typescript": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "prepare": "rm -rf lib && bun typescript && bob build",
+    "bootstrap": "bun --filter=\"**\" install && bun tsc && bun --filter=\"example\" pods",
+    "specs": "bun typescript && bun nitro-codegen --logLevel=\"debug\"",
+    "release": "bun prepare && release-it"
+  },
+  "dependencies": {
+    "typeorm": "^0.3.20"
+  },
+  "devDependencies": {
+    "@react-native/typescript-config": "0.75.2",
+    "babel-plugin-transform-typescript-metadata": "^0.3.2",
+    "nitro-codegen": "^0.11.0",
+    "react": "18.3.1",
+    "react-native": "0.75.2",
+    "react-native-builder-bob": "^0.18.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": ">=0.74.0",
+    "react-native-nitro-modules": "*"
+  },
+  "codegenConfig": {
+    "name": "RNNitroSQLite",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.margelo.rnnitrosqlite"
+    }
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "tsc": "../node_modules/.bin/tsc"
+        }
+      ]
+    ]
+  },
+  "release-it": {
+    "npm": {
+      "publish": true,
+      "publishPackageManager": "bun"
+    },
+    "git": false
+  }
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+import { transaction } from './operations/transaction'
+import { HybridNitroSQLite } from './nitro'
+import { open } from './operations/session'
+import NitroSQLiteOnLoad from './specs/NativeNitroSQLiteOnLoad'
+import { execute, executeAsync } from './operations/execute'
+
+export * from './types'
+export { typeORMDriver } from './typeORM'
+
+export const onInitialized = new Promise<void>((resolve) => {
+  NitroSQLiteOnLoad.onReactApplicationContextReady(resolve)
+})
+
+export const NitroSQLite = {
+  ...HybridNitroSQLite,
+  native: HybridNitroSQLite,
+  onInitialized,
+  // Overwrite native functions with session-based JS implementations,
+  // where the database name can be ommited once opened
+  open,
+  transaction,
+  execute,
+  executeAsync,
+}
+
+export { open } from './operations/session'

package/src/nitro.ts

@@ -0,0 +1,11 @@
+import { NitroModules } from 'react-native-nitro-modules'
+import type { NitroSQLite as NitroSQLiteSpec } from './specs/NitroSQLite.nitro'
+import type { PendingTransaction } from './operations/transaction'
+
+export const HybridNitroSQLite =
+  NitroModules.createHybridObject<NitroSQLiteSpec>('NitroSQLite')
+
+export const locks: Record<
+  string,
+  { queue: PendingTransaction[]; inProgress: boolean }
+> = {}

package/src/operations/execute.ts

@@ -0,0 +1,45 @@
+import { HybridNitroSQLite } from '../nitro'
+import type { NativeQueryResult } from '../specs/NativeQueryResult.nitro'
+import type { QueryResult, SQLiteItem, SQLiteQueryParams } from '../types'
+
+export function execute<Data extends SQLiteItem = never>(
+  dbName: string,
+  query: string,
+  params?: SQLiteQueryParams
+): QueryResult<Data> {
+  const nativeResult = HybridNitroSQLite.execute(dbName, query, params)
+  const result = buildJsQueryResult<Data>(nativeResult)
+  return result
+}
+
+export async function executeAsync<Data extends SQLiteItem = never>(
+  dbName: string,
+  query: string,
+  params?: SQLiteQueryParams
+): Promise<QueryResult<Data>> {
+  const nativeResult = await HybridNitroSQLite.executeAsync(
+    dbName,
+    query,
+    params
+  )
+  const result = buildJsQueryResult<Data>(nativeResult)
+  return result
+}
+
+function buildJsQueryResult<Data extends SQLiteItem = never>({
+  insertId,
+  rowsAffected,
+  results,
+}: NativeQueryResult): QueryResult<Data> {
+  const data = results as Data[]
+
+  return {
+    insertId,
+    rowsAffected,
+    rows: {
+      _array: data,
+      length: data.length,
+      item: (idx: number) => data[idx],
+    },
+  }
+}

package/src/operations/session.ts

@@ -0,0 +1,58 @@
+import { locks, HybridNitroSQLite } from '../nitro'
+import { transaction } from './transaction'
+import type {
+  BatchQueryCommand,
+  NitroSQLiteConnection,
+  NitroSQLiteConnectionOptions,
+  QueryResult,
+  SQLiteItem,
+  SQLiteQueryParams,
+  Transaction,
+} from '../types'
+import { execute, executeAsync } from './execute'
+
+export function open(
+  options: NitroSQLiteConnectionOptions
+): NitroSQLiteConnection {
+  openDb(options.name, options.location)
+
+  return {
+    close: () => close(options.name),
+    delete: () => HybridNitroSQLite.drop(options.name, options.location),
+    attach: (dbNameToAttach: string, alias: string, location?: string) =>
+      HybridNitroSQLite.attach(options.name, dbNameToAttach, alias, location),
+    detach: (alias: string) => HybridNitroSQLite.detach(options.name, alias),
+    transaction: (fn: (tx: Transaction) => Promise<void> | void) =>
+      transaction(options.name, fn),
+    execute: <Data extends SQLiteItem = never>(
+      query: string,
+      params?: SQLiteQueryParams
+    ): QueryResult<Data> => execute(options.name, query, params),
+    executeAsync: <Data extends SQLiteItem = never>(
+      query: string,
+      params?: SQLiteQueryParams
+    ): Promise<QueryResult<Data>> => executeAsync(options.name, query, params),
+    executeBatch: (commands: BatchQueryCommand[]) =>
+      HybridNitroSQLite.executeBatch(options.name, commands),
+    executeBatchAsync: (commands: BatchQueryCommand[]) =>
+      HybridNitroSQLite.executeBatchAsync(options.name, commands),
+    loadFile: (location: string) =>
+      HybridNitroSQLite.loadFile(options.name, location),
+    loadFileAsync: (location: string) =>
+      HybridNitroSQLite.loadFileAsync(options.name, location),
+  }
+}
+
+export function openDb(dbName: string, location?: string) {
+  HybridNitroSQLite.open(dbName, location)
+
+  locks[dbName] = {
+    queue: [],
+    inProgress: false,
+  }
+}
+
+export function close(dbName: string) {
+  HybridNitroSQLite.close(dbName)
+  delete locks[dbName]
+}

package/src/operations/transaction.ts

@@ -0,0 +1,137 @@
+import { locks, HybridNitroSQLite } from '../nitro'
+import type {
+  QueryResult,
+  SQLiteItem,
+  SQLiteQueryParams,
+  Transaction,
+} from '../types'
+import { execute, executeAsync } from './execute'
+
+export interface 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.
+   *
+   * It should catch any errors and call the resolve or reject of the wrapping
+   * promise when complete.
+   *
+   * It should also automatically commit or rollback the transaction if needed
+   */
+  start: () => void
+}
+
+export const transaction = async (
+  dbName: string,
+  fn: (tx: Transaction) => Promise<void> | void
+): Promise<void> => {
+  if (locks[dbName] == null)
+    throw Error(`Nitro SQLite Error: No lock found on db: ${dbName}`)
+
+  let isFinalized = false
+
+  // Local transaction context object implementation
+  const executeOnTransaction = <Data extends SQLiteItem = never>(
+    query: string,
+    params?: SQLiteQueryParams
+  ): QueryResult<Data> => {
+    if (isFinalized) {
+      throw Error(
+        `Nitro SQLite Error: Cannot execute query on finalized transaction: ${dbName}`
+      )
+    }
+    return execute(dbName, query, params)
+  }
+
+  const executeAsyncOnTransaction = <Data extends SQLiteItem = never>(
+    query: string,
+    params?: SQLiteQueryParams
+  ): Promise<QueryResult<Data>> => {
+    if (isFinalized) {
+      throw Error(
+        `Nitro SQLite Error: Cannot execute query on finalized transaction: ${dbName}`
+      )
+    }
+    return executeAsync(dbName, query, params)
+  }
+
+  const commit = () => {
+    if (isFinalized) {
+      throw Error(
+        `Nitro SQLite Error: Cannot execute commit on finalized transaction: ${dbName}`
+      )
+    }
+    const result = HybridNitroSQLite.execute(dbName, 'COMMIT')
+    isFinalized = true
+    return result
+  }
+
+  const rollback = () => {
+    if (isFinalized) {
+      throw Error(
+        `Nitro SQLite Error: Cannot execute rollback on finalized transaction: ${dbName}`
+      )
+    }
+    const result = HybridNitroSQLite.execute(dbName, 'ROLLBACK')
+    isFinalized = true
+    return result
+  }
+
+  async function run() {
+    try {
+      await HybridNitroSQLite.executeAsync(dbName, 'BEGIN TRANSACTION')
+
+      await fn({
+        commit,
+        execute: executeOnTransaction,
+        executeAsync: executeAsyncOnTransaction,
+        rollback,
+      })
+
+      if (!isFinalized) commit()
+    } catch (executionError) {
+      if (!isFinalized) {
+        try {
+          rollback()
+        } catch (rollbackError) {
+          throw rollbackError
+        }
+      }
+
+      throw executionError
+    } finally {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      locks[dbName]!.inProgress = false
+      isFinalized = false
+      startNextTransaction(dbName)
+    }
+  }
+
+  return new Promise((resolve, reject) => {
+    const tx: PendingTransaction = {
+      start: () => {
+        run().then(resolve).catch(reject)
+      },
+    }
+
+    locks[dbName]?.queue.push(tx)
+    startNextTransaction(dbName)
+  })
+}
+
+function startNextTransaction(dbName: string) {
+  if (locks[dbName] == null) 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 > 0) {
+    locks[dbName].inProgress = true
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const tx = locks[dbName].queue.shift()!
+    setImmediate(() => {
+      tx.start()
+    })
+  }
+}

package/src/specs/NativeNitroSQLiteOnLoad.ios.ts

@@ -0,0 +1,7 @@
+import type { Spec as AndroidOnLoadTurboModuleSpec } from './NativeNitroSQLiteOnLoad'
+
+export const noop: AndroidOnLoadTurboModuleSpec = {
+  onReactApplicationContextReady: () => undefined,
+}
+
+export default noop

package/src/specs/NativeNitroSQLiteOnLoad.ts

@@ -0,0 +1,7 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native'
+
+export interface Spec extends TurboModule {
+  onReactApplicationContextReady(callback: () => void): void
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNitroSQLiteOnLoad')

package/src/specs/NativeQueryResult.nitro.ts

@@ -0,0 +1,44 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { ColumnType, SQLiteValue } from '../types'
+
+/**
+ * Object returned by SQL Query executions {
+ *  insertId: Represent the auto-generated row id if applicable
+ *  rowsAffected: Number of affected rows if result of a update query
+ *  message: if status === 1, here you will find error description
+ *  rows: if status is undefined or 0 this object will contain the query results
+ * }
+ *
+ * @interface NativeQueryResult
+ */
+export interface NativeQueryResult
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  readonly rowsAffected: number
+  readonly insertId?: number
+
+  /** Query results */
+  readonly results: SQLiteQueryResults
+  /** Table metadata */
+  readonly metadata?: Record<string, SQLiteQueryColumnMetadata>
+}
+
+/**
+ * Table metadata
+ * Describes some information about the table and it's columns fetched by the query
+ * The index is the name of the column
+ */
+// TODO: Investigate why this doesn't work with nitrogen
+// export type SQLiteQueryResultRow = Record<string, SQLiteValue>
+// export type SQLiteQueryResults = SQLiteQueryResultRow[]
+export type SQLiteQueryResults = Record<string, SQLiteValue>[]
+
+// TODO: Investigate why this doesn't work with nitrogen
+// export type SQLiteQueryTableMetadata = Record<string, SQLiteQueryColumnMetadata>
+export interface SQLiteQueryColumnMetadata {
+  /** The name used for this column for this result set */
+  name: string
+  /** The declared column type for this column, when fetched directly from a table or a View resulting from a table column. "UNKNOWN" for dynamic values, like function returned ones. */
+  type: ColumnType
+  /** The index for this column for this result set */
+  index: number
+}

package/src/specs/NitroSQLite.nitro.ts

@@ -0,0 +1,39 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+import type {
+  BatchQueryResult,
+  FileLoadResult,
+  BatchQueryCommand,
+  SQLiteQueryParams,
+} from '../types'
+import type { NativeQueryResult } from './NativeQueryResult.nitro'
+
+export interface NitroSQLite
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  open(dbName: string, location?: string): void
+  close(dbName: string): void
+  drop(dbName: string, location?: string): void
+  attach(
+    mainDbName: string,
+    dbNameToAttach: string,
+    alias: string,
+    location?: string
+  ): void
+  detach(mainDbName: string, alias: string): void
+  execute(
+    dbName: string,
+    query: string,
+    params?: SQLiteQueryParams
+  ): NativeQueryResult
+  executeAsync(
+    dbName: string,
+    query: string,
+    params?: SQLiteQueryParams
+  ): Promise<NativeQueryResult>
+  executeBatch(dbName: string, commands: BatchQueryCommand[]): BatchQueryResult
+  executeBatchAsync(
+    dbName: string,
+    commands: BatchQueryCommand[]
+  ): Promise<BatchQueryResult>
+  loadFile(dbName: string, location: string): FileLoadResult
+  loadFileAsync(dbName: string, location: string): Promise<FileLoadResult>
+}

package/src/typeORM.ts

@@ -0,0 +1,101 @@
+//   _________     _______  ______ ____  _____  __  __            _____ _____
+//  |__   __\ \   / /  __ \|  ____/ __ \|  __ \|  \/  |     /\   |  __ \_   _|
+//     | |   \ \_/ /| |__) | |__ | |  | | |__) | \  / |    /  \  | |__) || |
+//     | |    \   / |  ___/|  __|| |  | |  _  /| |\/| |   / /\ \ |  ___/ | |
+//     | |     | |  | |    | |___| |__| | | \ \| |  | |  / ____ \| |    _| |_
+//     |_|     |_|  |_|    |______\____/|_|  \_\_|  |_| /_/    \_\_|   |_____|
+
+import type {
+  QueryResult,
+  SQLiteItem,
+  SQLiteQueryParams,
+  Transaction,
+} from './types'
+import * as Operations from './operations/session'
+
+interface TypeOrmNitroSQLiteConnection {
+  executeSql: <RowData extends SQLiteItem = never>(
+    sql: string,
+    params: SQLiteQueryParams | undefined,
+    okExecute: (res: QueryResult<RowData>) => void,
+    failExecute: (msg: string) => void
+  ) => Promise<void>
+  transaction: (fn: (tx: Transaction) => Promise<void>) => Promise<void>
+  close: (okClose: () => void, failClose: (e: unknown) => void) => void
+  attach: (
+    dbNameToAttach: string,
+    alias: string,
+    location: string | undefined,
+    callback: () => void
+  ) => void
+  detach: (alias: string, callback: () => void) => void
+}
+
+/**
+ * DO NOT USE THIS! THIS IS MEANT FOR TYPEORM
+ * If you are looking for a convenience wrapper use `connect`
+ */
+export const typeORMDriver = {
+  openDatabase: (
+    options: {
+      name: string
+      location?: string
+    },
+    ok: (db: TypeOrmNitroSQLiteConnection) => void,
+    fail: (msg: string) => void
+  ): TypeOrmNitroSQLiteConnection | null => {
+    try {
+      const db = Operations.open(options)
+
+      const connection: TypeOrmNitroSQLiteConnection = {
+        executeSql: async <RowData extends SQLiteItem = never>(
+          sql: string,
+          params: SQLiteQueryParams | undefined,
+          okExecute: (res: QueryResult<RowData>) => void,
+          failExecute: (msg: string) => void
+        ) => {
+          try {
+            const result = await db.executeAsync<RowData>(sql, params)
+            okExecute(result)
+          } catch (e: unknown) {
+            failExecute(e as string)
+          }
+        },
+        transaction: (
+          fn: (tx: Transaction) => Promise<void>
+        ): Promise<void> => {
+          return db.transaction(fn)
+        },
+        close: (okClose: () => void, failClose: (e: unknown) => void) => {
+          try {
+            db.close()
+            okClose()
+          } catch (e) {
+            failClose(e)
+          }
+        },
+        attach: (
+          dbNameToAttach: string,
+          alias: string,
+          location: string | undefined,
+          callback: () => void
+        ) => {
+          db.attach(dbNameToAttach, alias, location)
+          callback()
+        },
+        detach: (alias: string, callback: () => void) => {
+          db.detach(alias)
+          callback()
+        },
+      }
+
+      ok(connection)
+
+      return connection
+    } catch (e: unknown) {
+      fail(e as string)
+
+      return null
+    }
+  },
+}

package/src/types.ts

@@ -0,0 +1,105 @@
+export interface NitroSQLiteConnectionOptions {
+  name: string
+  location?: string
+}
+
+export interface NitroSQLiteConnection {
+  close(): void
+  delete(): void
+  attach(dbNameToAttach: string, alias: string, location?: string): void
+  detach(alias: string): void
+  transaction(fn: (tx: Transaction) => Promise<void> | void): Promise<void>
+  execute: ExecuteQuery
+  executeAsync: ExecuteAsyncQuery
+  executeBatch(commands: BatchQueryCommand[]): BatchQueryResult
+  executeBatchAsync(commands: BatchQueryCommand[]): Promise<BatchQueryResult>
+  loadFile(location: string): FileLoadResult
+  loadFileAsync(location: string): Promise<FileLoadResult>
+}
+
+// eslint-disable-next-line no-restricted-syntax
+export enum ColumnType {
+  BOOLEAN,
+  NUMBER,
+  INT64,
+  TEXT,
+  ARRAY_BUFFER,
+  NULL_VALUE,
+}
+
+/**
+ * Represents a value that can be stored in a SQLite database
+ */
+export type SQLiteValue =
+  | boolean
+  | number
+  | bigint
+  | string
+  | ArrayBuffer
+  | undefined
+
+export type SQLiteItem = Record<string, SQLiteValue>
+
+export interface QueryResult<RowData extends SQLiteItem = SQLiteItem> {
+  readonly insertId?: number
+  readonly rowsAffected: number
+
+  readonly rows?: {
+    /** Raw array with all dataset */
+    _array: RowData[]
+    /** The lengh of the dataset */
+    length: number
+    /** A convenience function to acess the index based the row object
+     * @param idx the row index
+     * @returns the row structure identified by column names
+     */
+    item: (idx: number) => RowData | undefined
+  }
+}
+
+export type SQLiteQueryParams = SQLiteValue[]
+
+export type ExecuteQuery = <RowData extends SQLiteItem = SQLiteItem>(
+  query: string,
+  params?: SQLiteQueryParams
+) => QueryResult<RowData>
+
+export type ExecuteAsyncQuery = <RowData extends SQLiteItem = SQLiteItem>(
+  query: string,
+  params?: SQLiteQueryParams
+) => Promise<QueryResult<RowData>>
+
+export interface Transaction {
+  commit(): QueryResult
+  rollback(): QueryResult
+  execute: ExecuteQuery
+  executeAsync: ExecuteAsyncQuery
+}
+
+/**
+ * Allows the execution of bulk of sql commands
+ * inside a transaction
+ * If a single query must be executed many times with different arguments, its preferred
+ * to declare it a single time, and use an array of array parameters.
+ */
+export interface BatchQueryCommand {
+  query: string
+  params?: SQLiteQueryParams | SQLiteQueryParams[]
+}
+
+/**
+ * status: 0 or undefined for correct execution, 1 for error
+ * message: if status === 1, here you will find error description
+ * rowsAffected: Number of affected rows if status == 0
+ */
+export interface BatchQueryResult {
+  rowsAffected?: number
+}
+
+/**
+ * Result of loading a file and executing every line as a SQL command
+ * Similar to BatchQueryResult
+ */
+export interface FileLoadResult extends BatchQueryResult {
+  commands?: number
+}