uql-orm 0.63.0 → 0.65.0

package/dist/pglite/pgliteQuerier.d.ts

@@ -20,10 +20,8 @@ export type PgliteDatabase = {
 /**
  * Querier for PGlite, Postgres compiled to WASM and run in this process.
  *
- * @remarks Extends {@link AbstractSqlQuerier} rather than `PgQuerier`, whose `internalStream`
- * hands a `pg-query-stream` object to `query()`, which PGlite's client has no equivalent of - so
- * streaming pages the rows in SQL instead. `BEGIN`/`COMMIT` are plain statements on the single
- * connection, leaving transactions to the base class.
+ * @remarks Extends {@link AbstractSqlQuerier} rather than `PgQuerier`, whose stream needs `pg-query-stream`,
+ * which PGlite's client cannot run. `BEGIN`/`COMMIT` are plain statements on the single connection.
  */
 export declare class PgliteQuerier extends AbstractSqlQuerier {
     readonly db: PgliteDatabase;
@@ -31,8 +29,6 @@ export declare class PgliteQuerier extends AbstractSqlQuerier {
     constructor(db: PgliteDatabase, dialect: PostgresDialect, extra?: ExtraOptions | undefined);
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
     internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
-    /** Postgres compiled to WASM is still Postgres: `DECLARE`/`FETCH` streams what the client cannot. */
-    protected internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, any>;
     /** The handle belongs to the pool, which hands out one querier per unit of work over it. */
     internalRelease(): Promise<void>;
 }

package/dist/pglite/pgliteQuerier.js

@@ -1,12 +1,9 @@
-import { streamViaCursor } from '../postgres/pgCursorStream.js';
 import { AbstractSqlQuerier } from '../querier/index.js';
 /**
  * Querier for PGlite, Postgres compiled to WASM and run in this process.
  *
- * @remarks Extends {@link AbstractSqlQuerier} rather than `PgQuerier`, whose `internalStream`
- * hands a `pg-query-stream` object to `query()`, which PGlite's client has no equivalent of - so
- * streaming pages the rows in SQL instead. `BEGIN`/`COMMIT` are plain statements on the single
- * connection, leaving transactions to the base class.
+ * @remarks Extends {@link AbstractSqlQuerier} rather than `PgQuerier`, whose stream needs `pg-query-stream`,
+ * which PGlite's client cannot run. `BEGIN`/`COMMIT` are plain statements on the single connection.
  */
 export class PgliteQuerier extends AbstractSqlQuerier {
     db;
@@ -26,10 +23,6 @@ export class PgliteQuerier extends AbstractSqlQuerier {
         // where the latter also counts a `SELECT`'s rows and is absent altogether from a DDL tag.
         return this.buildUpdateResult({ rows: res.rows, changes: res.affectedRows ?? 0 });
     }
-    /** Postgres compiled to WASM is still Postgres: `DECLARE`/`FETCH` streams what the client cannot. */
-    async *internalStream(query, values) {
-        yield* streamViaCursor((sql, params) => this.internalAll(sql, params), query, values, this.hasOpenTransaction);
-    }
     /** The handle belongs to the pool, which hands out one querier per unit of work over it. */
     async internalRelease() { }
 }

package/dist/postgres/index.d.ts

@@ -1,4 +1,3 @@
 export * from './pgQuerier.js';
 export * from './pgQuerierPool.js';
 export * from './postgresDialect.js';
-export * from './postgresWireDriverCapabilities.js';

package/dist/postgres/index.js

@@ -1,4 +1,3 @@
 export * from './pgQuerier.js';
 export * from './pgQuerierPool.js';
 export * from './postgresDialect.js';
-export * from './postgresWireDriverCapabilities.js';

package/dist/querier/abstractSharedHandleQuerierPool.d.ts

@@ -15,13 +15,10 @@ import { AbstractSqlQuerierPool } from './abstractSqlQuerierPool.js';
  * into the transaction already open - see {@link PgliteQuerierPool}, which is why that one is worth
  * saying out loud.
  *
- * Subclasses supply only how to open the handle and how to wrap it, the way {@link AbstractPgQuerierPool}
- * takes `buildQuerier` alone. The lazy open and the close were written out once per pool before, along
- * with three partial copies of the paragraph above.
+ * Subclasses supply only how to open the handle and how to wrap it.
  *
  * @remarks Deliberately not re-exported from `querier/index.ts`, which the root entry point re-exports:
- * only the three driver entries need this, and each imports it by path, as `postgres/abstractPgQuerier.ts`
- * is imported.
+ * only the driver entries that open a single handle need this, and each imports it by path.
  */
 export declare abstract class AbstractSharedHandleQuerierPool<DB extends {
     close(): unknown;

package/dist/querier/abstractSharedHandleQuerierPool.js

@@ -13,13 +13,10 @@ import { AbstractSqlQuerierPool } from './abstractSqlQuerierPool.js';
  * into the transaction already open - see {@link PgliteQuerierPool}, which is why that one is worth
  * saying out loud.
  *
- * Subclasses supply only how to open the handle and how to wrap it, the way {@link AbstractPgQuerierPool}
- * takes `buildQuerier` alone. The lazy open and the close were written out once per pool before, along
- * with three partial copies of the paragraph above.
+ * Subclasses supply only how to open the handle and how to wrap it.
  *
  * @remarks Deliberately not re-exported from `querier/index.ts`, which the root entry point re-exports:
- * only the three driver entries need this, and each imports it by path, as `postgres/abstractPgQuerier.ts`
- * is imported.
+ * only the driver entries that open a single handle need this, and each imports it by path.
  */
 export class AbstractSharedHandleQuerierPool extends AbstractSqlQuerierPool {
     /**

package/dist/querier/abstractSqlQuerier.d.ts

@@ -80,9 +80,8 @@ export declare abstract class AbstractSqlQuerier extends AbstractQuerier impleme
     private hydrateRows;
     protected internalFindManyStream<E extends object>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): AsyncGenerator<Awaited<E>, void, unknown>;
     /**
-     * Internal streaming query - returns an async iterable of raw rows.
-     * Default implementation falls back to `internalAll()` then yields each row.
-     * Drivers with native cursor/streaming APIs (SQLite, Pg) should override this.
+     * A read's rows one at a time: paged through a server-side cursor where the engine has one, read whole
+     * where it has none. A driver that streams on its own overrides this.
      */
     protected internalStream<T>(query: string, values?: unknown[]): AsyncIterable<T>;
     /**

package/dist/querier/abstractSqlQuerier.js

@@ -4,6 +4,7 @@ import { getMeta, idOf, namesKey } from '../entity/index.js';
 import { COUNT_RESULT_KEY } from '../type/index.js';
 import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, idOnlyQuery, isAutoIncrement, isPagedQuery, isRecord, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
+import { streamViaCursor } from './cursorStream.js';
 import { enrichError } from './queryError.js';
 /**
  * Row indexes grouped by whether the caller supplied the key, payload order kept within each group.
@@ -240,12 +241,15 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         }
     }
     /**
-     * Internal streaming query - returns an async iterable of raw rows.
-     * Default implementation falls back to `internalAll()` then yields each row.
-     * Drivers with native cursor/streaming APIs (SQLite, Pg) should override this.
+     * A read's rows one at a time: paged through a server-side cursor where the engine has one, read whole
+     * where it has none. A driver that streams on its own overrides this.
      */
     async *internalStream(query, values) {
-        yield* await this.internalAll(query, values);
+        if (!this.dialect.features.serverSideCursors) {
+            yield* await this.internalAll(query, values);
+            return;
+        }
+        yield* streamViaCursor((sql, params) => this.internalAll(sql, params), query, values, this.hasOpenTransaction);
     }
     /**
      * Turn what a driver returned back into the types the entity declares, for every row and everything

package/dist/querier/cursorStream.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runs one statement of the cursor protocol on the querier's own connection, which holds the cursor, and
+ * not through `all()`, whose `serialize` is not re-entrant.
+ */
+type CursorExecutor<T> = (query: string, values?: unknown[]) => Promise<T[]>;
+/**
+ * Streams a Postgres-wire read through a server-side cursor. `DECLARE` needs a transaction, so one is
+ * opened on the connection itself when the caller has none, leaving the querier's state untouched.
+ * Cleanup sits in `finally`, which a consumer that stops early still reaches, and is best-effort once
+ * the read failed, so the read's error stays the one thrown.
+ */
+export declare function streamViaCursor<T>(exec: CursorExecutor<T>, query: string, values?: unknown[], inTransaction?: boolean): AsyncIterable<T>;
+export {};

package/dist/{postgres/pgCursorStream.js → querier/cursorStream.js}

@@ -4,17 +4,10 @@ const CURSOR_ALIAS = '_uql_cursor';
 const FETCH_SIZE = 100;
 let cursorSeq = 0;
 /**
- * Stream a Postgres-wire result through a server-side cursor, for a driver whose client exposes none:
- * `bun:sql` (no cursor API at all, [oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181))
- * and PGlite. `pg` has `pg-query-stream` and keeps using it.
- *
- * `DECLARE` is only legal inside a transaction, so one is opened here when the caller has none - and
- * then committed, or rolled back if the stream failed. That `BEGIN` goes straight to the connection
- * rather than through `beginTransaction`, so the querier's own transaction state stays untouched:
- * this one is the generator's, and ends with it.
- *
- * The cleanup lives in `finally` because a consumer that stops early (`break`, a `throw` downstream)
- * ends the generator there and nowhere else, and an abandoned cursor holds its transaction open.
+ * Streams a Postgres-wire read through a server-side cursor. `DECLARE` needs a transaction, so one is
+ * opened on the connection itself when the caller has none, leaving the querier's state untouched.
+ * Cleanup sits in `finally`, which a consumer that stops early still reaches, and is best-effort once
+ * the read failed, so the read's error stays the one thrown.
  */
 export async function* streamViaCursor(exec, query, values, inTransaction = false) {
     const cursor = `${CURSOR_ALIAS}_${++cursorSeq}`;
@@ -38,8 +31,6 @@ export async function* streamViaCursor(exec, query, values, inTransaction = fals
         throw err;
     }
     finally {
-        // Best-effort once the stream has failed: an error raised here would replace the one that brought
-        // us here, which is the one worth reporting, and the rollback discards the cursor either way.
         const end = failed ? (sql) => exec(sql).catch(() => []) : exec;
         await end(`CLOSE ${cursor}`);
         if (ownsTransaction) {

package/dist/schema/canonicalType.js

@@ -338,7 +338,7 @@ export function canonicalToSql(type, dialect) {
     }
     return type.unsigned && features.supportsUnsigned ? `${sqlType} UNSIGNED` : sqlType;
 }
-/** See {@link EngineFeatures.stringSizing} for what each mode means. */
+/** See {@link DialectFeatures.stringSizing} for what each mode means. */
 function formatStringSqlType(type, base, sizing) {
     if (sizing === 'text') {
         return base;

package/dist/schema/schemaASTBuilder.d.ts

@@ -29,6 +29,8 @@ export interface BuildSchemaASTOptions {
      * predicate - which only a dialect can render. `buildEntityAST` supplies it from the generator.
      */
     compileDdl?: (sql: EntityWhereMeta<object>, entity: Type<object>) => string;
+    /** A partial index's predicate as the engine writes it, `compileDdl` where none is given. `buildEntityAST` supplies it. */
+    compileIndexPredicate?: (where: EntityWhereMeta<object>, entity: Type<object>, indexName: string) => string;
 }
 /**
  * Build a SchemaAST from entity classes (decorated with `@Entity`, `@Field`, etc.).

package/dist/schema/schemaASTBuilder.js

@@ -5,8 +5,8 @@
  * - Entity metadata (decorator-based entities)
  * - Database introspection results (TableSchema[])
  */
-import { getMeta, soleIdOf } from '../entity/metadata/definition.js';
-import { indexNameParts, renderIndexColumn } from '../util/ddlExpression.util.js';
+import { foreignKeysOf, getMeta, soleIdOf } from '../entity/metadata/definition.js';
+import { declaredIndexes, indexNameParts, renderIndexColumn } from '../util/ddlExpression.util.js';
 import { isInlinedExpression } from '../util/field.util.js';
 import { isSoleIdField } from '../util/field.util.js';
 import { isAutoIncrement } from '../util/field.util.js';
@@ -23,6 +23,7 @@ import { DEFAULT_FOREIGN_KEY_ACTION, } from './types.js';
  */
 export function buildSchemaAST(entities, options = {}) {
     const { namingStrategy } = options;
+    const compileDdl = options.compileDdl ?? refuseDdl;
     const ctx = {
         ast: new SchemaAST(),
         resolveTableName: options.resolveTableName ??
@@ -30,7 +31,8 @@ export function buildSchemaAST(entities, options = {}) {
         resolveSchema: options.resolveSchema ?? ((m) => m.schema),
         resolveColumnName: options.resolveColumnName ?? ((k, f) => namingStrategy?.columnName(f.name ?? k) ?? f.name ?? k),
         defaultForeignKeyAction: options.defaultForeignKeyAction ?? DEFAULT_FOREIGN_KEY_ACTION,
-        compileDdl: options.compileDdl ?? refuseDdl,
+        compileDdl,
+        compileIndexPredicate: options.compileIndexPredicate ?? compileDdl,
     };
     for (const pass of [addTableFromEntity, addRelationshipsFromEntity, addIndexesFromEntity]) {
         for (const entity of entities) {
@@ -122,54 +124,48 @@ function tableOf(ctx, meta) {
     return ctx.ast.getTable(qualifyName(ctx.resolveTableName(meta), ctx.resolveSchema(meta)));
 }
 /**
- * Add relationships from entity relation decorators.
+ * Add a relationship for each foreign key the entity holds, whether a relation declares it or a bare
+ * `@Field({ references })` does.
  */
 function addRelationshipsFromEntity(ctx, meta) {
     const table = tableOf(ctx, meta);
     if (!table)
         return;
-    for (const [key, relation] of definedEntries(meta.relations)) {
-        const relatedMeta = getMeta(relation.entity());
+    for (const foreignKey of foreignKeysOf(meta)) {
+        const relatedMeta = getMeta(foreignKey.entity());
         const relatedTable = tableOf(ctx, relatedMeta);
         if (!relatedTable)
             continue;
-        // Only the owning side gets the FK. `mappedBy` marks the inverse side of a one-to-one, whose
-        // `references` describe how to join back (its own primary key against the owner's FK column) -
-        // reading those as a foreign key emitted a reversed constraint (`User(id) REFERENCES
-        // user_profile(creatorId)`), which SQLite rejects outright as a foreign key mismatch.
-        const ownsForeignKey = relation.cardinality === 'm1' || (relation.cardinality === '11' && !relation.mappedBy);
-        if (ownsForeignKey) {
-            // Every pair, not just the first: a composite key is one constraint over all its columns, and
-            // the engine requires the referenced columns to match a unique constraint as a whole.
-            const localColumns = [];
-            const foreignColumns = [];
-            for (const { local: localProp, foreign: foreignProp } of relation.references) {
-                const localField = meta.fields[localProp];
-                const foreignField = relatedMeta.fields[foreignProp];
-                const localColumn = localField && table.columns.get(ctx.resolveColumnName(localProp, localField));
-                const foreignColumn = foreignField && relatedTable.columns.get(ctx.resolveColumnName(foreignProp, foreignField));
-                if (!localColumn || !foreignColumn)
-                    break;
-                localColumns.push(localColumn);
-                foreignColumns.push(foreignColumn);
-            }
-            // A pair that cannot be resolved drops the whole constraint: half of one enforces a rule
-            // nobody declared, over a subset of the key.
-            if (localColumns.length !== relation.references.length)
-                continue;
-            ctx.ast.addRelationship({
-                name: derivedForeignKeyName(table.name, localColumns.map((column) => column.name)),
-                type: relation.cardinality === 'm1' ? 'ManyToOne' : 'OneToOne',
-                from: { table, columns: localColumns },
-                to: { table: relatedTable, columns: foreignColumns },
-                // Falls back to the FK column's own `onDelete`, which is what makes a bare `@Field({
-                // references, onDelete })` work with no relation declared at all.
-                onDelete: relation.onDelete ?? meta.fields[relation.references[0].local]?.onDelete ?? ctx.defaultForeignKeyAction,
-                onUpdate: relation.onUpdate ?? ctx.defaultForeignKeyAction,
-                confidence: 1.0,
-                inferredFrom: 'entity_decorator',
-            });
+        // Every pair, not just the first: a composite key is one constraint over all its columns, and
+        // the engine requires the referenced columns to match a unique constraint as a whole.
+        const localColumns = [];
+        const foreignColumns = [];
+        for (const { local: localProp, foreign: foreignProp } of foreignKey.references) {
+            const localField = meta.fields[localProp];
+            const foreignField = relatedMeta.fields[foreignProp];
+            const localColumn = localField && table.columns.get(ctx.resolveColumnName(localProp, localField));
+            const foreignColumn = foreignField && relatedTable.columns.get(ctx.resolveColumnName(foreignProp, foreignField));
+            if (!localColumn || !foreignColumn)
+                break;
+            localColumns.push(localColumn);
+            foreignColumns.push(foreignColumn);
         }
+        // A pair that cannot be resolved drops the whole constraint: half of one enforces a rule
+        // nobody declared, over a subset of the key.
+        if (localColumns.length !== foreignKey.references.length)
+            continue;
+        ctx.ast.addRelationship({
+            name: derivedForeignKeyName(table.name, localColumns.map((column) => column.name)),
+            type: foreignKey.cardinality === 'm1' ? 'ManyToOne' : 'OneToOne',
+            from: { table, columns: localColumns },
+            to: { table: relatedTable, columns: foreignColumns },
+            // Falls back to the FK column's own `onDelete`, which is what makes a bare `@Field({
+            // references, onDelete })` work with no relation declared at all.
+            onDelete: foreignKey.onDelete ?? meta.fields[foreignKey.references[0].local]?.onDelete ?? ctx.defaultForeignKeyAction,
+            onUpdate: foreignKey.onUpdate ?? ctx.defaultForeignKeyAction,
+            confidence: 1.0,
+            inferredFrom: 'entity_decorator',
+        });
     }
 }
 /**
@@ -180,23 +176,7 @@ function addIndexesFromEntity(ctx, meta) {
     const table = tableOf(ctx, meta);
     if (!table)
         return;
-    for (const key of Object.keys(meta.fields)) {
-        const field = meta.fields[key];
-        if (!field?.index)
-            continue;
-        const column = table.columns.get(ctx.resolveColumnName(key, field));
-        if (!column)
-            continue;
-        ctx.ast.addIndex({
-            name: typeof field.index === 'string' ? field.index : derivedIndexName(table.name, [column.name]),
-            table,
-            entries: [{ column: column.name }],
-            unique: field.unique ?? false,
-            source: 'entity',
-            syncStatus: 'entity_only',
-        });
-    }
-    for (const idxMeta of meta.indexes ?? []) {
+    for (const idxMeta of declaredIndexes(meta)) {
         addCompositeIndex(ctx, table, meta, idxMeta);
     }
     addForeignKeyIndexes(ctx, meta, table);
@@ -235,7 +215,7 @@ function resolveIncludeColumn(ctx, meta, column) {
     return field ? ctx.resolveColumnName(column, field) : column;
 }
 /**
- * One `@Index`. Its entries keep the authored form (expression, prefix length, order) with
+ * One index the entity declares. Its entries keep the authored form (expression, prefix length, order) with
  * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
  * subset, which is what diffing and introspection compare.
  */
@@ -251,14 +231,15 @@ function addCompositeIndex(ctx, table, meta, idxMeta) {
     });
     if (!resolved.length)
         return;
+    const name = idxMeta.name ?? derivedIndexName(table.name, indexNameParts(resolved));
     ctx.ast.addIndex({
-        name: idxMeta.name ?? derivedIndexName(table.name, indexNameParts(resolved)),
+        name,
         table,
         entries: resolved.map((entry) => renderIndexColumn(entry, (sql) => ctx.compileDdl(sql, meta.entity))),
         include: idxMeta.include?.map((column) => resolveIncludeColumn(ctx, meta, column)),
         unique: idxMeta.unique ?? false,
         type: idxMeta.type,
-        where: idxMeta.where && ctx.compileDdl(idxMeta.where, meta.entity),
+        where: idxMeta.where && ctx.compileIndexPredicate(idxMeta.where, meta.entity, name),
         distance: idxMeta.distance,
         m: idxMeta.m,
         efConstruction: idxMeta.efConstruction,

package/dist/sqlite/abstractSqliteQuerier.d.ts

@@ -15,14 +15,18 @@ export type SqliteExecution = {
     readonly changes: number;
 };
 /**
- * Querier for every SQLite driver. Each supplies one hook, {@link execute}; what they share - the
- * wide-integer decode, and a RETURNING statement counted by its rows - is written once here.
+ * Querier for every SQLite driver. Each supplies {@link execute}, and {@link iterate} where it steps a
+ * statement row by row; what they share - the values bound as SQLite takes them, the wide-integer
+ * decode, and a RETURNING statement counted by its rows - is written once here.
  */
 export declare abstract class AbstractSqliteQuerier extends AbstractSqlQuerier {
     /** Runs one statement, answering its rows as the driver read them. */
-    protected abstract execute(query: string, values?: unknown[]): Promise<SqliteExecution>;
+    protected abstract execute(query: string, values: SqliteBindValue[]): Promise<SqliteExecution>;
+    /** A statement's rows as the driver answers them: read whole, unless it steps them one at a time. */
+    protected iterate(query: string, values: SqliteBindValue[]): Promise<Iterable<RawRow> | AsyncIterable<RawRow>>;
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
     internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
+    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
     /**
      * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
      * a querier returns nothing at all. Drivers owning a closable per-querier connection override this.

package/dist/sqlite/abstractSqliteQuerier.js

@@ -1,22 +1,36 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
 import { decodeBigInts } from '../util/wideNumber.js';
 /**
- * Querier for every SQLite driver. Each supplies one hook, {@link execute}; what they share - the
- * wide-integer decode, and a RETURNING statement counted by its rows - is written once here.
+ * Querier for every SQLite driver. Each supplies {@link execute}, and {@link iterate} where it steps a
+ * statement row by row; what they share - the values bound as SQLite takes them, the wide-integer
+ * decode, and a RETURNING statement counted by its rows - is written once here.
  */
 export class AbstractSqliteQuerier extends AbstractSqlQuerier {
+    /** A statement's rows as the driver answers them: read whole, unless it steps them one at a time. */
+    async iterate(query, values) {
+        return (await this.execute(query, values)).rows;
+    }
     async internalAll(query, values) {
-        const { rows } = await this.execute(query, values);
+        const { rows } = await this.execute(query, toBindValues(values));
         return rows.map(decodeBigInts);
     }
     async internalRun(query, values) {
-        const { rows, changes } = await this.execute(query, values);
+        const { rows, changes } = await this.execute(query, toBindValues(values));
         // A driver's own count is unreliable for a RETURNING statement (Hrana answers 0), so its rows answer.
         return this.buildUpdateResult({ rows: rows.map(decodeBigInts), changes: rows.length || changes });
     }
+    async *internalStream(query, values) {
+        for await (const row of await this.iterate(query, toBindValues(values))) {
+            yield decodeBigInts(row);
+        }
+    }
     /**
      * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
      * a querier returns nothing at all. Drivers owning a closable per-querier connection override this.
      */
     async internalRelease() { }
 }
+/** The compiler hands values over untyped, which the dialect has already normalized to what SQLite binds. */
+function toBindValues(values = []) {
+    return values;
+}

package/dist/sqlite/hranaQuerier.d.ts

@@ -44,7 +44,7 @@ export declare class HranaQuerier extends AbstractSqliteQuerier {
     private readonly closeClientOnRelease;
     constructor(client: HranaClient, dialect: SqliteDialect, extra?: ExtraOptions | undefined, connection?: HranaQuerierConnectionOptions);
     /** Runs on the open transaction's handle when there is one. */
-    protected execute(query: string, values?: unknown[]): Promise<{
+    protected execute(query: string, values: SqliteBindValue[]): Promise<{
         rows: RawRow[];
         changes: number;
     }>;

package/dist/sqlite/localSqliteQuerierPool.d.ts

@@ -20,6 +20,13 @@ export type LocalSqliteDatabase = {
     loadExtension(path: string): void;
     close(): unknown;
 };
+/**
+ * A `node:sqlite` or `bun:sqlite` handle as a {@link LocalSqliteDatabase}. Neither says whether a statement
+ * reads, so `reads` does: taken by `run()`, a RETURNING statement's rows would be lost, and its ids with them.
+ */
+export declare function adaptSqlite<S extends Omit<SqlitePreparedStatement, 'reader'>>(db: Omit<LocalSqliteDatabase, 'prepare'> & {
+    prepare(sql: string): S;
+}, reads: (stmt: S) => boolean): LocalSqliteDatabase;
 /**
  * Pool for a SQLite database opened in this process, whichever driver provides it. SQLite gives one
  * connection per file, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.

package/dist/sqlite/localSqliteQuerierPool.js

@@ -3,6 +3,25 @@ import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandle
 import { SqliteDialect } from './sqliteDialect.js';
 import { applySqlitePragmas } from './sqlitePragmas.js';
 import { SqliteQuerier } from './sqliteQuerier.js';
+/**
+ * A `node:sqlite` or `bun:sqlite` handle as a {@link LocalSqliteDatabase}. Neither says whether a statement
+ * reads, so `reads` does: taken by `run()`, a RETURNING statement's rows would be lost, and its ids with them.
+ */
+export function adaptSqlite(db, reads) {
+    return {
+        prepare: (sql) => {
+            const stmt = db.prepare(sql);
+            return {
+                reader: reads(stmt),
+                all: (...values) => stmt.all(...values),
+                run: (...values) => stmt.run(...values),
+                iterate: (...values) => stmt.iterate(...values),
+            };
+        },
+        loadExtension: (path) => db.loadExtension(path),
+        close: () => db.close(),
+    };
+}
 /**
  * Pool for a SQLite database opened in this process, whichever driver provides it. SQLite gives one
  * connection per file, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.

package/dist/sqlite/nodeSqliteQuerierPool.js

@@ -1,5 +1,4 @@
-import { AbstractLocalSqliteQuerierPool, } from './localSqliteQuerierPool.js';
-import { adaptNodeSqlite } from './nodeSqliteAdapter.js';
+import { AbstractLocalSqliteQuerierPool, adaptSqlite, } from './localSqliteQuerierPool.js';
 /**
  * Pool backed by Node's built-in `node:sqlite`, so SQLite works with **no dependency at all** rather
  * than requiring the `better-sqlite3` native build. Use {@link Sqlite3QuerierPool} instead when you
@@ -25,6 +24,6 @@ export class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool {
             // `node:sqlite` refuses `loadExtension` unless the database was opened with this on.
             ...(extensions?.length ? { allowExtension: true } : undefined),
         });
-        return adaptNodeSqlite(nodeDb);
+        return adaptSqlite(nodeDb, (stmt) => stmt.columns().length > 0);
     }
 }

package/dist/sqlite/sqliteDialect.js

@@ -7,9 +7,6 @@ import { columnFamily, isIntegerColumn } from '../util/field.util.js';
 export class SqliteDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
     featureDefaults = {
-        explicitJsonCast: false,
-        nativeArrays: false,
-        supportsJsonb: false,
         ifNotExists: true,
         indexIfNotExists: true,
         schemas: false, // SQLite's namespaces are attached database files, not declared objects

package/dist/sqlite/sqliteQuerier.d.ts

@@ -1,9 +1,12 @@
 import type { ExtraOptions, RawRow } from '../type/index.js';
 import { AbstractSqliteQuerier, type SqliteBindValue } from './abstractSqliteQuerier.js';
 import type { SqliteDialect } from './sqliteDialect.js';
-/** What uql reads of a driver's `run()`: the row count. An inserted id comes back through `RETURNING`. */
+/**
+ * What uql reads of a driver's `run()`: the row count, which `node:sqlite` answers as a `bigint` once it
+ * reads integers as ones. An inserted id comes back through `RETURNING`.
+ */
 export type SqliteRunResult = {
-    changes: number;
+    changes: number | bigint;
 };
 /** A prepared statement with better-sqlite3 semantics, answering at once or with a promise. */
 export type SqlitePreparedStatement = {
@@ -15,7 +18,7 @@ export type SqlitePreparedStatement = {
 };
 /**
  * A SQLite driver that prepares statements. `better-sqlite3` and the embedded Turso engine satisfy it
- * as they are, `bun:sqlite` and `node:sqlite` through their adapters.
+ * as they are, `bun:sqlite` and `node:sqlite` through `adaptSqlite`.
  */
 export type SqliteDatabase = {
     prepare(sql: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
@@ -31,9 +34,9 @@ export declare class SqliteQuerier extends AbstractSqliteQuerier {
     readonly extra?: ExtraOptions | undefined;
     constructor(db: SqliteDatabase, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
     /** `reader` picks the call: `run()` would discard the rows of a statement that reads, RETURNING included. */
-    protected execute(query: string, values?: unknown[]): Promise<{
+    protected execute(query: string, values: SqliteBindValue[]): Promise<{
         rows: RawRow[];
         changes: number;
     }>;
-    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    protected iterate(query: string, values: SqliteBindValue[]): Promise<AsyncIterable<RawRow> | Iterable<RawRow>>;
 }

package/dist/sqlite/sqliteQuerier.js

@@ -1,4 +1,3 @@
-import { decodeBigInts } from '../util/wideNumber.js';
 import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
 /**
  * Querier for the SQLite drivers that prepare statements: `better-sqlite3`, `bun:sqlite`, `node:sqlite`
@@ -16,20 +15,12 @@ export class SqliteQuerier extends AbstractSqliteQuerier {
     /** `reader` picks the call: `run()` would discard the rows of a statement that reads, RETURNING included. */
     async execute(query, values) {
         const stmt = await this.db.prepare(query);
-        const bound = toBindValues(values);
         if (stmt.reader) {
-            return { rows: (await stmt.all(...bound)), changes: 0 };
+            return { rows: (await stmt.all(...values)), changes: 0 };
         }
-        return { rows: [], changes: (await stmt.run(...bound)).changes };
+        return { rows: [], changes: Number((await stmt.run(...values)).changes) };
     }
-    async *internalStream(query, values) {
-        const stmt = await this.db.prepare(query);
-        for await (const row of stmt.iterate(...toBindValues(values))) {
-            yield decodeBigInts(row);
-        }
+    async iterate(query, values) {
+        return (await this.db.prepare(query)).iterate(...values);
     }
 }
-/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
-function toBindValues(values) {
-    return (values ?? []);
-}

package/dist/sqlite/sqliteQuerierPool.js

@@ -1,4 +1,4 @@
-import { AbstractLocalSqliteQuerierPool, } from './localSqliteQuerierPool.js';
+import { AbstractLocalSqliteQuerierPool, adaptSqlite, } from './localSqliteQuerierPool.js';
 /**
  * Pool for `better-sqlite3`, or `bun:sqlite` when running under Bun - the same file, through whichever
  * driver the runtime provides.
@@ -18,11 +18,11 @@ export class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool {
         const { extensions, ...driverOpts } = this.opts ?? {};
         if (typeof Bun !== 'undefined') {
             const { Database } = await import('bun:sqlite');
-            const { adaptBunSqlite } = await import('./bunSqliteAdapter.bun.js');
             const bunOpts = { ...driverOpts, safeIntegers: true };
-            return adaptBunSqlite(typeof this.filename === 'string'
+            const bunDb = typeof this.filename === 'string'
                 ? new Database(this.filename, bunOpts)
-                : Database.deserialize(this.filename, bunOpts));
+                : Database.deserialize(this.filename, bunOpts);
+            return adaptSqlite(bunDb, (stmt) => stmt.columnNames.length > 0);
         }
         const { default: BetterSqlite3 } = await import('better-sqlite3');
         return new BetterSqlite3(this.filename, driverOpts).defaultSafeIntegers(true);

package/dist/turso/tursoSessionQuerier.d.ts

@@ -47,11 +47,11 @@ export declare class TursoSessionQuerier extends AbstractSqliteQuerier {
     readonly session: TursoSession;
     readonly extra?: ExtraOptions | undefined;
     constructor(session: TursoSession, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
-    protected execute(query: string, values?: unknown[]): Promise<{
+    protected execute(query: string, values: SqliteBindValue[]): Promise<{
         rows: RawRow[];
         changes: number;
     }>;
     /** Row by row off the statement's cursor, as the server steps it, each decoded as `execute` decodes one. */
-    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    protected iterate(query: string, values: SqliteBindValue[]): Promise<AsyncGenerator<RawRow, void, unknown>>;
     internalRelease(): Promise<void>;
 }