@symbiote-native/sqlite 0.1.0

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

@@ -0,0 +1,14 @@
+/** Flattens `ISQLiteOpenOptions` into the shape the native module expects. */
+export function flattenOpenOptions(options) {
+    const { libSQLOptions, ...restOptions } = options;
+    const result = { ...restOptions };
+    if (libSQLOptions) {
+        Object.assign(result, {
+            libSQLUrl: libSQLOptions.url,
+            libSQLAuthToken: libSQLOptions.authToken,
+            libSQLRemoteOnly: libSQLOptions.remoteOnly,
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=native-database.js.map

package/build-ngc/core/native-database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-database.js","sourceRoot":"","sources":["../../src/core/native-database.ts"],"names":[],"mappings":"AAuGA,8EAA8E;AAC9E,MAAM,UAAU,kBAAkB,CAChC,OAA2B;IAE3B,MAAM,EAAE,aAAa,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC;IAClD,MAAM,MAAM,GAA0B,EAAE,GAAG,WAAW,EAAE,CAAC;IACzD,IAAI,aAAa,EAAE,CAAC;QAClB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;YACpB,SAAS,EAAE,aAAa,CAAC,GAAG;YAC5B,eAAe,EAAE,aAAa,CAAC,SAAS;YACxC,gBAAgB,EAAE,aAAa,CAAC,UAAU;SAC3C,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,25 @@
+import type { EventSubscription } from 'expo-modules-core';
+import { NativeDatabase } from './native-database';
+import { NativeSession } from './native-session';
+import { NativeStatement } from './native-statement';
+import type { IDatabaseChangeEvent } from './types';
+export type INativeSQLiteModule = {
+    readonly NativeDatabase: typeof NativeDatabase;
+    readonly NativeStatement: typeof NativeStatement;
+    readonly NativeSession: typeof NativeSession;
+    /** The directory new databases are created in when no explicit directory is given. */
+    readonly defaultDatabaseDirectory: string;
+    /** Pre-bundled SQLite extensions (e.g. `sqlite-vec`), keyed by extension name. */
+    readonly bundledExtensions: Record<string, {
+        libPath: string;
+        entryPoint: string;
+    } | undefined>;
+    ensureDatabasePathExistsAsync(databasePath: string): Promise<void>;
+    ensureDatabasePathExistsSync(databasePath: string): void;
+    deleteDatabaseAsync(databasePath: string): Promise<void>;
+    deleteDatabaseSync(databasePath: string): void;
+    backupDatabaseAsync(destDatabase: NativeDatabase, destDatabaseName: string, sourceDatabase: NativeDatabase, sourceDatabaseName: string): Promise<void>;
+    backupDatabaseSync(destDatabase: NativeDatabase, destDatabaseName: string, sourceDatabase: NativeDatabase, sourceDatabaseName: string): void;
+    addListener(eventName: 'onDatabaseChange', listener: (event: IDatabaseChangeEvent) => void): EventSubscription;
+};
+export declare const expoSQLite: INativeSQLiteModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,18 @@
+// Resolves expo-sqlite's native module by the same name its own `ExpoSQLite.ts` one-liner uses
+// (`.vendors/expo` @ origin/sdk-57, packages/expo-sqlite/src/ExpoSQLite.ts:
+// `requireNativeModule('ExpoSQLite')`) — through `expo-modules-core` directly, never the `expo`
+// meta-package (root CLAUDE.md's dependency-scope invariant). Verified against the Android
+// module's `Name("ExpoSQLite")` declaration
+// (packages/expo-sqlite/android/.../SQLiteModule.kt) — see this package's `native-link.json`.
+//
+// `NativeDatabase`/`NativeStatement`/`NativeSession` are plain constructors exposed as CLASS
+// PROPERTIES on the native module (`new ExpoSQLite.NativeDatabase(...)`), not `SharedObject`
+// subclasses — see native-database.ts's header for why that makes this simpler than
+// `@symbiote-native/audio`'s port.
+import { requireNativeModule } from 'expo-modules-core';
+import { NativeDatabase } from './native-database';
+import { NativeSession } from './native-session';
+import { NativeStatement } from './native-statement';
+const EXPO_SQLITE_MODULE_NAME = 'ExpoSQLite';
+export const expoSQLite = requireNativeModule(EXPO_SQLITE_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,4EAA4E;AAC5E,gGAAgG;AAChG,2FAA2F;AAC3F,4CAA4C;AAC5C,8FAA8F;AAC9F,EAAE;AACF,6FAA6F;AAC7F,6FAA6F;AAC7F,oFAAoF;AACpF,mCAAmC;AACnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,MAAM,uBAAuB,GAAG,YAAY,CAAC;AAmC7C,MAAM,CAAC,MAAM,UAAU,GAAG,mBAAmB,CAC3C,uBAAuB,CACxB,CAAC"}

package/build-ngc/core/native-session.d.ts

@@ -0,0 +1,20 @@
+import type { ISQLiteAnyDatabase } from './native-statement';
+/** A changeset produced by the session extension. */
+export type IChangeset = Uint8Array;
+export type INativeChangeset = ArrayBuffer;
+export declare class NativeSession {
+    attachAsync(database: ISQLiteAnyDatabase, table: string | null): Promise<void>;
+    enableAsync(database: ISQLiteAnyDatabase, enabled: boolean): Promise<void>;
+    closeAsync(database: ISQLiteAnyDatabase): Promise<void>;
+    createChangesetAsync(database: ISQLiteAnyDatabase): Promise<INativeChangeset>;
+    createInvertedChangesetAsync(database: ISQLiteAnyDatabase): Promise<INativeChangeset>;
+    applyChangesetAsync(database: ISQLiteAnyDatabase, changeset: IChangeset | INativeChangeset): Promise<void>;
+    invertChangesetAsync(database: ISQLiteAnyDatabase, changeset: IChangeset | INativeChangeset): Promise<INativeChangeset>;
+    attachSync(database: ISQLiteAnyDatabase, table: string | null): void;
+    enableSync(database: ISQLiteAnyDatabase, enabled: boolean): void;
+    closeSync(database: ISQLiteAnyDatabase): void;
+    createChangesetSync(database: ISQLiteAnyDatabase): INativeChangeset;
+    createInvertedChangesetSync(database: ISQLiteAnyDatabase): INativeChangeset;
+    applyChangesetSync(database: ISQLiteAnyDatabase, changeset: IChangeset | INativeChangeset): void;
+    invertChangesetSync(database: ISQLiteAnyDatabase, changeset: IChangeset | INativeChangeset): INativeChangeset;
+}

package/build-ngc/core/native-session.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=native-session.js.map

package/build-ngc/core/native-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-session.js","sourceRoot":"","sources":["../../src/core/native-session.ts"],"names":[],"mappings":""}

package/build-ngc/core/native-statement.d.ts

@@ -0,0 +1,45 @@
+/** A result returned by `SQLiteStatement.executeAsync()`/`executeSync()`. */
+export type ISQLiteRunResult = {
+    /**
+     * The last inserted row ID, from
+     * [`sqlite3_last_insert_rowid()`](https://www.sqlite.org/c3ref/last_insert_rowid.html).
+     */
+    lastInsertRowId: number;
+    /**
+     * The number of rows affected, from
+     * [`sqlite3_changes()`](https://www.sqlite.org/c3ref/changes.html).
+     */
+    changes: number;
+};
+/**
+ * Bind parameters to a prepared statement — a single array/variadic args for unnamed
+ * parameters (`?`), or a single object for named parameters (`:VVV`, `@VVV`, `$VVV`).
+ */
+export type ISQLiteBindValue = string | number | null | boolean | ISQLiteBindBlobValue;
+export type ISQLiteBindParams = Record<string, ISQLiteBindValue> | ISQLiteBindValue[];
+export type ISQLiteVariadicBindParams = ISQLiteBindValue[];
+export type ISQLiteBindBlobValue = Uint8Array | ArrayBuffer;
+export type ISQLiteBindPrimitiveParams = Record<string, Exclude<ISQLiteBindValue, ISQLiteBindBlobValue>>;
+export type ISQLiteBindBlobParams = Record<string, ISQLiteBindBlobValue>;
+export type ISQLiteColumnNames = string[];
+export type ISQLiteColumnValues = any[];
+export type ISQLiteAnyDatabase = any;
+/** An instance of a prepared SQLite statement. */
+export declare class NativeStatement {
+    runAsync(database: ISQLiteAnyDatabase, bindParams: ISQLiteBindPrimitiveParams, bindBlobParams: ISQLiteBindBlobParams, shouldPassAsArray: boolean): Promise<ISQLiteRunResult & {
+        firstRowValues: ISQLiteColumnValues;
+    }>;
+    stepAsync(database: ISQLiteAnyDatabase): Promise<ISQLiteColumnValues | null | undefined>;
+    getAllAsync(database: ISQLiteAnyDatabase): Promise<ISQLiteColumnValues[]>;
+    resetAsync(database: ISQLiteAnyDatabase): Promise<void>;
+    getColumnNamesAsync(): Promise<ISQLiteColumnNames>;
+    finalizeAsync(database: ISQLiteAnyDatabase): Promise<void>;
+    runSync(database: ISQLiteAnyDatabase, bindParams: ISQLiteBindPrimitiveParams, bindBlobParams: ISQLiteBindBlobParams, shouldPassAsArray: boolean): ISQLiteRunResult & {
+        firstRowValues: ISQLiteColumnValues;
+    };
+    stepSync(database: ISQLiteAnyDatabase): ISQLiteColumnValues | null | undefined;
+    getAllSync(database: ISQLiteAnyDatabase): ISQLiteColumnValues[];
+    resetSync(database: ISQLiteAnyDatabase): void;
+    getColumnNamesSync(): string[];
+    finalizeSync(database: ISQLiteAnyDatabase): void;
+}

package/build-ngc/core/native-statement.js

@@ -0,0 +1,7 @@
+// Ported from expo-sqlite's NativeStatement.ts (.vendors/expo @ origin/sdk-57,
+// packages/expo-sqlite/src/NativeStatement.ts), renamed with this repo's `I`-prefix convention.
+//
+// A plain native class, instantiated directly (`new ExpoSQLite.NativeStatement()`) and then
+// mutated in place by `NativeDatabase.prepareAsync`/`prepareSync` — see `sqlite-database.ts`.
+export {};
+//# sourceMappingURL=native-statement.js.map

package/build-ngc/core/native-statement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-statement.js","sourceRoot":"","sources":["../../src/core/native-statement.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,gGAAgG;AAChG,EAAE;AACF,4FAA4F;AAC5F,8FAA8F"}

package/build-ngc/core/param-utils.d.ts

@@ -0,0 +1,28 @@
+import type { ISQLiteBindBlobParams, ISQLiteBindPrimitiveParams, ISQLiteColumnNames, ISQLiteColumnValues } from './native-statement';
+/**
+ * Normalizes bind params into `[primitiveParams, blobParams, shouldPassAsArray]` for the
+ * native module. `params` is untyped because the public overloads
+ * (`ISQLiteBindParams` vs. variadic `ISQLiteVariadicBindParams`) already constrain what a
+ * type-checked caller can pass here — this only has to survive a caller that bypasses them.
+ * @hidden
+ */
+export declare function normalizeParams(...params: unknown[]): [ISQLiteBindPrimitiveParams, ISQLiteBindBlobParams, boolean];
+/**
+ * Composes `columnNames` and `columnValues` into a row object.
+ * @hidden
+ */
+export declare function composeRow<T>(columnNames: ISQLiteColumnNames, columnValues: ISQLiteColumnValues): T;
+/**
+ * Composes `columnNames` and `columnValuesList` into an array of row objects.
+ * @hidden
+ */
+export declare function composeRows<T>(columnNames: ISQLiteColumnNames, columnValuesList: ISQLiteColumnValues[]): T[];
+/**
+ * Normalizes the index for `SQLiteStorage.getKeyByIndexAsync`/`getKeyByIndexSync`. `index` is
+ * `unknown` (upstream types it `any`) because the function coerces defensively via `Number()` —
+ * a caller reaching this from untyped host data (e.g. a `web` `Storage` polyfill) may hand it
+ * anything.
+ * @returns The normalized index, or `null` when out of bounds.
+ * @hidden
+ */
+export declare function normalizeStorageIndex(index: unknown): number | null;

package/build-ngc/core/param-utils.js

@@ -0,0 +1,127 @@
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Normalizes bind params into `[primitiveParams, blobParams, shouldPassAsArray]` for the
+ * native module. `params` is untyped because the public overloads
+ * (`ISQLiteBindParams` vs. variadic `ISQLiteVariadicBindParams`) already constrain what a
+ * type-checked caller can pass here — this only has to survive a caller that bypasses them.
+ * @hidden
+ */
+export function normalizeParams(...params) {
+    const rawParams = params.length > 1 ? params : params[0];
+    let bindParams = rawParams ?? [];
+    if (typeof bindParams !== 'object' ||
+        bindParams === null ||
+        bindParams instanceof ArrayBuffer ||
+        ArrayBuffer.isView(bindParams)) {
+        bindParams = [bindParams];
+    }
+    const shouldPassAsArray = Array.isArray(bindParams);
+    const entries = Array.isArray(bindParams)
+        ? bindParams.map((value, index) => [
+            String(index),
+            value,
+        ])
+        : isPlainRecord(bindParams)
+            ? Object.entries(bindParams)
+            : [];
+    const primitiveParams = {};
+    const blobParams = {};
+    for (const [key, value] of entries) {
+        if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+            blobParams[key] = value;
+        }
+        else if (typeof value === 'boolean') {
+            primitiveParams[key] = value ? 1 : 0;
+        }
+        else if (value === null ||
+            typeof value === 'string' ||
+            typeof value === 'number') {
+            primitiveParams[key] = value;
+        }
+        else {
+            // Not a recognized ISQLiteBindValue at this point (undefined, an object, an array, a
+            // function...) — keep it as-is, matching upstream's `value ?? null`, which only guards
+            // null/undefined and otherwise passes the value through untouched. Binding an invalid
+            // value is the native bridge's problem at bind time; this function only reshapes params.
+            // I/O edge: `value` is genuinely unknown here — a caller that bypassed the public
+            // `ISQLiteBindParams` overloads is the only way to reach this branch.
+            primitiveParams[key] = (value ?? null);
+        }
+    }
+    return [primitiveParams, blobParams, shouldPassAsArray];
+}
+/**
+ * Composes `columnNames` and `columnValues` into a row object.
+ * @hidden
+ */
+export function composeRow(columnNames, columnValues) {
+    const row = {};
+    if (columnNames.length !== columnValues.length) {
+        throw new Error(`Column names and values count mismatch. Names: ${columnNames.length}, Values: ${columnValues.length}`);
+    }
+    for (let i = 0; i < columnNames.length; i++) {
+        const columnName = columnNames[i];
+        if (columnName != null) {
+            row[columnName] = columnValues[i];
+        }
+    }
+    // I/O edge: T is the caller-specified row shape (SQLiteStatement.executeAsync<T>, etc.) — the
+    // native bridge has no way to describe it, so it is asserted here, at the narrowest point
+    // native data enters the type system.
+    return row;
+}
+/**
+ * Composes `columnNames` and `columnValuesList` into an array of row objects.
+ * @hidden
+ */
+export function composeRows(columnNames, columnValuesList) {
+    const firstRow = columnValuesList[0];
+    if (firstRow == null) {
+        return [];
+    }
+    if (columnNames.length !== firstRow.length) {
+        // Only the first row is checked — SQLite returns the same column count for every row. A
+        // shorter LATER row is not an error case (unlike composeRow's own check, which this
+        // deliberately does NOT delegate to) — a missing trailing value just composes as
+        // `undefined`, matching upstream's inline (non-composeRow) row construction here.
+        throw new Error(`Column names and values count mismatch. Names: ${columnNames.length}, Values: ${firstRow.length}`);
+    }
+    const results = [];
+    for (const columnValues of columnValuesList) {
+        const row = {};
+        for (let i = 0; i < columnNames.length; i++) {
+            const columnName = columnNames[i];
+            if (columnName != null) {
+                row[columnName] = columnValues[i];
+            }
+        }
+        // I/O edge, same as composeRow above.
+        results.push(row);
+    }
+    return results;
+}
+/**
+ * Normalizes the index for `SQLiteStorage.getKeyByIndexAsync`/`getKeyByIndexSync`. `index` is
+ * `unknown` (upstream types it `any`) because the function coerces defensively via `Number()` —
+ * a caller reaching this from untyped host data (e.g. a `web` `Storage` polyfill) may hand it
+ * anything.
+ * @returns The normalized index, or `null` when out of bounds.
+ * @hidden
+ */
+export function normalizeStorageIndex(index) {
+    const value = Math.floor(Number(index));
+    if (Object.is(value, -0)) {
+        return 0;
+    }
+    if (!Number.isSafeInteger(value)) {
+        // Chromium uses a zero index when the index is out of bounds.
+        return 0;
+    }
+    if (value < 0) {
+        return null;
+    }
+    return value;
+}
+//# sourceMappingURL=param-utils.js.map

package/build-ngc/core/param-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-utils.js","sourceRoot":"","sources":["../../src/core/param-utils.ts"],"names":[],"mappings":"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"}

package/build-ngc/core/path-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a normalized database path by combining the directory and database name — no
+ * trailing slash on the directory, no leading slash on the name, so the join never doubles up.
+ */
+export declare function createDatabasePath(databaseName: string, directory?: string): string;
+export declare function basename(path: string): string;

package/build-ngc/core/path-utils.js

@@ -0,0 +1,30 @@
+// Ported verbatim (logic unchanged) from expo-sqlite's pathUtils.ts (.vendors/expo @
+// origin/sdk-57, packages/expo-sqlite/src/pathUtils.ts).
+import { expoSQLite } from './native-module';
+function resolveDbDirectory(directory) {
+    const resolvedDirectory = directory ?? expoSQLite.defaultDatabaseDirectory;
+    if (resolvedDirectory == null) {
+        throw new Error('Both provided directory and defaultDatabaseDirectory are null.');
+    }
+    return resolvedDirectory;
+}
+/**
+ * Creates a normalized database path by combining the directory and database name — no
+ * trailing slash on the directory, no leading slash on the name, so the join never doubles up.
+ */
+export function createDatabasePath(databaseName, directory) {
+    if (databaseName === ':memory:')
+        return databaseName;
+    const resolvedDirectory = resolveDbDirectory(directory);
+    function removeTrailingSlash(path) {
+        return path.replace(/\/*$/, '');
+    }
+    function removeLeadingSlash(path) {
+        return path.replace(/^\/+/, '');
+    }
+    return `${removeTrailingSlash(resolvedDirectory)}/${removeLeadingSlash(databaseName)}`;
+}
+export function basename(path) {
+    return path.substring(path.lastIndexOf('/') + 1);
+}
+//# sourceMappingURL=path-utils.js.map

package/build-ngc/core/path-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.js","sourceRoot":"","sources":["../../src/core/path-utils.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,yDAAyD;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,SAAS,kBAAkB,CAAC,SAA6B;IACvD,MAAM,iBAAiB,GAAG,SAAS,IAAI,UAAU,CAAC,wBAAwB,CAAC;IAC3E,IAAI,iBAAiB,IAAI,IAAI,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;IACJ,CAAC;IACD,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,YAAoB,EACpB,SAAkB;IAElB,IAAI,YAAY,KAAK,UAAU;QAAE,OAAO,YAAY,CAAC;IACrD,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAExD,SAAS,mBAAmB,CAAC,IAAY;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAClC,CAAC;IACD,SAAS,kBAAkB,CAAC,IAAY;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,IAAI,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;AACzF,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AACnD,CAAC"}

package/build-ngc/core/query-utils.d.ts

@@ -0,0 +1,17 @@
+/** Information about a parsed SQL query. */
+export type ISQLParsedInfo = {
+    canReturnRows: boolean;
+};
+/**
+ * Parses a SQL query to determine whether it can return rows, using a priority-based approach:
+ * `RETURNING` always returns rows; a bare mutation keyword never does; a query keyword does;
+ * anything else does not.
+ *
+ * @example
+ * ```ts
+ * parseSQLQuery('SELECT * FROM users') // { canReturnRows: true }
+ * parseSQLQuery('INSERT INTO users VALUES (1)') // { canReturnRows: false }
+ * parseSQLQuery('INSERT INTO users VALUES (1) RETURNING *') // { canReturnRows: true }
+ * ```
+ */
+export declare function parseSQLQuery(query: string): ISQLParsedInfo;

package/build-ngc/core/query-utils.js

@@ -0,0 +1,38 @@
+// Ported verbatim (logic unchanged) from expo-sqlite's queryUtils.ts (.vendors/expo @
+// origin/sdk-57, packages/expo-sqlite/src/queryUtils.ts), renamed with this repo's `I`-prefix
+// convention. A reimplementation of Bun's SQLite query parser (credited upstream).
+const SINGLE_QUOTED_STRING = /'(?:[^']|'')*'/g;
+const DOUBLE_QUOTED_STRING = /"(?:[^"]|"")*"/g;
+const RETURNING_KEYWORD = /\bRETURNING\b/i;
+const MUTATION_KEYWORDS = /\b(INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)\b/i;
+const QUERY_KEYWORDS = /\b(SELECT|PRAGMA|WITH|EXPLAIN)\b/i;
+/**
+ * Parses a SQL query to determine whether it can return rows, using a priority-based approach:
+ * `RETURNING` always returns rows; a bare mutation keyword never does; a query keyword does;
+ * anything else does not.
+ *
+ * @example
+ * ```ts
+ * parseSQLQuery('SELECT * FROM users') // { canReturnRows: true }
+ * parseSQLQuery('INSERT INTO users VALUES (1)') // { canReturnRows: false }
+ * parseSQLQuery('INSERT INTO users VALUES (1) RETURNING *') // { canReturnRows: true }
+ * ```
+ */
+export function parseSQLQuery(query) {
+    // SQLite doubles quotes to escape them ('don''t', "test""quote") — strip quoted strings first
+    // so a keyword INSIDE a string literal can't produce a false positive.
+    const cleaned = query
+        .replace(SINGLE_QUOTED_STRING, "''")
+        .replace(DOUBLE_QUOTED_STRING, '""');
+    if (RETURNING_KEYWORD.test(cleaned)) {
+        return { canReturnRows: true };
+    }
+    if (MUTATION_KEYWORDS.test(cleaned)) {
+        return { canReturnRows: false };
+    }
+    if (QUERY_KEYWORDS.test(cleaned)) {
+        return { canReturnRows: true };
+    }
+    return { canReturnRows: false };
+}
+//# sourceMappingURL=query-utils.js.map

package/build-ngc/core/query-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-utils.js","sourceRoot":"","sources":["../../src/core/query-utils.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,8FAA8F;AAC9F,mFAAmF;AAOnF,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAC/C,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAC/C,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AAC3C,MAAM,iBAAiB,GAAG,+CAA+C,CAAC;AAC1E,MAAM,cAAc,GAAG,mCAAmC,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,8FAA8F;IAC9F,uEAAuE;IACvE,MAAM,OAAO,GAAG,KAAK;SAClB,OAAO,CAAC,oBAAoB,EAAE,IAAI,CAAC;SACnC,OAAO,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC;IAEvC,IAAI,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;IAClC,CAAC;IACD,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACjC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;IACjC,CAAC;IACD,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;AAClC,CAAC"}