@atscript/db-mongo 0.1.135 → 0.1.137

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_mongo_filter = require("./mongo-filter-Bf5rWV4P.cjs");
+const require_mongo_accumulator = require("./mongo-accumulator-BalE9LkU.cjs");
 let _atscript_db = require("@atscript/db");
 let mongodb = require("mongodb");
 let _atscript_db_agg = require("@atscript/db/agg");
@@ -498,7 +498,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 = (0, _atscript_db.tableNameOf)(relation.targetType());
 	const innerPipeline = buildLookupInnerPipeline(withRel, remoteFK.fields);
 	const { letVars, exprMatch } = buildLookupJoin(remoteFK.targetFields, remoteFK.fields, "pk_");
 	const stages = [{ $lookup: {
@@ -523,8 +523,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 = (0, _atscript_db.tableNameOf)(junctionType);
+	const targetTableName = (0, _atscript_db.tableNameOf)(relation.targetType());
 	const fkToThis = findRemoteFK(junctionMeta, host._table.tableName);
 	if (!fkToThis) return;
 	const fkToTarget = findRemoteFK(junctionMeta, targetTableName);
@@ -565,7 +565,7 @@ function buildLookupInnerPipeline(withRel, requiredFields) {
 	const limit = nested.$limit ?? flatRel.$limit;
 	const skip = nested.$skip ?? flatRel.$skip;
 	const select = nested.$select || flatRel.$select;
-	if (filter && Object.keys(filter).length > 0) pipeline.push({ $match: require_mongo_filter.buildMongoFilter(filter) });
+	if (filter && Object.keys(filter).length > 0) pipeline.push({ $match: require_mongo_accumulator.buildMongoFilter(filter) });
 	if (sort) pipeline.push({ $sort: sort });
 	if (skip) pipeline.push({ $skip: skip });
 	if (limit !== null && limit !== void 0) pipeline.push({ $limit: limit });
@@ -620,7 +620,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 = (0, _atscript_db.tableNameOf)(relation.targetType());
 	for (const fk of foreignKeys.values()) if (relation.alias) {
 		if (fk.alias === relation.alias) return {
 			localFields: fk.fields,
@@ -640,11 +640,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. */
@@ -752,7 +747,7 @@ function buildGeoNearStage(host, point, query, indexName) {
 		distanceField: DISTANCE_FIELD,
 		spherical: true,
 		key: resolveGeoKeyPath(host, indexName),
-		query: require_mongo_filter.buildMongoFilter(query.filter)
+		query: require_mongo_accumulator.buildMongoFilter(query.filter)
 	};
 	if (typeof controls.$maxDistance === "number") geoNear.maxDistance = controls.$maxDistance;
 	if (typeof controls.$minDistance === "number") geoNear.minDistance = controls.$minDistance;
@@ -965,7 +960,7 @@ function buildVectorSearchStage(host, vector, indexName, limit) {
 }
 /** Runs a search/vector pipeline and returns results. Shared by search + vectorSearch. */
 async function runSearchPipeline(host, stage, query, label, threshold, classicText = false) {
-	const filter = require_mongo_filter.buildMongoFilter(query.filter);
+	const filter = require_mongo_accumulator.buildMongoFilter(query.filter);
 	const controls = query.controls || {};
 	const pipeline = [stage];
 	if (threshold !== void 0) {
@@ -987,7 +982,7 @@ async function runSearchPipeline(host, stage, query, label, threshold, classicTe
 }
 /** Runs a search/vector pipeline with $facet for count. Shared by searchWithCount + vectorSearchWithCount. */
 async function runSearchWithCountPipeline(host, stage, query, label, threshold, classicText = false) {
-	const filter = require_mongo_filter.buildMongoFilter(query.filter);
+	const filter = require_mongo_accumulator.buildMongoFilter(query.filter);
 	const controls = query.controls || {};
 	const preStages = [];
 	if (threshold !== void 0) {
@@ -1020,6 +1015,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 ? require_mongo_accumulator.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 ? require_mongo_accumulator.queryNodeToExpr(col.aggFilter, (ref) => `$${pathOf(ref)}`) : void 0;
+			group[col.viewColumn] = require_mongo_accumulator.buildAccumulator(col.aggFn, col.aggField === "*" ? "*" : colSourceField(col), predicate, col.viewColumn);
+			project[col.viewColumn] = `$${col.viewColumn}`;
+			if (col.aggFn === "countDistinct") distinctSizes[col.viewColumn] = require_mongo_accumulator.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 = require_mongo_accumulator.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" || !(0, _atscript_db.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 require_mongo_accumulator.buildMongoFilter((0, _atscript_db.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",
@@ -1080,134 +1244,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();
@@ -1250,65 +1297,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) {
@@ -1767,6 +1824,17 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 	calendarBucketUnits() {
 		return _atscript_db.ALL_BUCKET_UNITS;
 	}
+	/** Every aggregate function, `countDistinct` included. */
+	aggregateFns() {
+		return _atscript_db.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];
 	}
@@ -1875,11 +1943,6 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.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,
@@ -1955,9 +2018,14 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.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). */
@@ -2030,7 +2098,7 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		return geoSearchWithCountImpl(this, point, query, indexName);
 	}
 	async findManyWithCount(query) {
-		const filter = require_mongo_filter.buildMongoFilter(query.filter);
+		const filter = require_mongo_accumulator.buildMongoFilter(query.filter);
 		const controls = query.controls || {};
 		const dataStages = [];
 		if (controls.$sort) dataStages.push({ $sort: controls.$sort });
@@ -2077,7 +2145,7 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 	_buildCasFilter(filter, expectedVersion, op) {
 		const versionColumn = this._table.versionColumn;
 		if (expectedVersion !== void 0 && versionColumn === void 0) throw new Error(`${op}: expectedVersion requires versionColumn`);
-		const mongoFilter = require_mongo_filter.buildMongoFilter(filter);
+		const mongoFilter = require_mongo_accumulator.buildMongoFilter(filter);
 		if (expectedVersion !== void 0 && versionColumn !== void 0) mongoFilter[versionColumn] = expectedVersion;
 		return mongoFilter;
 	}
@@ -2128,7 +2196,7 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		};
 	}
 	async findOne(query) {
-		const filter = require_mongo_filter.buildMongoFilter(query.filter);
+		const filter = require_mongo_accumulator.buildMongoFilter(query.filter);
 		const opts = this._buildFindOptions(query.controls);
 		this._log("findOne", filter, opts);
 		return wrapInvalidQuery(() => this.collection.findOne(filter, {
@@ -2138,7 +2206,7 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		}));
 	}
 	async findMany(query) {
-		const filter = require_mongo_filter.buildMongoFilter(query.filter);
+		const filter = require_mongo_accumulator.buildMongoFilter(query.filter);
 		const opts = this._buildFindOptions(query.controls);
 		this._log("findMany", filter, opts);
 		return wrapInvalidQuery(() => this.collection.find(filter, {
@@ -2148,7 +2216,7 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		}).toArray());
 	}
 	async count(query) {
-		const filter = require_mongo_filter.buildMongoFilter(query.filter);
+		const filter = require_mongo_accumulator.buildMongoFilter(query.filter);
 		this._log("countDocuments", filter);
 		return this.collection.countDocuments(filter, {
 			...this._getCollationOpts(query),
@@ -2183,13 +2251,13 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		};
 	}
 	async deleteOne(filter) {
-		const mongoFilter = require_mongo_filter.buildMongoFilter(filter);
+		const mongoFilter = require_mongo_accumulator.buildMongoFilter(filter);
 		this._log("deleteOne", mongoFilter);
 		return { deletedCount: (await this.collection.deleteOne(mongoFilter, this._getSessionOpts())).deletedCount };
 	}
 	async updateMany(filter, data, ops) {
 		const versionColumn = this._table.versionColumn;
-		const mongoFilter = require_mongo_filter.buildMongoFilter(filter);
+		const mongoFilter = require_mongo_accumulator.buildMongoFilter(filter);
 		const updateDoc = buildMongoUpdateDoc(data, ops, versionColumn);
 		this._log("updateMany", mongoFilter, updateDoc);
 		const result = await this.collection.updateMany(mongoFilter, updateDoc, this._getSessionOpts());
@@ -2199,7 +2267,7 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		};
 	}
 	async replaceMany(filter, data) {
-		const mongoFilter = require_mongo_filter.buildMongoFilter(filter);
+		const mongoFilter = require_mongo_accumulator.buildMongoFilter(filter);
 		const updateDoc = buildMongoUpdateDoc(data, void 0, this._table.versionColumn);
 		this._log("replaceMany", mongoFilter, updateDoc);
 		const result = await this.collection.updateMany(mongoFilter, updateDoc, this._getSessionOpts());
@@ -2209,7 +2277,7 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		};
 	}
 	async deleteMany(filter) {
-		const mongoFilter = require_mongo_filter.buildMongoFilter(filter);
+		const mongoFilter = require_mongo_accumulator.buildMongoFilter(filter);
 		this._log("deleteMany", mongoFilter);
 		return { deletedCount: (await this.collection.deleteMany(mongoFilter, this._getSessionOpts())).deletedCount };
 	}
@@ -2519,7 +2587,7 @@ function createAdapter(connection, _options) {
 exports.CollectionPatcher = CollectionPatcher;
 exports.INDEX_PREFIX = INDEX_PREFIX;
 exports.MongoAdapter = MongoAdapter;
-exports.buildMongoFilter = require_mongo_filter.buildMongoFilter;
+exports.buildMongoFilter = require_mongo_accumulator.buildMongoFilter;
 exports.createAdapter = createAdapter;
 exports.mongoIndexKey = mongoIndexKey;
 exports.validateMongoIdPlugin = validateMongoIdPlugin;