uql-orm 0.54.0 → 0.56.0

package/dist/mongo/mongoDialect.js

@@ -2,7 +2,7 @@ import { ObjectId } from 'mongodb';
 import { AbstractDialect } from '../dialect/abstractDialect.js';
 import { COUNT_ALIAS, REL_NESTED_KEY, REL_TEMP_PREFIX, sortCountField } from '../dialect/aliases.js';
 import { resolveQueryJoins, resolveSortableJoin } from '../dialect/queryJoins.js';
-import { assertSoleId, getMeta, soleIdOf } from '../entity/index.js';
+import { assertSoleId, fieldOf, getMeta, relationOf, soleIdOf } from '../entity/index.js';
 import { QueryRaw } from '../type/queryRaw.js';
 import { asSelectMap, assertAggregateColumns, assertNonNegativeInteger, columnFamily, entityName, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isJsonUpdateOp, isOperatorMap, isOperatorObject, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationSize, parseSortByCount, someKey, targetKeyColumns, } from '../util/index.js';
 /** Default {@link DialectFeatures} for MongoDB; shared by {@link MongoDialect} and its schema generator. */
@@ -39,14 +39,6 @@ export class MongoDialect extends AbstractDialect {
     static ID_KEY = '_id';
     /** Atlas rejects a `$vectorSearch` asking for more candidates than this. */
     static MAX_NUM_CANDIDATES = 10_000;
-    // Direct field aggregates → MongoDB accumulator. `$count` is handled separately (COUNT(*) vs
-    // COUNT(field) differ), so it is not listed here.
-    static AGGREGATE_OP_MAP = new Map([
-        ['$sum', '$sum'],
-        ['$avg', '$avg'],
-        ['$min', '$min'],
-        ['$max', '$max'],
-    ]);
     /**
      * MongoDB stores the primary key as `_id`; everything else resolves as usual. Projections, sorts,
      * `$group` refs and `$where` keys all map through here, so no read path can address a property name
@@ -511,7 +503,7 @@ export class MongoDialect extends AbstractDialect {
      */
     aliasSort(sort) {
         const normalized = {};
-        for (const [alias, dir] of Object.entries(sort ?? {})) {
+        for (const [alias, dir] of Object.entries(sort)) {
             normalized[alias] = sortDirection(dir);
         }
         return normalized;
@@ -730,7 +722,7 @@ export class MongoDialect extends AbstractDialect {
     #renamedColumns = new WeakMap();
     #referenceKeys = new WeakMap();
     normalizeIds(meta, docs) {
-        return docs?.map((doc) => this.normalizeId(meta, doc));
+        return docs.map((doc) => this.normalizeId(meta, doc));
     }
     /** `doc` is the wire shape - `_id`, stored names, `ObjectId`s - and what comes back is the code's. */
     normalizeId(meta, doc) {
@@ -763,10 +755,7 @@ export class MongoDialect extends AbstractDialect {
         }
         const relKeys = getKeys(meta.relations).filter((key) => res[key]);
         for (const relKey of relKeys) {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts)
-                continue;
-            const relMeta = getMeta(relOpts.entity());
+            const relMeta = getMeta(relationOf(meta, relKey).entity());
             res[relKey] = Array.isArray(res[relKey])
                 ? this.normalizeIds(relMeta, res[relKey])
                 : this.normalizeId(relMeta, res[relKey]);
@@ -902,7 +891,7 @@ export class MongoDialect extends AbstractDialect {
             const named = inserting && it[idKey] != null;
             if (inserting && !named) {
                 // Nothing named the key, so the database is being asked to mint one.
-                this.assertMintableKey(meta, meta.fields[idKey]);
+                this.assertMintableKey(meta, fieldOf(meta, idKey));
             }
             const doc = named ? { [MongoDialect.ID_KEY]: this.toWireId(it[idKey]) } : {};
             for (const key of filterFieldKeys(meta, it, callbackKey)) {
@@ -999,11 +988,8 @@ export class MongoDialect extends AbstractDialect {
                     entry.fieldRef === '*' ? { $sum: 1 } : { $sum: { $cond: [{ $ne: [ref, null] }, 1, 0] } };
             }
             else {
-                const mongoOp = MongoDialect.AGGREGATE_OP_MAP.get(entry.op);
-                if (!mongoOp) {
-                    throw TypeError(`unsupported aggregate operator: ${entry.op}`);
-                }
-                groupAccumulators[entry.alias] = { [mongoOp]: ref };
+                // `$sum`, `$avg`, `$min` and `$max` are MongoDB accumulators of the same name.
+                groupAccumulators[entry.alias] = { [entry.op]: ref };
             }
         }
         return { groupId, groupAccumulators, distinctReducers };

package/dist/mongo/mongodbQuerier.js

@@ -1,6 +1,6 @@
 import { COUNT_ALIAS } from '../dialect/aliases.js';
 import { hasRequiredJoin } from '../dialect/queryJoins.js';
-import { getMeta, idOf, namesKey, soleIdOf } from '../entity/index.js';
+import { fieldOf, getMeta, idOf, namesKey, soleIdOf } from '../entity/index.js';
 import { AbstractQuerier, enrichError } from '../querier/index.js';
 import { clone, getKeys, getRelationRequestSummary, getSoftDeleteValue, hasKeys, idOnlyQuery, isPagedQuery, populatesRelations, queryChildrenOf, throwNoPendingTransaction, throwPendingTransaction, withoutSoftDeleteFilter, } from '../util/index.js';
 /**
@@ -63,7 +63,7 @@ export class MongodbQuerier extends AbstractQuerier {
                 else {
                     const cursor = this.buildFindCursor(entity, q, opts);
                     documents = await this.execute(() => cursor.toArray());
-                    documents = this.dialect.normalizeIds(meta, documents) || [];
+                    documents = this.dialect.normalizeIds(meta, documents);
                 }
             }
             return documents;
@@ -92,7 +92,7 @@ export class MongodbQuerier extends AbstractQuerier {
         const pipelines = queries.map((it) => this.dialect.aggregationPipeline(entity, it));
         // Counted, not estimated: the leading branch's own length grows with every `$lookup` a populate
         // adds, so a fixed parent budget would let a richer query overflow at the server instead.
-        const stages = (pipelines[0]?.length ?? 0) + pipelines.length - 1;
+        const stages = pipelines[0].length + pipelines.length - 1;
         return stages > MAX_PIPELINE_STAGES
             ? this.readEachInTurn(entity, queries)
             : this.readInOnePipeline(entity, q, pipelines);
@@ -139,7 +139,7 @@ export class MongodbQuerier extends AbstractQuerier {
         const cursor = this.buildFindCursor(entity, q, opts);
         try {
             for await (const doc of cursor) {
-                const [normalized] = this.dialect.normalizeIds(meta, [doc]) || [doc];
+                const [normalized] = this.dialect.normalizeIds(meta, [doc]);
                 yield normalized;
             }
         }
@@ -177,7 +177,7 @@ export class MongodbQuerier extends AbstractQuerier {
     /** Execute an aggregation pipeline and normalize `_id` → `id`. */
     async runPipeline(entity, meta, pipeline) {
         const documents = await this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
-        return this.dialect.normalizeIds(meta, documents) || [];
+        return this.dialect.normalizeIds(meta, documents);
     }
     /**
      * Build an aggregation pipeline for vector similarity search.
@@ -257,7 +257,7 @@ export class MongodbQuerier extends AbstractQuerier {
         const founds = await this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
         // `normalizeIds` has already spread a compound `_id` back into its columns, so the settled rows
         // are named the same way every other driver names them.
-        return (this.dialect.normalizeIds(meta, founds) || []).map((found) => idOf(meta, found));
+        return this.dialect.normalizeIds(meta, founds).map((found) => idOf(meta, found));
     }
     async internalInsertMany(entity, rows) {
         return this.timed('internalInsertMany', undefined, async () => {
@@ -356,7 +356,7 @@ export class MongodbQuerier extends AbstractQuerier {
                 };
             });
             const res = await this.execute((session) => this.collection(entity).bulkWrite(operations, { session }));
-            const changes = (res.upsertedCount ?? 0) + (res.modifiedCount ?? 0);
+            const changes = res.upsertedCount + res.modifiedCount;
             // `upsertedIds` names only the documents inserted, keyed by operation index, so each lands on
             // its own row; an updated document's `_id` is read back by the conflict fields instead.
             const reported = payload.map((_, index) => {
@@ -372,9 +372,9 @@ export class MongodbQuerier extends AbstractQuerier {
         return this.timed('internalDeleteMany', undefined, async () => {
             const meta = getMeta(entity);
             // Soft-delete (stamp) unless `hardDelete` is requested or the entity has no soft-delete field.
-            const field = !opts.hardDelete && meta.softDelete ? meta.fields[meta.softDelete] : undefined;
+            const softDelete = opts.hardDelete ? undefined : meta.softDelete;
             // Hard delete targets matching rows regardless of soft-delete state (keeps other filters).
-            const findOpts = field ? opts : { ...opts, filters: withoutSoftDeleteFilter(opts.filters) };
+            const findOpts = softDelete ? opts : { ...opts, filters: withoutSoftDeleteFilter(opts.filters) };
             // Delete has always resolved its ids first (it stamps or removes them by `_id`), so a relation
             // condition needs nothing extra here - and passing the whole query is what makes its page apply.
             const ids = await this.settleIds(entity, qm, findOpts);
@@ -382,10 +382,11 @@ export class MongodbQuerier extends AbstractQuerier {
                 return 0;
             }
             let changes;
-            if (field) {
+            if (softDelete) {
+                const field = fieldOf(meta, softDelete);
                 // Stamp the mapped column: reads filter on it, so a `@Field({ name })` mismatch here would
                 // report a successful delete and leave the row visible.
-                const softDeleteColumn = this.dialect.resolveColumnName(meta.softDelete, field);
+                const softDeleteColumn = this.dialect.resolveColumnName(softDelete, field);
                 const updateResult = await this.execute((session) => this.collection(entity).updateMany({ _id: { $in: this.dialect.toWireId(ids) } }, { $set: { [softDeleteColumn]: getSoftDeleteValue(field) } }, {
                     session,
                 }));

package/dist/mongo/mongodbQuerierPool.d.ts

@@ -1,9 +1,9 @@
 import { type MongoClientOptions } from 'mongodb';
 import { AbstractQuerierPool } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.js';
-import { MongodbNativeDialect } from './mongodbNativeDialect.js';
+import { MongoDialect } from './mongoDialect.js';
 import { MongodbQuerier } from './mongodbQuerier.js';
-export declare class MongodbQuerierPool extends AbstractQuerierPool<MongodbQuerier, MongodbNativeDialect> {
+export declare class MongodbQuerierPool extends AbstractQuerierPool<MongodbQuerier, MongoDialect> {
     private readonly client;
     constructor(uri: string, opts?: MongoClientOptions, extra?: ExtraOptions);
     getQuerier(): Promise<MongodbQuerier>;

package/dist/mongo/mongodbQuerierPool.js

@@ -1,12 +1,12 @@
 import { MongoClient } from 'mongodb';
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractQuerierPool } from '../querier/index.js';
-import { MongodbNativeDialect } from './mongodbNativeDialect.js';
+import { MongoDialect } from './mongoDialect.js';
 import { MongodbQuerier } from './mongodbQuerier.js';
 export class MongodbQuerierPool extends AbstractQuerierPool {
     client;
     constructor(uri, opts, extra) {
-        super(new MongodbNativeDialect(dialectOptionsFrom(extra)), extra);
+        super(new MongoDialect(dialectOptionsFrom(extra)), extra);
         this.client = new MongoClient(uri, opts);
     }
     async getQuerier() {

package/dist/mssql/mssqlDialect.d.ts

@@ -18,12 +18,10 @@ export declare class MsSqlDialect extends MergeSqlDialect {
     readonly commitTransactionCommand = "COMMIT TRANSACTION";
     readonly rollbackTransactionCommand = "ROLLBACK TRANSACTION";
     /**
-     * The level rides the `BEGIN` rather than preceding it as its own statement: a `SET TRANSACTION
-     * ISOLATION LEVEL` sent on its own would go to whichever pooled connection served it, not the one
-     * the transaction opens on, and would then stick to that connection for unrelated later queries.
-     * `MsSqlQuerier` reads the level back off this command and hands it to the driver.
+     * T-SQL has no inline form, so the level is set before the `BEGIN`. What a driver that sends these
+     * as statements would run; `MsSqlQuerier` opens its transactions through the driver instead.
      */
-    readonly isolationLevelStrategy = "inline";
+    readonly isolationLevelStrategy = "set-before";
     readonly dropIndexSyntax = "on-table";
     readonly booleanLiteral = "integer";
     /** [The hard server limit](https://github.com/yiisoft/yii2/issues/10371), not a driver preference. */

package/dist/mssql/mssqlDialect.js

@@ -52,12 +52,10 @@ export class MsSqlDialect extends MergeSqlDialect {
     commitTransactionCommand = 'COMMIT TRANSACTION';
     rollbackTransactionCommand = 'ROLLBACK TRANSACTION';
     /**
-     * The level rides the `BEGIN` rather than preceding it as its own statement: a `SET TRANSACTION
-     * ISOLATION LEVEL` sent on its own would go to whichever pooled connection served it, not the one
-     * the transaction opens on, and would then stick to that connection for unrelated later queries.
-     * `MsSqlQuerier` reads the level back off this command and hands it to the driver.
+     * T-SQL has no inline form, so the level is set before the `BEGIN`. What a driver that sends these
+     * as statements would run; `MsSqlQuerier` opens its transactions through the driver instead.
      */
-    isolationLevelStrategy = 'inline';
+    isolationLevelStrategy = 'set-before';
     dropIndexSyntax = 'on-table';
     booleanLiteral = 'integer';
     /** [The hard server limit](https://github.com/yiisoft/yii2/issues/10371), not a driver preference. */
@@ -270,11 +268,14 @@ export class MsSqlDialect extends MergeSqlDialect {
         return typeof value === 'boolean' ? `CAST(${placeholder} AS BIT)` : placeholder;
     }
     /**
-     * An object or array bound as JSON, which is the half both binders spell the same way, or
-     * `undefined` for a scalar - where they diverge.
+     * An object or array bound as JSON, or a `raw()` rendered in place, which is the half both binders
+     * spell the same way; `undefined` for a scalar - where they diverge.
      */
     #jsonCompound(ctx, value) {
-        if (value === null || typeof value !== 'object' || value instanceof QueryRaw) {
+        if (value instanceof QueryRaw) {
+            return this.rawFragment(ctx, value);
+        }
+        if (value === null || typeof value !== 'object') {
             return undefined;
         }
         ctx.pushValue(JSON.stringify(value));

package/dist/mssql/mssqlQuerier.d.ts

@@ -1,7 +1,6 @@
 import type { ConnectionPool } from 'mssql';
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
-import type { ExtraOptions, QueryUpdateResult } from '../type/index.js';
-import type { MsSqlDialect } from './mssqlDialect.js';
+import type { QueryUpdateResult, TransactionOptions } from '../type/index.js';
 /**
  * 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,
@@ -9,15 +8,23 @@ import type { MsSqlDialect } from './mssqlDialect.js';
  */
 export declare class MsSqlQuerier extends AbstractPoolQuerier<ConnectionPool> {
     #private;
-    constructor(connect: () => Promise<ConnectionPool>, dialect: MsSqlDialect, extra?: ExtraOptions);
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
     internalRun(query: string, values?: unknown[]): Promise<QueryUpdateResult>;
     /**
-     * `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.
      */
     internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    /**
+     * `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 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.
+     */
+    protected internalBegin(opts?: TransactionOptions): Promise<void>;
+    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>;
 }

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