uql-orm 0.65.1 → 0.67.0

package/dist/mssql/mssqlDialect.js

@@ -10,34 +10,39 @@ import { parseQueryLock } from '../type/index.js';
 import { isAutoIncrement } from '../util/field.util.js';
 import { assertNonNegativeInteger } from '../util/index.js';
 import { escapeSingleQuotes } from '../util/sqlLiteral.js';
-/**
- * Microsoft SQL Server 2017 and up - the floor `STRING_AGG` sets, every other construct here being
- * 2016 or older.
- *
- * Identifiers are `"`-quoted rather than bracketed: `escapeIdChar` is one character that doubles to
- * escape itself, `"` is the ANSI spelling, and `tedious` enables `QUOTED_IDENTIFIER` by default.
- * Brackets would buy nothing and cost the shared dialect spec, which reads that one character.
- */
+/** What SQL Server has. */
+const MSSQL_FEATURES = {
+    // Neither object takes an `IF NOT EXISTS`; both need a `sys` catalogue lookup around them, which
+    // the generator does not emit.
+    ifNotExists: false,
+    indexIfNotExists: false,
+    schemas: true,
+    dropTableCascade: false,
+    foreignKeyAlter: true,
+    primaryKeyAlter: true,
+    generatedColumnAdd: true,
+    // Extended properties are out-of-band metadata with their own procedures, not comments.
+    commentSyntax: 'none',
+    vectorIndexRequiresNotNull: false,
+    vectorSupportsLength: true,
+    supportsTimestamptz: false,
+    stringSizing: 'varchar',
+    supportsUnsigned: false,
+    serverSideCursors: false,
+    rowLocks: true,
+    rowLockWithWindow: true,
+    rowLockOf: true,
+    orderedUpsertReturning: false,
+    orderedJsonAggregates: true,
+    partialJsonContainment: false,
+    typedJsonElements: false,
+    narrowVectorTypes: false,
+    vectorTuningNeedsTransaction: false,
+    serialDeclaresPrimaryKey: false,
+};
+/** Microsoft SQL Server 2017 and up. Identifiers are `"`-quoted, the ANSI spelling `tedious` enables. */
 export class MsSqlDialect extends MergeSqlDialect {
-    featureDefaults = {
-        // Neither object takes an `IF NOT EXISTS`; both need a `sys` catalogue lookup around them, which
-        // the generator does not emit.
-        ifNotExists: false,
-        indexIfNotExists: false,
-        schemas: true,
-        dropTableCascade: false,
-        foreignKeyAlter: true,
-        primaryKeyAlter: true,
-        generatedColumnAdd: true,
-        // Extended properties are out-of-band metadata with their own procedures, not comments.
-        commentSyntax: 'none',
-        vectorIndexRequiresNotNull: false,
-        vectorSupportsLength: true,
-        supportsTimestamptz: false,
-        stringSizing: 'varchar',
-        supportsUnsigned: false,
-        serverSideCursors: false,
-    };
+    features = MSSQL_FEATURES;
     dialectName = 'mssql';
     /** `OPENJSON`'s own output columns, which every JSON operator below reads through. */
     #elem = {
@@ -61,8 +66,6 @@ export class MsSqlDialect extends MergeSqlDialect {
     maxBindValues = 2100;
     /** `OUTPUT` has no trailing form: it sits between the column list and `VALUES`. */
     returningPosition = 'after-target';
-    /** Microsoft documents no row order for a `MERGE ... OUTPUT`. */
-    upsertReturningOrdered = false;
     insertIdSource = 'returning';
     /** Holds the update key lock across the insert; without it two concurrent upserts of one key race. */
     mergeTargetHint = ' WITH (HOLDLOCK)';
@@ -86,12 +89,8 @@ export class MsSqlDialect extends MergeSqlDialect {
         super.pager(ctx, opts, sorted);
     }
     /**
-     * `SET IDENTITY_INSERT` around the insert, where the payload states a key the engine would
-     * otherwise generate: writing one is refused outright ("cannot insert explicit value for identity
-     * column ... when IDENTITY_INSERT is set to OFF") rather than ignored.
-     *
-     * Emitted only for that case, because the setting is per-session and only one table may hold it at
-     * a time, so it is turned back off in the same batch it was turned on.
+     * `SET IDENTITY_INSERT` around an insert that states a key the engine would generate, which it otherwise
+     * refuses; turned off in the same batch, since one table per session may hold it.
      */
     insert(ctx, entity, payload, opts) {
         const table = this.identityInsertTarget(entity, payload);
@@ -115,13 +114,7 @@ export class MsSqlDialect extends MergeSqlDialect {
         const stated = records.some((record) => record[idKey] !== undefined);
         return stated ? this.escapedTableName(meta) : undefined;
     }
-    /**
-     * A `DECIMAL` read back as the exact text it was written as, where the entity declared the field a
-     * `String`. `tedious` decodes the type to a JS number before anything here can see it, so the
-     * digits past 2^53 are gone at the wire unless the column is converted before it crosses - the same
-     * reason MariaDB reads a vector column through `VEC_ToText`. 41 characters covers `DECIMAL(38, s)`
-     * with room for the sign and the point.
-     */
+    /** A `DECIMAL` declared `String`, converted before it crosses the wire, where `tedious` would round it. */
     selectFieldExpr(escapedColumn, field) {
         const exactDecimal = field.type === String && fieldOptionsToCanonical(field).category === 'decimal';
         return exactDecimal ? `CONVERT(NVARCHAR(41), ${escapedColumn})` : escapedColumn;
@@ -261,13 +254,8 @@ export class MsSqlDialect extends MergeSqlDialect {
         return this.getJsonPathScalarExpr(escapedColumn, jsonPathStr);
     }
     /**
-     * A value being *compared* against a JSON path, which reads back as the text `JSON_VALUE` yields:
-     * `'true'` for a boolean, `'12'` for a number. So only a boolean needs re-spelling; a number or a
-     * string already binds as the text it will be compared with.
-     *
-     * There is no "parse this text as JSON" cast to bind through the way `CAST(? AS JSON)` and
-     * `json(?)` serve the other families - `JSON_QUERY` marks text as JSON but answers NULL for a
-     * scalar - which is why reading and writing need the two different binders here.
+     * A value compared against a JSON path, which reads back as text, so only a boolean needs spelling as
+     * `'true'`; SQL Server has no cast that parses text as JSON.
      */
     jsonScalarParam(ctx, value) {
         return (this.#jsonCompound(ctx, value) ?? this.addValue(ctx, typeof value === 'boolean' ? JSON.stringify(value) : value));
@@ -298,8 +286,6 @@ export class MsSqlDialect extends MergeSqlDialect {
         }
         return `JSON_QUERY(${this.addValue(ctx, JSON.stringify(value))})`;
     }
-    /** An exploded element compares as text here, so `$elemMatch` always expands per field. */
-    jsonContainmentIsPartial = false;
     jsonElemFrom(jsonField, _fields, alias) {
         return `OPENJSON(${jsonField}) ${alias}`;
     }

package/dist/mssql/mssqlQuerier.d.ts

@@ -1,12 +1,44 @@
-import type { ConnectionPool } from 'mssql';
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
-import type { QueryUpdateResult, TransactionOptions } from '../type/index.js';
+import type { QueryUpdateResult, RawRow, TransactionOptions } from '../type/index.js';
+/** What `tedious` hands back for one statement, whichever shape it took. */
+type MsSqlResult = {
+    recordset?: RawRow[] & {
+        columns?: Record<string, {
+            type: unknown;
+        }>;
+    };
+    rowsAffected: number[];
+};
+/** The part of the `Readable` a request streams into that a querier drives. */
+type MsSqlRowStream = AsyncIterable<unknown> & {
+    destroy(error: Error): unknown;
+    on(event: 'error', listener: (error: Error) => void): unknown;
+};
+/** The part of an `mssql` `Request` a querier drives. */
+type MsSqlRequest = {
+    input(name: string, value: unknown): unknown;
+    query(command: string): Promise<MsSqlResult>;
+    toReadableStream(): MsSqlRowStream;
+    cancel(): unknown;
+};
+/** The part of an `mssql` `Transaction` a querier drives. */
+type MsSqlTransaction = {
+    begin(isolationLevel?: number): Promise<unknown>;
+    commit(): Promise<unknown>;
+    rollback(): Promise<unknown>;
+    request(): MsSqlRequest;
+};
+/** The part of an `mssql` `ConnectionPool` a querier drives. */
+export type MsSqlConnection = {
+    request(): MsSqlRequest;
+    transaction(): MsSqlTransaction;
+};
 /**
  * A connection is a `ConnectionPool` handle here rather than a checked-out socket: `mssql` owns its
  * own pool and hands out `Request`s, so what UQL holds is the pool plus, once a transaction opens,
  * the `Transaction` every later request has to be bound to.
  */
-export declare class MsSqlQuerier extends AbstractPoolQuerier<ConnectionPool> {
+export declare class MsSqlQuerier extends AbstractPoolQuerier<MsSqlConnection> {
     #private;
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
     internalRun(query: string, values?: unknown[]): Promise<QueryUpdateResult>;
@@ -26,5 +58,6 @@ export declare class MsSqlQuerier extends AbstractPoolQuerier<ConnectionPool> {
     protected internalCommit(): Promise<void>;
     protected internalRollback(): Promise<void>;
     /** The pool owns the socket; releasing a querier only drops this one's claim on it. */
-    protected releaseConn(_conn: ConnectionPool, _discard: boolean): Promise<void>;
+    protected releaseConn(_conn: MsSqlConnection, _discard: boolean): Promise<void>;
 }
+export {};

package/dist/mssql/mssqlQuerier.js

@@ -19,11 +19,11 @@ export class MsSqlQuerier extends AbstractPoolQuerier {
         return request;
     }
     async internalAll(query, values) {
-        const res = (await this.#request(values).query(query));
+        const res = await this.#request(values).query(query);
         return decodeWireTypes(res.recordset, res.recordset?.columns);
     }
     async internalRun(query, values) {
-        const res = (await this.#request(values).query(query));
+        const res = await this.#request(values).query(query);
         return this.buildUpdateResult({
             // `rowsAffected` carries one entry per statement, and a `MERGE` upsert emits its `OUTPUT`
             // alongside the write, so the counts are summed rather than read at [0].

package/dist/mssql/mssqlWireTypes.d.ts

@@ -3,20 +3,8 @@ type ColumnTypes = Record<string, {
     readonly type: unknown;
 }>;
 /**
- * Decode `BIGINT` as a JS number, leaving every other type to the driver.
- *
- * uql owes this to the caller because uql picks the column: `type: Number` maps to BIGINT (see
- * `schema/canonicalType.ts`), and `tedious` hands that back as a string to protect the digits past
- * 2^53 - so without this a field declared `number` reads back as `'9'`, including every generated
- * primary key on every entity.
- *
- * At the wire, for the reason `pgNumericTypes` gives: everything crosses it exactly once - entity
- * reads, the ids an `OUTPUT` reports, raw SQL, counts, aggregates - where the ORM's own hydration
- * only ever sees entity reads.
- *
- * 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' })`.
+ * Decodes `BIGINT`, which `tedious` returns as text, by `decodeWideNumber`: `type: Number` maps to
+ * BIGINT, so otherwise every generated key reads back as a string. At the wire, which every result crosses.
  */
 export declare function decodeWireTypes<T>(rows: T[] | undefined, columns: ColumnTypes | undefined): T[];
 export {};

package/dist/mssql/mssqlWireTypes.js

@@ -1,19 +1,7 @@
 import { decodeWideNumber } from '../util/wideNumber.js';
 /**
- * Decode `BIGINT` as a JS number, leaving every other type to the driver.
- *
- * uql owes this to the caller because uql picks the column: `type: Number` maps to BIGINT (see
- * `schema/canonicalType.ts`), and `tedious` hands that back as a string to protect the digits past
- * 2^53 - so without this a field declared `number` reads back as `'9'`, including every generated
- * primary key on every entity.
- *
- * At the wire, for the reason `pgNumericTypes` gives: everything crosses it exactly once - entity
- * reads, the ids an `OUTPUT` reports, raw SQL, counts, aggregates - where the ORM's own hydration
- * only ever sees entity reads.
- *
- * 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' })`.
+ * Decodes `BIGINT`, which `tedious` returns as text, by `decodeWideNumber`: `type: Number` maps to
+ * BIGINT, so otherwise every generated key reads back as a string. At the wire, which every result crosses.
  */
 export function decodeWireTypes(rows, columns) {
     if (!rows?.length || !columns) {

package/dist/nestjs/uqlModule.js

@@ -43,13 +43,8 @@ import { UqlContextInterceptor } from './uqlContextInterceptor.js';
  */
 export const UQL_QUERIER_POOL = Symbol('UQL_QUERIER_POOL');
 /**
- * Ends the pool when Nest shuts down.
- *
- * @remarks A provider rather than a hook on the module class, and built through `useFactory` with an
- * `inject` list rather than constructor injection: Nest injects constructor parameters with a parameter
- * decorator, and the TC39 decorator spec has none, so `@Inject()` cannot appear in a file compiled
- * against it. Nest runs lifecycle hooks on providers too, so this keeps the pool that *this* module was
- * configured with instead of reaching for the global default.
+ * Ends the pool this module was configured with when Nest shuts down: a provider built by `useFactory`,
+ * since TC39 decorators have no parameter decorator for `@Inject()`.
  */
 class UqlPoolLifecycle {
     pool;

package/dist/pglite/pgliteQuerier.d.ts

@@ -1,15 +1,7 @@
 import type { PostgresDialect } from '../postgres/postgresDialect.js';
 import { AbstractSqlQuerier } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.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.
- *
- * @remarks This is what uql *consumes* from the driver, so it is two methods and stating them costs
- * nothing. `PglitePoolOptions` is the opposite case and imports PGlite's own type: those options are
- * the caller's input to the driver, so restating them would mean re-deriving its whole option surface
- * and then casting at the `PGlite.create` call.
- */
+/** The two methods uql uses of `@electric-sql/pglite`, stated so its published types do not depend on a pre-1.0 package. */
 export type PgliteDatabase = {
     query<T>(query: string, params?: unknown[]): Promise<{
         rows: T[];

package/dist/pglite/pgliteQuerierPool.d.ts

@@ -3,34 +3,12 @@ import { PostgresDialect } from '../postgres/postgresDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import type { ExtraOptions } from '../type/index.js';
 import { type PgliteDatabase, PgliteQuerier } from './pgliteQuerier.js';
-/**
- * The driver's own options, minus the `dataDir` this pool takes as its first argument.
- *
- * @remarks Imported rather than restated so extensions and the filesystem hooks keep their real types:
- * `extensions: { vector }` from `@electric-sql/pglite-pgvector` is how a vector column becomes usable,
- * mirroring `LocalSqlitePoolOptions.extensions` for `sqlite-vec`. Type-only, like the `pg` imports in
- * `abstractPgQuerierPool.ts`, so nothing here reaches a runtime without the peer installed.
- */
+/** PGlite's own options but `dataDir`, the pool's first argument; `extensions: { vector }` enables pgvector. Type-only. */
 export type PglitePoolOptions = Omit<PGliteOptions, 'dataDir'>;
 /**
- * Pool for PGlite, Postgres compiled to WASM and run in this process. No server, no container.
- *
- * PGlite is single connection, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.
- * Where PGlite differs from the two SQLite-family pools there is that it does not refuse a second
- * `BEGIN`: a querier that opens a transaction while another already has one silently joins it, and that
- * one's `ROLLBACK` then discards both queriers' writes. Nothing reports it, so a unit of work that needs
- * a transaction of its own needs its own pool, and therefore its own database.
- *
- * @remarks Transactions are plain `BEGIN`/`COMMIT` statements rather than `db.transaction()`, whose
- * callback holds PGlite's transaction mutex and would block every other querier's reads until commit.
- * 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]`.
+ * A pool for PGlite, Postgres in WASM in this process, on one connection. A second `BEGIN` silently joins
+ * the open transaction, so a unit of work needing its own needs its own pool. Transactions are plain
+ * statements, so pass `relaxedDurability` on a persistent `dataDir` to skip a flush per statement.
  */
 export declare class PgliteQuerierPool extends AbstractSharedHandleQuerierPool<PgliteDatabase, PgliteQuerier, PostgresDialect> {
     readonly dataDir: string;

package/dist/pglite/pgliteQuerierPool.js

@@ -4,24 +4,9 @@ import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandle
 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.
- *
- * PGlite is single connection, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.
- * Where PGlite differs from the two SQLite-family pools there is that it does not refuse a second
- * `BEGIN`: a querier that opens a transaction while another already has one silently joins it, and that
- * one's `ROLLBACK` then discards both queriers' writes. Nothing reports it, so a unit of work that needs
- * a transaction of its own needs its own pool, and therefore its own database.
- *
- * @remarks Transactions are plain `BEGIN`/`COMMIT` statements rather than `db.transaction()`, whose
- * callback holds PGlite's transaction mutex and would block every other querier's reads until commit.
- * 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]`.
+ * A pool for PGlite, Postgres in WASM in this process, on one connection. A second `BEGIN` silently joins
+ * the open transaction, so a unit of work needing its own needs its own pool. Transactions are plain
+ * statements, so pass `relaxedDurability` on a persistent `dataDir` to skip a flush per statement.
  */
 export class PgliteQuerierPool extends AbstractSharedHandleQuerierPool {
     dataDir;

package/dist/postgres/abstractPgQuerierPool.d.ts

@@ -7,14 +7,7 @@ export interface PgAnyPool<C extends PgAnyClient> extends ErrorEmittingPool {
     connect: () => Promise<C>;
     end: () => Promise<void>;
 }
-/**
- * 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.
- */
+/** A Postgres-wire pool of {@link PgQuerier}s, attaching the error handler that keeps a dropped connection from crashing the process. */
 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);

package/dist/postgres/abstractPgQuerierPool.js

@@ -1,14 +1,7 @@
 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. 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.
- */
+/** A Postgres-wire pool of {@link PgQuerier}s, attaching the error handler that keeps a dropped connection from crashing the process. */
 export class AbstractPgQuerierPool extends AbstractSqlQuerierPool {
     pool;
     constructor(dialect, pool, extra) {

package/dist/postgres/pgNumericTypes.d.ts

@@ -10,32 +10,9 @@ type PgTypes = {
     getTypeParser(oid: number, format?: 'text' | 'binary'): (value: string) => unknown;
 };
 /**
- * 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
- * every auto-increment primary key, on every entity. `FLOAT8` is a float64, which is exactly what a
- * JS number is, so decoding it loses nothing at all.
- *
- * At the driver because everything crosses the wire decoder exactly once - entity reads, `RETURNING
- * id`, raw SQL, counts, aggregates - while the ORM's hydration only ever sees entity reads. Which
- * types belong here and which need the entity's declaration is settled in `hydratableFields`.
- *
- * `NUMERIC` is deliberately absent, and decoded in hydration instead: `type: BigInt` also maps to
- * BIGINT, so a blanket decode here is already as far as a driver can go without the declaration. That
- * split also covers mysql2, which returns DECIMAL as text and has no equivalent hook.
- *
- * Per pool, never global, which is the whole reason this takes `types` as an argument. TypeORM does
- * the same job by assigning `postgres.defaults.parseInt8`, a module-wide flag every pool in the
- * process then shares; MikroORM passes a per-pool `TypeOverrides`, as here. Two globals of exactly
- * that shape have already been deleted from this repo - `test/pgTypeParsers.util.ts` and the
- * `types.setTypeParser` calls in `neon/neonQuerier.test.ts` - and both made the suite pass on
- * behaviour the library never shipped. Do not reintroduce one.
- *
- * 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.
+ * Decodes `INT8` by `decodeWideNumber` and `FLOAT8` as the float64 it is, since `type: Number` maps to
+ * BIGINT. At the wire, which every result crosses; `NUMERIC` is left to hydration, which knows the field.
+ * Per pool, never a global parser, and a caller's own `types` win.
  */
 export declare function numericTypes(types: PgTypes): CustomTypesConfig;
 export {};

package/dist/postgres/pgNumericTypes.js

@@ -1,31 +1,8 @@
 import { decodeWideNumber } from '../util/wideNumber.js';
 /**
- * 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
- * every auto-increment primary key, on every entity. `FLOAT8` is a float64, which is exactly what a
- * JS number is, so decoding it loses nothing at all.
- *
- * At the driver because everything crosses the wire decoder exactly once - entity reads, `RETURNING
- * id`, raw SQL, counts, aggregates - while the ORM's hydration only ever sees entity reads. Which
- * types belong here and which need the entity's declaration is settled in `hydratableFields`.
- *
- * `NUMERIC` is deliberately absent, and decoded in hydration instead: `type: BigInt` also maps to
- * BIGINT, so a blanket decode here is already as far as a driver can go without the declaration. That
- * split also covers mysql2, which returns DECIMAL as text and has no equivalent hook.
- *
- * Per pool, never global, which is the whole reason this takes `types` as an argument. TypeORM does
- * the same job by assigning `postgres.defaults.parseInt8`, a module-wide flag every pool in the
- * process then shares; MikroORM passes a per-pool `TypeOverrides`, as here. Two globals of exactly
- * that shape have already been deleted from this repo - `test/pgTypeParsers.util.ts` and the
- * `types.setTypeParser` calls in `neon/neonQuerier.test.ts` - and both made the suite pass on
- * behaviour the library never shipped. Do not reintroduce one.
- *
- * 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.
+ * Decodes `INT8` by `decodeWideNumber` and `FLOAT8` as the float64 it is, since `type: Number` maps to
+ * BIGINT. At the wire, which every result crosses; `NUMERIC` is left to hydration, which knows the field.
+ * Per pool, never a global parser, and a caller's own `types` win.
  */
 export function numericTypes(types) {
     // Text only: in binary mode an INT8 arrives as an 8-byte Buffer, and `Number(buffer)` is `NaN`.

package/dist/postgres/postgresDialect.d.ts

@@ -1,17 +1,11 @@
 import { PgLikeSqlDialect } from '../dialect/pgLikeSqlDialect.js';
-import type { QueryConflictPaths, QueryContext, SqlDialectName, Type } from '../type/index.js';
-/**
- * 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.
- */
+import type { QueryConflictPaths, QueryContext, SqlDialectFeatures, SqlDialectName, Type } from '../type/index.js';
+/** PostgreSQL, under every driver: `pg`, Neon, PGlite, `bun:sql`. Adds pgvector and the `xmax` upsert `created`. */
 export declare class PostgresDialect extends PgLikeSqlDialect {
     readonly dialectName: SqlDialectName;
     readonly vectorExtension: string | undefined;
-    /** pgvector is the only engine with `halfvec` and `sparsevec`; every other maps them onto `vector`. */
-    protected readonly hasNarrowVectorTypes = true;
+    /** pgvector is the only engine with `halfvec` and `sparsevec`. */
+    readonly features: SqlDialectFeatures;
     upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E | E[]): void;
     /**
      * `to_regclass` rather than a `::regclass` cast: it answers `NULL` for a table that does not exist

package/dist/postgres/postgresDialect.js

@@ -1,18 +1,12 @@
 import { COUNT_ALIAS } from '../dialect/aliases.js';
-import { PgLikeSqlDialect } from '../dialect/pgLikeSqlDialect.js';
+import { PG_FEATURES, PgLikeSqlDialect } from '../dialect/pgLikeSqlDialect.js';
 import { getMeta } from '../entity/index.js';
-/**
- * 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.
- */
+/** PostgreSQL, under every driver: `pg`, Neon, PGlite, `bun:sql`. Adds pgvector and the `xmax` upsert `created`. */
 export class PostgresDialect extends PgLikeSqlDialect {
     dialectName = 'postgres';
     vectorExtension = 'vector';
-    /** pgvector is the only engine with `halfvec` and `sparsevec`; every other maps them onto `vector`. */
-    hasNarrowVectorTypes = true;
+    /** pgvector is the only engine with `halfvec` and `sparsevec`. */
+    features = { ...PG_FEATURES, narrowVectorTypes: true };
     upsert(ctx, entity, conflictPaths, payload) {
         // The xmax system column is 0 for a newly inserted row and non-zero for an updated one (MVCC).
         super.upsert(ctx, entity, conflictPaths, payload, `(xmax = 0) AS ${this.escapeId('_created')}`);