uql-orm 0.54.0 → 0.56.0

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

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

@@ -1,5 +1,5 @@
-import { assertSoleId, getMeta, idOf, namesKey, soleIdOf } from '../entity/index.js';
-import { asSelectMap, childrenOf, clone, dataKeyed, fillOnFields, filterPersistableRelationKeys, forEachRequestedRelation, getKeys, getRelationRequestSummary, idOnlyQuery, isScalarId, joinedColumns, keyColumns, LoggerWrapper, isBoundedPerParent, parentJoins, queryChildrenOfAll, parseRelationAtKey, parseRelationQueryValue, rowKey, runHooks, someKey, targetKeyColumns, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
+import { assertSoleId, getMeta, idOf, namesKey, relationOf, soleIdOf } from '../entity/index.js';
+import { asSelectMap, childrenOf, clone, dataKeyed, entityName, fillOnFields, filterPersistableRelationKeys, forEachRequestedRelation, getKeys, getRelationRequestSummary, idOnlyQuery, isScalarId, joinedColumns, keyColumns, LoggerWrapper, isBoundedPerParent, parentJoins, queryChildrenOfAll, queryLoggerFor, parseRelationAtKey, parseRelationQueryValue, rowKey, runHooks, someKey, targetKeyColumns, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { enrichError } from './queryError.js';
 import { fillRelationCounts, withIdForCounts } from './relationCount.js';
 /**
@@ -78,13 +78,10 @@ export class AbstractQuerier {
     logger;
     constructor(extra) {
         this.extra = extra;
-        this.logger = new LoggerWrapper(extra?.logger, {
-            logValues: extra?.logValues,
-            slowQuery: extra?.slowQuery,
-        });
+        this.logger = queryLoggerFor(extra);
     }
     validateProjectionQuery(entity, q) {
-        this.validateProjectionQueryRecursive(entity, q, getMeta(entity).name ?? entity.name);
+        this.validateProjectionQueryRecursive(entity, q, entityName(getMeta(entity)));
     }
     validateProjectionQueryRecursive(entity, q, path) {
         const meta = getMeta(entity);
@@ -96,9 +93,7 @@ export class AbstractQuerier {
             }
         }
         forEachRequestedRelation(meta, q.$populate, (relKey, relValue) => {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                return;
+            const relOpts = relationOf(meta, relKey);
             const relEntity = relOpts.entity();
             const parsed = parseRelationQueryValue(relValue);
             if (parsed.nested) {
@@ -136,8 +131,14 @@ export class AbstractQuerier {
         const [entity, q, opts] = this.resolveEntityQuery(entityOrQuery, maybeQueryOrOpts, maybeOpts);
         this.validateProjectionQuery(entity, q);
         const founds = await this.internalFindMany(entity, withIdForCounts(entity, q), opts);
-        await fillRelationCounts(this, entity, founds, q.$count);
-        await this.emitHook(entity, 'afterLoad', founds);
+        // Guarded here rather than only inside: awaiting a call that returns at once still costs every read
+        // a promise and a turn of the microtask queue, and most reads count nothing and hook nothing.
+        if (q.$count) {
+            await fillRelationCounts(this, entity, founds, q.$count);
+        }
+        if (this.hasHook(entity, 'afterLoad')) {
+            await this.emitHook(entity, 'afterLoad', founds);
+        }
         return founds;
     }
     findManyStream(entityOrQuery, maybeQueryOrOpts, maybeOpts) {
@@ -348,9 +349,7 @@ export class AbstractQuerier {
         const meta = getMeta(entity);
         const relKeys = getRelationRequestSummary(meta, populate).toManyKeys;
         for (const relKey of relKeys) {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                continue;
+            const relOpts = relationOf(meta, relKey);
             const relEntity = relOpts.entity();
             const relationQuery = clone(parseRelationAtKey(relKey, populate).query);
             if (relOpts.through) {
@@ -498,9 +497,7 @@ export class AbstractQuerier {
         const relKeys = filterPersistableRelationKeys(meta, meta.relations, 'delete');
         // Cascade forwards `opts` (including `hardDelete`); each child soft-deletes only if it can.
         for (const relKey of relKeys) {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                continue;
+            const relOpts = relationOf(meta, relKey);
             const relEntity = relOpts.entity();
             const target = relOpts.through ? relOpts.through() : relEntity;
             const where = childrenOf(parentJoins(relOpts, meta.ids.length), ids);
@@ -514,9 +511,7 @@ export class AbstractQuerier {
      */
     async saveRelation(entity, ids, relValue, relKey, isUpdate) {
         const meta = getMeta(entity);
-        const relOpts = meta.relations[relKey];
-        if (!relOpts)
-            return;
+        const relOpts = relationOf(meta, relKey);
         // Here rather than only in the callers below: writing the parent's key into a child is one column
         // per key, so a composite takes a statement per parent. `soleParentColumn` and the sole
         // `targetKeyColumns` under it read the *first* pair, which is a real column of a wrong pairing
@@ -684,7 +679,7 @@ export class AbstractQuerier {
      * another one would wait for a task queued behind itself. Callers below keep their `serialize` calls
      * sequential rather than nested.
      */
-    async serialize(task) {
+    serialize(task) {
         const res = this.taskQueue.then(task);
         this.taskQueue = res.catch(() => { });
         return res;

package/dist/querier/abstractSqlQuerier.d.ts

@@ -100,14 +100,16 @@ export declare abstract class AbstractSqlQuerier extends AbstractQuerier impleme
      */
     protected internalStream<T>(query: string, values?: unknown[]): AsyncIterable<T>;
     /**
-     * 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.
+     */
+    private hydrateAll;
+    /**
+     * 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.
      */
     private hydrateFields;
     /**
@@ -129,14 +131,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;
 }