uql-orm 0.54.0 → 0.56.0

package/dist/querier/abstractSqlQuerier.js

@@ -1,7 +1,7 @@
 import { COUNT_ALIAS, TOTAL_ALIAS } from '../dialect/aliases.js';
 import { decodeColumn } from '../dialect/hydrateColumn.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 { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, getRelationRequestSummary, idOnlyQuery, isAutoIncrement, isPagedQuery, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
 import { enrichError } from './queryError.js';
 /**
@@ -223,8 +223,11 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         return this.all(ctx.sql, ctx.values);
     }
     async hydrateRows(entity, q, rows) {
-        const founds = unflatObjects(rows).map((row) => this.hydrateFields(entity, row));
-        await this.fillToManyRelations(entity, founds, q.$populate);
+        const founds = unflatObjects(rows);
+        this.hydrateAll(entity, founds);
+        if (q.$populate) {
+            await this.fillToManyRelations(entity, founds, q.$populate);
+        }
         return founds;
     }
     async *internalFindManyStream(entity, q, opts) {
@@ -241,18 +244,22 @@ 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);
+        const fields = this.dialect.hydratableFields(entity);
         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));
+                const found = unflatObject(row, attrsPaths);
+                this.hydrateFields(meta, fields, found);
+                yield found;
             }
         }
         catch (err) {
-            throw enrichError(err, this.logger, ctx.sql, normalizedParams);
+            throw enrichError(err, this.logger, ctx.sql, ctx.values);
         }
     }
     /**
@@ -261,37 +268,38 @@ 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
-     * populated under it. Which columns, and as what, is `hydratableFields`; the per-cell decode is
-     * `decodeColumn`. Both live with the dialect, because a `sparsevec` is only sparse on Postgres.
-     *
-     * `visited` guards a populated graph that points back at itself, and makes a node two paths reach
-     * decode once. Only a relation can lead the walk back somewhere it has been, so an entity that
-     * declares none skips the guard rather than allocating a set per row to hold a single object -
-     * which cost more than the decoding it guards, on a flat read.
+     * Turn what a driver returned back into the types the entity declares, for every row and everything
+     * populated under them. Which columns, and as what, is `hydratableFields`, resolved once for all the
+     * rows; the per-cell decode is `decodeColumn`. Both live with the dialect, because a `sparsevec` is
+     * only sparse on Postgres.
      */
-    hydrateFields(entity, dto, visited) {
+    hydrateAll(entity, dtos, visited) {
+        const meta = getMeta(entity);
+        const fields = this.dialect.hydratableFields(entity);
+        for (const dto of dtos) {
+            this.hydrateFields(meta, fields, dto, visited);
+        }
+    }
+    /**
+     * One row of {@link hydrateAll}. `visited` guards a populated graph that points back at itself, and
+     * makes a node two paths reach decode once. Only a populated relation can lead the walk back, so the
+     * guard is created at the first one a row carries: rows that populated nothing never allocate one.
+     */
+    hydrateFields(meta, fields, dto, visited) {
         if (!dto || typeof dto !== 'object' || visited?.has(dto)) {
-            return dto;
+            return;
         }
-        const meta = getMeta(entity);
+        visited?.add(dto);
         const row = dto;
-        for (const [key, kind] of this.dialect.hydratableFields(entity)) {
+        for (const [key, kind] of fields) {
             const value = row[key];
             if (value != null) {
                 row[key] = decodeColumn(value, kind);
             }
         }
-        // Allocated only where the walk can continue: an entity declaring no relation cannot lead back
-        // to a node already decoded, and the loop below is a no-op for it anyway.
-        if (hasKeys(meta.relations)) {
-            visited ??= new WeakSet();
-        }
-        visited?.add(dto);
         // The value is read before the relation's target is resolved: a query that populated nothing
         // still walks every relation the entity declares, and `rel.entity()` is a call per row per
         // relation that only the populated ones need.
@@ -302,16 +310,14 @@ export class AbstractSqlQuerier extends AbstractQuerier {
             const rel = meta.relations[key];
             if (!rel)
                 continue;
+            visited ??= new WeakSet([dto]);
             const relEntity = rel.entity();
             if (Array.isArray(value)) {
-                for (const it of value) {
-                    this.hydrateFields(relEntity, it, visited);
-                }
+                this.hydrateAll(relEntity, value, visited);
                 continue;
             }
-            this.hydrateFields(relEntity, value, visited);
+            this.hydrateFields(getMeta(relEntity), this.dialect.hydratableFields(relEntity), value, visited);
         }
-        return dto;
     }
     /**
      * Runs a statement whose one row carries a {@link COUNT_ALIAS} column. `Number` because `COUNT(*)` is BIGINT and
@@ -504,35 +510,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/canonicalType.js

@@ -492,7 +492,5 @@ export function canonicalToColumnType(type) {
             return 'halfvec';
         case 'sparsevec':
             return 'sparsevec';
-        default:
-            return 'varchar';
     }
 }

package/dist/schema/dependencyGraph.js

@@ -38,11 +38,9 @@ export function findCycles(nodes, dependenciesOf) {
     const visited = new Set();
     const onPath = new Set();
     const visit = (node, path) => {
+        // A node on the walk was handed down in `path` too, so the cycle closes where it first appears.
         if (onPath.has(node)) {
-            const start = path.indexOf(node);
-            if (start !== -1) {
-                cycles.push(path.slice(start));
-            }
+            cycles.push(path.slice(path.indexOf(node)));
             return;
         }
         if (visited.has(node)) {

package/dist/schema/indexDifferences.js

@@ -64,8 +64,8 @@ export function describeIndexDifferences(source, target, facets) {
             differences.push(`columns: (${targetColumns}) → (${sourceColumns})`);
         }
     }
-    if ((source.unique ?? false) !== (target.unique ?? false)) {
-        differences.push(`unique: ${target.unique ?? false} → ${source.unique ?? false}`);
+    if (source.unique !== target.unique) {
+        differences.push(`unique: ${target.unique} → ${source.unique}`);
     }
     if (facets.has('accessMethod') && (source.type ?? 'btree') !== (target.type ?? 'btree')) {
         differences.push(`type: ${target.type ?? 'btree'} → ${source.type ?? 'btree'}`);

package/dist/schema/schemaASTBuilder.js

@@ -10,6 +10,7 @@ import { ddlText } 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';
+import { definedEntries } from '../util/object.util.js';
 import { derivedForeignKeyName, derivedIndexName, qualifyName } from '../util/sql.util.js';
 import { fieldOptionsToCanonical } from './canonicalType.js';
 import { createTableNode, SchemaAST } from './schemaAST.js';
@@ -79,11 +80,7 @@ function addTableFromEntity(ctx, meta) {
     const { columns, primaryKey } = table;
     table.checks?.push(...(meta.checks ?? []));
     // Add columns from fields
-    const fields = meta.fields;
-    for (const key of Object.keys(fields)) {
-        const field = fields[key];
-        if (!field)
-            continue;
+    for (const [key, field] of definedEntries(meta.fields)) {
         // An inlined expression has no column; a stored one is a column like any other.
         if (isInlinedExpression(field))
             continue;
@@ -126,11 +123,7 @@ function addRelationshipsFromEntity(ctx, meta) {
     const table = tableOf(ctx, meta);
     if (!table)
         return;
-    const relations = meta.relations;
-    for (const key of Object.keys(relations)) {
-        const relation = relations[key];
-        if (!relation)
-            continue;
+    for (const [key, relation] of definedEntries(meta.relations)) {
         const relatedMeta = getMeta(relation.entity());
         const relatedTable = tableOf(ctx, relatedMeta);
         if (!relatedTable)

package/dist/schema/schemaASTDiffer.d.ts

@@ -10,7 +10,7 @@
 import { type IndexFacet } from './indexDifferences.js';
 import type { SchemaAST } from './schemaAST.js';
 import type { CanonicalType } from './types.js';
-import type { RelationshipDiff, RelationshipNode, SchemaDiffResult, TableDiff, TableNode } from './types.js';
+import type { ColumnDiff, ForeignKeyAction, IndexDiff, RelationshipDiff, RelationshipNode, SchemaDiffResult, TableDiff, TableNode } from './types.js';
 /**
  * Options for schema diffing.
  */
@@ -59,7 +59,10 @@ export declare function diffSchemas(source: SchemaAST, target: SchemaAST, option
  * against the one the database reported, then projects the result into a `SchemaDiff`. One
  * comparison serves both, so drift and migrations can no longer disagree about what has changed.
  */
-export declare function diffTable(source: TableNode, target: TableNode, options?: DiffOptions): TableDiff | undefined;
+export declare function diffTable(source: TableNode, target: TableNode, options?: DiffOptions): (TableDiff & {
+    readonly columnDiffs: ColumnDiff[];
+    readonly indexDiffs: IndexDiff[];
+}) | undefined;
 /**
  * Compare two lists of relationships.
  *
@@ -70,3 +73,8 @@ export declare function diffTable(source: TableNode, target: TableNode, options?
  * pairing on names would report every hand-named one as a drop and an add.
  */
 export declare function diffRelationshipNodes(source: readonly RelationshipNode[], target: readonly RelationshipNode[], opts?: DiffOptions): RelationshipDiff[];
+/** A relationship's `ON DELETE` and `ON UPDATE`, an unstated one read as the action the database applies. */
+export declare function referentialActions(rel: RelationshipNode): {
+    readonly onDelete: ForeignKeyAction;
+    readonly onUpdate: ForeignKeyAction;
+};

package/dist/schema/schemaASTDiffer.js

@@ -61,8 +61,8 @@ export function diffSchemas(source, target, options = {}) {
     const tablesToAlter = matched
         .map(([sourceTable, targetTable]) => diffTable(sourceTable, targetTable, opts))
         .filter((tableDiff) => tableDiff !== undefined);
-    const columnDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.columnDiffs ?? []);
-    const indexDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.indexDiffs ?? []);
+    const columnDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.columnDiffs);
+    const indexDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.indexDiffs);
     const primaryKeyDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.primaryKeyDiff ?? []);
     // Relationships span tables, so they are compared over the whole schema rather than per table.
     const relationshipDiffs = opts.compareRelationships
@@ -265,16 +265,17 @@ export function diffRelationshipNodes(source, target, opts = {}) {
             .filter((diff) => diff !== undefined),
     ];
 }
-/**
- * Compare two relationships.
- */
+/** A relationship's `ON DELETE` and `ON UPDATE`, an unstated one read as the action the database applies. */
+export function referentialActions(rel) {
+    return {
+        onDelete: rel.onDelete ?? DEFAULT_FOREIGN_KEY_ACTION,
+        onUpdate: rel.onUpdate ?? DEFAULT_FOREIGN_KEY_ACTION,
+    };
+}
+/** Two relationships over the same columns differ only in what they do when the row they point at goes. */
 function diffRelationship(source, target) {
-    // Compare on delete/update actions (normalizing defaults)
-    const sDelete = source.onDelete ?? DEFAULT_FOREIGN_KEY_ACTION;
-    const tDelete = target.onDelete ?? DEFAULT_FOREIGN_KEY_ACTION;
-    const sUpdate = source.onUpdate ?? DEFAULT_FOREIGN_KEY_ACTION;
-    const tUpdate = target.onUpdate ?? DEFAULT_FOREIGN_KEY_ACTION;
-    if (sDelete !== tDelete || sUpdate !== tUpdate) {
+    const [expected, actual] = [referentialActions(source), referentialActions(target)];
+    if (expected.onDelete !== actual.onDelete || expected.onUpdate !== actual.onUpdate) {
         return { ...relationEnds(source), type: 'alter', expected: source, actual: target };
     }
     return undefined;

package/dist/schema/types.d.ts

@@ -342,7 +342,7 @@ export type DriftSeverity = 'critical' | 'warning' | 'info';
 /**
  * Type of schema drift.
  */
-export type DriftType = 'missing_table' | 'unexpected_table' | 'missing_column' | 'unexpected_column' | 'type_mismatch' | 'constraint_mismatch' | 'missing_index' | 'unexpected_index' | 'index_mismatch' | 'missing_relationship' | 'unexpected_relationship';
+export type DriftType = 'missing_table' | 'unexpected_table' | 'missing_column' | 'unexpected_column' | 'type_mismatch' | 'constraint_mismatch' | 'missing_index' | 'unexpected_index' | 'index_mismatch' | 'missing_relationship' | 'unexpected_relationship' | 'relationship_mismatch';
 /**
  * A single schema drift issue.
  */

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/sqliteDialect.js

@@ -1,6 +1,7 @@
 import { AbstractSqlDialect } from '../dialect/abstractSqlDialect.js';
 import { JSON_ELEM_ALIAS_PREFIX, JSON_PULL_ALIAS } from '../dialect/aliases.js';
 import { jsonAssignCall, jsonElemExists, jsonPath, jsonRemoveCall, jsonSetTarget } from '../dialect/jsonSql.js';
+import { textSearchFields } from '../util/dialect.util.js';
 export class SqliteDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
     featureDefaults = {
@@ -86,7 +87,7 @@ export class SqliteDialect extends AbstractSqlDialect {
      * FTS5 virtual table (UQL does not create those; declare it outside your entities).
      */
     appendTextSearch(ctx, entity, meta, search) {
-        const columns = search.$fields.map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
+        const columns = textSearchFields(meta, search).map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
         ctx.append(`${this.escapedTableName(meta)} MATCH {${columns.join(' ')}} : `);
         ctx.addValue(search.$value);
     }

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>;
 }

package/dist/sqlite/sqliteQuerierPool.js

@@ -10,11 +10,6 @@ export class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool {
         super(opts, extra);
         this.filename = filename;
     }
-    /**
-     * 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.
-     */
     async createDb() {
         // `bun:sqlite` rejects option keys it does not know, and rejects an options object carrying no
         // open flags, so `extensions` is stripped out and what remains of it collapses back to nothing.
@@ -23,15 +18,9 @@ export class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool {
         if (typeof Bun !== 'undefined') {
             const { Database: BunDatabase } = await import('bun:sqlite');
             const { adaptBunSqlite } = await import('./bunSqliteAdapter.bun.js');
-            const bunDb = new BunDatabase(this.filename, opts);
-            bunDb.run('PRAGMA journal_mode = WAL');
-            bunDb.run('PRAGMA foreign_keys = ON');
-            return adaptBunSqlite(bunDb);
+            return adaptBunSqlite(new BunDatabase(this.filename, opts));
         }
         const { default: BetterSqlite3 } = await import('better-sqlite3');
-        const db = new BetterSqlite3(this.filename, opts);
-        db.pragma('journal_mode = WAL');
-        db.pragma('foreign_keys = ON');
-        return db;
+        return new BetterSqlite3(this.filename, opts);
     }
 }

package/dist/turso/index.d.ts

@@ -1,3 +1,2 @@
 export * from './tursoDialect.js';
-export * from './tursoQuerier.js';
 export * from './tursoQuerierPool.js';

package/dist/turso/index.js

@@ -1,3 +1,2 @@
 export * from './tursoDialect.js';
-export * from './tursoQuerier.js';
 export * from './tursoQuerierPool.js';

package/dist/turso/tursoLocalQuerier.d.ts

@@ -7,7 +7,6 @@ import type { ExtraOptions } from '../type/index.js';
  */
 export type TursoDatabase = {
     prepare(sql: string): Promise<SqlitePreparedStatement>;
-    pragma(source: string, options?: unknown): Promise<unknown[]>;
     close(): Promise<void>;
 };
 /**