@symbiote-native/sqlite 0.1.0

package/build/core/sqlite-statement.d.ts

@@ -0,0 +1,96 @@
+import type { NativeDatabase } from './native-database';
+import type { NativeStatement, ISQLiteBindParams, ISQLiteVariadicBindParams } from './native-statement';
+export type { ISQLiteBindParams, ISQLiteBindValue, ISQLiteRunResult, ISQLiteVariadicBindParams, } from './native-statement';
+type IValuesOf<T extends object> = T[keyof T][];
+/**
+ * A prepared statement returned by `SQLiteDatabase.prepareAsync()`/`prepareSync()`, bound with
+ * parameters and executed.
+ */
+export declare class SQLiteStatement {
+    private readonly nativeDatabase;
+    private readonly nativeStatement;
+    constructor(nativeDatabase: NativeDatabase, nativeStatement: NativeStatement);
+    /** Runs the prepared statement and returns an `ISQLiteExecuteAsyncResult`. */
+    executeAsync<T>(params: ISQLiteBindParams): Promise<ISQLiteExecuteAsyncResult<T>>;
+    /** @hidden */
+    executeAsync<T>(...params: ISQLiteVariadicBindParams): Promise<ISQLiteExecuteAsyncResult<T>>;
+    /**
+     * Like `executeAsync()` but returns the raw value-array result instead of row objects.
+     * @hidden Advanced use only.
+     */
+    executeForRawResultAsync<T extends object>(params: ISQLiteBindParams): Promise<ISQLiteExecuteAsyncResult<IValuesOf<T>>>;
+    /** @hidden */
+    executeForRawResultAsync<T extends object>(...params: ISQLiteVariadicBindParams): Promise<ISQLiteExecuteAsyncResult<IValuesOf<T>>>;
+    /** Gets the column names of the prepared statement. */
+    getColumnNamesAsync(): Promise<string[]>;
+    /**
+     * Finalizes the prepared statement — calls
+     * [`sqlite3_finalize()`](https://www.sqlite.org/c3ref/finalize.html) under the hood.
+     * Accessing a finalized statement afterward throws. `expo-sqlite` finalizes any orphaned
+     * statement automatically when its database closes, but finalize as soon as you no longer
+     * need one — wrap the call in `try...finally` so it runs even if an earlier step throws.
+     */
+    finalizeAsync(): Promise<void>;
+    /**
+     * Runs the prepared statement and returns an `ISQLiteExecuteSyncResult`.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    executeSync<T>(params: ISQLiteBindParams): ISQLiteExecuteSyncResult<T>;
+    /** @hidden */
+    executeSync<T>(...params: ISQLiteVariadicBindParams): ISQLiteExecuteSyncResult<T>;
+    /**
+     * Like `executeSync()` but returns the raw value-array result instead of row objects.
+     * @hidden Advanced use only.
+     */
+    executeForRawResultSync<T extends object>(params: ISQLiteBindParams): ISQLiteExecuteSyncResult<IValuesOf<T>>;
+    /** @hidden */
+    executeForRawResultSync<T extends object>(...params: ISQLiteVariadicBindParams): ISQLiteExecuteSyncResult<IValuesOf<T>>;
+    /** Gets the column names of the prepared statement. */
+    getColumnNamesSync(): string[];
+    /**
+     * Finalizes the prepared statement synchronously.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    finalizeSync(): void;
+}
+/** A result returned by `SQLiteStatement.executeAsync()`. */
+export type ISQLiteExecuteAsyncResult<T> = AsyncIterableIterator<T> & {
+    /** The last inserted row ID, from `sqlite3_last_insert_rowid()`. */
+    readonly lastInsertRowId: number;
+    /** The number of rows affected, from `sqlite3_changes()`. */
+    readonly changes: number;
+    /**
+     * Gets the first row of the result set. Requires the cursor to be in its initial state —
+     * call `resetAsync()` first if rows have already been retrieved, or this throws.
+     */
+    getFirstAsync(): Promise<T | null>;
+    /**
+     * Gets all rows of the result set. Requires the cursor to be in its initial state — call
+     * `resetAsync()` first if rows have already been retrieved, or this throws.
+     */
+    getAllAsync(): Promise<T[]>;
+    /** Resets the prepared statement's cursor — calls `sqlite3_reset()` under the hood. */
+    resetAsync(): Promise<void>;
+};
+/**
+ * A result returned by `SQLiteStatement.executeSync()`.
+ * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+ */
+export type ISQLiteExecuteSyncResult<T> = IterableIterator<T> & {
+    /** The last inserted row ID, from `sqlite3_last_insert_rowid()`. */
+    readonly lastInsertRowId: number;
+    /** The number of rows affected, from `sqlite3_changes()`. */
+    readonly changes: number;
+    /**
+     * Gets the first row of the result set. Requires the cursor to be in its initial state — call
+     * `resetSync()` first if rows have already been retrieved, or this throws.
+     */
+    getFirstSync(): T | null;
+    /**
+     * Gets all rows of the result set. Requires the cursor to be in its initial state — call
+     * `resetSync()` first if rows have already been retrieved, or this throws.
+     */
+    getAllSync(): T[];
+    /** Resets the prepared statement's cursor — calls `sqlite3_reset()` under the hood. */
+    resetSync(): void;
+};

package/build/core/sqlite-statement.js

@@ -0,0 +1,321 @@
+import { composeRow, composeRows, normalizeParams } from './param-utils.js';
+/**
+ * A prepared statement returned by `SQLiteDatabase.prepareAsync()`/`prepareSync()`, bound with
+ * parameters and executed.
+ */
+export class SQLiteStatement {
+    nativeDatabase;
+    nativeStatement;
+    constructor(nativeDatabase, nativeStatement) {
+        this.nativeDatabase = nativeDatabase;
+        this.nativeStatement = nativeStatement;
+    }
+    async executeAsync(...params) {
+        const { lastInsertRowId, changes, firstRowValues } = await this.nativeStatement.runAsync(this.nativeDatabase, ...normalizeParams(...params));
+        return createSQLiteExecuteAsyncResult(this.nativeDatabase, this.nativeStatement, firstRowValues, { rawResult: false, lastInsertRowId, changes });
+    }
+    async executeForRawResultAsync(...params) {
+        const { lastInsertRowId, changes, firstRowValues } = await this.nativeStatement.runAsync(this.nativeDatabase, ...normalizeParams(...params));
+        return createSQLiteExecuteAsyncResult(this.nativeDatabase, this.nativeStatement, firstRowValues, { rawResult: true, lastInsertRowId, changes });
+    }
+    /** Gets the column names of the prepared statement. */
+    getColumnNamesAsync() {
+        return this.nativeStatement.getColumnNamesAsync();
+    }
+    /**
+     * Finalizes the prepared statement — calls
+     * [`sqlite3_finalize()`](https://www.sqlite.org/c3ref/finalize.html) under the hood.
+     * Accessing a finalized statement afterward throws. `expo-sqlite` finalizes any orphaned
+     * statement automatically when its database closes, but finalize as soon as you no longer
+     * need one — wrap the call in `try...finally` so it runs even if an earlier step throws.
+     */
+    async finalizeAsync() {
+        await this.nativeStatement.finalizeAsync(this.nativeDatabase);
+    }
+    executeSync(...params) {
+        const { lastInsertRowId, changes, firstRowValues } = this.nativeStatement.runSync(this.nativeDatabase, ...normalizeParams(...params));
+        return createSQLiteExecuteSyncResult(this.nativeDatabase, this.nativeStatement, firstRowValues, { rawResult: false, lastInsertRowId, changes });
+    }
+    executeForRawResultSync(...params) {
+        const { lastInsertRowId, changes, firstRowValues } = this.nativeStatement.runSync(this.nativeDatabase, ...normalizeParams(...params));
+        return createSQLiteExecuteSyncResult(this.nativeDatabase, this.nativeStatement, firstRowValues, { rawResult: true, lastInsertRowId, changes });
+    }
+    /** Gets the column names of the prepared statement. */
+    getColumnNamesSync() {
+        return this.nativeStatement.getColumnNamesSync();
+    }
+    /**
+     * Finalizes the prepared statement synchronously.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    finalizeSync() {
+        this.nativeStatement.finalizeSync(this.nativeDatabase);
+    }
+}
+/**
+ * Creates the `ISQLiteExecuteAsyncResult` — an async generator with the extra fields/methods
+ * attached via `Object.defineProperties`, since Hermes does not support `Symbol.asyncIterator`
+ * on a plain object literal.
+ */
+async function createSQLiteExecuteAsyncResult(database, statement, firstRowValues, options) {
+    const instance = new SQLiteExecuteAsyncResultImpl(database, statement, firstRowValues ? processNativeRow(firstRowValues) : null, options);
+    const generator = instance.generatorAsync();
+    Object.defineProperties(generator, {
+        lastInsertRowId: {
+            value: options.lastInsertRowId,
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        changes: {
+            value: options.changes,
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        getFirstAsync: {
+            value: instance.getFirstAsync.bind(instance),
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        getAllAsync: {
+            value: instance.getAllAsync.bind(instance),
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        resetAsync: {
+            value: instance.resetAsync.bind(instance),
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+    });
+    // I/O edge: the generator is given the four extra members above at runtime via
+    // `Object.defineProperties` — nothing narrower can describe that to the type checker.
+    return generator;
+}
+/** Creates the `ISQLiteExecuteSyncResult`. */
+function createSQLiteExecuteSyncResult(database, statement, firstRowValues, options) {
+    const instance = new SQLiteExecuteSyncResultImpl(database, statement, firstRowValues ? processNativeRow(firstRowValues) : firstRowValues, options);
+    const generator = instance.generatorSync();
+    Object.defineProperties(generator, {
+        lastInsertRowId: {
+            value: options.lastInsertRowId,
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        changes: {
+            value: options.changes,
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        getFirstSync: {
+            value: instance.getFirstSync.bind(instance),
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        getAllSync: {
+            value: instance.getAllSync.bind(instance),
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+        resetSync: {
+            value: instance.resetSync.bind(instance),
+            enumerable: true,
+            writable: false,
+            configurable: true,
+        },
+    });
+    // I/O edge: see createSQLiteExecuteAsyncResult above.
+    return generator;
+}
+class SQLiteExecuteAsyncResultImpl {
+    database;
+    statement;
+    firstRowValues;
+    options;
+    columnNames = null;
+    isStepCalled = false;
+    constructor(database, statement, firstRowValues, options) {
+        this.database = database;
+        this.statement = statement;
+        this.firstRowValues = firstRowValues;
+        this.options = options;
+    }
+    async getFirstAsync() {
+        if (this.isStepCalled) {
+            throw new Error('The SQLite cursor has been shifted and is unable to retrieve the first row without being reset. Invoke `resetAsync()` to reset the cursor first if you want to retrieve the first row.');
+        }
+        this.isStepCalled = true;
+        const columnNames = await this.getColumnNamesAsync();
+        const firstRowValues = this.popFirstRowValues();
+        if (firstRowValues != null) {
+            return composeRowIfNeeded(this.options.rawResult, columnNames, firstRowValues);
+        }
+        const firstRow = await this.statement.stepAsync(this.database);
+        return firstRow != null
+            ? composeRowIfNeeded(this.options.rawResult, columnNames, processNativeRow(firstRow))
+            : null;
+    }
+    async getAllAsync() {
+        if (this.isStepCalled) {
+            throw new Error('The SQLite cursor has been shifted and is unable to retrieve all rows without being reset. Invoke `resetAsync()` to reset the cursor first if you want to retrieve all rows.');
+        }
+        this.isStepCalled = true;
+        const firstRowValues = this.popFirstRowValues();
+        if (firstRowValues == null) {
+            // An empty first row means this SQL was a write operation — calling getAllAsync() again
+            // would write a second time.
+            return [];
+        }
+        const columnNames = await this.getColumnNamesAsync();
+        const nativeRows = await this.statement.getAllAsync(this.database);
+        const allRows = processNativeRows(nativeRows);
+        if (firstRowValues.length > 0) {
+            return composeRowsIfNeeded(this.options.rawResult, columnNames, [
+                firstRowValues,
+                ...allRows,
+            ]);
+        }
+        return composeRowsIfNeeded(this.options.rawResult, columnNames, allRows);
+    }
+    async *generatorAsync() {
+        this.isStepCalled = true;
+        const columnNames = await this.getColumnNamesAsync();
+        const firstRowValues = this.popFirstRowValues();
+        if (firstRowValues != null) {
+            yield composeRowIfNeeded(this.options.rawResult, columnNames, firstRowValues);
+        }
+        let result;
+        do {
+            result = await this.statement.stepAsync(this.database);
+            if (result != null) {
+                yield composeRowIfNeeded(this.options.rawResult, columnNames, processNativeRow(result));
+            }
+        } while (result != null);
+    }
+    resetAsync() {
+        const result = this.statement.resetAsync(this.database);
+        this.isStepCalled = false;
+        return result;
+    }
+    popFirstRowValues() {
+        if (this.firstRowValues != null) {
+            const firstRowValues = this.firstRowValues;
+            this.firstRowValues = null;
+            return firstRowValues.length > 0 ? firstRowValues : null;
+        }
+        return null;
+    }
+    async getColumnNamesAsync() {
+        if (this.columnNames == null) {
+            this.columnNames = await this.statement.getColumnNamesAsync();
+        }
+        return this.columnNames;
+    }
+}
+class SQLiteExecuteSyncResultImpl {
+    database;
+    statement;
+    firstRowValues;
+    options;
+    columnNames = null;
+    isStepCalled = false;
+    constructor(database, statement, firstRowValues, options) {
+        this.database = database;
+        this.statement = statement;
+        this.firstRowValues = firstRowValues;
+        this.options = options;
+    }
+    getFirstSync() {
+        if (this.isStepCalled) {
+            throw new Error('The SQLite cursor has been shifted and is unable to retrieve the first row without being reset. Invoke `resetSync()` to reset the cursor first if you want to retrieve the first row.');
+        }
+        const columnNames = this.getColumnNamesSync();
+        const firstRowValues = this.popFirstRowValues();
+        if (firstRowValues != null) {
+            return composeRowIfNeeded(this.options.rawResult, columnNames, firstRowValues);
+        }
+        const firstRow = this.statement.stepSync(this.database);
+        return firstRow != null
+            ? composeRowIfNeeded(this.options.rawResult, columnNames, processNativeRow(firstRow))
+            : null;
+    }
+    getAllSync() {
+        if (this.isStepCalled) {
+            throw new Error('The SQLite cursor has been shifted and is unable to retrieve all rows without being reset. Invoke `resetSync()` to reset the cursor first if you want to retrieve all rows.');
+        }
+        const firstRowValues = this.popFirstRowValues();
+        if (firstRowValues == null) {
+            return [];
+        }
+        const columnNames = this.getColumnNamesSync();
+        const nativeRows = this.statement.getAllSync(this.database);
+        const allRows = processNativeRows(nativeRows);
+        if (firstRowValues.length > 0) {
+            return composeRowsIfNeeded(this.options.rawResult, columnNames, [
+                firstRowValues,
+                ...allRows,
+            ]);
+        }
+        return composeRowsIfNeeded(this.options.rawResult, columnNames, allRows);
+    }
+    *generatorSync() {
+        const columnNames = this.getColumnNamesSync();
+        const firstRowValues = this.popFirstRowValues();
+        if (firstRowValues != null) {
+            yield composeRowIfNeeded(this.options.rawResult, columnNames, firstRowValues);
+        }
+        let result;
+        do {
+            result = this.statement.stepSync(this.database);
+            if (result != null) {
+                yield composeRowIfNeeded(this.options.rawResult, columnNames, processNativeRow(result));
+            }
+        } while (result != null);
+    }
+    resetSync() {
+        const result = this.statement.resetSync(this.database);
+        this.isStepCalled = false;
+        return result;
+    }
+    popFirstRowValues() {
+        if (this.firstRowValues != null) {
+            const firstRowValues = this.firstRowValues;
+            this.firstRowValues = null;
+            return firstRowValues.length > 0 ? firstRowValues : null;
+        }
+        return null;
+    }
+    getColumnNamesSync() {
+        if (this.columnNames == null) {
+            this.columnNames = this.statement.getColumnNamesSync();
+        }
+        return this.columnNames;
+    }
+}
+function composeRowIfNeeded(rawResult, columnNames, columnValues) {
+    // I/O edge: `rawResult` selects between two shapes of T (a row object, or `IValuesOf<T>`) that
+    // only the caller's own generic parameter distinguishes — see the two call sites above.
+    return rawResult
+        ? columnValues
+        : composeRow(columnNames, columnValues);
+}
+function composeRowsIfNeeded(rawResult, columnNames, columnValuesList) {
+    return rawResult
+        ? columnValuesList
+        : composeRows(columnNames, columnValuesList);
+}
+function processNativeRow(nativeRow) {
+    return nativeRow.map(column => column instanceof ArrayBuffer ? new Uint8Array(column) : column);
+}
+function processNativeRows(nativeRows) {
+    return nativeRows.map(processNativeRow);
+}
+//#endregion

package/build/core/sqlite-tagged-query.d.ts

@@ -0,0 +1,73 @@
+import type { ISQLiteRunResult } from './native-statement';
+import type { SQLiteDatabase } from './sqlite-database';
+/**
+ * Returns `T[]` when a type parameter is explicitly given, or a union of the possible shapes
+ * when relying on the default `unknown` type.
+ */
+type ISQLiteTaggedQueryResult<T> = [unknown] extends [T] ? unknown[] | ISQLiteRunResult : T[];
+/**
+ * A SQL query built from a tagged template literal, awaitable directly (returns an array of
+ * objects by default) or reshaped via `.values()` / `.first()` / `.each()`. Bun's `sql` API is
+ * the inspiration (credited upstream).
+ *
+ * @example
+ * ```ts
+ * const users = await sql`SELECT * FROM users WHERE age > ${21}`;
+ * const values = await sql`SELECT name, age FROM users`.values(); // [["Alice", 30], ...]
+ * const user = await sql`SELECT * FROM users WHERE id = ${1}`.first();
+ * const users = await sql<User>`SELECT * FROM users`; // typed
+ * const result = (await sql`INSERT INTO users (name) VALUES (${'Alice'})`) as ISQLiteRunResult;
+ * const users = sql<User>`SELECT * FROM users WHERE age > ${21}`.allSync();
+ * ```
+ */
+export declare class SQLiteTaggedQuery<T = unknown> implements PromiseLike<ISQLiteTaggedQueryResult<T>> {
+    private readonly database;
+    private readonly source;
+    private readonly params;
+    private readonly parsedInfo;
+    constructor(database: SQLiteDatabase, strings: TemplateStringsArray, values: unknown[]);
+    /**
+     * Makes the query awaitable, returning rows or metadata depending on the query's shape — called
+     * automatically when the tagged query is `await`ed.
+     */
+    then<TResult1 = ISQLiteTaggedQueryResult<T>, TResult2 = never>(onfulfilled?: ((value: ISQLiteTaggedQueryResult<T>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    /**
+     * Executes the query and returns rows as arrays of values (Bun-style) instead of objects.
+     * @example
+     * ```ts
+     * const rows = await sql`SELECT name, age FROM users`.values(); // [["Alice", 30], ...]
+     * ```
+     */
+    values(): Promise<unknown[][]>;
+    /** Executes the query and returns the first row only, or `null` if no rows match. */
+    first(): Promise<T | null>;
+    /**
+     * Executes the query and returns an async iterator over the rows.
+     * @example
+     * ```ts
+     * for await (const user of sql`SELECT * FROM users`.each()) { console.log(user.name); }
+     * ```
+     */
+    each(): AsyncIterableIterator<T>;
+    /**
+     * Executes the query synchronously, returning rows or metadata depending on the query's shape.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    allSync(): ISQLiteTaggedQueryResult<T>;
+    /**
+     * Executes the query synchronously and returns rows as arrays of values.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    valuesSync(): unknown[][];
+    /**
+     * Executes the query synchronously and returns the first row.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    firstSync(): T | null;
+    /**
+     * Executes the query synchronously and returns an iterator.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    eachSync(): IterableIterator<T>;
+}
+export {};

package/build/core/sqlite-tagged-query.js

@@ -0,0 +1,119 @@
+import { parseSQLQuery } from './query-utils.js';
+/**
+ * A SQL query built from a tagged template literal, awaitable directly (returns an array of
+ * objects by default) or reshaped via `.values()` / `.first()` / `.each()`. Bun's `sql` API is
+ * the inspiration (credited upstream).
+ *
+ * @example
+ * ```ts
+ * const users = await sql`SELECT * FROM users WHERE age > ${21}`;
+ * const values = await sql`SELECT name, age FROM users`.values(); // [["Alice", 30], ...]
+ * const user = await sql`SELECT * FROM users WHERE id = ${1}`.first();
+ * const users = await sql<User>`SELECT * FROM users`; // typed
+ * const result = (await sql`INSERT INTO users (name) VALUES (${'Alice'})`) as ISQLiteRunResult;
+ * const users = sql<User>`SELECT * FROM users WHERE age > ${21}`.allSync();
+ * ```
+ */
+export class SQLiteTaggedQuery {
+    database;
+    source;
+    params;
+    parsedInfo;
+    constructor(database, strings, values) {
+        this.database = database;
+        const sql = strings.join('?');
+        this.source = sql;
+        // I/O edge: a tagged-template interpolation site (`${...}`) is only constrained to
+        // ISQLiteBindValue by the public overload of `SQLiteDatabase.sql`; nothing narrower can be
+        // inferred from `TemplateStringsArray`'s own interpolated-value type (`unknown[]` by design).
+        this.params = values;
+        this.parsedInfo = parseSQLQuery(sql);
+    }
+    /**
+     * Makes the query awaitable, returning rows or metadata depending on the query's shape — called
+     * automatically when the tagged query is `await`ed.
+     */
+    then(onfulfilled, onrejected) {
+        if (this.parsedInfo.canReturnRows) {
+            return this.database
+                .getAllAsync(this.source, this.params)
+                .then(rows => rows)
+                .then(onfulfilled, onrejected);
+        }
+        return this.database
+            .runAsync(this.source, this.params)
+            .then(result => result)
+            .then(onfulfilled, onrejected);
+    }
+    /**
+     * Executes the query and returns rows as arrays of values (Bun-style) instead of objects.
+     * @example
+     * ```ts
+     * const rows = await sql`SELECT name, age FROM users`.values(); // [["Alice", 30], ...]
+     * ```
+     */
+    async values() {
+        const statement = await this.database.prepareAsync(this.source);
+        try {
+            const result = await statement.executeForRawResultAsync(this.params);
+            return await result.getAllAsync();
+        }
+        finally {
+            await statement.finalizeAsync();
+        }
+    }
+    /** Executes the query and returns the first row only, or `null` if no rows match. */
+    async first() {
+        return this.database.getFirstAsync(this.source, this.params);
+    }
+    /**
+     * Executes the query and returns an async iterator over the rows.
+     * @example
+     * ```ts
+     * for await (const user of sql`SELECT * FROM users`.each()) { console.log(user.name); }
+     * ```
+     */
+    each() {
+        return this.database.getEachAsync(this.source, this.params);
+    }
+    //#region Synchronous variants
+    /**
+     * Executes the query synchronously, returning rows or metadata depending on the query's shape.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    allSync() {
+        // I/O edge: see `ISQLiteTaggedQueryResult`'s own definition — the conditional type cannot be
+        // narrowed from `canReturnRows`, a plain runtime boolean.
+        return this.parsedInfo.canReturnRows
+            ? this.database.getAllSync(this.source, this.params)
+            : this.database.runSync(this.source, this.params);
+    }
+    /**
+     * Executes the query synchronously and returns rows as arrays of values.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    valuesSync() {
+        const statement = this.database.prepareSync(this.source);
+        try {
+            const result = statement.executeForRawResultSync(this.params);
+            return result.getAllSync();
+        }
+        finally {
+            statement.finalizeSync();
+        }
+    }
+    /**
+     * Executes the query synchronously and returns the first row.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    firstSync() {
+        return this.database.getFirstSync(this.source, this.params);
+    }
+    /**
+     * Executes the query synchronously and returns an iterator.
+     * > **Note:** Running heavy tasks with this function can block the JavaScript thread.
+     */
+    eachSync() {
+        return this.database.getEachSync(this.source, this.params);
+    }
+}