uql-orm 0.53.0 → 0.55.0

package/dist/mssql/mssqlQuerier.js

@@ -8,9 +8,6 @@ import { decodeWireTypes } from './mssqlWireTypes.js';
  */
 export class MsSqlQuerier extends AbstractPoolQuerier {
     #transaction;
-    constructor(connect, dialect, extra) {
-        super(dialect, connect, extra);
-    }
     /**
      * Values bind by name, `@p1` upward, matching {@link MsSqlDialect.placeholder}. `tedious` infers
      * a type from the JS value, which is why a `Date` and a `Uint8Array` reach it unconverted - the
@@ -26,9 +23,6 @@ export class MsSqlQuerier extends AbstractPoolQuerier {
         return decodeWireTypes(res.recordset, res.recordset?.columns);
     }
     async internalRun(query, values) {
-        if (await this.#driveTransaction(query)) {
-            return { changes: 0 };
-        }
         const res = (await this.#request(values).query(query));
         return this.buildUpdateResult({
             // `rowsAffected` carries one entry per statement, and a `MERGE` upsert emits its `OUTPUT`
@@ -38,57 +32,24 @@ export class MsSqlQuerier extends AbstractPoolQuerier {
         });
     }
     /**
-     * `tedious` streams by event, not by async iterator, so rows are handed over as they arrive rather
-     * than collected first - buffering the whole result set would make this `all()` with extra steps.
-     * The `query` promise is awaited at the end so its rejection surfaces rather than going unhandled.
+     * The driver's own stream over the request, which pauses the request while the loop is behind, so
+     * rows arrive only as fast as they are read. A failure the driver reports through the promise alone
+     * would leave the loop waiting for rows, so it ends the stream instead.
      */
     async *internalStream(query, values) {
         const request = this.#request(values);
-        request.stream = true;
-        let pending = [];
-        let done = false;
-        let failure;
-        let wake;
-        const arrived = () => {
-            wake?.();
-            wake = undefined;
-        };
-        request.on('row', (row) => {
-            pending.push(row);
-            arrived();
-        });
-        request.on('error', (err) => {
-            failure ??= err;
-            arrived();
-        });
-        request.on('done', () => {
-            done = true;
-            arrived();
-        });
+        const rows = request.toReadableStream();
         const completed = request.query(query).catch((err) => {
-            failure ??= err instanceof Error ? err : new Error(String(err));
-            arrived();
+            rows.destroy(err instanceof Error ? err : new Error(String(err)));
         });
         try {
-            while (true) {
-                if (pending.length) {
-                    const batch = pending;
-                    pending = [];
-                    yield* batch;
-                    continue;
-                }
-                if (failure)
-                    throw failure;
-                if (done)
-                    return;
-                await new Promise((resolve) => {
-                    wake = resolve;
-                });
+            for await (const row of rows) {
+                yield row;
             }
         }
         finally {
-            // `completed` is awaited rather than left floating so a late rejection is handled; its own
-            // `catch` has already recorded it, and the loop above is what raises one to the caller.
+            // The cancel reports itself as an error on the stream, and the loop that would hear it is gone.
+            rows.on('error', () => { });
             request.cancel();
             await completed;
         }
@@ -96,24 +57,23 @@ export class MsSqlQuerier extends AbstractPoolQuerier {
     /**
      * `mssql` owns its pool and hands out a `Request` per call, so a `BEGIN TRANSACTION` sent as text
      * would open one on a connection the next call may not be given. Its `Transaction` object is the
-     * only thing that pins them together, so the three commands the dialect names are driven through
-     * it here instead of being sent. Compared against the dialect's own strings rather than literals,
-     * so renaming one cannot silently turn it back into text.
+     * only thing that pins them together, so the transaction is that object rather than statements, and
+     * the level goes to its `begin`: sent as a statement it would land on whichever connection served it.
      */
-    async #driveTransaction(query) {
-        const { beginTransactionCommand, commitTransactionCommand, rollbackTransactionCommand } = this.dialect;
-        if (query.startsWith(beginTransactionCommand)) {
-            this.#transaction = this.getConn().transaction();
-            await this.#transaction.begin(isolationLevelOf(query.slice(beginTransactionCommand.length)));
-            return true;
-        }
-        if (query !== commitTransactionCommand && query !== rollbackTransactionCommand) {
-            return false;
-        }
+    async internalBegin(opts) {
+        const transaction = this.getConn().transaction();
+        await transaction.begin(opts?.isolationLevel && ISOLATION_LEVEL[ISOLATION[opts.isolationLevel]]);
+        this.#transaction = transaction;
+    }
+    async internalCommit() {
+        const transaction = this.#transaction;
+        this.#transaction = undefined;
+        await transaction?.commit();
+    }
+    async internalRollback() {
         const transaction = this.#transaction;
         this.#transaction = undefined;
-        await (query === commitTransactionCommand ? transaction?.commit() : transaction?.rollback());
-        return true;
+        await transaction?.rollback();
     }
     /** The pool owns the socket; releasing a querier only drops this one's claim on it. */
     async releaseConn(_conn, _discard) {
@@ -123,15 +83,10 @@ export class MsSqlQuerier extends AbstractPoolQuerier {
         await transaction?.rollback().catch(() => undefined);
     }
 }
-/**
- * The driver constant for the level the dialect spelled into its `BEGIN`, so it applies to the
- * connection the transaction actually opens on. Undefined leaves the server's own default.
- */
-function isolationLevelOf(suffix) {
-    const level = suffix
-        .replace(/^\s*ISOLATION LEVEL\s*/i, '')
-        .trim()
-        .toUpperCase()
-        .replaceAll(' ', '_');
-    return level ? ISOLATION_LEVEL[level] : undefined;
-}
+/** The driver's constant for each level UQL names; total, so a new level is a compile error here. */
+const ISOLATION = {
+    'read uncommitted': 'READ_UNCOMMITTED',
+    'read committed': 'READ_COMMITTED',
+    'repeatable read': 'REPEATABLE_READ',
+    serializable: 'SERIALIZABLE',
+};

package/dist/mssql/mssqlQuerierPool.js

@@ -1,6 +1,7 @@
 import { ConnectionPool } from 'mssql';
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { attachPoolErrorHandler } from '../util/index.js';
 import { MsSqlDialect } from './mssqlDialect.js';
 import { MsSqlQuerier } from './mssqlQuerier.js';
 export class MsSqlQuerierPool extends AbstractSqlQuerierPool {
@@ -9,6 +10,7 @@ export class MsSqlQuerierPool extends AbstractSqlQuerierPool {
     constructor(opts, extra) {
         super(new MsSqlDialect(dialectOptionsFrom(extra)), extra);
         this.pool = new ConnectionPool(opts);
+        attachPoolErrorHandler(this.pool, 'Idle SQL Server pool connection encountered an error', extra?.logger);
     }
     /**
      * `mssql` connects the pool as a whole rather than per checkout, so the promise is shared. A

package/dist/mssql/mssqlWireTypes.d.ts

@@ -14,10 +14,9 @@ type ColumnTypes = Record<string, {
  * reads, the ids an `OUTPUT` reports, raw SQL, counts, aggregates - where the ORM's own hydration
  * only ever sees entity reads.
  *
- * Exact to 2^53, which covers any generated id. A value past it keeps the string the driver gave,
- * because a number could no longer represent it: that is the one case where handing back the exact
- * text is more useful than handing back the type that was asked for. The lighter escape hatch for a
- * column that big is the declaration - `@Field({ type: String, columnType: 'bigint' })`.
+ * By the rule every driver here shares, `decodeWideNumber`: a number where one is exact, the driver's
+ * exact text past 2^53. The lighter escape hatch for a column that big is the declaration -
+ * `@Field({ type: String, columnType: 'bigint' })`.
  */
 export declare function decodeWireTypes<T>(rows: T[] | undefined, columns: ColumnTypes | undefined): T[];
 export {};

package/dist/mssql/mssqlWireTypes.js

@@ -1,3 +1,4 @@
+import { decodeWideNumber } from '../util/wideNumber.js';
 /**
  * Decode `BIGINT` as a JS number, leaving every other type to the driver.
  *
@@ -10,10 +11,9 @@
  * reads, the ids an `OUTPUT` reports, raw SQL, counts, aggregates - where the ORM's own hydration
  * only ever sees entity reads.
  *
- * Exact to 2^53, which covers any generated id. A value past it keeps the string the driver gave,
- * because a number could no longer represent it: that is the one case where handing back the exact
- * text is more useful than handing back the type that was asked for. The lighter escape hatch for a
- * column that big is the declaration - `@Field({ type: String, columnType: 'bigint' })`.
+ * By the rule every driver here shares, `decodeWideNumber`: a number where one is exact, the driver's
+ * exact text past 2^53. The lighter escape hatch for a column that big is the declaration -
+ * `@Field({ type: String, columnType: 'bigint' })`.
  */
 export function decodeWireTypes(rows, columns) {
     if (!rows?.length || !columns) {
@@ -29,10 +29,7 @@ export function decodeWireTypes(rows, columns) {
         for (const name of wide) {
             const value = decoded[name];
             if (typeof value === 'string') {
-                const asNumber = Number(value);
-                if (Number.isSafeInteger(asNumber)) {
-                    decoded[name] = asNumber;
-                }
+                decoded[name] = decodeWideNumber(value);
             }
         }
         return decoded;

package/dist/mysql/index.d.ts

@@ -1,4 +1,3 @@
-export * from './mysql2Dialect.js';
 export * from './mysql2Querier.js';
 export * from './mysql2QuerierPool.js';
 export * from './mysqlDialect.js';

package/dist/mysql/index.js

@@ -1,4 +1,3 @@
-export * from './mysql2Dialect.js';
 export * from './mysql2Querier.js';
 export * from './mysql2QuerierPool.js';
 export * from './mysqlDialect.js';

package/dist/mysql/mysql2Querier.d.ts

@@ -1,11 +1,8 @@
 import type { PoolConnection } from 'mysql2/promise';
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
-import type { ExtraOptions } from '../type/index.js';
-import type { MySqlDialect } from './mysqlDialect.js';
 export declare class MySql2Querier extends AbstractPoolQuerier<PoolConnection> {
-    constructor(connect: () => Promise<PoolConnection>, dialect: MySqlDialect, extra?: ExtraOptions);
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
-    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
+    internalRun(query: string, values?: unknown[]): Promise<import("../index.js").QueryUpdateResult>;
     internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
     protected releaseConn(conn: PoolConnection, discard: boolean): Promise<void>;
 }

package/dist/mysql/mysql2Querier.js

@@ -1,8 +1,5 @@
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
 export class MySql2Querier extends AbstractPoolQuerier {
-    constructor(connect, dialect, extra) {
-        super(dialect, connect, extra);
-    }
     async internalAll(query, values) {
         const [res] = await this.getConn().query(query, values);
         return res;

package/dist/mysql/mysql2QuerierPool.d.ts

@@ -1,9 +1,9 @@
 import { type Pool, type PoolOptions } from 'mysql2/promise';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.js';
-import { MySql2Dialect } from './mysql2Dialect.js';
 import { MySql2Querier } from './mysql2Querier.js';
-export declare class MySql2QuerierPool extends AbstractSqlQuerierPool<MySql2Querier, MySql2Dialect> {
+import { MySqlDialect } from './mysqlDialect.js';
+export declare class MySql2QuerierPool extends AbstractSqlQuerierPool<MySql2Querier, MySqlDialect> {
     readonly pool: Pool;
     constructor(opts: PoolOptions, extra?: ExtraOptions);
     getQuerier(): Promise<MySql2Querier>;

package/dist/mysql/mysql2QuerierPool.js

@@ -1,13 +1,15 @@
 import { createPool } from 'mysql2/promise';
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
-import { MySql2Dialect } from './mysql2Dialect.js';
 import { MySql2Querier } from './mysql2Querier.js';
+import { MySqlDialect } from './mysqlDialect.js';
 export class MySql2QuerierPool extends AbstractSqlQuerierPool {
     pool;
     constructor(opts, extra) {
-        super(new MySql2Dialect(dialectOptionsFrom(extra)), extra);
-        this.pool = createPool(opts);
+        super(new MySqlDialect(dialectOptionsFrom(extra)), extra);
+        // A BIGINT past 2^53 as its exact text rather than a rounded number, the rule every driver here
+        // decodes by (`decodeWideNumber`); within that range it stays a number, and DECIMAL is untouched.
+        this.pool = createPool({ supportBigNumbers: true, ...opts });
     }
     async getQuerier() {
         return new MySql2Querier(() => this.pool.getConnection(), this.dialect, this.extra);

package/dist/neon/index.d.ts

@@ -1,3 +1 @@
-export * from './neonDialect.js';
-export * from './neonQuerier.js';
 export * from './neonQuerierPool.js';

package/dist/neon/index.js

@@ -1,3 +1 @@
-export * from './neonDialect.js';
-export * from './neonQuerier.js';
 export * from './neonQuerierPool.js';

package/dist/neon/neonQuerierPool.d.ts

@@ -1,10 +1,8 @@
 import { Pool, type PoolClient, type PoolConfig } from '@neondatabase/serverless';
 import { AbstractPgQuerierPool } from '../postgres/abstractPgQuerierPool.js';
+import { PostgresDialect } from '../postgres/postgresDialect.js';
 import type { ExtraOptions } from '../type/index.js';
-import { NeonDialect } from './neonDialect.js';
-import { NeonQuerier } from './neonQuerier.js';
-export declare class NeonQuerierPool extends AbstractPgQuerierPool<PoolClient, NeonQuerier, NeonDialect> {
+export declare class NeonQuerierPool extends AbstractPgQuerierPool<PoolClient, PostgresDialect> {
     readonly pool: Pool;
     constructor(opts: PoolConfig, extra?: ExtraOptions);
-    protected buildQuerier(connect: () => Promise<PoolClient>): NeonQuerier;
 }

package/dist/neon/neonQuerierPool.js

@@ -2,14 +2,10 @@ import { Pool, types } from '@neondatabase/serverless';
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractPgQuerierPool } from '../postgres/abstractPgQuerierPool.js';
 import { numericTypes } from '../postgres/pgNumericTypes.js';
-import { NeonDialect } from './neonDialect.js';
-import { NeonQuerier } from './neonQuerier.js';
+import { PostgresDialect } from '../postgres/postgresDialect.js';
 export class NeonQuerierPool extends AbstractPgQuerierPool {
     constructor(opts, extra) {
         // Neon's own `types`, not `pg`'s: this entry has to load on an edge runtime where `pg` is absent.
-        super(new NeonDialect(dialectOptionsFrom(extra)), new Pool({ types: numericTypes(types), ...opts }), extra);
-    }
-    buildQuerier(connect) {
-        return new NeonQuerier(connect, this.dialect, this.extra);
+        super(new PostgresDialect(dialectOptionsFrom(extra)), new Pool({ types: numericTypes(types), ...opts }), extra);
     }
 }

package/dist/pglite/index.d.ts

@@ -1,3 +1,2 @@
-export * from './pgliteDialect.js';
 export * from './pgliteQuerier.js';
 export * from './pgliteQuerierPool.js';

package/dist/pglite/index.js

@@ -1,3 +1,2 @@
-export * from './pgliteDialect.js';
 export * from './pgliteQuerier.js';
 export * from './pgliteQuerierPool.js';

package/dist/pglite/pgliteQuerier.d.ts

@@ -1,6 +1,6 @@
+import type { PostgresDialect } from '../postgres/postgresDialect.js';
 import { AbstractSqlQuerier } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.js';
-import type { PgliteDialect } from './pgliteDialect.js';
 /**
  * Structural subset of the `@electric-sql/pglite` API actually used here, declared locally so this
  * package does not couple its published types to a pre-1.0 dependency.
@@ -20,7 +20,7 @@ export type PgliteDatabase = {
 /**
  * Querier for PGlite, Postgres compiled to WASM and run in this process.
  *
- * @remarks Extends {@link AbstractSqlQuerier} rather than `AbstractPgQuerier`, whose `internalStream`
+ * @remarks Extends {@link AbstractSqlQuerier} rather than `PgQuerier`, whose `internalStream`
  * hands a `pg-query-stream` object to `query()`, which PGlite's client has no equivalent of - so
  * streaming pages the rows in SQL instead. `BEGIN`/`COMMIT` are plain statements on the single
  * connection, leaving transactions to the base class.
@@ -28,7 +28,7 @@ export type PgliteDatabase = {
 export declare class PgliteQuerier extends AbstractSqlQuerier {
     readonly db: PgliteDatabase;
     readonly extra?: ExtraOptions | undefined;
-    constructor(db: PgliteDatabase, dialect: PgliteDialect, extra?: ExtraOptions | undefined);
+    constructor(db: PgliteDatabase, dialect: PostgresDialect, extra?: ExtraOptions | undefined);
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
     internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
     /** Postgres compiled to WASM is still Postgres: `DECLARE`/`FETCH` streams what the client cannot. */

package/dist/pglite/pgliteQuerier.js

@@ -3,7 +3,7 @@ import { AbstractSqlQuerier } from '../querier/index.js';
 /**
  * Querier for PGlite, Postgres compiled to WASM and run in this process.
  *
- * @remarks Extends {@link AbstractSqlQuerier} rather than `AbstractPgQuerier`, whose `internalStream`
+ * @remarks Extends {@link AbstractSqlQuerier} rather than `PgQuerier`, whose `internalStream`
  * hands a `pg-query-stream` object to `query()`, which PGlite's client has no equivalent of - so
  * streaming pages the rows in SQL instead. `BEGIN`/`COMMIT` are plain statements on the single
  * connection, leaving transactions to the base class.

package/dist/pglite/pgliteQuerierPool.d.ts

@@ -1,7 +1,7 @@
 import type { PGliteOptions } from '@electric-sql/pglite';
+import { PostgresDialect } from '../postgres/postgresDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import type { ExtraOptions } from '../type/index.js';
-import { PgliteDialect } from './pgliteDialect.js';
 import { type PgliteDatabase, PgliteQuerier } from './pgliteQuerier.js';
 /**
  * The driver's own options, minus the `dataDir` this pool takes as its first argument.
@@ -26,8 +26,13 @@ export type PglitePoolOptions = Omit<PGliteOptions, 'dataDir'>;
  * The cost is that PGlite cannot see the transaction, so it flushes to the filesystem after each
  * statement within one: pass `relaxedDurability: true` on a persistent `dataDir` to skip waiting on
  * those flushes.
+ *
+ * The dialect is plain `PostgresDialect`, `dialectName` included: PGlite *is* Postgres, so the
+ * introspector, schema generator and CLI resolve to Postgres's. Both driver capabilities hold as
+ * they are - PGlite serializes every built-in array type itself, and the `$n::jsonb` cast is what
+ * makes its `Describe` report JSONB and pick its JSON serializer; a bare `$n` binds `[object Object]`.
  */
-export declare class PgliteQuerierPool extends AbstractSharedHandleQuerierPool<PgliteDatabase, PgliteQuerier, PgliteDialect> {
+export declare class PgliteQuerierPool extends AbstractSharedHandleQuerierPool<PgliteDatabase, PgliteQuerier, PostgresDialect> {
     readonly dataDir: string;
     readonly opts?: PglitePoolOptions | undefined;
     constructor(dataDir?: string, opts?: PglitePoolOptions | undefined, extra?: ExtraOptions);

package/dist/pglite/pgliteQuerierPool.js

@@ -1,6 +1,7 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
+import { PostgresDialect } from '../postgres/postgresDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
-import { PgliteDialect } from './pgliteDialect.js';
+import { decodeWideNumber } from '../util/wideNumber.js';
 import { PgliteQuerier } from './pgliteQuerier.js';
 /**
  * Pool for PGlite, Postgres compiled to WASM and run in this process. No server, no container.
@@ -16,20 +17,29 @@ import { PgliteQuerier } from './pgliteQuerier.js';
  * The cost is that PGlite cannot see the transaction, so it flushes to the filesystem after each
  * statement within one: pass `relaxedDurability: true` on a persistent `dataDir` to skip waiting on
  * those flushes.
+ *
+ * The dialect is plain `PostgresDialect`, `dialectName` included: PGlite *is* Postgres, so the
+ * introspector, schema generator and CLI resolve to Postgres's. Both driver capabilities hold as
+ * they are - PGlite serializes every built-in array type itself, and the `$n::jsonb` cast is what
+ * makes its `Describe` report JSONB and pick its JSON serializer; a bare `$n` binds `[object Object]`.
  */
 export class PgliteQuerierPool extends AbstractSharedHandleQuerierPool {
     dataDir;
     opts;
     constructor(dataDir = 'memory://', opts, extra) {
-        super(new PgliteDialect(dialectOptionsFrom(extra)), extra);
+        super(new PostgresDialect(dialectOptionsFrom(extra)), extra);
         this.dataDir = dataDir;
         this.opts = opts;
     }
     async openDb() {
-        const { PGlite } = await import('@electric-sql/pglite');
-        // The declared return type is what checks {@link PgliteDatabase} against the real driver, so no
-        // cast is needed here or anywhere below it.
-        return PGlite.create(this.dataDir, this.opts);
+        const { PGlite, types } = await import('@electric-sql/pglite');
+        // INT8 by the one wide-integer rule, where PGlite's own answers a `bigint` past 2^53; a caller's own
+        // `parsers` still win. The declared return type is what checks {@link PgliteDatabase} against the
+        // real driver, so no cast is needed here or anywhere below it.
+        return PGlite.create(this.dataDir, {
+            ...this.opts,
+            parsers: { [types.INT8]: decodeWideNumber, ...this.opts?.parsers },
+        });
     }
     buildQuerier(db) {
         return new PgliteQuerier(db, this.dialect, this.extra);

package/dist/postgres/abstractPgQuerierPool.d.ts

@@ -2,26 +2,22 @@ import type { AbstractSqlDialect } from '../dialect/index.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.js';
 import { type ErrorEmittingPool } from '../util/index.js';
-import type { AbstractPgQuerier, PgAnyClient } from './abstractPgQuerier.js';
+import { type PgAnyClient, PgQuerier } from './pgQuerier.js';
 export interface PgAnyPool<C extends PgAnyClient> extends ErrorEmittingPool {
     connect: () => Promise<C>;
     end: () => Promise<void>;
 }
 /**
- * Shared base class for Postgres-compatible querier pools.
+ * Shared base class for Postgres-compatible querier pools. Each hands out a {@link PgQuerier} over its
+ * driver's client, so a subclass supplies only the dialect and the driver's pool.
  *
- * Wires the crash-preventing error handler here, once, so a new pg-compatible
- * pool subclass can't be added without it - the constructor takes the already
- * constructed pool and attaches the handler unconditionally.
+ * Wires the crash-preventing error handler here, once, so a new pg-compatible pool subclass can't be
+ * added without it - the constructor takes the already constructed pool and attaches the handler
+ * unconditionally.
  */
-export declare abstract class AbstractPgQuerierPool<C extends PgAnyClient, Q extends AbstractPgQuerier<C, D>, D extends AbstractSqlDialect> extends AbstractSqlQuerierPool<Q, D> {
+export declare abstract class AbstractPgQuerierPool<C extends PgAnyClient, D extends AbstractSqlDialect> extends AbstractSqlQuerierPool<PgQuerier<C>, D> {
     readonly pool: PgAnyPool<C>;
     constructor(dialect: D, pool: PgAnyPool<C>, extra?: ExtraOptions);
-    /**
-     * Every pg-compatible pool acquires a client the same way, so only the querier class varies.
-     * Subclasses name that instead of restating the lazy `connect` the querier expects.
-     */
-    protected abstract buildQuerier(connect: () => Promise<C>): Q;
-    getQuerier(): Promise<Q>;
+    getQuerier(): Promise<PgQuerier<C>>;
     end(): Promise<void>;
 }

package/dist/postgres/abstractPgQuerierPool.js

@@ -1,21 +1,23 @@
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import { attachPoolErrorHandler } from '../util/index.js';
+import { PgQuerier } from './pgQuerier.js';
 /**
- * Shared base class for Postgres-compatible querier pools.
+ * Shared base class for Postgres-compatible querier pools. Each hands out a {@link PgQuerier} over its
+ * driver's client, so a subclass supplies only the dialect and the driver's pool.
  *
- * Wires the crash-preventing error handler here, once, so a new pg-compatible
- * pool subclass can't be added without it - the constructor takes the already
- * constructed pool and attaches the handler unconditionally.
+ * Wires the crash-preventing error handler here, once, so a new pg-compatible pool subclass can't be
+ * added without it - the constructor takes the already constructed pool and attaches the handler
+ * unconditionally.
  */
 export class AbstractPgQuerierPool extends AbstractSqlQuerierPool {
     pool;
     constructor(dialect, pool, extra) {
         super(dialect, extra);
         this.pool = pool;
-        attachPoolErrorHandler(pool, 'Idle Postgres pool client encountered an error');
+        attachPoolErrorHandler(pool, 'Idle Postgres pool client encountered an error', extra?.logger);
     }
     async getQuerier() {
-        return this.buildQuerier(() => this.pool.connect());
+        return new PgQuerier(() => this.pool.connect(), this.dialect, this.extra);
     }
     async end() {
         await this.pool.end();

package/dist/postgres/index.d.ts

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

package/dist/postgres/index.js

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

package/dist/postgres/pgNumericTypes.d.ts

@@ -10,7 +10,8 @@ type PgTypes = {
     getTypeParser(oid: number, format?: 'text' | 'binary'): (value: string) => unknown;
 };
 /**
- * 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
@@ -32,10 +33,9 @@ type PgTypes = {
  * `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 declare function numericTypes(types: PgTypes): CustomTypesConfig;
 export {};

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