@atscript/db-mongo 0.1.135 → 0.1.137

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TPrimaryKeyChange, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
 import { AggregationCursor, ClientSession, Collection, Db, Document, Filter, MongoClient, ObjectId, UpdateFilter, UpdateOptions } from "mongodb";
 import { TAtscriptAnnotatedType, TMetadataMap, TValidatorOptions, TValidatorPlugin, Validator } from "@atscript/typescript/utils";
-import { BucketUnit } from "@uniqu/core";
+import { AggregateFn, BucketUnit } from "@uniqu/core";
 
 //#region src/lib/collection-patcher.d.ts
 /**
@@ -303,6 +303,13 @@ declare class MongoAdapter extends BaseDbAdapter {
   supportsNativePatch(): boolean;
   /** All five units, over MongoDB's bundled time zone database (see `agg.ts` `bucketExpression`). */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
+  /** Every aggregate function, `countDistinct` included. */
+  aggregateFns(): ReadonlySet<AggregateFn>;
+  /**
+   * See BaseDbAdapter.viewRenderRevision. 2 = 0.1.137 (null-guarded field filters, nested document paths).
+   * BUMP whenever `buildViewPipeline` output changes for an unchanged view definition.
+   */
+  viewRenderRevision(): string;
   getValidatorPlugins(): ReturnType<BaseDbAdapter["getValidatorPlugins"]>;
   /**
    * Mongo can filter on JSON-stored fields natively — arrays via implicit
@@ -471,8 +478,15 @@ declare class MongoAdapter extends BaseDbAdapter {
  *
  * MongoDB's query language is nearly identical to the `FilterExpr` structure,
  * so this is largely a structural pass-through via the `walkFilter` visitor.
+ * `fieldOperands` (view predicates only — `translateQueryTree` output) turns
+ * `{ $field: path }` operands into field-to-field `$expr` comparisons; a
+ * request filter never gets that reading.
  */
-declare function buildMongoFilter(filter: FilterExpr): Filter<any>;
+declare function buildMongoFilter(filter: FilterExpr, {
+  fieldOperands
+}?: {
+  fieldOperands?: boolean;
+}): Filter<any>;
 //#endregion
 //#region src/lib/validate-plugins.d.ts
 declare const validateMongoIdPlugin: TValidatorPlugin;

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TPrimaryKeyChange, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
 import { AggregationCursor, ClientSession, Collection, Db, Document, Filter, MongoClient, ObjectId, UpdateFilter, UpdateOptions } from "mongodb";
-import { BucketUnit } from "@uniqu/core";
+import { AggregateFn, BucketUnit } from "@uniqu/core";
 import { TAtscriptAnnotatedType, TMetadataMap, TValidatorOptions, TValidatorPlugin, Validator } from "@atscript/typescript/utils";
 
 //#region src/lib/collection-patcher.d.ts
@@ -303,6 +303,13 @@ declare class MongoAdapter extends BaseDbAdapter {
   supportsNativePatch(): boolean;
   /** All five units, over MongoDB's bundled time zone database (see `agg.ts` `bucketExpression`). */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
+  /** Every aggregate function, `countDistinct` included. */
+  aggregateFns(): ReadonlySet<AggregateFn>;
+  /**
+   * See BaseDbAdapter.viewRenderRevision. 2 = 0.1.137 (null-guarded field filters, nested document paths).
+   * BUMP whenever `buildViewPipeline` output changes for an unchanged view definition.
+   */
+  viewRenderRevision(): string;
   getValidatorPlugins(): ReturnType<BaseDbAdapter["getValidatorPlugins"]>;
   /**
    * Mongo can filter on JSON-stored fields natively — arrays via implicit
@@ -471,8 +478,15 @@ declare class MongoAdapter extends BaseDbAdapter {
  *
  * MongoDB's query language is nearly identical to the `FilterExpr` structure,
  * so this is largely a structural pass-through via the `walkFilter` visitor.
+ * `fieldOperands` (view predicates only — `translateQueryTree` output) turns
+ * `{ $field: path }` operands into field-to-field `$expr` comparisons; a
+ * request filter never gets that reading.
  */
-declare function buildMongoFilter(filter: FilterExpr): Filter<any>;
+declare function buildMongoFilter(filter: FilterExpr, {
+  fieldOperands
+}?: {
+  fieldOperands?: boolean;
+}): Filter<any>;
 //#endregion
 //#region src/lib/validate-plugins.d.ts
 declare const validateMongoIdPlugin: TValidatorPlugin;

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { t as buildMongoFilter } from "./mongo-filter-CtyITmZM.mjs";
-import { ALL_BUCKET_UNITS, BaseDbAdapter, DbError, DbSpace, bucketTimeZoneUnavailable, computeInsights, createFailureCollector, getDbFieldOp, getKeyProps, isAtscriptDbView, resolveDesignType } from "@atscript/db";
+import { a as queryNodeToExpr, i as orNull, n as distinctCountExpr, r as buildMongoFilter, t as buildAccumulator } from "./mongo-accumulator-Dc0w4t0l.mjs";
+import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, BaseDbAdapter, DbError, DbSpace, bucketTimeZoneUnavailable, computeInsights, createFailureCollector, getDbFieldOp, getKeyProps, isAtscriptDbView, isFieldRef, resolveDesignType, tableNameOf, translateQueryTree } from "@atscript/db";
 import { MongoClient, MongoServerError, ObjectId } from "mongodb";
 import { resolveAggregateSearch } from "@atscript/db/agg";
 //#region src/lib/path-utils.ts
@@ -497,7 +497,7 @@ function buildFromLookup(host, withRel, relation, tableResolver) {
 	if (!targetMeta) return;
 	const remoteFK = findRemoteFK(targetMeta, host._table.tableName, relation.alias);
 	if (!remoteFK) return;
-	const targetTableName = resolveRelTargetTableName(relation);
+	const targetTableName = tableNameOf(relation.targetType());
 	const innerPipeline = buildLookupInnerPipeline(withRel, remoteFK.fields);
 	const { letVars, exprMatch } = buildLookupJoin(remoteFK.targetFields, remoteFK.fields, "pk_");
 	const stages = [{ $lookup: {
@@ -522,8 +522,8 @@ function buildViaLookup(host, withRel, relation, tableResolver) {
 	if (!junctionType) return;
 	const junctionMeta = tableResolver(junctionType);
 	if (!junctionMeta) return;
-	const junctionTableName = junctionType.metadata?.get("db.table") || junctionType.id || "";
-	const targetTableName = resolveRelTargetTableName(relation);
+	const junctionTableName = tableNameOf(junctionType);
+	const targetTableName = tableNameOf(relation.targetType());
 	const fkToThis = findRemoteFK(junctionMeta, host._table.tableName);
 	if (!fkToThis) return;
 	const fkToTarget = findRemoteFK(junctionMeta, targetTableName);
@@ -619,7 +619,7 @@ function mergeRelationResults(rows, results, primaryKeys, relMeta) {
 }
 /** Finds FK entry for a TO relation from this table's foreignKeys map. */
 function findFKForRelation(relation, foreignKeys) {
-	const targetTableName = resolveRelTargetTableName(relation);
+	const targetTableName = tableNameOf(relation.targetType());
 	for (const fk of foreignKeys.values()) if (relation.alias) {
 		if (fk.alias === relation.alias) return {
 			localFields: fk.fields,
@@ -639,11 +639,6 @@ function findRemoteFK(target, thisTableName, alias) {
 		if (!alias && fk.targetTable === thisTableName) return fk;
 	}
 }
-/** Resolves the target table/collection name from a relation's target type. */
-function resolveRelTargetTableName(relation) {
-	const targetType = relation.targetType();
-	return targetType?.metadata?.get("db.table") || targetType?.id || "";
-}
 //#endregion
 //#region src/lib/mongo-search.ts
 /** Returns available search indexes as generic metadata for UI. */
@@ -1019,6 +1014,175 @@ async function runSearchWithCountPipeline(host, stage, query, label, threshold,
 	};
 }
 //#endregion
+//#region src/lib/mongo-view-pipeline.ts
+/** Where a joined table's document lands (`$lookup.as`, then unwound). */
+function joinedAs(table) {
+	return `${JOINED_PREFIX}${table}`;
+}
+/**
+* Builds the aggregation pipeline of a managed MongoDB view (created with
+* `viewOn: <entry collection>`):
+*
+* 1. per join, in declaration order: `$lookup` + `$unwind` (inner joins drop
+*    unmatched documents, left joins keep them — `preserveNullAndEmptyArrays`);
+* 2. `@db.view.filter` → `$match`;
+* 3. aggregates → `$group` (+ `$addFields` turning `countDistinct` sets into
+*    their sizes, + `@db.view.having` → `$match`) + `$project`, otherwise a
+*    flat `$project`. A conditional aggregate's predicate reads the same
+*    pipeline paths (SQL null semantics — `queryNodeToExpr`).
+*
+* All field paths are PHYSICAL document paths (`@db.column` renames), joined
+* tables live under `__joined_<table>`. A column whose source may be missing
+* (`nullable` mapping) reads as null; every other column is a plain path, so
+* a `$match` / `$sort` on the view can still push down to an index.
+* @since 0.1.136
+*/
+function buildViewPipeline(view) {
+	const plan = view.viewPlan;
+	const columns = view.getViewColumnMappings();
+	const pipeline = [];
+	const prefixes = new Map([[plan.entryTable, ""]]);
+	const pathOf = (ref) => {
+		const { table, source } = view.resolveRefSource(ref);
+		const prefix = prefixes.get(table);
+		if (prefix === void 0) throw new Error(`View "${view.tableName}": "${table}" is not joined before it is referenced`);
+		return prefix + source.column;
+	};
+	for (const join of plan.joins) {
+		pipeline.push(buildLookup(view, join, prefixes));
+		pipeline.push({ $unwind: {
+			path: `$${joinedAs(join.targetTable)}`,
+			preserveNullAndEmptyArrays: join.kind === "left"
+		} });
+		prefixes.set(join.targetTable, `${joinedAs(join.targetTable)}.`);
+	}
+	if (plan.filter) pipeline.push({ $match: viewMatch(plan.filter, pathOf) });
+	/** A column's source field as an aggregation operand. */
+	const colSourceField = (col) => `$${prefixes.get(col.sourceTable) ?? ""}${col.sourceColumn}`;
+	const colValue = (col) => col.nullable ? orNull(colSourceField(col)) : colSourceField(col);
+	if (columns.some((c) => c.aggFn)) {
+		const group = { _id: {} };
+		const project = { _id: 0 };
+		const distinctSizes = {};
+		for (const col of columns) if (col.aggFn) {
+			const predicate = col.aggFilter ? queryNodeToExpr(col.aggFilter, (ref) => `$${pathOf(ref)}`) : void 0;
+			group[col.viewColumn] = buildAccumulator(col.aggFn, col.aggField === "*" ? "*" : colSourceField(col), predicate, col.viewColumn);
+			project[col.viewColumn] = `$${col.viewColumn}`;
+			if (col.aggFn === "countDistinct") distinctSizes[col.viewColumn] = distinctCountExpr(`$${col.viewColumn}`);
+		} else {
+			group._id[col.viewColumn] = colValue(col);
+			project[col.viewColumn] = `$_id.${col.viewColumn}`;
+		}
+		pipeline.push({ $group: group });
+		if (Object.keys(distinctSizes).length > 0) pipeline.push({ $addFields: distinctSizes });
+		if (plan.having) pipeline.push({ $match: havingMatch(plan.having, columns) });
+		pipeline.push({ $project: project });
+	} else {
+		const project = { _id: 0 };
+		for (const col of columns) project[col.viewColumn] = colValue(col);
+		pipeline.push({ $project: project });
+	}
+	return pipeline;
+}
+/**
+* One join's `$lookup`.
+*
+* The simple `localField` / `foreignField` form is used whenever it is exact:
+* a single `=` between a field of the joined table and a field of an outer
+* table (the entry or an earlier join), with the joined field REQUIRED — the
+* simple form matches a null / missing local value to null / missing foreign
+* values, which a required foreign field can never hold. It is kept (rather
+* than always using the pipeline form) because it can use an index on the
+* foreign field on every MongoDB version; the pipeline form's `$expr` match
+* can't before MongoDB 5.0. Everything else uses the pipeline form (`let` +
+* `$match: { $expr }`, SQL null semantics).
+*/
+function buildLookup(view, join, outer) {
+	const as = joinedAs(join.targetTable);
+	const simple = simpleJoinFields(view, join, outer);
+	if (simple) return { $lookup: {
+		from: join.targetTable,
+		...simple,
+		as
+	} };
+	const letVars = {};
+	const varByPath = /* @__PURE__ */ new Map();
+	const pathOf = (ref) => {
+		const { table, source } = view.resolveRefSource(ref);
+		if (table === join.targetTable) return `$${source.column}`;
+		const prefix = outer.get(table);
+		if (prefix === void 0) throw new Error(`View "${view.tableName}": the join on "${join.targetTable}" references "${table}", which is not joined before it`);
+		const outerPath = prefix + source.column;
+		let varName = varByPath.get(outerPath);
+		if (!varName) {
+			varName = `v${varByPath.size}`;
+			varByPath.set(outerPath, varName);
+			letVars[varName] = `$${outerPath}`;
+		}
+		return `$$${varName}`;
+	};
+	const expr = queryNodeToExpr(join.condition, pathOf);
+	return { $lookup: {
+		from: join.targetTable,
+		...varByPath.size > 0 ? { let: letVars } : {},
+		pipeline: [{ $match: { $expr: expr } }],
+		as
+	} };
+}
+/** `{ localField, foreignField }` when the simple `$lookup` form is exact, else `undefined`. */
+function simpleJoinFields(view, join, outer) {
+	let node = join.condition;
+	if ("$and" in node) {
+		const children = node.$and;
+		if (children.length !== 1) return void 0;
+		node = children[0];
+	}
+	if ("$or" in node || "$not" in node || "$and" in node) return void 0;
+	const comp = node;
+	if (comp.op !== "$eq" || !isFieldRef(comp.right)) return void 0;
+	const left = view.resolveRefSource(comp.left);
+	const right = view.resolveRefSource(comp.right);
+	let target;
+	let local;
+	if (left.table === join.targetTable && right.table !== join.targetTable) {
+		target = left;
+		local = right;
+	} else if (right.table === join.targetTable && left.table !== join.targetTable) {
+		target = right;
+		local = left;
+	} else return;
+	const localPrefix = outer.get(local.table);
+	if (localPrefix === void 0) return void 0;
+	const foreign = target.source;
+	if (!(!foreign.optional && foreign.designType !== "union" && foreign.designType !== "unknown")) return void 0;
+	return {
+		localField: localPrefix + local.source.column,
+		foreignField: foreign.column
+	};
+}
+/**
+* A view predicate (`@db.view.filter`, `@db.view.having`) as a `$match`
+* over pipeline paths: the shared query translation (`translateQueryTree` →
+* `buildMongoFilter`), so operators mean what they mean in queries (`exists`
+* = holds a value, `matches` takes `/re/flags`); a field-to-field comparison
+* becomes `$expr`.
+*/
+function viewMatch(node, pathOf) {
+	return buildMongoFilter(translateQueryTree(node, pathOf), { fieldOperands: true });
+}
+/**
+* `@db.view.having` as a `$match` after `$group`: refs name view fields —
+* aggregates are top-level, dimensions under `_id`.
+*/
+function havingMatch(node, columns) {
+	const colMap = new Map(columns.map((c) => [c.viewPath, c]));
+	return viewMatch(node, (ref) => {
+		const col = ref.type ? void 0 : colMap.get(ref.field);
+		if (!col) return ref.field;
+		return col.aggFn ? col.viewColumn : `_id.${col.viewColumn}`;
+	});
+}
+//#endregion
 //#region src/lib/mongo-schema-sync.ts
 const DESTRUCTIVE_OPTION_KEYS = new Set([
 	"capped",
@@ -1079,134 +1243,17 @@ async function getObjectKindImpl(host, name) {
 	if (type === void 0) return;
 	return type === "view" ? "view" : "table";
 }
-/** Creates a MongoDB view from the AtscriptDbView's view plan. */
+/** Creates a MongoDB view from the AtscriptDbView's view plan (pipeline: {@link buildViewPipeline}). */
 async function ensureView(host, view) {
 	if (await host.collectionExists()) return;
 	const plan = view.viewPlan;
-	const columns = view.getViewColumnMappings();
-	const pipeline = [];
-	for (const join of plan.joins) {
-		const { localField, foreignField } = resolveJoinFields(join.condition, plan.entryTable, join.targetTable);
-		pipeline.push({ $lookup: {
-			from: join.targetTable,
-			localField,
-			foreignField,
-			as: `${JOINED_PREFIX}${join.targetTable}`
-		} });
-		pipeline.push({ $unwind: {
-			path: `$__joined_${join.targetTable}`,
-			preserveNullAndEmptyArrays: true
-		} });
-	}
-	if (plan.filter) {
-		const matchExpr = queryNodeToMatch(plan.filter, plan.entryTable);
-		pipeline.push({ $match: matchExpr });
-	}
-	const hasAggregates = columns.some((c) => c.aggFn);
-	/** Resolves a column to its MongoDB source field path. */
-	const colSourceField = (col) => col.sourceTable === plan.entryTable ? `$${col.sourceColumn}` : `$${JOINED_PREFIX}${col.sourceTable}.${col.sourceColumn}`;
-	if (hasAggregates) {
-		const group = { _id: {} };
-		const project = { _id: 0 };
-		for (const col of columns) if (col.aggFn) {
-			if (col.aggFn === "count" && col.aggField === "*") group[col.viewColumn] = { $sum: 1 };
-			else group[col.viewColumn] = { [`$${col.aggFn}`]: colSourceField(col) };
-			project[col.viewColumn] = `$${col.viewColumn}`;
-		} else {
-			group._id[col.viewColumn] = colSourceField(col);
-			project[col.viewColumn] = `$_id.${col.viewColumn}`;
-		}
-		pipeline.push({ $group: group });
-		if (plan.having) {
-			const havingMatch = queryNodeToHaving(plan.having, columns);
-			pipeline.push({ $match: havingMatch });
-		}
-		pipeline.push({ $project: project });
-	} else {
-		const project = { _id: 0 };
-		for (const col of columns) project[col.viewColumn] = colSourceField(col);
-		pipeline.push({ $project: project });
-	}
+	const pipeline = buildViewPipeline(view);
 	host._log("createView", host._table.tableName, plan.entryTable, pipeline);
 	await host.db.createCollection(host._table.tableName, {
 		viewOn: plan.entryTable,
 		pipeline
 	});
 }
-/** Extracts localField/foreignField from a join condition. */
-function resolveJoinFields(condition, entryTable, joinTable) {
-	const c = "$and" in condition ? condition.$and[0] : condition;
-	if ((c.left.type ? c.left.type()?.metadata?.get("db.table") || "" : entryTable) === joinTable) return {
-		localField: c.right.field,
-		foreignField: c.left.field
-	};
-	return {
-		localField: c.left.field,
-		foreignField: c.right.field
-	};
-}
-/** Translates an AtscriptQueryNode to a MongoDB $match expression. */
-function queryNodeToMatch(node, entryTable) {
-	if ("$and" in node) {
-		const items = node.$and;
-		const result = [];
-		for (const item of items) result.push(queryNodeToMatch(item, entryTable));
-		return { $and: result };
-	}
-	if ("$or" in node) {
-		const items = node.$or;
-		const result = [];
-		for (const item of items) result.push(queryNodeToMatch(item, entryTable));
-		return { $or: result };
-	}
-	if ("$not" in node) return { $not: queryNodeToMatch(node.$not, entryTable) };
-	const comp = node;
-	const fieldPath = resolveViewFieldPath(comp.left, entryTable);
-	if (comp.right && typeof comp.right === "object" && "field" in comp.right) {
-		const rightPath = resolveViewFieldPath(comp.right, entryTable);
-		return { $expr: { [comp.op]: [`$${fieldPath}`, `$${rightPath}`] } };
-	}
-	if (comp.op === "$eq") return { [fieldPath]: comp.right };
-	if (comp.op === "$ne") return { [fieldPath]: { $ne: comp.right } };
-	return { [fieldPath]: { [comp.op]: comp.right } };
-}
-/** Resolves a field ref to a MongoDB dot path for view pipeline expressions. */
-function resolveViewFieldPath(ref, entryTable) {
-	if (!ref.type) return ref.field;
-	const table = ref.type()?.metadata?.get("db.table") || "";
-	if (table === entryTable) return ref.field;
-	return `${JOINED_PREFIX}${table}.${ref.field}`;
-}
-/**
-* Translates an AtscriptQueryNode to a MongoDB $match for use after $group (HAVING).
-* After $group, aggregate fields are top-level and dimension fields are under _id.
-*/
-function queryNodeToHaving(node, columns) {
-	const colMap = new Map(columns.map((c) => [c.viewColumn, c]));
-	const resolveHavingField = (ref) => {
-		if (!ref.type) {
-			const col = colMap.get(ref.field);
-			if (col?.aggFn) return ref.field;
-			if (col) return `_id.${ref.field}`;
-		}
-		return ref.field;
-	};
-	return queryNodeToHavingInner(node, resolveHavingField);
-}
-function queryNodeToHavingInner(node, resolveField) {
-	if ("$and" in node) return { $and: node.$and.map((n) => queryNodeToHavingInner(n, resolveField)) };
-	if ("$or" in node) return { $or: node.$or.map((n) => queryNodeToHavingInner(n, resolveField)) };
-	if ("$not" in node) return { $not: queryNodeToHavingInner(node.$not, resolveField) };
-	const comp = node;
-	const fieldPath = resolveField(comp.left);
-	if (comp.right && typeof comp.right === "object" && "field" in comp.right) {
-		const rightPath = resolveField(comp.right);
-		return { $expr: { [comp.op]: [`$${fieldPath}`, `$${rightPath}`] } };
-	}
-	if (comp.op === "$eq") return { [fieldPath]: comp.right };
-	if (comp.op === "$ne") return { [fieldPath]: { $ne: comp.right } };
-	return { [fieldPath]: { [comp.op]: comp.right } };
-}
 async function dropTableImpl(host) {
 	host._log("drop", host._table.tableName);
 	await host.collection.drop();
@@ -1249,65 +1296,75 @@ async function renameTableImpl(host, oldName) {
 async function syncColumnsImpl(host, diff) {
 	const renamed = [];
 	const added = [];
-	const update = {};
-	if (diff.renamed.length > 0) {
-		const renameSpec = {};
-		for (const r of diff.renamed) {
-			if (pathCrossesArray(host, r.field.path)) {
-				host._log("syncColumns: skipping $rename for array-element field", r.oldName, "→", r.field.physicalName, "(Mongo $rename cannot traverse arrays)");
-				continue;
-			}
-			renameSpec[r.oldName] = r.field.physicalName;
-			renamed.push(r.field.physicalName);
-		}
-		if (Object.keys(renameSpec).length > 0) update.$rename = renameSpec;
-	}
-	if (diff.added.length > 0) {
-		const setSpec = {};
-		for (const field of diff.added) {
-			const defaultVal = resolveSyncDefault(field);
-			if (defaultVal !== void 0) setSpec[arraySafePath(host, field.physicalName, field.path)] = defaultVal;
-			added.push(field.physicalName);
+	const renameSpec = {};
+	for (const r of diff.renamed) {
+		if (pathCrossesArray(host, r.field.path)) {
+			host._log("syncColumns: skipping $rename for array-element field", r.oldName, "→", r.field.physicalName, "(Mongo $rename cannot traverse arrays)");
+			continue;
 		}
-		if (Object.keys(setSpec).length > 0) update.$set = setSpec;
+		renameSpec[r.oldName] = r.field.physicalName;
+		renamed.push(r.field.physicalName);
+	}
+	if (renamed.length > 0) await host.collection.updateMany({}, { $rename: renameSpec }, host._getSessionOpts());
+	for (const field of diff.added) {
+		const value = resolveSyncDefault(field);
+		if (value !== void 0) await defaultBackfill(host, field.path, value);
+		added.push(field.physicalName);
 	}
-	if (Object.keys(update).length > 0) await host.collection.updateMany({}, update, host._getSessionOpts());
 	return {
 		added,
 		renamed
 	};
 }
+/**
+* Backfills an added field's `@db.default` literal where the field is
+* missing — a stored value is never overwritten. Optional fields without a
+* default get no backfill (absent = "optional" in Mongo). A path crossing an
+* array narrows the innermost `$[]` to an `arrayFilters` element missing the
+* sub-path; outer arrays keep `$[]`, so empty arrays are a no-op (a bare
+* dotted path into an empty array is rejected with code 28).
+*/
+async function defaultBackfill(host, logicalPath, value) {
+	const segments = positionalSegments(host, logicalPath);
+	const inner = segments.lastIndexOf("$[]");
+	const opts = host._getSessionOpts();
+	if (inner === -1) {
+		const path = segments.join(".");
+		await host.collection.updateMany({ [path]: { $exists: false } }, { $set: { [path]: value } }, opts);
+		return;
+	}
+	segments[inner] = "$[backfill]";
+	const rest = segments.slice(inner + 1).join(".");
+	await host.collection.updateMany({}, { $set: { [segments.join(".")]: value } }, {
+		...opts,
+		arrayFilters: [{ [`backfill.${rest}`]: { $exists: false } }]
+	});
+}
 async function dropColumnsImpl(host, columns) {
 	if (columns.length === 0) return;
 	const dropped = new Set(columns);
 	const minimal = columns.filter((col) => !hasAncestorIn(col, dropped));
 	const unsetSpec = {};
-	for (const col of minimal) unsetSpec[arraySafePath(host, col, col)] = "";
+	for (const col of minimal) unsetSpec[positionalSegments(host, col, col).join(".")] = "";
 	await host.collection.updateMany({}, { $unset: unsetSpec }, host._getSessionOpts());
 }
 /**
-* Rewrites a dotted physical path to use Mongo's all-positional $[] operator
-* at every segment that's typed as an array in the table's flatMap. Returns
-* the input unchanged when no segment crosses an array boundary.
-*
-* `logicalPath` drives the array-boundary walk (flatMap is keyed by logical
-* path); the leaf of `physicalPath` is preserved so any `@db.column` rename
-* on the leaf still applies.
+* The segments of a field's physical document path with `$[]` after every
+* segment whose logical prefix is an array in the flatMap — Mongo's
+* all-positional operator walks every element. `physicalPath` defaults to
+* the logical path's document path (same segment count).
 */
-function arraySafePath(host, physicalPath, logicalPath) {
-	const logicalSegments = logicalPath.split(".");
-	if (logicalSegments.length < 2) return physicalPath;
-	const physicalSegments = physicalPath.split(".");
-	const physicalLeaf = physicalSegments[physicalSegments.length - 1];
+function positionalSegments(host, logicalPath, physicalPath = host._table.getMetadata().documentPath(logicalPath)) {
+	const logical = logicalPath.split(".");
+	const physical = physicalPath.split(".");
 	const out = [];
 	let prefix = "";
-	for (let i = 0; i < logicalSegments.length; i++) {
-		const isLeaf = i === logicalSegments.length - 1;
-		out.push(isLeaf ? physicalLeaf : logicalSegments[i]);
-		prefix = joinPath(prefix, logicalSegments[i]);
-		if (!isLeaf && isArrayPath(host._table.flatMap, prefix)) out.push("$[]");
+	for (let i = 0; i < logical.length; i++) {
+		out.push(physical[i]);
+		prefix = joinPath(prefix, logical[i]);
+		if (i < logical.length - 1 && isArrayPath(host._table.flatMap, prefix)) out.push("$[]");
 	}
-	return out.join(".");
+	return out;
 }
 /** Returns true if any non-leaf segment of the path is typed as an array. */
 function pathCrossesArray(host, logicalPath) {
@@ -1766,6 +1823,17 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	calendarBucketUnits() {
 		return ALL_BUCKET_UNITS;
 	}
+	/** Every aggregate function, `countDistinct` included. */
+	aggregateFns() {
+		return ALL_AGGREGATE_FNS;
+	}
+	/**
+	* See BaseDbAdapter.viewRenderRevision. 2 = 0.1.137 (null-guarded field filters, nested document paths).
+	* BUMP whenever `buildViewPipeline` output changes for an unchanged view definition.
+	*/
+	viewRenderRevision() {
+		return "2";
+	}
 	getValidatorPlugins() {
 		return [validateMongoIdPlugin];
 	}
@@ -1874,11 +1942,6 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 			this._addMongoIndexField("unique", "__pk", field);
 			this._pendingUniqueFields.push(field);
 		}
-		if (metadata.has("db.default.increment")) {
-			const physicalName = metadata.get("db.column") ?? field;
-			const startValue = metadata.get("db.default.increment");
-			this._incrementFields.set(physicalName, typeof startValue === "number" ? startValue : void 0);
-		}
 		for (const index of metadata.get("db.mongo.search.text") || []) this._pendingSearchFields.push({
 			indexName: index.indexName,
 			field,
@@ -1954,9 +2017,14 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 				path: value
 			});
 		}
-		for (const fd of this._table.fieldDescriptors) if (fd.collate && fd.collate !== "binary") {
-			if (!this._collateFields) this._collateFields = /* @__PURE__ */ new Map();
-			this._collateFields.set(fd.physicalName, fd.collate);
+		for (const fd of this._table.fieldDescriptors) {
+			if (fd.collate && fd.collate !== "binary") {
+				this._collateFields ??= /* @__PURE__ */ new Map();
+				this._collateFields.set(fd.path, fd.collate);
+				this._collateFields.set(fd.physicalName, fd.collate);
+			}
+			const def = fd.defaultValue;
+			if (def?.kind === "fn" && def.fn === "increment") this._incrementFields.set(fd.physicalName, def.start);
 		}
 	}
 	/** Returns MongoDB-specific search index map (internal). */