uql-orm 0.54.0 → 0.55.0

package/dist/postgres/pgNumericTypes.js

@@ -1,5 +1,7 @@
+import { decodeWideNumber } from '../util/wideNumber.js';
 /**
- * Decode `INT8` and `FLOAT8` as JS numbers, leaving every other type to the driver.
+ * Decode `INT8` and `FLOAT8`, leaving every other type to the driver: an INT8 by `decodeWideNumber` - a
+ * number where one is exact, its exact text past 2^53 - and a FLOAT8 as the float64 it already is.
  *
  * uql owes this to the caller because uql picks the column: `type: Number` maps to BIGINT (see
  * `schema/canonicalType.ts`), so without it a field declared `number` read back as `'9'` - including
@@ -21,15 +23,17 @@
  * `types.setTypeParser` calls in `neon/neonQuerier.test.ts` - and both made the suite pass on
  * behaviour the library never shipped. Do not reintroduce one.
  *
- * Exact to 2^53, which covers any auto-increment id. A caller who needs more passes their own
- * `types` in the pool options: it is spread after this one and therefore wins. For a decimal, the
- * lighter escape hatch is the declaration itself: `@Field({ type: String, columnType: 'decimal' })`
- * keeps the column DECIMAL while leaving the value as the exact text the driver returned.
+ * A caller's own `types` in the pool options are spread after this one and therefore win. For a
+ * decimal, the lighter escape hatch is the declaration itself: `@Field({ type: String, columnType:
+ * 'decimal' })` keeps the column DECIMAL while leaving the value as the exact text the driver returned.
  */
 export function numericTypes(types) {
     // Text only: in binary mode an INT8 arrives as an 8-byte Buffer, and `Number(buffer)` is `NaN`.
-    const textNumeric = new Set([types.builtins['INT8'], types.builtins['FLOAT8']]);
+    const decoders = new Map([
+        [types.builtins['INT8'], decodeWideNumber],
+        [types.builtins['FLOAT8'], Number],
+    ]);
     return {
-        getTypeParser: (oid, format) => format === 'text' && textNumeric.has(oid) ? Number : types.getTypeParser(oid, format),
+        getTypeParser: (oid, format) => (format === 'text' && decoders.get(oid)) || types.getTypeParser(oid, format),
     };
 }

package/dist/postgres/pgQuerier.d.ts

@@ -1,5 +1,23 @@
-import type { PoolClient } from 'pg';
-import { AbstractPgQuerier } from './abstractPgQuerier.js';
-import type { PostgresDialect } from './postgresDialect.js';
-export declare class PgQuerier extends AbstractPgQuerier<PoolClient, PostgresDialect> {
+import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
+import type { RawRow } from '../type/index.js';
+export interface PgAnyClient {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: RawRow[];
+        rowCount: number | null;
+    }>;
+    query(stream: object): AsyncIterable<RawRow> & {
+        destroy(): void;
+    };
+    /** Any truthy argument makes `pg-pool` evict the client instead of returning it to the idle list. */
+    release(discard?: boolean): void | Promise<void>;
+}
+/**
+ * Querier for every client with node-postgres' API: `pg` itself, for Postgres and CockroachDB, and
+ * Neon's serverless driver. Generic over the client alone - the dialect is whichever the pool built.
+ */
+export declare class PgQuerier<C extends PgAnyClient = PgAnyClient> extends AbstractPoolQuerier<C> {
+    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>;
+    protected releaseConn(conn: C, discard: boolean): Promise<void>;
 }

package/dist/postgres/pgQuerier.js

@@ -1,3 +1,30 @@
-import { AbstractPgQuerier } from './abstractPgQuerier.js';
-export class PgQuerier extends AbstractPgQuerier {
+import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
+/**
+ * Querier for every client with node-postgres' API: `pg` itself, for Postgres and CockroachDB, and
+ * Neon's serverless driver. Generic over the client alone - the dialect is whichever the pool built.
+ */
+export class PgQuerier extends AbstractPoolQuerier {
+    async internalAll(query, values) {
+        const res = await this.getConn().query(query, values);
+        return res.rows;
+    }
+    async internalRun(query, values) {
+        const res = await this.getConn().query(query, values);
+        return this.buildUpdateResult({ rows: res.rows, changes: res.rowCount ?? 0 });
+    }
+    async *internalStream(query, values) {
+        const { default: QueryStream } = await import('pg-query-stream');
+        const stream = this.getConn().query(new QueryStream(query, values));
+        try {
+            for await (const row of stream) {
+                yield row;
+            }
+        }
+        finally {
+            stream.destroy();
+        }
+    }
+    async releaseConn(conn, discard) {
+        await conn.release(discard);
+    }
 }

package/dist/postgres/pgQuerierPool.d.ts

@@ -1,10 +1,8 @@
 import { Pool, type PoolClient, type PoolConfig } from 'pg';
 import type { ExtraOptions } from '../type/index.js';
 import { AbstractPgQuerierPool } from './abstractPgQuerierPool.js';
-import { PgDialect } from './pgDialect.js';
-import { PgQuerier } from './pgQuerier.js';
-export declare class PgQuerierPool extends AbstractPgQuerierPool<PoolClient, PgQuerier, PgDialect> {
+import { PostgresDialect } from './postgresDialect.js';
+export declare class PgQuerierPool extends AbstractPgQuerierPool<PoolClient, PostgresDialect> {
     readonly pool: Pool;
     constructor(opts: PoolConfig, extra?: ExtraOptions);
-    protected buildQuerier(connect: () => Promise<PoolClient>): PgQuerier;
 }

package/dist/postgres/pgQuerierPool.js

@@ -1,16 +1,12 @@
 import { Pool, types } from 'pg';
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractPgQuerierPool } from './abstractPgQuerierPool.js';
-import { PgDialect } from './pgDialect.js';
 import { numericTypes } from './pgNumericTypes.js';
-import { PgQuerier } from './pgQuerier.js';
+import { PostgresDialect } from './postgresDialect.js';
 export class PgQuerierPool extends AbstractPgQuerierPool {
     constructor(opts, extra) {
         // keepAlive reduces (but can't eliminate) idle connections being silently
         // dropped by NATs/firewalls on long-lived remote connections.
-        super(new PgDialect(dialectOptionsFrom(extra)), new Pool({ keepAlive: true, types: numericTypes(types), ...opts }), extra);
-    }
-    buildQuerier(connect) {
-        return new PgQuerier(connect, this.dialect, this.extra);
+        super(new PostgresDialect(dialectOptionsFrom(extra)), new Pool({ keepAlive: true, types: numericTypes(types), ...opts }), extra);
     }
 }

package/dist/postgres/postgresDialect.d.ts

@@ -1,11 +1,11 @@
 import { PgLikeSqlDialect } from '../dialect/pgLikeSqlDialect.js';
 import type { QueryConflictPaths, QueryContext, SqlDialectName, Type } from '../type/index.js';
 /**
- * PostgreSQL dialect. For node-pg use PgDialect. Neon, Bun SQL, and Cockroach use driver-specific
- * subclasses. Shared Postgres-wire AST/quoting/JSONB/full-text-search/vector-search logic
- * (including BIGINT IDENTITY PKs) lives in {@link PgLikeSqlDialect}; this class adds what's
- * Postgres-only: the `vector` extension requirement, pgvector's index syntax, and `xmax`-based
- * upsert `created` detection.
+ * PostgreSQL dialect, the same class under every Postgres driver - `pg`, Neon, PGlite, `bun:sql` -
+ * where a driver that binds differently passes `driverCapabilities` rather than subclassing it.
+ * Shared Postgres-wire AST/quoting/JSONB/full-text-search/vector-search logic (including BIGINT
+ * IDENTITY PKs) lives in {@link PgLikeSqlDialect}; this class adds what's Postgres-only: the `vector`
+ * extension requirement, pgvector's index syntax, and `xmax`-based upsert `created` detection.
  */
 export declare class PostgresDialect extends PgLikeSqlDialect {
     readonly dialectName: SqlDialectName;

package/dist/postgres/postgresDialect.js

@@ -2,11 +2,11 @@ import { COUNT_ALIAS } from '../dialect/aliases.js';
 import { PgLikeSqlDialect } from '../dialect/pgLikeSqlDialect.js';
 import { getMeta } from '../entity/index.js';
 /**
- * PostgreSQL dialect. For node-pg use PgDialect. Neon, Bun SQL, and Cockroach use driver-specific
- * subclasses. Shared Postgres-wire AST/quoting/JSONB/full-text-search/vector-search logic
- * (including BIGINT IDENTITY PKs) lives in {@link PgLikeSqlDialect}; this class adds what's
- * Postgres-only: the `vector` extension requirement, pgvector's index syntax, and `xmax`-based
- * upsert `created` detection.
+ * PostgreSQL dialect, the same class under every Postgres driver - `pg`, Neon, PGlite, `bun:sql` -
+ * where a driver that binds differently passes `driverCapabilities` rather than subclassing it.
+ * Shared Postgres-wire AST/quoting/JSONB/full-text-search/vector-search logic (including BIGINT
+ * IDENTITY PKs) lives in {@link PgLikeSqlDialect}; this class adds what's Postgres-only: the `vector`
+ * extension requirement, pgvector's index syntax, and `xmax`-based upsert `created` detection.
  */
 export class PostgresDialect extends PgLikeSqlDialect {
     dialectName = 'postgres';

package/dist/postgres/postgresWireDriverCapabilities.d.ts

@@ -9,11 +9,11 @@
  *
  * The pair is one constant because it is one driver's shape, and `BunSqlQuerierPool` hands it to
  * `PostgresDialect`/`CockroachDialect` as their `driverCapabilities` rather than subclassing either:
- * Bun changes how a parameter binds, never the SQL. `PgDialect` uses neither, keeping the base
+ * Bun changes how a parameter binds, never the SQL. `PgQuerierPool` uses neither, keeping the base
  * {@link PgLikeSqlDialect} defaults, since node-`pg` needs no fix.
  *
  * @remarks Optional import for custom pools. Neon uses its own serverless driver (not `bun:sql`),
- * so `NeonDialect` is a separate, unverified case - do not assume it needs this without testing.
+ * so `NeonQuerierPool` is a separate, unverified case - do not assume it needs this without testing.
  */
 export declare const POSTGRES_WIRE_DRIVER_CAPABILITIES: {
     readonly nativeArrays: false;

package/dist/postgres/postgresWireDriverCapabilities.js

@@ -9,11 +9,11 @@
  *
  * The pair is one constant because it is one driver's shape, and `BunSqlQuerierPool` hands it to
  * `PostgresDialect`/`CockroachDialect` as their `driverCapabilities` rather than subclassing either:
- * Bun changes how a parameter binds, never the SQL. `PgDialect` uses neither, keeping the base
+ * Bun changes how a parameter binds, never the SQL. `PgQuerierPool` uses neither, keeping the base
  * {@link PgLikeSqlDialect} defaults, since node-`pg` needs no fix.
  *
  * @remarks Optional import for custom pools. Neon uses its own serverless driver (not `bun:sql`),
- * so `NeonDialect` is a separate, unverified case - do not assume it needs this without testing.
+ * so `NeonQuerierPool` is a separate, unverified case - do not assume it needs this without testing.
  */
 export const POSTGRES_WIRE_DRIVER_CAPABILITIES = {
     nativeArrays: false,

package/dist/querier/abstractPoolQuerier.d.ts

@@ -6,7 +6,7 @@ export declare abstract class AbstractPoolQuerier<C> extends AbstractSqlQuerier
     readonly extra?: ExtraOptions | undefined;
     protected conn: C | undefined;
     protected getConn(): C;
-    constructor(dialect: AbstractSqlDialect, connect: () => Promise<C>, extra?: ExtraOptions | undefined);
+    constructor(connect: () => Promise<C>, dialect: AbstractSqlDialect, extra?: ExtraOptions | undefined);
     protected lazyConnect(): Promise<void>;
     internalRelease(discard: boolean): Promise<void>;
     protected abstract releaseConn(conn: C, discard: boolean): Promise<void>;

package/dist/querier/abstractPoolQuerier.js

@@ -8,7 +8,7 @@ export class AbstractPoolQuerier extends AbstractSqlQuerier {
             throw new TypeError('pool querier not connected');
         return this.conn;
     }
-    constructor(dialect, connect, extra) {
+    constructor(connect, dialect, extra) {
         super(dialect, extra);
         this.connect = connect;
         this.extra = extra;

package/dist/querier/abstractSqlQuerier.d.ts

@@ -129,14 +129,21 @@ export declare abstract class AbstractSqlQuerier extends AbstractQuerier impleme
     protected internalDeleteMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
     get hasOpenTransaction(): boolean;
     beginTransaction(opts?: TransactionOptions): Promise<void>;
+    /**
+     * 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.
+     */
     commitTransaction(): Promise<void>;
     rollbackTransaction(): Promise<void>;
     /**
-     * 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.
      */
-    private endTransactionWith;
+    protected internalBegin(opts?: TransactionOptions): Promise<void>;
+    protected internalCommit(): Promise<void>;
+    protected internalRollback(): Promise<void>;
     /** Transaction statements skip `timed()`, so they attach their own query context to a failure. */
     private runTransactionCommand;
 }

package/dist/querier/abstractSqlQuerier.js

@@ -241,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);
         }
     }
     /**
@@ -261,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
@@ -504,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/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>;
 }

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