@symbiote-native/sqlite 0.1.0

package/build-ngc/core/sqlite-database.d.ts

@@ -0,0 +1,246 @@
+import type { EventSubscription } from 'expo-modules-core';
+import { NativeDatabase } from './native-database';
+import type { ISQLiteOpenOptions } from './native-database';
+import { SQLiteSession } from './sqlite-session';
+import { SQLiteStatement } from './sqlite-statement';
+import type { ISQLiteBindParams, ISQLiteRunResult, ISQLiteVariadicBindParams } from './sqlite-statement';
+import { SQLiteTaggedQuery } from './sqlite-tagged-query';
+import type { IDatabaseChangeEvent, IOpenDatabaseOptions } from './types';
+export type { ISQLiteOpenOptions } from './native-database';
+export type { IDatabaseChangeEvent, IOnInitCallback, IOpenDatabaseOptions, } from './types';
+/** A SQLite database. */
+export declare class SQLiteDatabase {
+    readonly databasePath: string;
+    readonly options: ISQLiteOpenOptions;
+    readonly nativeDatabase: NativeDatabase;
+    constructor(databasePath: string, options: ISQLiteOpenOptions, nativeDatabase: NativeDatabase);
+    /** Whether the database is currently in a transaction. */
+    isInTransactionAsync(): Promise<boolean>;
+    /** Closes the database. */
+    closeAsync(): Promise<void>;
+    /**
+     * Executes all SQL queries in the supplied string.
+     * > **Note:** The queries are not escaped for you — be careful when constructing them.
+     */
+    execAsync(source: string): Promise<void>;
+    /**
+     * [Serializes the database](https://sqlite.org/c3ref/serialize.html) as a `Uint8Array`.
+     * @param databaseName The attached database name. Defaults to `main`.
+     */
+    serializeAsync(databaseName?: string): Promise<Uint8Array>;
+    /**
+     * Creates a [prepared statement](https://www.sqlite.org/c3ref/prepare.html) from `source`.
+     */
+    prepareAsync(source: string): Promise<SQLiteStatement>;
+    /**
+     * Creates a new session for the database.
+     * @see [`sqlite3session_create`](https://www.sqlite.org/session/sqlite3session_create.html)
+     * @param dbName The database name to create a session for. Defaults to `main`.
+     */
+    createSessionAsync(dbName?: string): Promise<SQLiteSession>;
+    /**
+     * Loads a SQLite extension.
+     * @param libPath The path to the extension library file.
+     * @param entryPoint The extension's entry point. Inferred by
+     *   [`sqlite3_load_extension`](https://www.sqlite.org/c3ref/load_extension.html) when omitted.
+     */
+    loadExtensionAsync(libPath: string, entryPoint?: string): Promise<void>;
+    /**
+     * Executes a transaction, committing/rolling back automatically based on `task`'s result.
+     *
+     * > **Note:** Not exclusive — other async queries can interleave, so the order of execution
+     * > relative to a query issued outside the transaction is not guaranteed. Use
+     * > `withExclusiveTransactionAsync` when that matters.
+     */
+    withTransactionAsync(task: () => Promise<void>): Promise<void>;
+    /**
+     * Executes a transaction, committing/rolling back automatically based on `task`'s result.
+     * The transaction may be exclusive: once it becomes a write transaction, other async write
+     * queries abort with a `database is locked` error.
+     *
+     * > **Note:** Not supported on web.
+     *
+     * @param task Any queries inside it must run on the `txn` object it receives — a private
+     *   `SQLiteDatabase` subclass bound to the exclusive connection, typed here as the base class
+     *   since the subclass is an implementation detail, not a public export.
+     */
+    withExclusiveTransactionAsync(task: (txn: SQLiteDatabase) => Promise<void>): Promise<void>;
+    /** Whether the database is currently in a transaction. */
+    isInTransactionSync(): boolean;
+    /** Closes the database. */
+    closeSync(): void;
+    /**
+     * Executes all SQL queries in the supplied string.
+     * > **Note:** The queries are not escaped for you. Running heavy tasks with this function can
+     * > block the JavaScript thread.
+     */
+    execSync(source: string): void;
+    /**
+     * [Serializes the database](https://sqlite.org/c3ref/serialize.html) as a `Uint8Array`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    serializeSync(databaseName?: string): Uint8Array;
+    /**
+     * Creates a [prepared statement](https://www.sqlite.org/c3ref/prepare.html) from `source`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    prepareSync(source: string): SQLiteStatement;
+    /**
+     * Creates a new session for the database.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     * @see [`sqlite3session_create`](https://www.sqlite.org/session/sqlite3session_create.html)
+     */
+    createSessionSync(dbName?: string): SQLiteSession;
+    /**
+     * Loads a SQLite extension.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    loadExtensionSync(libPath: string, entryPoint?: string): void;
+    /**
+     * Executes a transaction, committing/rolling back automatically based on `task`'s result.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    withTransactionSync(task: () => void): void;
+    /**
+     * Executes SQL queries using tagged template literals (Bun-style), automatically parameterized
+     * against SQL injection. Directly awaitable (returns rows/`ISQLiteRunResult`); use `.values()`,
+     * `.first()`, `.each()`, or the `*Sync` variants for other shapes.
+     *
+     * @example
+     * ```ts
+     * const users = await db.sql<User>`SELECT * FROM users WHERE age > ${21}`;
+     * const rows = await db.sql`SELECT name, age FROM users`.values();
+     * const user = await db.sql<User>`SELECT * FROM users WHERE id = ${userId}`.first();
+     * ```
+     */
+    sql: <T = unknown>(strings: TemplateStringsArray, ...values: unknown[]) => SQLiteTaggedQuery<T>;
+    /**
+     * A convenience wrapper around `prepareAsync()`, `SQLiteStatement.executeAsync()`, and
+     * `SQLiteStatement.finalizeAsync()`.
+     */
+    runAsync(source: string, params: ISQLiteBindParams): Promise<ISQLiteRunResult>;
+    /** @hidden */
+    runAsync(source: string, ...params: ISQLiteVariadicBindParams): Promise<ISQLiteRunResult>;
+    /**
+     * A convenience wrapper around `prepareAsync()`, `SQLiteStatement.executeAsync()`,
+     * `ISQLiteExecuteAsyncResult.getFirstAsync()`, and `SQLiteStatement.finalizeAsync()`.
+     */
+    getFirstAsync<T>(source: string, params: ISQLiteBindParams): Promise<T | null>;
+    /** @hidden */
+    getFirstAsync<T>(source: string, ...params: ISQLiteVariadicBindParams): Promise<T | null>;
+    /**
+     * A convenience wrapper around `prepareAsync()`, `SQLiteStatement.executeAsync()`, the
+     * `ISQLiteExecuteAsyncResult` async iterator, and `SQLiteStatement.finalizeAsync()`.
+     */
+    getEachAsync<T>(source: string, params: ISQLiteBindParams): AsyncIterableIterator<T>;
+    /** @hidden */
+    getEachAsync<T>(source: string, ...params: ISQLiteVariadicBindParams): AsyncIterableIterator<T>;
+    /**
+     * A convenience wrapper around `prepareAsync()`, `SQLiteStatement.executeAsync()`,
+     * `ISQLiteExecuteAsyncResult.getAllAsync()`, and `SQLiteStatement.finalizeAsync()`.
+     */
+    getAllAsync<T>(source: string, params: ISQLiteBindParams): Promise<T[]>;
+    /** @hidden */
+    getAllAsync<T>(source: string, ...params: ISQLiteVariadicBindParams): Promise<T[]>;
+    /**
+     * A convenience wrapper around `prepareSync()`, `SQLiteStatement.executeSync()`, and
+     * `SQLiteStatement.finalizeSync()`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    runSync(source: string, params: ISQLiteBindParams): ISQLiteRunResult;
+    /** @hidden */
+    runSync(source: string, ...params: ISQLiteVariadicBindParams): ISQLiteRunResult;
+    /**
+     * A convenience wrapper around `prepareSync()`, `SQLiteStatement.executeSync()`,
+     * `ISQLiteExecuteSyncResult.getFirstSync()`, and `SQLiteStatement.finalizeSync()`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getFirstSync<T>(source: string, params: ISQLiteBindParams): T | null;
+    /** @hidden */
+    getFirstSync<T>(source: string, ...params: ISQLiteVariadicBindParams): T | null;
+    /**
+     * A convenience wrapper around `prepareSync()`, `SQLiteStatement.executeSync()`, the
+     * `ISQLiteExecuteSyncResult` iterator, and `SQLiteStatement.finalizeSync()`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getEachSync<T>(source: string, params: ISQLiteBindParams): IterableIterator<T>;
+    /** @hidden */
+    getEachSync<T>(source: string, ...params: ISQLiteVariadicBindParams): IterableIterator<T>;
+    /**
+     * A convenience wrapper around `prepareSync()`, `SQLiteStatement.executeSync()`,
+     * `ISQLiteExecuteSyncResult.getAllSync()`, and `SQLiteStatement.finalizeSync()`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    getAllSync<T>(source: string, params: ISQLiteBindParams): T[];
+    /** @hidden */
+    getAllSync<T>(source: string, ...params: ISQLiteVariadicBindParams): T[];
+    /** Synchronizes the local database with the remote libSQL server (libSQL integration only). */
+    syncLibSQL(): Promise<void>;
+}
+/** The default directory new databases are created in. */
+export declare const defaultDatabaseDirectory: string;
+/**
+ * Pre-bundled SQLite extensions. Bundling one (e.g. `sqlite-vec`) is a manual native-config
+ * step this package does not automate — see the README.
+ */
+export declare const bundledExtensions: Record<string, {
+    libPath: string;
+    entryPoint: string;
+} | undefined>;
+/**
+ * Opens a database.
+ * @param databaseName The database file name to open.
+ * @param options Open options — see `IOpenDatabaseOptions` for the `onInit` deviation from
+ *   upstream (documented in the README).
+ * @param directory The directory the database file is located in. Defaults to
+ *   `defaultDatabaseDirectory`.
+ */
+export declare function openDatabaseAsync(databaseName: string, options?: IOpenDatabaseOptions, directory?: string): Promise<SQLiteDatabase>;
+/**
+ * Opens a database.
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ */
+export declare function openDatabaseSync(databaseName: string, options?: IOpenDatabaseOptions, directory?: string): SQLiteDatabase;
+/**
+ * Given `Uint8Array` data, [deserializes it to an in-memory database](https://sqlite.org/c3ref/deserialize.html).
+ * @param serializedData The binary array from `SQLiteDatabase.serializeAsync()`.
+ */
+export declare function deserializeDatabaseAsync(serializedData: Uint8Array, options?: ISQLiteOpenOptions): Promise<SQLiteDatabase>;
+/**
+ * Given `Uint8Array` data, [deserializes it to an in-memory database](https://sqlite.org/c3ref/deserialize.html).
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ */
+export declare function deserializeDatabaseSync(serializedData: Uint8Array, options?: ISQLiteOpenOptions): SQLiteDatabase;
+/** Deletes a database file. */
+export declare function deleteDatabaseAsync(databaseName: string, directory?: string): Promise<void>;
+/**
+ * Deletes a database file.
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ */
+export declare function deleteDatabaseSync(databaseName: string, directory?: string): void;
+/**
+ * Backs up a database to another database.
+ * @see https://www.sqlite.org/c3ref/backup_finish.html
+ */
+export declare function backupDatabaseAsync(options: {
+    sourceDatabase: SQLiteDatabase;
+    sourceDatabaseName?: string;
+    destDatabase: SQLiteDatabase;
+    destDatabaseName?: string;
+}): Promise<void>;
+/**
+ * Backs up a database to another database.
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ * @see https://www.sqlite.org/c3ref/backup_finish.html
+ */
+export declare function backupDatabaseSync(options: {
+    sourceDatabase: SQLiteDatabase;
+    sourceDatabaseName?: string;
+    destDatabase: SQLiteDatabase;
+    destDatabaseName?: string;
+}): void;
+/**
+ * Adds a listener for database changes.
+ * > **Note:** requires `enableChangeListener: true` in `ISQLiteOpenOptions` when opening.
+ */
+export declare function addDatabaseChangeListener(listener: (event: IDatabaseChangeEvent) => void): EventSubscription;

package/build-ngc/core/sqlite-database.js

@@ -0,0 +1,428 @@
+// Ported from expo-sqlite's SQLiteDatabase.ts (.vendors/expo @ origin/sdk-57,
+// packages/expo-sqlite/src/SQLiteDatabase.ts), renamed with this repo's `I`-prefix convention.
+//
+// Not ported: `registerDatabaseForDevToolsAsync`/`unregisterDatabaseForDevToolsAsync`
+// (SQLiteDevToolsClient.ts) — wiring for Expo's own DevTools browser extension, which this
+// project has no equivalent of and does not otherwise depend on.
+import { Platform } from 'expo-modules-core';
+import { expoSQLite } from './native-module';
+import { NativeDatabase, flattenOpenOptions } from './native-database';
+import { SQLiteSession } from './sqlite-session';
+import { SQLiteStatement } from './sqlite-statement';
+import { SQLiteTaggedQuery } from './sqlite-tagged-query';
+import { createDatabasePath } from './path-utils';
+/** A SQLite database. */
+export class SQLiteDatabase {
+    databasePath;
+    options;
+    nativeDatabase;
+    constructor(databasePath, options, nativeDatabase) {
+        this.databasePath = databasePath;
+        this.options = options;
+        this.nativeDatabase = nativeDatabase;
+    }
+    /** Whether the database is currently in a transaction. */
+    isInTransactionAsync() {
+        return this.nativeDatabase.isInTransactionAsync();
+    }
+    /** Closes the database. */
+    closeAsync() {
+        return this.nativeDatabase.closeAsync();
+    }
+    /**
+     * Executes all SQL queries in the supplied string.
+     * > **Note:** The queries are not escaped for you — be careful when constructing them.
+     */
+    execAsync(source) {
+        return this.nativeDatabase.execAsync(source);
+    }
+    /**
+     * [Serializes the database](https://sqlite.org/c3ref/serialize.html) as a `Uint8Array`.
+     * @param databaseName The attached database name. Defaults to `main`.
+     */
+    serializeAsync(databaseName = 'main') {
+        return this.nativeDatabase.serializeAsync(databaseName);
+    }
+    /**
+     * Creates a [prepared statement](https://www.sqlite.org/c3ref/prepare.html) from `source`.
+     */
+    async prepareAsync(source) {
+        const nativeStatement = new expoSQLite.NativeStatement();
+        await this.nativeDatabase.prepareAsync(nativeStatement, source);
+        return new SQLiteStatement(this.nativeDatabase, nativeStatement);
+    }
+    /**
+     * Creates a new session for the database.
+     * @see [`sqlite3session_create`](https://www.sqlite.org/session/sqlite3session_create.html)
+     * @param dbName The database name to create a session for. Defaults to `main`.
+     */
+    async createSessionAsync(dbName = 'main') {
+        const nativeSession = new expoSQLite.NativeSession();
+        await this.nativeDatabase.createSessionAsync(nativeSession, dbName);
+        return new SQLiteSession(this.nativeDatabase, nativeSession);
+    }
+    /**
+     * Loads a SQLite extension.
+     * @param libPath The path to the extension library file.
+     * @param entryPoint The extension's entry point. Inferred by
+     *   [`sqlite3_load_extension`](https://www.sqlite.org/c3ref/load_extension.html) when omitted.
+     */
+    loadExtensionAsync(libPath, entryPoint) {
+        return this.nativeDatabase.loadExtensionAsync(libPath, entryPoint);
+    }
+    /**
+     * Executes a transaction, committing/rolling back automatically based on `task`'s result.
+     *
+     * > **Note:** Not exclusive — other async queries can interleave, so the order of execution
+     * > relative to a query issued outside the transaction is not guaranteed. Use
+     * > `withExclusiveTransactionAsync` when that matters.
+     */
+    async withTransactionAsync(task) {
+        try {
+            await this.execAsync('BEGIN');
+            await task();
+            await this.execAsync('COMMIT');
+        }
+        catch (error) {
+            await this.execAsync('ROLLBACK');
+            throw error;
+        }
+    }
+    /**
+     * Executes a transaction, committing/rolling back automatically based on `task`'s result.
+     * The transaction may be exclusive: once it becomes a write transaction, other async write
+     * queries abort with a `database is locked` error.
+     *
+     * > **Note:** Not supported on web.
+     *
+     * @param task Any queries inside it must run on the `txn` object it receives — a private
+     *   `SQLiteDatabase` subclass bound to the exclusive connection, typed here as the base class
+     *   since the subclass is an implementation detail, not a public export.
+     */
+    async withExclusiveTransactionAsync(task) {
+        if (Platform.OS === 'web') {
+            throw new Error('withExclusiveTransactionAsync is not supported on web');
+        }
+        const transaction = await SQLiteTransaction.createAsync(this);
+        let error;
+        try {
+            await transaction.execAsync('BEGIN');
+            await task(transaction);
+            await transaction.execAsync('COMMIT');
+        }
+        catch (thrown) {
+            await transaction.execAsync('ROLLBACK');
+            error = thrown;
+        }
+        finally {
+            await transaction.closeAsync();
+        }
+        if (error !== undefined) {
+            throw error;
+        }
+    }
+    /** Whether the database is currently in a transaction. */
+    isInTransactionSync() {
+        return this.nativeDatabase.isInTransactionSync();
+    }
+    /** Closes the database. */
+    closeSync() {
+        return this.nativeDatabase.closeSync();
+    }
+    /**
+     * Executes all SQL queries in the supplied string.
+     * > **Note:** The queries are not escaped for you. Running heavy tasks with this function can
+     * > block the JavaScript thread.
+     */
+    execSync(source) {
+        return this.nativeDatabase.execSync(source);
+    }
+    /**
+     * [Serializes the database](https://sqlite.org/c3ref/serialize.html) as a `Uint8Array`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    serializeSync(databaseName = 'main') {
+        return this.nativeDatabase.serializeSync(databaseName);
+    }
+    /**
+     * Creates a [prepared statement](https://www.sqlite.org/c3ref/prepare.html) from `source`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    prepareSync(source) {
+        const nativeStatement = new expoSQLite.NativeStatement();
+        this.nativeDatabase.prepareSync(nativeStatement, source);
+        return new SQLiteStatement(this.nativeDatabase, nativeStatement);
+    }
+    /**
+     * Creates a new session for the database.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     * @see [`sqlite3session_create`](https://www.sqlite.org/session/sqlite3session_create.html)
+     */
+    createSessionSync(dbName = 'main') {
+        const nativeSession = new expoSQLite.NativeSession();
+        this.nativeDatabase.createSessionSync(nativeSession, dbName);
+        return new SQLiteSession(this.nativeDatabase, nativeSession);
+    }
+    /**
+     * Loads a SQLite extension.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    loadExtensionSync(libPath, entryPoint) {
+        this.nativeDatabase.loadExtensionSync(libPath, entryPoint);
+    }
+    /**
+     * Executes a transaction, committing/rolling back automatically based on `task`'s result.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    withTransactionSync(task) {
+        try {
+            this.execSync('BEGIN');
+            task();
+            this.execSync('COMMIT');
+        }
+        catch (error) {
+            this.execSync('ROLLBACK');
+            throw error;
+        }
+    }
+    /**
+     * Executes SQL queries using tagged template literals (Bun-style), automatically parameterized
+     * against SQL injection. Directly awaitable (returns rows/`ISQLiteRunResult`); use `.values()`,
+     * `.first()`, `.each()`, or the `*Sync` variants for other shapes.
+     *
+     * @example
+     * ```ts
+     * const users = await db.sql<User>`SELECT * FROM users WHERE age > ${21}`;
+     * const rows = await db.sql`SELECT name, age FROM users`.values();
+     * const user = await db.sql<User>`SELECT * FROM users WHERE id = ${userId}`.first();
+     * ```
+     */
+    sql = (strings, ...values) => new SQLiteTaggedQuery(this, strings, values);
+    // `any[]`: the implementation signature of an overloaded function is not itself callable, so
+    // TS checks `statement.executeAsync(...params)` below against ITS overloads, not against
+    // whatever narrower type is written here — `unknown[]` fails that check for every one of
+    // these forwarding methods, matching upstream's own `any[]` for the identical reason.
+    async runAsync(source, ...params) {
+        const statement = await this.prepareAsync(source);
+        let result;
+        try {
+            result = await statement.executeAsync(...params);
+        }
+        finally {
+            await statement.finalizeAsync();
+        }
+        return result;
+    }
+    async getFirstAsync(source, ...params) {
+        const statement = await this.prepareAsync(source);
+        let firstRow;
+        try {
+            const result = await statement.executeAsync(...params);
+            firstRow = await result.getFirstAsync();
+        }
+        finally {
+            await statement.finalizeAsync();
+        }
+        return firstRow;
+    }
+    async *getEachAsync(source, ...params) {
+        const statement = await this.prepareAsync(source);
+        try {
+            const result = await statement.executeAsync(...params);
+            for await (const row of result) {
+                yield row;
+            }
+        }
+        finally {
+            await statement.finalizeAsync();
+        }
+    }
+    async getAllAsync(source, ...params) {
+        const statement = await this.prepareAsync(source);
+        let allRows;
+        try {
+            const result = await statement.executeAsync(...params);
+            allRows = await result.getAllAsync();
+        }
+        finally {
+            await statement.finalizeAsync();
+        }
+        return allRows;
+    }
+    runSync(source, ...params) {
+        const statement = this.prepareSync(source);
+        let result;
+        try {
+            result = statement.executeSync(...params);
+        }
+        finally {
+            statement.finalizeSync();
+        }
+        return result;
+    }
+    getFirstSync(source, ...params) {
+        const statement = this.prepareSync(source);
+        let firstRow;
+        try {
+            const result = statement.executeSync(...params);
+            firstRow = result.getFirstSync();
+        }
+        finally {
+            statement.finalizeSync();
+        }
+        return firstRow;
+    }
+    *getEachSync(source, ...params) {
+        const statement = this.prepareSync(source);
+        try {
+            const result = statement.executeSync(...params);
+            for (const row of result) {
+                yield row;
+            }
+        }
+        finally {
+            statement.finalizeSync();
+        }
+    }
+    getAllSync(source, ...params) {
+        const statement = this.prepareSync(source);
+        let allRows;
+        try {
+            const result = statement.executeSync(...params);
+            allRows = result.getAllSync();
+        }
+        finally {
+            statement.finalizeSync();
+        }
+        return allRows;
+    }
+    /** Synchronizes the local database with the remote libSQL server (libSQL integration only). */
+    syncLibSQL() {
+        if (typeof this.nativeDatabase.syncLibSQL !== 'function') {
+            throw new Error('syncLibSQL is not supported in the current environment');
+        }
+        return this.nativeDatabase.syncLibSQL();
+    }
+}
+/** The default directory new databases are created in. */
+export const defaultDatabaseDirectory = expoSQLite.defaultDatabaseDirectory;
+/**
+ * Pre-bundled SQLite extensions. Bundling one (e.g. `sqlite-vec`) is a manual native-config
+ * step this package does not automate — see the README.
+ */
+export const bundledExtensions = expoSQLite.bundledExtensions;
+async function runOnInit(db, onInit) {
+    if (onInit) {
+        await onInit(db);
+    }
+}
+/**
+ * Opens a database.
+ * @param databaseName The database file name to open.
+ * @param options Open options — see `IOpenDatabaseOptions` for the `onInit` deviation from
+ *   upstream (documented in the README).
+ * @param directory The directory the database file is located in. Defaults to
+ *   `defaultDatabaseDirectory`.
+ */
+export async function openDatabaseAsync(databaseName, options, directory) {
+    const { onInit, ...openOptions } = options ?? {};
+    const databasePath = createDatabasePath(databaseName, directory);
+    await expoSQLite.ensureDatabasePathExistsAsync(databasePath);
+    const nativeDatabase = new expoSQLite.NativeDatabase(databasePath, flattenOpenOptions(openOptions));
+    await nativeDatabase.initAsync();
+    const database = new SQLiteDatabase(databasePath, openOptions, nativeDatabase);
+    await runOnInit(database, onInit);
+    return database;
+}
+/**
+ * Opens a database.
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ */
+export function openDatabaseSync(databaseName, options, directory) {
+    const { onInit, ...openOptions } = options ?? {};
+    const databasePath = createDatabasePath(databaseName, directory);
+    expoSQLite.ensureDatabasePathExistsSync(databasePath);
+    const nativeDatabase = new expoSQLite.NativeDatabase(databasePath, flattenOpenOptions(openOptions));
+    nativeDatabase.initSync();
+    const database = new SQLiteDatabase(databasePath, openOptions, nativeDatabase);
+    if (onInit) {
+        const result = onInit(database);
+        if (result instanceof Promise) {
+            throw new Error('openDatabaseSync: onInit returned a Promise — pass a synchronous callback, or use openDatabaseAsync.');
+        }
+    }
+    return database;
+}
+/**
+ * Given `Uint8Array` data, [deserializes it to an in-memory database](https://sqlite.org/c3ref/deserialize.html).
+ * @param serializedData The binary array from `SQLiteDatabase.serializeAsync()`.
+ */
+export async function deserializeDatabaseAsync(serializedData, options) {
+    const openOptions = options ?? {};
+    const nativeDatabase = new expoSQLite.NativeDatabase(':memory:', flattenOpenOptions(openOptions), serializedData);
+    await nativeDatabase.initAsync();
+    return new SQLiteDatabase(':memory:', openOptions, nativeDatabase);
+}
+/**
+ * Given `Uint8Array` data, [deserializes it to an in-memory database](https://sqlite.org/c3ref/deserialize.html).
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ */
+export function deserializeDatabaseSync(serializedData, options) {
+    const openOptions = options ?? {};
+    const nativeDatabase = new expoSQLite.NativeDatabase(':memory:', flattenOpenOptions(openOptions), serializedData);
+    nativeDatabase.initSync();
+    return new SQLiteDatabase(':memory:', openOptions, nativeDatabase);
+}
+/** Deletes a database file. */
+export async function deleteDatabaseAsync(databaseName, directory) {
+    const databasePath = createDatabasePath(databaseName, directory);
+    return await expoSQLite.deleteDatabaseAsync(databasePath);
+}
+/**
+ * Deletes a database file.
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ */
+export function deleteDatabaseSync(databaseName, directory) {
+    const databasePath = createDatabasePath(databaseName, directory);
+    return expoSQLite.deleteDatabaseSync(databasePath);
+}
+/**
+ * Backs up a database to another database.
+ * @see https://www.sqlite.org/c3ref/backup_finish.html
+ */
+export function backupDatabaseAsync(options) {
+    const { sourceDatabase, sourceDatabaseName, destDatabase, destDatabaseName } = options;
+    return expoSQLite.backupDatabaseAsync(destDatabase.nativeDatabase, destDatabaseName ?? 'main', sourceDatabase.nativeDatabase, sourceDatabaseName ?? 'main');
+}
+/**
+ * Backs up a database to another database.
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ * @see https://www.sqlite.org/c3ref/backup_finish.html
+ */
+export function backupDatabaseSync(options) {
+    const { sourceDatabase, sourceDatabaseName, destDatabase, destDatabaseName } = options;
+    return expoSQLite.backupDatabaseSync(destDatabase.nativeDatabase, destDatabaseName ?? 'main', sourceDatabase.nativeDatabase, sourceDatabaseName ?? 'main');
+}
+/**
+ * Adds a listener for database changes.
+ * > **Note:** requires `enableChangeListener: true` in `ISQLiteOpenOptions` when opening.
+ */
+export function addDatabaseChangeListener(listener) {
+    return expoSQLite.addListener('onDatabaseChange', listener);
+}
+/**
+ * A new connection specifically used by `withExclusiveTransactionAsync`.
+ * @hidden not exposing all the database methods to the public API surface
+ */
+class SQLiteTransaction extends SQLiteDatabase {
+    static async createAsync(db) {
+        const options = {
+            ...db.options,
+            useNewConnection: true,
+        };
+        const nativeDatabase = new expoSQLite.NativeDatabase(db.databasePath, flattenOpenOptions(options));
+        await nativeDatabase.initAsync();
+        return new SQLiteTransaction(db.databasePath, options, nativeDatabase);
+    }
+}
+//# sourceMappingURL=sqlite-database.js.map