uql-orm 0.65.1 → 0.67.0

package/dist/mongo/mongoDialect.d.ts

@@ -1,6 +1,6 @@
 import { type Document, type Filter, type Sort, type UpdateFilter } from 'mongodb';
 import { AbstractDialect } from '../dialect/abstractDialect.js';
-import type { DialectFeatures, EntityData, EntityMeta, FieldValue, Query, QueryAggMap, QueryAggregate, QueryExclude, QueryGroupMap, QueryOptions, QueryPopulate, QuerySelectValue, QuerySortMap, QueryVectorSearch, QueryWhere, Type } from '../type/index.js';
+import type { DialectFeatures, EntityData, EntityMeta, Query, QueryAggMap, QueryAggregate, QueryExclude, QueryGroupMap, QueryOptions, QueryPager, QueryPopulate, QuerySelectValue, QuerySortMap, QueryVectorSearch, QueryWhere, Type } from '../type/index.js';
 import { type CallbackKey } from '../util/index.js';
 /** What a read pipeline contributes to {@link MongoDialect.readStages} beyond the query itself. */
 type MongoReadStages = {
@@ -19,7 +19,7 @@ type RelationLookups = {
 export declare const mongoDialectFeatures: DialectFeatures;
 export declare class MongoDialect extends AbstractDialect {
     #private;
-    protected readonly featureDefaults: DialectFeatures;
+    readonly features: DialectFeatures;
     readonly dialectName = "mongodb";
     readonly insertIdSource = "returning";
     private static readonly ID_KEY;
@@ -33,11 +33,8 @@ export declare class MongoDialect extends AbstractDialect {
     columnOf<E>(meta: EntityMeta<E>, key: string): string;
     where<E extends Document>(entity: Type<E>, where?: QueryWhere<E>, opts?: QueryOptions): Filter<E>;
     /**
-     * A `$where` that may constrain relations, split into the `$lookup` stages it needs and the `$match`
-     * filter that consumes them. Each relation condition becomes one correlated lookup into a temporary
-     * field plus an ordinary condition on that field, so the caller's boolean structure survives intact
-     * (a relation inside `$or` still means what it says) and nothing depends on materializing ids.
-     * `unset` names the temporary fields, which the caller drops once the match is done.
+     * A `$where` that may constrain relations, as the `$lookup` stages it needs and the `$match` reading
+     * them: each condition a lookup into a temporary field (`unset` names them), so `$or` keeps its meaning.
      */
     whereWithRelations<E extends Document>(entity: Type<E>, where?: QueryWhere<E>, opts?: QueryOptions): {
         readonly stages: MongoAggregationPipelineEntry<Document>[];
@@ -53,13 +50,8 @@ export declare class MongoDialect extends AbstractDialect {
      */
     protected renderFilter<E extends Document>(entity: Type<E>, where?: QueryWhere<E>, lookups?: RelationLookups): Filter<E>;
     /**
-     * Renders `$and`/`$or`/`$not`/`$nor` into `filter`. MongoDB has no root-level `$not`, so both
-     * negating operators become its `$nor`, which is exactly `NOT (a OR b)` - and by De Morgan that
-     * makes a `$nor` list its clauses directly while a `$not` wraps them in one `$and` first.
-     *
-     * Clauses that render to nothing are dropped and an empty operator emits no key at all: MongoDB
-     * rejects an empty `$and`/`$or`/`$nor` outright, where the SQL dialects contribute no term.
-     * Negations accumulate into the one `$nor`, since `NOT a AND NOT b` is `$nor: [a, b]`.
+     * Renders `$and`/`$or`/`$not`/`$nor` into `filter`, both negations as MongoDB's `$nor` (a `$not`'s clauses
+     * wrapped in one `$and`), dropping empty clauses, since MongoDB refuses an empty operator.
      */
     private appendLogicalOperator;
     /**
@@ -103,9 +95,6 @@ export declare class MongoDialect extends AbstractDialect {
      * apply to JSON paths.
      */
     private assertKnownPathRoot;
-    protected mapTableNameRow(row: {
-        table_name: string;
-    }): string;
     /** String operators -> { pattern: (v) => regex, caseInsensitive } */
     private static readonly REGEX_OP_MAP;
     /** MongoDB native operators - pass through as-is. */
@@ -167,13 +156,11 @@ export declare class MongoDialect extends AbstractDialect {
      */
     private pathOf;
     aggregationPipeline<E extends Document>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): MongoAggregationPipelineEntry<E>[];
+    /** The `$skip`/`$limit` stages of a page, each checked: `/http` hands a page over untyped. */
+    pagerStages(q: QueryPager): MongoAggregationPipelineEntry<Document>[];
     /**
-     * What a read runs after its entry stage, in the one order that works: the lookups its relations
-     * need, the ordering and paging that may read them, and the projection last of all - it names the
-     * fields the lookups add, and no stage after it could read what it dropped.
-     *
-     * Shared by the plain pipeline and the `$vectorSearch` one, which each used to spell the order out
-     * for themselves and each got a different part of it wrong.
+     * What a read runs after its entry stage, in the one order that works: the lookups, then the sort and
+     * page that may read them, then the projection. Shared with the `$vectorSearch` pipeline.
      */
     readStages<E extends Document>(entity: Type<E>, q: Query<E>, extra?: MongoReadStages): MongoAggregationPipelineEntry<Document>[];
     /**
@@ -184,10 +171,8 @@ export declare class MongoDialect extends AbstractDialect {
      */
     private distinctStages;
     /**
-     * The scalar projection a narrowing query asks for, widened by what the pipeline itself produced:
-     * each populated relation and the tallies. It goes last, after the lookups have read the join keys -
-     * projecting any earlier is what used to leave `$populate` empty, and is why the pipeline emitted no
-     * projection at all and returned every column.
+     * The projection a narrowing query asks for, widened by what the pipeline produced (each populated
+     * relation and the tallies); last, once the lookups have read the join keys.
      */
     pipelineProjection<E extends Document>(entity: Type<E>, q: Query<E>): Record<string, 0 | 1> | undefined;
     /**
@@ -209,11 +194,8 @@ export declare class MongoDialect extends AbstractDialect {
     /** `doc` is the wire shape - `_id`, stored names, `ObjectId`s - and what comes back is the code's. */
     normalizeId<E extends Document>(meta: EntityMeta<E>, doc: Document | undefined): E | undefined;
     /**
-     * The seam into the driver: a key, or a reference to one, as MongoDB stores it. A 24-hex string
-     * becomes an `ObjectId`, so a write agrees with the filter that will later look for it; anything
-     * else - a UUID, a number, an `ObjectId` already - is stored as given, which is how those keys keep
-     * their value. Strictly 24-hex: the driver also accepts any 12-byte string, and coercing one of
-     * those turned an ordinary short key into a foreign `ObjectId`. Arrays convert element-wise.
+     * A key as MongoDB stores it: a 24-hex string as an `ObjectId`, so a write matches the filter looking for
+     * it, and anything else as given. Only 24-hex, not any 12-byte string. Arrays convert element-wise.
      */
     toWireId(value: unknown): unknown;
     /** The seam out of the driver: an `ObjectId` becomes its hex string, the type the code declares. */
@@ -228,26 +210,11 @@ export declare class MongoDialect extends AbstractDialect {
      */
     getUpdateFilter<E extends Document>(persistable: Partial<E>): UpdateFilter<E> | Document[];
     /**
-     * MongoDB rejects two operators targeting one path in a single update document, so any path shared
-     * across operator groups is expressed as one aggregation-pipeline update instead.
-     *
-     * Each path's expression is composed in the same order stated on {@link JsonUpdateOp} (`$pull` ->
-     * `$set` -> `$push` -> `$unset`), so every combination yields the identical result: a `$pull`
-     * filters the stored array, a `$set` on the same path then replaces it outright, and a `$push`
-     * appends to whatever those produced. `$unset` is a later stage, so it wins over a `$set` on the
-     * same path - again matching SQL, where it is the outermost wrapper. Values are wrapped in
-     * `$literal` so a string starting with `$` stays data rather than becoming a field reference.
+     * A JSON update as one pipeline, since MongoDB refuses two operators on one path: each path composed as
+     * `$pull`, `$set`, `$push`, then `$unset`, as SQL does, with values as `$literal` so `$x` stays data.
      */
     private getUpdatePipeline;
-    /**
-     * Refuses a key the caller left to MongoDB that MongoDB cannot mint one of.
-     *
-     * The only key a server generates is an `ObjectId`, which {@link fromWireId} hands back as its hex
-     * string - so a key declared `String` is satisfiable and one declared `Number` is not. Answering a
-     * numeric declaration with a string is the lie this exists to refuse: the field says `number`, the
-     * value is not one, and every consumer that indexes or compares by it is quietly wrong. Prisma
-     * refuses the same shape at its schema, and this is the first moment uql can.
-     */
+    /** Refuses a key left to MongoDB that it cannot mint: only an `ObjectId`, read back as a string, so not a `Number`. */
     private assertMintableKey;
     getPersistables<E extends Document>(meta: EntityMeta<E>, payload: EntityData<E> | EntityData<E>[], callbackKey: CallbackKey): Partial<E>[];
     /**
@@ -273,7 +240,7 @@ export declare class MongoDialect extends AbstractDialect {
     buildVectorSearchStage<E extends Document>(entity: Type<E>, key: string, search: QueryVectorSearch, where: QueryWhere<E> | undefined, limit: number, opts?: QueryOptions, candidates?: number): Record<string, unknown>;
 }
 export type MongoAggregationPipelineEntry<E extends Document> = {
-    $lookup?: MongoAggregationLookup<E>;
+    $lookup?: MongoAggregationLookup;
     $match?: Filter<E> | Record<string, unknown>;
     $sort?: Sort;
     $unwind?: MongoAggregationUnwind;
@@ -289,11 +256,12 @@ export type MongoAggregationPipelineEntry<E extends Document> = {
     $skip?: number;
     $limit?: number;
 };
-type MongoAggregationLookup<E extends Document> = {
+/** A `$lookup`, whose pipeline runs over the collection it reads. */
+type MongoAggregationLookup = {
     readonly from?: string;
     readonly foreignField?: string;
     readonly localField?: string;
-    readonly pipeline?: MongoAggregationPipelineEntry<FieldValue<E>>[];
+    readonly pipeline?: MongoAggregationPipelineEntry<Document>[];
     /** A relation key when populating, a temporary field when a relation condition is being tested. */
     readonly as?: string;
 };

package/dist/mongo/mongoDialect.js

@@ -30,7 +30,7 @@ function declaredTypeName(type) {
     return typeof type === 'function' ? type.name : String(type);
 }
 export class MongoDialect extends AbstractDialect {
-    featureDefaults = mongoDialectFeatures;
+    features = mongoDialectFeatures;
     dialectName = 'mongodb';
     // The MongoDB driver reports the exact `_id` of every inserted document (`insertedIds`).
     insertIdSource = 'returning';
@@ -61,11 +61,8 @@ export class MongoDialect extends AbstractDialect {
         return this.renderFilter(entity, this.scopedWhere(meta, where, opts));
     }
     /**
-     * A `$where` that may constrain relations, split into the `$lookup` stages it needs and the `$match`
-     * filter that consumes them. Each relation condition becomes one correlated lookup into a temporary
-     * field plus an ordinary condition on that field, so the caller's boolean structure survives intact
-     * (a relation inside `$or` still means what it says) and nothing depends on materializing ids.
-     * `unset` names the temporary fields, which the caller drops once the match is done.
+     * A `$where` that may constrain relations, as the `$lookup` stages it needs and the `$match` reading
+     * them: each condition a lookup into a temporary field (`unset` names them), so `$or` keeps its meaning.
      */
     whereWithRelations(entity, where = {}, opts = {}) {
         const meta = getMeta(entity);
@@ -130,13 +127,8 @@ export class MongoDialect extends AbstractDialect {
         return filter;
     }
     /**
-     * Renders `$and`/`$or`/`$not`/`$nor` into `filter`. MongoDB has no root-level `$not`, so both
-     * negating operators become its `$nor`, which is exactly `NOT (a OR b)` - and by De Morgan that
-     * makes a `$nor` list its clauses directly while a `$not` wraps them in one `$and` first.
-     *
-     * Clauses that render to nothing are dropped and an empty operator emits no key at all: MongoDB
-     * rejects an empty `$and`/`$or`/`$nor` outright, where the SQL dialects contribute no term.
-     * Negations accumulate into the one `$nor`, since `NOT a AND NOT b` is `$nor: [a, b]`.
+     * Renders `$and`/`$or`/`$not`/`$nor` into `filter`, both negations as MongoDB's `$nor` (a `$not`'s clauses
+     * wrapped in one `$and`), dropping empty clauses, since MongoDB refuses an empty operator.
      */
     appendLogicalOperator(filter, entity, key, val, lookups) {
         const { join, negate } = MongoDialect.GROUP_OPS[key];
@@ -282,9 +274,6 @@ export class MongoDialect extends AbstractDialect {
         }
         throw new TypeError(`path ${key} does not exist in ${entityName(meta)}`);
     }
-    mapTableNameRow(row) {
-        return row.table_name;
-    }
     /** String operators -> { pattern: (v) => regex, caseInsensitive } */
     static REGEX_OP_MAP = new Map([
         ['$startsWith', { wrap: (v) => `^${v}`, ci: false }],
@@ -352,17 +341,9 @@ export class MongoDialect extends AbstractDialect {
                 case '$isNotNull':
                     result[val ? '$ne' : '$eq'] = null;
                     break;
-                case '$text':
-                    result['$text'] = { $search: val };
-                    break;
                 case '$near':
-                    // Atlas has no distance operator. The only threshold it offers is a `$match` on
-                    // `{$meta:'vectorSearchScore'}`, which is a *similarity* on a scale set by the index's own
-                    // `similarity` - and that lives in the Atlas index definition, which UQL neither emits nor
-                    // reads (the same reason `$distance` is index-defined for `$text` above). Converting a
-                    // distance to that scale would mean guessing which metric produced the score, and guessing
-                    // wrong filters the wrong rows silently. So this refuses, the way an unsupported
-                    // `DISTANCE=` does rather than defaulting.
+                    // Atlas offers only a similarity threshold, on the index's own scale, which UQL neither emits nor
+                    // reads: converting a distance would mean guessing the metric, so this refuses.
                     throw new TypeError('$near is not supported on MongoDB: Atlas scores by index-defined similarity, not distance. ' +
                         "Project the score with $sort's $project and filter on it instead.");
                 default:
@@ -579,20 +560,20 @@ export class MongoDialect extends AbstractDialect {
             ...(unset.length ? [{ $unset: unset }] : []),
             ...this.readStages(entity, q, {
                 sort: this.sort(entity, q.$sort, q.$populate),
-                pager: [
-                    ...(q.$skip === undefined ? [] : [{ $skip: assertNonNegativeInteger(q.$skip, '$skip') }]),
-                    ...(q.$limit === undefined ? [] : [{ $limit: assertNonNegativeInteger(q.$limit, '$limit') }]),
-                ],
+                pager: this.pagerStages(q),
             }),
         ];
     }
+    /** The `$skip`/`$limit` stages of a page, each checked: `/http` hands a page over untyped. */
+    pagerStages(q) {
+        return [
+            ...(q.$skip === undefined ? [] : [{ $skip: assertNonNegativeInteger(q.$skip, '$skip') }]),
+            ...(q.$limit === undefined ? [] : [{ $limit: assertNonNegativeInteger(q.$limit, '$limit') }]),
+        ];
+    }
     /**
-     * What a read runs after its entry stage, in the one order that works: the lookups its relations
-     * need, the ordering and paging that may read them, and the projection last of all - it names the
-     * fields the lookups add, and no stage after it could read what it dropped.
-     *
-     * Shared by the plain pipeline and the `$vectorSearch` one, which each used to spell the order out
-     * for themselves and each got a different part of it wrong.
+     * What a read runs after its entry stage, in the one order that works: the lookups, then the sort and
+     * page that may read them, then the projection. Shared with the `$vectorSearch` pipeline.
      */
     readStages(entity, q, extra = {}) {
         const meta = getMeta(entity);
@@ -662,10 +643,8 @@ export class MongoDialect extends AbstractDialect {
         return [{ $group: { _id: groupId } }, { $replaceRoot: { newRoot: '$_id' } }];
     }
     /**
-     * The scalar projection a narrowing query asks for, widened by what the pipeline itself produced:
-     * each populated relation and the tallies. It goes last, after the lookups have read the join keys -
-     * projecting any earlier is what used to leave `$populate` empty, and is why the pipeline emitted no
-     * projection at all and returned every column.
+     * The projection a narrowing query asks for, widened by what the pipeline produced (each populated
+     * relation and the tallies); last, once the lookups have read the join keys.
      */
     pipelineProjection(entity, q) {
         if (!q.$select && !q.$exclude) {
@@ -802,11 +781,8 @@ export class MongoDialect extends AbstractDialect {
         return res;
     }
     /**
-     * The seam into the driver: a key, or a reference to one, as MongoDB stores it. A 24-hex string
-     * becomes an `ObjectId`, so a write agrees with the filter that will later look for it; anything
-     * else - a UUID, a number, an `ObjectId` already - is stored as given, which is how those keys keep
-     * their value. Strictly 24-hex: the driver also accepts any 12-byte string, and coercing one of
-     * those turned an ordinary short key into a foreign `ObjectId`. Arrays convert element-wise.
+     * A key as MongoDB stores it: a 24-hex string as an `ObjectId`, so a write matches the filter looking for
+     * it, and anything else as given. Only 24-hex, not any 12-byte string. Arrays convert element-wise.
      */
     toWireId(value) {
         if (Array.isArray(value)) {
@@ -870,15 +846,8 @@ export class MongoDialect extends AbstractDialect {
         };
     }
     /**
-     * MongoDB rejects two operators targeting one path in a single update document, so any path shared
-     * across operator groups is expressed as one aggregation-pipeline update instead.
-     *
-     * Each path's expression is composed in the same order stated on {@link JsonUpdateOp} (`$pull` ->
-     * `$set` -> `$push` -> `$unset`), so every combination yields the identical result: a `$pull`
-     * filters the stored array, a `$set` on the same path then replaces it outright, and a `$push`
-     * appends to whatever those produced. `$unset` is a later stage, so it wins over a `$set` on the
-     * same path - again matching SQL, where it is the outermost wrapper. Values are wrapped in
-     * `$literal` so a string starting with `$` stays data rather than becoming a field reference.
+     * A JSON update as one pipeline, since MongoDB refuses two operators on one path: each path composed as
+     * `$pull`, `$set`, `$push`, then `$unset`, as SQL does, with values as `$literal` so `$x` stays data.
      */
     getUpdatePipeline({ set, push, pull, unset }, exprPaths) {
         const assignments = {};
@@ -899,15 +868,7 @@ export class MongoDialect extends AbstractDialect {
         }
         return [{ $set: assignments }, ...(unset.size > 0 ? [{ $unset: [...unset] }] : [])];
     }
-    /**
-     * Refuses a key the caller left to MongoDB that MongoDB cannot mint one of.
-     *
-     * The only key a server generates is an `ObjectId`, which {@link fromWireId} hands back as its hex
-     * string - so a key declared `String` is satisfiable and one declared `Number` is not. Answering a
-     * numeric declaration with a string is the lie this exists to refuse: the field says `number`, the
-     * value is not one, and every consumer that indexes or compares by it is quietly wrong. Prisma
-     * refuses the same shape at its schema, and this is the first moment uql can.
-     */
+    /** Refuses a key left to MongoDB that it cannot mint: only an `ObjectId`, read back as a string, so not a `Number`. */
     assertMintableKey(meta, field) {
         if (columnFamily(field.type) === 'string') {
             return;
@@ -989,13 +950,7 @@ export class MongoDialect extends AbstractDialect {
                 pipeline.push({ $sort: sort });
             }
         }
-        // $skip and $limit stages
-        if (q.$skip !== undefined) {
-            pipeline.push({ $skip: assertNonNegativeInteger(q.$skip, '$skip') });
-        }
-        if (q.$limit !== undefined) {
-            pipeline.push({ $limit: assertNonNegativeInteger(q.$limit, '$limit') });
-        }
+        pipeline.push(...this.pagerStages(q));
         return pipeline;
     }
     /**

package/dist/mongo/mongodbQuerier.d.ts

@@ -1,6 +1,6 @@
 import type { Document, MongoClient } from 'mongodb';
 import { AbstractQuerier } from '../querier/index.js';
-import type { EntityData, ExtraOptions, PrimaryKey, Query, QueryAggMap, QueryAggregate, QueryAggregateResult, QueryConflictPaths, QueryFilter, QueryGroupMap, QueryOptions, QuerySearch, TransactionOptions, Type, UpdatePayload } from '../type/index.js';
+import type { EntityData, ExtraOptions, PrimaryKey, Query, QueryAggMap, QueryAggregate, QueryAggregateResult, QueryConflictPaths, QueryPage, QueryGroupMap, QueryOptions, QuerySearch, TransactionOptions, Type, UpdatePayload } from '../type/index.js';
 import type { MongoDialect } from './mongoDialect.js';
 export declare class MongodbQuerier extends AbstractQuerier {
     readonly dialect: MongoDialect;
@@ -37,18 +37,15 @@ export declare class MongodbQuerier extends AbstractQuerier {
      * other query counts through {@link internalCount}, which needs no pipeline of its own.
      */
     protected internalFindManyAndCount<E extends Document>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): Promise<[E[], number]>;
-    protected internalCount<E extends Document>(entity: Type<E>, qm?: QueryFilter<E>, opts?: QueryOptions): Promise<number>;
+    /** The pipeline `countDocuments` runs, spelled out so a relation condition gets its lookups and a page its stages. */
+    protected internalCount<E extends Document>(entity: Type<E>, q: QueryPage<E>, opts?: QueryOptions): Promise<number>;
     /**
      * The collection's metadata count, which the driver exposes as its own call and which takes no
      * filter - the reason {@link UniversalQuerier.estimatedCount} takes none either.
      */
     estimatedCount<E extends Document>(entity: Type<E>): Promise<number>;
-    /**
-     * The ids matching `q`, in `q`'s own order and page, so a write can name the rows it settled on.
-     * Built from the read pipeline rather than stages assembled here: that dropped `$sort`/`$limit` on
-     * the floor, and skipped the relation-sort rejection {@link MongoDialect.sort} raises.
-     */
-    private settleIds;
+    /** A `find` filter cannot host the `$lookup` a relation condition needs, so such a write names its rows by id. */
+    protected settlesWrite<E extends Document>(entity: Type<E>, q: QuerySearch<E>): boolean;
     internalInsertMany<E extends Document>(entity: Type<E>, rows: EntityData<E>[]): Promise<void>;
     internalUpdateMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, payload: UpdatePayload<E>, opts?: QueryOptions): Promise<number>;
     /**

package/dist/mongo/mongodbQuerier.js

@@ -1,8 +1,8 @@
 import { COUNT_ALIAS } from '../dialect/aliases.js';
 import { hasRequiredJoin } from '../dialect/queryJoins.js';
-import { fieldOf, getMeta, idOf, namesKey, soleIdOf } from '../entity/index.js';
+import { fieldOf, getMeta, namesKey, soleIdOf } from '../entity/index.js';
 import { AbstractQuerier, enrichError } from '../querier/index.js';
-import { clone, getKeys, getSoftDeleteValue, hasKeys, idOnlyQuery, isPagedQuery, populatesRelations, throwNoPendingTransaction, throwPendingTransaction, withoutSoftDeleteFilter, } from '../util/index.js';
+import { clone, getKeys, getSoftDeleteValue, hasKeys, populatesRelations, throwNoPendingTransaction, throwPendingTransaction, withoutSoftDeleteFilter, } from '../util/index.js';
 /**
  * `$limit: 0` asks for no rows, the way it does on every SQL dialect - but MongoDB reads `limit(0)`
  * as *unlimited*, so a read that passed it straight to the driver came back with the whole
@@ -147,21 +147,16 @@ export class MongodbQuerier extends AbstractQuerier {
         ]);
         return [founds, counted[0]?.[COUNT_ALIAS] ?? 0];
     }
-    async internalCount(entity, qm = {}, opts) {
+    /** The pipeline `countDocuments` runs, spelled out so a relation condition gets its lookups and a page its stages. */
+    async internalCount(entity, q, opts) {
+        if (asksForNoRows(q)) {
+            return 0;
+        }
         return this.timed('internalCount', undefined, async () => {
-            if (this.dialect.constrainsRelations(entity, qm.$where)) {
-                const { stages, filter } = this.dialect.whereWithRelations(entity, qm.$where, opts);
-                const [counted] = await this.execute((session) => this.collection(entity)
-                    .aggregate([...stages, { $match: filter }, { $count: COUNT_ALIAS }], {
-                    session,
-                })
-                    .toArray());
-                return counted?.[COUNT_ALIAS] ?? 0;
-            }
-            const filter = this.dialect.where(entity, qm.$where, opts);
-            return this.execute((session) => this.collection(entity).countDocuments(filter, {
-                session,
-            }));
+            const { stages, filter } = this.dialect.whereWithRelations(entity, q.$where, opts);
+            const pipeline = [...stages, { $match: filter }, ...this.dialect.pagerStages(q), { $count: COUNT_ALIAS }];
+            const [counted] = await this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
+            return counted?.[COUNT_ALIAS] ?? 0;
         });
     }
     /**
@@ -171,18 +166,9 @@ export class MongodbQuerier extends AbstractQuerier {
     async estimatedCount(entity) {
         return this.timed('estimatedCount', undefined, async () => this.execute((session) => this.collection(entity).estimatedDocumentCount({ session })));
     }
-    /**
-     * The ids matching `q`, in `q`'s own order and page, so a write can name the rows it settled on.
-     * Built from the read pipeline rather than stages assembled here: that dropped `$sort`/`$limit` on
-     * the floor, and skipped the relation-sort rejection {@link MongoDialect.sort} raises.
-     */
-    async settleIds(entity, q, opts) {
-        const meta = getMeta(entity);
-        const pipeline = this.dialect.aggregationPipeline(entity, idOnlyQuery(meta, q), opts);
-        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));
+    /** A `find` filter cannot host the `$lookup` a relation condition needs, so such a write names its rows by id. */
+    settlesWrite(entity, q) {
+        return super.settlesWrite(entity, q) || this.dialect.constrainsRelations(entity, q.$where);
     }
     async internalInsertMany(entity, rows) {
         return this.timed('internalInsertMany', undefined, async () => {
@@ -199,21 +185,11 @@ export class MongodbQuerier extends AbstractQuerier {
     }
     async internalUpdateMany(entity, qm, payload, opts) {
         return this.timed('internalUpdateMany', undefined, async () => {
-            payload = clone(payload);
-            const meta = getMeta(entity);
-            const persistable = this.dialect.getPersistable(meta, payload, 'onUpdate');
-            // Settled to ids first in two cases: an `updateMany` filter cannot host a `$lookup`, so a
-            // relation condition has nowhere to go, and MongoDB takes no page on a write, so a paged one
-            // has to name the rows it picked rather than touching every match.
-            const where = this.dialect.constrainsRelations(entity, qm.$where) || isPagedQuery(qm)
-                ? { _id: { $in: this.dialect.toWireId(await this.settleIds(entity, qm, opts)) } }
-                : this.dialect.where(entity, qm.$where, opts);
+            const persistable = this.dialect.getPersistable(getMeta(entity), payload, 'onUpdate');
+            const filter = this.dialect.where(entity, qm.$where, opts);
             // Maps JSON operators ($set/$unset/$push/$pull) onto their native MongoDB equivalents.
             const update = this.dialect.getUpdateFilter(persistable);
-            const { matchedCount } = await this.execute((session) => this.collection(entity).updateMany(where, update, {
-                session,
-            }));
-            await this.updateRelations(entity, qm, payload, opts);
+            const { matchedCount } = await this.execute((session) => this.collection(entity).updateMany(filter, update, { session }));
             return matchedCount;
         });
     }
@@ -298,31 +274,21 @@ export class MongodbQuerier extends AbstractQuerier {
             const meta = getMeta(entity);
             // Soft-delete (stamp) unless `hardDelete` is requested or the entity has no soft-delete field.
             const softDelete = opts.hardDelete ? undefined : meta.softDelete;
-            // Hard delete targets matching rows regardless of soft-delete state (keeps other 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);
-            if (!ids.length) {
-                return 0;
+            if (!softDelete) {
+                const filter = this.dialect.where(entity, qm.$where, {
+                    ...opts,
+                    filters: withoutSoftDeleteFilter(opts.filters),
+                });
+                const { deletedCount } = await this.execute((session) => this.collection(entity).deleteMany(filter, { session }));
+                return deletedCount;
             }
-            let changes;
-            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(softDelete, field);
-                const updateResult = await this.execute((session) => this.collection(entity).updateMany({ _id: { $in: this.dialect.toWireId(ids) } }, { $set: { [softDeleteColumn]: getSoftDeleteValue(field) } }, {
-                    session,
-                }));
-                changes = updateResult.matchedCount;
-            }
-            else {
-                const deleteResult = await this.execute((session) => this.collection(entity).deleteMany({ _id: { $in: this.dialect.toWireId(ids) } }, { session }));
-                changes = deleteResult.deletedCount;
-            }
-            await this.deleteRelations(entity, ids, opts);
-            return changes;
+            const field = fieldOf(meta, softDelete);
+            // The mapped column, which reads filter on: a `@Field({ name })` mismatch would leave the row visible.
+            const column = this.dialect.resolveColumnName(softDelete, field);
+            const update = { $set: { [column]: getSoftDeleteValue(field) } };
+            const filter = this.dialect.where(entity, qm.$where, opts);
+            const { matchedCount } = await this.execute((session) => this.collection(entity).updateMany(filter, update, { session }));
+            return matchedCount;
         });
     }
     get hasOpenTransaction() {

package/dist/mssql/mssqlDialect.d.ts

@@ -1,17 +1,10 @@
 import { type RelationRows } from '../dialect/abstractSqlDialect.js';
 import { MergeSqlDialect } from '../dialect/mergeSqlDialect.js';
-import type { DialectFeatures, EntityMeta, FieldOptions, InsertIdSource, Query, QueryContext, QueryOptions, QueryPager, QuerySizeComparisonOps, Type, VectorDistance, VectorMetric } from '../type/index.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.
- */
+import type { EntityMeta, FieldOptions, InsertIdSource, Query, QueryContext, QueryOptions, QueryPager, QuerySizeComparisonOps, SqlDialectFeatures, Type, VectorDistance, VectorMetric } from '../type/index.js';
+/** Microsoft SQL Server 2017 and up. Identifiers are `"`-quoted, the ANSI spelling `tedious` enables. */
 export declare class MsSqlDialect extends MergeSqlDialect {
     #private;
-    protected readonly featureDefaults: DialectFeatures;
+    readonly features: SqlDialectFeatures;
     readonly dialectName = "mssql";
     readonly autoIncrementSuffix = "IDENTITY(1,1)";
     readonly tableOptions = "";
@@ -29,8 +22,6 @@ export declare class MsSqlDialect extends MergeSqlDialect {
     readonly maxBindValues = 2100;
     /** `OUTPUT` has no trailing form: it sits between the column list and `VALUES`. */
     readonly returningPosition = "after-target";
-    /** Microsoft documents no row order for a `MERGE ... OUTPUT`. */
-    readonly upsertReturningOrdered = false;
     readonly insertIdSource: InsertIdSource;
     /** Holds the update key lock across the insert; without it two concurrent upserts of one key race. */
     protected readonly mergeTargetHint = " WITH (HOLDLOCK)";
@@ -48,23 +39,13 @@ export declare class MsSqlDialect extends MergeSqlDialect {
         $distinct?: boolean;
     }, sorted?: boolean): void;
     /**
-     * `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<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;
     /** The table to toggle, or nothing when no record writes a key the engine would have generated. */
     private identityInsertTarget;
-    /**
-     * 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. */
     protected selectFieldExpr(escapedColumn: string, field: FieldOptions): string;
     /**
      * The rows read as they are, `FOR JSON PATH` making the array. It nests a dotted key and leaves a
@@ -135,13 +116,8 @@ export declare class MsSqlDialect extends MergeSqlDialect {
      */
     protected getJsonPathJsonbExpr(escapedColumn: string, jsonPathStr: string): string;
     /**
-     * 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.
      */
     protected jsonScalarParam(ctx: QueryContext, value: unknown): string;
     /**
@@ -150,8 +126,6 @@ export declare class MsSqlDialect extends MergeSqlDialect {
      * flattened a boolean to 1/0 for this engine's columns, so the cast is what restores it.
      */
     protected jsonWriteParam(ctx: QueryContext, value: unknown): string;
-    /** An exploded element compares as text here, so `$elemMatch` always expands per field. */
-    protected readonly jsonContainmentIsPartial = false;
     protected jsonElemFrom(jsonField: string, _fields: readonly string[], alias: string): string;
     /** `JSON_VALUE`'s 4000-character bound applies to an element's field, unlike a whole column. */
     protected jsonElemRef(alias: string, field?: string): string;