uql-orm 0.53.0 → 0.55.0

package/dist/querier/abstractSqlQuerier.js

@@ -1,6 +1,6 @@
 import { COUNT_ALIAS, TOTAL_ALIAS } from '../dialect/aliases.js';
 import { decodeColumn } from '../dialect/hydrateColumn.js';
-import { getMeta, idOf, soleIdOf } from '../entity/index.js';
+import { getMeta, idOf, namesKey } from '../entity/index.js';
 import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, getRelationRequestSummary, hasKeys, idOnlyQuery, isAutoIncrement, isPagedQuery, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
 import { enrichError } from './queryError.js';
@@ -22,50 +22,36 @@ function partitionBySuppliedId(payload, idKey) {
     return supplied.length && generated.length ? [supplied, generated] : [supplied.length ? supplied : generated];
 }
 /**
- * Rows grouped by the columns they carry, payload order kept within each group - or `undefined` when
- * they all carry the same ones, which is the batch as it stands and needs no grouping at all.
+ * Row indexes grouped by the columns their rows carry, payload order kept within each group.
  *
  * Deliberately finer than {@link partitionBySuppliedId}: an upsert's `DO UPDATE SET` is one
  * assignment list for the whole statement, so rows of different shapes cannot share one at all.
  */
 function groupByInsertShape(meta, payload) {
-    const first = insertShapeOf(meta, payload[0]);
-    let index = 1;
-    while (index < payload.length && insertShapeOf(meta, payload[index]) === first) {
-        index++;
-    }
-    if (index === payload.length) {
-        return undefined;
-    }
-    const groups = new Map([[first, payload.slice(0, index)]]);
-    for (; index < payload.length; index++) {
-        const row = payload[index];
-        const shape = insertShapeOf(meta, row);
+    const groups = new Map();
+    for (let index = 0; index < payload.length; index++) {
+        const shape = insertShapeOf(meta, payload[index]);
         const group = groups.get(shape);
         if (group) {
-            group.push(row);
+            group.push(index);
         }
         else {
-            groups.set(shape, [row]);
+            groups.set(shape, [index]);
         }
     }
     return [...groups.values()];
 }
 /**
- * How many rows one statement can carry within the dialect's bind budget. `DEFAULT` cells bind no
- * parameter, so fields-per-record is a safe upper bound. Every multi-row write splits on this: D1
- * allows 100 binds, which a couple of dozen rows reach.
+ * A group's row indexes split into statements within the dialect's bind budget, payload order kept.
+ * `DEFAULT` cells bind no parameter, so fields-per-record is a safe upper bound. Every multi-row
+ * write splits on this: D1 allows 100 binds, which a couple of dozen rows reach.
  */
-function bindBudgetChunkSize(meta, rows, maxBindValues) {
-    const fieldsPerRecord = getInsertFieldKeys(meta, rows).length || 1;
-    return Math.max(1, Math.floor(maxBindValues / fieldsPerRecord));
-}
-/** `rows` split into statement-sized slices, payload order kept. */
-function chunkByBindBudget(meta, rows, maxBindValues) {
-    const size = bindBudgetChunkSize(meta, rows, maxBindValues);
+function chunkByBindBudget(meta, payload, group, maxBindValues) {
+    const fieldsPerRecord = getInsertFieldKeys(meta, group.map((index) => payload[index])).length;
+    const size = Math.max(1, Math.floor(maxBindValues / (fieldsPerRecord || 1)));
     const chunks = [];
-    for (let start = 0; start < rows.length; start += size) {
-        chunks.push(rows.slice(start, start + size));
+    for (let start = 0; start < group.length; start += size) {
+        chunks.push(group.slice(start, start + size));
     }
     return chunks;
 }
@@ -186,17 +172,6 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         this.dialect.findPerParent(ctx, entity, q, partition);
         return this.hydrateRows(entity, q, await this.all(ctx.sql, ctx.values));
     }
-    /**
-     * One statement for both: the page carries its own unpaged total in an extra column. An empty page
-     * has no row to carry it, which is the one case still needing a count of its own - a `$skip` past
-     * the end, or a filter nothing matched.
-     *
-     * A `$required` relation needs no special case: the window counts what the INNER JOIN left, which
-     * is exactly the total a caller of a filtered read is asking for. A `$lock` is the one clause an
-     * engine may refuse to have in the same statement, which {@link AbstractSqlDialect.supportsWindowWithRowLock}
-     * answers; where it does, the total comes from a count of its own. A `$distinct` read needs one
-     * too, and a deduplicating one: see {@link AbstractSqlDialect.countDistinct}.
-     */
     /**
      * How to count when the total cannot ride along in the read's own `COUNT(*) OVER ()` column, or
      * `undefined` when it can. Two clauses rule the window out: `$distinct`, because a window counts
@@ -212,6 +187,17 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         }
         return undefined;
     }
+    /**
+     * One statement for both: the page carries its own unpaged total in an extra column. An empty page
+     * has no row to carry it, which is the one case still needing a count of its own - a `$skip` past
+     * the end, or a filter nothing matched.
+     *
+     * A `$required` relation needs no special case: the window counts what the INNER JOIN left, which
+     * is exactly the total a caller of a filtered read is asking for. A `$lock` is the one clause an
+     * engine may refuse to have in the same statement, which {@link AbstractSqlDialect.supportsWindowWithRowLock}
+     * answers; where it does, the total comes from a count of its own. A `$distinct` read needs one
+     * too, and a deduplicating one: see {@link AbstractSqlDialect.countDistinct}.
+     */
     async internalFindManyAndCount(entity, q, opts) {
         const separately = this.countedSeparately(entity, q, opts);
         if (separately) {
@@ -255,18 +241,19 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         // The one path that does not go through `all`/`run`, so it connects on its own: streaming first on
         // a freshly acquired querier used to reach `getConn()` with nothing acquired.
         await this.lazyConnect();
+        // No `normalizeValues` here, unlike `all`/`run`: those also take raw SQL, while every value a
+        // context holds was normalized as it was bound.
         const ctx = this.dialect.createContext();
         this.dialect.find(ctx, entity, q, opts);
-        const normalizedParams = this.dialect.normalizeValues(ctx.values);
         let attrsPaths;
         try {
-            for await (const row of this.internalStream(ctx.sql, normalizedParams)) {
+            for await (const row of this.internalStream(ctx.sql, ctx.values)) {
                 attrsPaths ??= obtainAttrsPaths(row);
                 yield this.hydrateFields(entity, unflatObject(row, attrsPaths));
             }
         }
         catch (err) {
-            throw enrichError(err, this.logger, ctx.sql, normalizedParams);
+            throw enrichError(err, this.logger, ctx.sql, ctx.values);
         }
     }
     /**
@@ -275,8 +262,7 @@ export class AbstractSqlQuerier extends AbstractQuerier {
      * Drivers with native cursor/streaming APIs (SQLite, Pg) should override this.
      */
     async *internalStream(query, values) {
-        const rows = await this.internalAll(query, this.dialect.normalizeValues(values));
-        yield* rows;
+        yield* await this.internalAll(query, values);
     }
     /**
      * Turn what a driver returned back into the types the entity declares, for the row and everything
@@ -359,24 +345,15 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         }
         return res;
     }
-    async internalInsertMany(entity, payload) {
-        if (!payload?.length) {
-            return [];
-        }
-        payload = clone(payload);
+    async internalInsertMany(entity, rows) {
         const meta = getMeta(entity);
-        // What comes back is one column's value, so a composite reports nothing here and `insertMany`
-        // names those rows from the payload instead. `sole` is what keeps every id path off a key that
-        // is several columns.
+        // What comes back is one column's value, so nothing is read back for a composite: its rows
+        // already carry every column of it. `sole` is what keeps every id path off such a key.
         const [idKey] = meta.ids;
         const sole = meta.ids.length === 1;
         const idField = sole ? meta.fields[idKey] : undefined;
         const generatedKey = !!idField && isAutoIncrement(idField, true);
-        const payloadIds = new Array(payload.length);
-        for (const group of partitionBySuppliedId(payload, idKey)) {
-            // Per group, not per batch: the two carry different columns - one names the key, one does not -
-            // so a budget taken over their union would under-fill the statement that is missing one.
-            const chunkSize = bindBudgetChunkSize(meta, group.map((index) => payload[index]), this.dialect.maxBindValues);
+        for (const group of partitionBySuppliedId(rows, idKey)) {
             // RETURNING-based ids are exact per row. Header-derived ones (LAST_INSERT_ID / lastInsertRowid
             // arithmetic) are only sound when the key is database-generated and every row *in this
             // statement* left it to the database. That is a property of the statement, not of the batch:
@@ -385,28 +362,26 @@ export class AbstractSqlQuerier extends AbstractQuerier {
             // most one extra statement and keeps each of them inferable.
             const idsReliable = sole &&
                 (this.dialect.insertIdSource === 'returning' ||
-                    (generatedKey && group.every((index) => payload[index][idKey] === undefined)));
+                    (generatedKey && group.every((index) => rows[index][idKey] === undefined)));
             // Inferring multiple ids from the single header id (MySQL) assumes a known stride; a clustered
             // server may set `auto_increment_increment` > 1, so probe it (once, cached) before inferring.
             if (idsReliable && group.length > 1 && this.dialect.insertIdSource === 'firstId') {
                 this.#insertIdIncrement ??= await this.loadInsertIdIncrement();
             }
-            for (let start = 0; start < group.length; start += chunkSize) {
-                const indexes = group.slice(start, start + chunkSize);
+            // Per group, not per batch: the two carry different columns - one names the key, one does not -
+            // so a budget taken over their union would under-fill the statement that is missing one.
+            for (const indexes of chunkByBindBudget(meta, rows, group, this.dialect.maxBindValues)) {
                 const ctx = this.dialect.createContext();
-                this.dialect.insert(ctx, entity, indexes.map((index) => payload[index]));
+                this.dialect.insert(ctx, entity, indexes.map((index) => rows[index]));
                 const { ids = [] } = await this.run(ctx.sql, ctx.values);
-                indexes.forEach((index, position) => {
-                    const it = payload[index];
-                    if (idsReliable) {
-                        it[idKey] ??= ids[position];
+                if (idsReliable) {
+                    for (let position = 0; position < indexes.length; position++) {
+                        rows[indexes[position]][idKey] ??= ids[position];
                     }
-                    payloadIds[index] = sole ? it[idKey] : undefined;
-                });
+                }
             }
         }
-        await this.insertRelations(entity, payload);
-        return payloadIds;
+        await this.insertRelations(entity, rows);
     }
     async internalUpdateMany(entity, q, payload, opts) {
         payload = clone(payload);
@@ -446,8 +421,7 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         // One statement per shape, each split again to stay inside the bind budget. Grouping first is
         // what makes the budget arithmetic right: every row of a group carries the same columns, so the
         // `DO UPDATE SET` resolves to non-binding `EXCLUDED` references rather than inlined values.
-        const groups = groupByInsertShape(meta, payload);
-        const statements = (groups ?? [payload]).flatMap((group) => chunkByBindBudget(meta, group, this.dialect.maxBindValues));
+        const statements = groupByInsertShape(meta, payload).flatMap((group) => chunkByBindBudget(meta, payload, group, this.dialect.maxBindValues));
         if (statements.length === 1) {
             return this.runUpsert(entity, conflictPaths, payload);
         }
@@ -459,31 +433,41 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         // than one statement; `transaction` is re-entrant, so this is free inside a caller's own.
         return this.transaction(async () => {
             let changes = 0;
-            const ids = [];
-            for (const statement of statements) {
-                const result = await this.runUpsert(entity, conflictPaths, statement);
-                changes += result.changes ?? 0;
-                if (result.ids) {
-                    ids.push(...result.ids);
+            // Placed by index, since grouping by shape reorders the rows. A statement reporting fewer ids
+            // than it wrote places none.
+            const ids = new Array(payload.length);
+            for (const indexes of statements) {
+                const { changes: written = 0, ids: reported } = await this.runUpsert(entity, conflictPaths, indexes.map((index) => payload[index]));
+                changes += written;
+                if (reported?.length === indexes.length) {
+                    for (let position = 0; position < indexes.length; position++) {
+                        ids[indexes[position]] = reported[position];
+                    }
                 }
             }
-            // No `created`/`firstId`: both speak for a single statement, and there were several.
-            return ids.length ? { changes, ids } : { changes };
+            // No `created`: it speaks for a single statement, and there were several.
+            return { changes, ids };
         });
     }
     async runUpsert(entity, conflictPaths, payload) {
+        const meta = getMeta(entity);
+        // Asked first: the statement fills an `onInsert` key into these rows whether it inserts them or not.
+        const unnamed = meta.ids.length === 1 && payload.some((row) => !namesKey(meta, row));
         const ctx = this.dialect.createContext();
         this.dialect.upsert(ctx, entity, conflictPaths, payload);
         const result = await this.run(ctx.sql, ctx.values);
-        // On a `firstId` dialect (MySQL: no `RETURNING`), a multi-row upsert's `affectedRows` is a
-        // per-row weighted sum (1=insert, 2=update, 0=no-op), not a row count, so `buildUpdateResult`'s
-        // header-derived `ids`/`firstId`/`created` can't be trusted the moment more than one row is
-        // involved (verified: a 1-insert-1-update batch reports `changes: 3`, which would otherwise
-        // infer 3 sequential ids for only 2 real rows). A single-row batch (`upsertOne`) is unambiguous.
-        if (this.dialect.insertIdSource !== 'returning' && payload.length > 1) {
-            return { changes: result.changes };
-        }
-        return result;
+        const ordered = payload.length === 1 || (this.dialect.insertIdSource === 'returning' && this.dialect.upsertReturningOrdered);
+        if (ordered && result.ids?.length === payload.length) {
+            return result;
+        }
+        // The statement's ids name its rows only in order and for every one. A MySQL batch reports a
+        // weighted count (1=insert, 2=update) instead, CockroachDB and SQL Server answer out of order, and
+        // `DO NOTHING` skips rows, so there the ids are read back by the conflict columns.
+        const { changes } = result;
+        const created = payload.length === 1 ? result.created : undefined;
+        return unnamed
+            ? { changes, created, ids: await this.idsByConflict(entity, conflictPaths, payload) }
+            : { changes, created };
     }
     async internalDeleteMany(entity, q, opts) {
         const meta = getMeta(entity);
@@ -520,35 +504,47 @@ export class AbstractSqlQuerier extends AbstractQuerier {
                 throwPendingTransaction();
             }
             await this.lazyConnect();
-            for (const sql of this.dialect.getBeginTransactionStatements(opts?.isolationLevel)) {
-                await this.runTransactionCommand(sql);
-            }
+            await this.internalBegin(opts);
             this.hasPendingTransaction = true;
         });
     }
+    /**
+     * Only an end that succeeded ends the transaction. A `COMMIT` that fails can leave it open (SQLite
+     * answers `SQLITE_BUSY` and keeps it), so the flag has to stay set for the `catch` in
+     * {@link AbstractQuerier.transaction} or {@link AbstractQuerier.release} to roll it back.
+     */
     async commitTransaction() {
         return this.serialize(async () => {
             if (!this.hasPendingTransaction) {
                 throwNoPendingTransaction();
             }
-            await this.endTransactionWith(this.dialect.commitTransactionCommand);
+            await this.internalCommit();
+            this.hasPendingTransaction = false;
         });
     }
     async rollbackTransaction() {
         return this.serialize(async () => {
             if (this.hasPendingTransaction) {
-                await this.endTransactionWith(this.dialect.rollbackTransactionCommand);
+                await this.internalRollback();
+                this.hasPendingTransaction = false;
             }
         });
     }
     /**
-     * Only a statement that succeeded ends the transaction. A `COMMIT` that fails can leave it open
-     * (SQLite answers `SQLITE_BUSY` and keeps it), so the flag has to stay set for the `catch` in
-     * {@link AbstractQuerier.transaction} or {@link AbstractQuerier.release} to roll it back.
+     * How this driver opens, commits and rolls back: the dialect's statements, unless its transactions
+     * are objects rather than statements - Hrana's session handle, `mssql`'s `Transaction` - in which
+     * case it overrides all three. The bookkeeping around them stays above, written once.
      */
-    async endTransactionWith(command) {
-        await this.runTransactionCommand(command);
-        this.hasPendingTransaction = false;
+    async internalBegin(opts) {
+        for (const sql of this.dialect.getBeginTransactionStatements(opts?.isolationLevel)) {
+            await this.runTransactionCommand(sql);
+        }
+    }
+    internalCommit() {
+        return this.runTransactionCommand(this.dialect.commitTransactionCommand);
+    }
+    internalRollback() {
+        return this.runTransactionCommand(this.dialect.rollbackTransactionCommand);
     }
     /** Transaction statements skip `timed()`, so they attach their own query context to a failure. */
     async runTransactionCommand(sql) {

package/dist/schema/schemaASTBuilder.js

@@ -7,7 +7,7 @@
  */
 import { getMeta, soleIdOf } from '../entity/metadata/definition.js';
 import { ddlText } from '../util/ddlExpression.util.js';
-import { computedExpression, isInlinedExpression } from '../util/field.util.js';
+import { isInlinedExpression } from '../util/field.util.js';
 import { isSoleIdField } from '../util/field.util.js';
 import { isAutoIncrement } from '../util/field.util.js';
 import { derivedForeignKeyName, derivedIndexName, qualifyName } from '../util/sql.util.js';
@@ -101,7 +101,7 @@ function addTableFromEntity(ctx, meta) {
             isPrimaryKey,
             isAutoIncrement: isAutoIncrement(field, isSoleKey),
             isUnique: field.unique ?? false,
-            generatedAs: ddlText(computedExpression(field), `the computed column '${columnName}'`),
+            generatedAs: ddlText(field.computed, `the computed column '${columnName}'`),
             comment: field.comment,
             enum: field.enum,
             table,
@@ -202,16 +202,16 @@ function addIndexesFromEntity(ctx, meta) {
         addCompositeIndex(ctx, table, meta, idxMeta);
     }
 }
-/**
- * One `@Index([...])`. 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.
- */
 /** An `include` column is named like any other, so a naming strategy has to reach it too. */
 function resolveIncludeColumn(ctx, meta, column) {
     const field = meta.fields[column];
     return field ? ctx.resolveColumnName(column, field) : column;
 }
+/**
+ * One `@Index([...])`. 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.
+ */
 function addCompositeIndex(ctx, table, meta, idxMeta) {
     // An entry survives if it is an expression (nothing to resolve) or names a column that exists;
     // an index left with none is dropped, the same as one naming only unknown columns always was.

package/dist/sqlite/hranaQuerier.d.ts

@@ -1,4 +1,4 @@
-import type { ExtraOptions, TransactionOptions } from '../type/index.js';
+import type { ExtraOptions } from '../type/index.js';
 import { AbstractSqliteQuerier, type SqliteBindValue } from './abstractSqliteQuerier.js';
 import type { SqliteDialect } from './sqliteDialect.js';
 /**
@@ -46,14 +46,12 @@ export declare class HranaQuerier extends AbstractSqliteQuerier {
     constructor(client: HranaClient, dialect: SqliteDialect, extra?: ExtraOptions | undefined, connection?: HranaQuerierConnectionOptions);
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
     internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
-    get hasOpenTransaction(): boolean;
-    beginTransaction(_opts?: TransactionOptions): Promise<void>;
+    protected internalBegin(): Promise<void>;
     /**
-     * Both drop the handle before the call, not after: one that outlived a failed commit or rollback left
-     * the querier unreleasable. The optional call in the rollback is also what makes it a no-op when
-     * there is nothing open.
+     * Both drop the handle before the call, not after: one that outlived a failed commit would carry
+     * every later statement into a transaction the server may already have ended.
      */
-    commitTransaction(): Promise<void>;
-    rollbackTransaction(): Promise<void>;
+    protected internalCommit(): Promise<void>;
+    protected internalRollback(): Promise<void>;
     internalRelease(): Promise<void>;
 }

package/dist/sqlite/hranaQuerier.js

@@ -1,4 +1,3 @@
-import { throwNoPendingTransaction, throwPendingTransaction } from '../util/index.js';
 import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
 /**
  * Querier for SQLite databases reached through a Hrana client.
@@ -30,38 +29,22 @@ export class HranaQuerier extends AbstractSqliteQuerier {
         // the actual row count when rows were returned.
         return this.buildUpdateResult({ rows, changes: rows.length || res.rowsAffected, id: res.lastInsertRowid });
     }
-    get hasOpenTransaction() {
-        return !!this.tx;
-    }
-    async beginTransaction(_opts) {
-        return this.serialize(async () => {
-            if (this.tx) {
-                throwPendingTransaction();
-            }
-            this.tx = await this.client.transaction('write');
-        });
+    async internalBegin() {
+        this.tx = await this.client.transaction('write');
     }
     /**
-     * Both drop the handle before the call, not after: one that outlived a failed commit or rollback left
-     * the querier unreleasable. The optional call in the rollback is also what makes it a no-op when
-     * there is nothing open.
+     * Both drop the handle before the call, not after: one that outlived a failed commit would carry
+     * every later statement into a transaction the server may already have ended.
      */
-    async commitTransaction() {
-        return this.serialize(async () => {
-            const tx = this.tx;
-            if (!tx) {
-                throwNoPendingTransaction();
-            }
-            this.tx = undefined;
-            await tx.commit();
-        });
-    }
-    async rollbackTransaction() {
-        return this.serialize(async () => {
-            const tx = this.tx;
-            this.tx = undefined;
-            await tx?.rollback();
-        });
+    async internalCommit() {
+        const tx = this.tx;
+        this.tx = undefined;
+        await tx?.commit();
+    }
+    async internalRollback() {
+        const tx = this.tx;
+        this.tx = undefined;
+        await tx?.rollback();
     }
     async internalRelease() {
         await super.internalRelease();

package/dist/sqlite/hranaQuerierPool.d.ts

@@ -1,5 +1,5 @@
 import { AbstractSqlQuerierPool } from '../querier/index.js';
-import type { HranaClient, HranaQuerier, HranaQuerierConnectionOptions } from './hranaQuerier.js';
+import { type HranaClient, HranaQuerier } from './hranaQuerier.js';
 import type { SqliteDialect } from './sqliteDialect.js';
 /**
  * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
@@ -10,12 +10,11 @@ import type { SqliteDialect } from './sqliteDialect.js';
  * constructor, so building a pool never throws when the optional driver peer is absent, which is what
  * lets a Workers bundle construct one at module scope.
  */
-export declare abstract class AbstractHranaQuerierPool<Q extends HranaQuerier, D extends SqliteDialect> extends AbstractSqlQuerierPool<Q, D> {
+export declare abstract class AbstractHranaQuerierPool<D extends SqliteDialect> extends AbstractSqlQuerierPool<HranaQuerier, D> {
     private client?;
     /** False when the caller injected their own client, in which case they own its lifecycle. */
     protected readonly ownsClient: boolean;
     protected abstract openClient(): Promise<HranaClient>;
-    protected abstract buildQuerier(client: HranaClient, connection?: HranaQuerierConnectionOptions): Q;
-    getQuerier(): Promise<Q>;
+    getQuerier(): Promise<HranaQuerier>;
     end(): Promise<void>;
 }

package/dist/sqlite/hranaQuerierPool.js

@@ -1,4 +1,5 @@
 import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { HranaQuerier } from './hranaQuerier.js';
 /**
  * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
  * `@tursodatabase/serverless/compat`).
@@ -14,7 +15,7 @@ export class AbstractHranaQuerierPool extends AbstractSqlQuerierPool {
     ownsClient = true;
     async getQuerier() {
         this.client ??= await this.openClient();
-        return this.buildQuerier(this.client);
+        return new HranaQuerier(this.client, this.dialect, this.extra);
     }
     async end() {
         if (this.ownsClient) {

package/dist/sqlite/localSqliteQuerierPool.d.ts

@@ -15,13 +15,13 @@ export type LocalSqlitePoolOptions = {
  * 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.
  *
- * Subclasses supply only {@link createDb}: loading the extensions on the way up is the same for
- * `better-sqlite3`, `bun:sqlite` and `node:sqlite`, and was written out once per pool before.
+ * Subclasses supply only {@link createDb}: configuring the connection on the way up - the pragmas,
+ * then the extensions - is the same for `better-sqlite3`, `bun:sqlite` and `node:sqlite`.
  */
 export declare abstract class AbstractLocalSqliteQuerierPool<O extends LocalSqlitePoolOptions> extends AbstractSharedHandleQuerierPool<SqliteDatabase, SqliteQuerier, SqliteDialect> {
     readonly opts?: O | undefined;
     constructor(opts?: O | undefined, extra?: ExtraOptions);
-    /** Opens the driver's database. Extensions are loaded by the caller, not here. */
+    /** Opens the driver's database, and nothing more: the caller configures it. */
     protected abstract createDb(): Promise<SqliteDatabase>;
     protected openDb(): Promise<SqliteDatabase>;
     protected buildQuerier(db: SqliteDatabase): SqliteQuerier;

package/dist/sqlite/localSqliteQuerierPool.js

@@ -1,13 +1,14 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { SqliteDialect } from './sqliteDialect.js';
+import { applySqlitePragmas } from './sqlitePragmas.js';
 import { SqliteQuerier } from './sqliteQuerier.js';
 /**
  * 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.
  *
- * Subclasses supply only {@link createDb}: loading the extensions on the way up is the same for
- * `better-sqlite3`, `bun:sqlite` and `node:sqlite`, and was written out once per pool before.
+ * Subclasses supply only {@link createDb}: configuring the connection on the way up - the pragmas,
+ * then the extensions - is the same for `better-sqlite3`, `bun:sqlite` and `node:sqlite`.
  */
 export class AbstractLocalSqliteQuerierPool extends AbstractSharedHandleQuerierPool {
     opts;
@@ -17,6 +18,7 @@ export class AbstractLocalSqliteQuerierPool extends AbstractSharedHandleQuerierP
     }
     async openDb() {
         const db = await this.createDb();
+        await applySqlitePragmas(db);
         for (const extension of this.opts?.extensions ?? []) {
             db.loadExtension(extension);
         }

package/dist/sqlite/nodeSqliteAdapter.d.ts

@@ -19,7 +19,6 @@ type NodeSqliteStatement = {
  */
 export type NodeSqliteDatabase = {
     prepare(sql: string): NodeSqliteStatement;
-    exec(sql: string): void;
     loadExtension(path: string): void;
     close(): void;
 };

package/dist/sqlite/nodeSqliteQuerierPool.js

@@ -23,8 +23,6 @@ export class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool {
             // `node:sqlite` refuses `loadExtension` unless the database was opened with this on.
             ...(extensions?.length ? { allowExtension: true } : undefined),
         });
-        nodeDb.exec('PRAGMA journal_mode = WAL');
-        nodeDb.exec('PRAGMA foreign_keys = ON');
         return adaptNodeSqlite(nodeDb);
     }
 }

package/dist/sqlite/sqlitePragmas.d.ts

@@ -0,0 +1,12 @@
+import type { SqlitePreparedStatement } from './abstractSqliteQuerier.js';
+/**
+ * How every local SQLite connection opens. WAL, so a reader does not wait on the writer, and
+ * `foreign_keys`, which SQLite ships off per connection for backward compatibility: without it the
+ * constraints uql's own DDL declares are decorative - a declared `onDelete: 'CASCADE'` silently does
+ * nothing and a dangling reference is accepted.
+ */
+export declare const SQLITE_PRAGMAS: readonly ['journal_mode = WAL', 'foreign_keys = ON'];
+/** Runs {@link SQLITE_PRAGMAS} through a driver's own statements, whether it answers now or later. */
+export declare function applySqlitePragmas(db: {
+    prepare(sql: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
+}): Promise<void>;

package/dist/sqlite/sqlitePragmas.js

@@ -0,0 +1,15 @@
+/**
+ * How every local SQLite connection opens. WAL, so a reader does not wait on the writer, and
+ * `foreign_keys`, which SQLite ships off per connection for backward compatibility: without it the
+ * constraints uql's own DDL declares are decorative - a declared `onDelete: 'CASCADE'` silently does
+ * nothing and a dangling reference is accepted.
+ */
+export const SQLITE_PRAGMAS = ['journal_mode = WAL', 'foreign_keys = ON'];
+/** Runs {@link SQLITE_PRAGMAS} through a driver's own statements, whether it answers now or later. */
+export async function applySqlitePragmas(db) {
+    for (const pragma of SQLITE_PRAGMAS) {
+        const stmt = await db.prepare(`PRAGMA ${pragma}`);
+        // `journal_mode` answers with a row and `foreign_keys` with none; `reader` picks the call for each.
+        await (stmt.reader ? stmt.all() : stmt.run());
+    }
+}

package/dist/sqlite/sqliteQuerierPool.d.ts

@@ -11,10 +11,5 @@ export type Sqlite3PoolOptions = Options & LocalSqlitePoolOptions;
 export declare class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool<Sqlite3PoolOptions> {
     readonly filename: string | Buffer;
     constructor(filename?: string | Buffer, opts?: Sqlite3PoolOptions, extra?: ExtraOptions);
-    /**
-     * SQLite ships with foreign keys unenforced, per connection, for backward compatibility. UQL emits the
-     * constraints in its DDL, so leaving them off means a declared `onDelete: 'CASCADE'` silently does
-     * nothing and a dangling reference is accepted. Enabled here on every driver, as TypeORM also does.
-     */
     protected createDb(): Promise<SqliteDatabase>;
 }