@atscript/db-mongo 0.1.135 → 0.1.136

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 buildMongoFilter, i as queryNodeToExpr, n as distinctCountExpr, r as orNull, t as buildAccumulator } from "./mongo-accumulator-Dh6eEkyR.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();
@@ -1766,6 +1813,10 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	calendarBucketUnits() {
 		return ALL_BUCKET_UNITS;
 	}
+	/** Every aggregate function, `countDistinct` included. */
+	aggregateFns() {
+		return ALL_AGGREGATE_FNS;
+	}
 	getValidatorPlugins() {
 		return [validateMongoIdPlugin];
 	}

package/dist/mongo-accumulator-C8J36t07.cjs

@@ -0,0 +1,256 @@
+let _atscript_db = require("@atscript/db");
+let _atscript_db_agg = require("@atscript/db/agg");
+//#region src/lib/mongo-filter.ts
+const EMPTY = {};
+function parseRegexString(value) {
+	if (value instanceof RegExp) return {
+		pattern: value.source,
+		flags: value.flags
+	};
+	const str = String(value);
+	const match = str.match(/^\/(.+)\/([gimsuy]*)$/);
+	if (match) return {
+		pattern: match[1],
+		flags: match[2]
+	};
+	return {
+		pattern: str,
+		flags: ""
+	};
+}
+/**
+* Earth radius in meters used by MongoDB's `$centerSphere` radians conversion
+* (Mongo documents dividing by 6378.1 km).
+*/
+const EARTH_RADIUS_M = 6378100;
+const mongoVisitor = {
+	comparison(field, op, value) {
+		if (op === "$eq") return { [field]: value };
+		if (op === "$exists") return value ? { [field]: { $ne: null } } : { [field]: null };
+		if (op === "$regex") {
+			const { pattern, flags } = parseRegexString(value);
+			return flags ? { [field]: {
+				$regex: pattern,
+				$options: flags
+			} } : { [field]: { $regex: pattern } };
+		}
+		if (op === "$geoWithin") {
+			const { center, radius } = value;
+			return { [field]: { $geoWithin: { $centerSphere: [center, radius / EARTH_RADIUS_M] } } };
+		}
+		return { [field]: { [op]: value } };
+	},
+	and(children) {
+		if (children.length === 0) return EMPTY;
+		if (children.length === 1) return children[0];
+		return { $and: children };
+	},
+	or(children) {
+		if (children.length === 0) return { _impossible: true };
+		if (children.length === 1) return children[0];
+		return { $or: children };
+	},
+	not(child) {
+		return { $nor: [child] };
+	}
+};
+/** A `{ $field: path }` comparison operand (a field-to-field comparison). */
+function isFieldOperand(value) {
+	return value !== null && typeof value === "object" && typeof value.$field === "string";
+}
+/** {@link mongoVisitor} plus field-to-field comparisons (`{ $field }` operands → `$expr`). */
+const fieldOperandVisitor = {
+	...mongoVisitor,
+	comparison(field, op, value) {
+		return isFieldOperand(value) ? { $expr: { [op]: [`$${field}`, `$${value.$field}`] } } : mongoVisitor.comparison(field, op, value);
+	}
+};
+/**
+* Translates a generic {@link FilterExpr} into a MongoDB-compatible
+* {@link Filter} document.
+*
+* 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.
+*/
+function buildMongoFilter(filter, { fieldOperands = false } = {}) {
+	if (!filter || Object.keys(filter).length === 0) return EMPTY;
+	return (0, _atscript_db.walkFilter)(filter, fieldOperands ? fieldOperandVisitor : mongoVisitor) ?? EMPTY;
+}
+//#endregion
+//#region src/lib/mongo-view-expr.ts
+/**
+* `x IS NOT NULL` in SQL terms — true when `x` is neither null nor missing.
+* Aggregation order puts a missing value below null and every other value
+* above it, so one comparison covers both (`{ $ne: [x, null] }` alone would
+* be true for a MISSING field).
+* @since 0.1.136
+*/
+function notNullExpr(x) {
+	return { $gt: [x, null] };
+}
+/** `x IS NULL` in SQL terms — true when `x` is null or missing (see {@link notNullExpr}). @since 0.1.136 */
+function isNullExpr(x) {
+	return { $lte: [x, null] };
+}
+/**
+* `x`, with a missing value read as null — for a projected column (a missing
+* key would drop it from the row) and a `$group` key (missing and null would
+* form two groups). Only where a value may be missing: the wrapper hides the
+* path from `$match` / `$sort` pushdown.
+* @since 0.1.136
+*/
+function orNull(x) {
+	return { $ifNull: [x, null] };
+}
+/** A literal inside `$expr` — `$`-prefixed strings would otherwise read as field paths. */
+function literal(value) {
+	return typeof value === "string" && value.startsWith("$") ? { $literal: value } : value;
+}
+const COMPARISONS = {
+	$eq: "$eq",
+	$ne: "$ne",
+	$gt: "$gt",
+	$gte: "$gte",
+	$lt: "$lt",
+	$lte: "$lte"
+};
+/** `cond` AND-guarded so that every field operand is non-null (SQL: NULL operand → not true). */
+function guarded(operands, cond) {
+	return { $and: [...operands.map((o) => notNullExpr(o)), cond] };
+}
+/**
+* Translates a view predicate (join condition, conditional-aggregate filter)
+* to an aggregation expression for `$match: { $expr }` / `$cond`, matching
+* SQL's three-valued logic wherever a NULL operand makes SQL's comparison
+* UNKNOWN (treated as false):
+*
+* - `<`, `<=`, `>`, `>=`, `!= <literal>`, field `=` field, field `!=` field
+*   and `not in` are guarded with "every field operand is not null";
+* - `= null` / `not exists` → null-or-missing; `!= null` / `exists` → neither;
+* - `= <literal>` and `in (…)` compare directly (a null operand never equals
+*   a non-null literal); an empty `not in` is true;
+* - `and` / `or` / `not` map directly — so `not (x > 1)` is TRUE for a null
+*   `x` here while SQL yields UNKNOWN (documented divergence);
+* - `matches` is rejected (`$regexMatch` needs MongoDB 4.2).
+* @since 0.1.136
+*/
+function queryNodeToExpr(node, pathOf) {
+	if ("$and" in node) return { $and: node.$and.map((n) => queryNodeToExpr(n, pathOf)) };
+	if ("$or" in node) return { $or: node.$or.map((n) => queryNodeToExpr(n, pathOf)) };
+	if ("$not" in node) return { $not: [queryNodeToExpr(node.$not, pathOf)] };
+	const comp = node;
+	const x = pathOf(comp.left);
+	switch (comp.op) {
+		case "$exists": return comp.right === false ? isNullExpr(x) : notNullExpr(x);
+		case "$in": return { $in: [x, (Array.isArray(comp.right) ? comp.right : [comp.right]).map((v) => literal(v))] };
+		case "$nin": {
+			const values = Array.isArray(comp.right) ? comp.right : [comp.right];
+			if (values.length === 0) return { $literal: true };
+			return guarded([x], { $not: [{ $in: [x, values.map((v) => literal(v))] }] });
+		}
+		case "$regex": throw new Error("matches is not supported in view predicates");
+		default:
+	}
+	const op = COMPARISONS[comp.op];
+	if (!op) throw new Error(`Operator "${comp.op}" is not supported in view predicates`);
+	if ((0, _atscript_db.isFieldRef)(comp.right)) {
+		const y = pathOf(comp.right);
+		return guarded([x, y], { [op]: [x, y] });
+	}
+	if (comp.right === null || comp.right === void 0) {
+		if (op === "$eq") return isNullExpr(x);
+		if (op === "$ne") return notNullExpr(x);
+		return { $literal: false };
+	}
+	const value = literal(comp.right);
+	if (op === "$eq") return { $eq: [x, value] };
+	return guarded([x], { [op]: [x, value] });
+}
+//#endregion
+//#region src/lib/mongo-accumulator.ts
+/**
+* The `$group` accumulator of one aggregate — shared by grouped queries
+* (`agg.ts`) and managed views (`mongo-view-pipeline.ts`), so both count and
+* sum alike.
+*
+* - `count(*)` → `{ $sum: 1 }`; `count(f)` counts values that are neither
+*   null nor missing (SQL `COUNT(f)`);
+* - `sum` / `avg` / `min` / `max` → `$sum` / `$avg` / `$min` / `$max` (all
+*   skip null / missing values);
+* - `countDistinct(f)` → `{ $addToSet: { $ifNull: [f, "$$REMOVE"] } }`, a
+*   SET of the non-null values (`$$REMOVE` adds nothing) the caller turns
+*   into its size with {@link distinctCountExpr}.
+*
+* `where` (a conditional aggregate's row predicate, an aggregation
+* expression) swaps the source for `{ $cond: [where, src, null] }` — the
+* rejected rows contribute a null, which every accumulator skips — and makes
+* the counts `{ $sum: { $cond: [where (and not null), 1, 0] } }`.
+*
+* @param fn - The aggregate function (re-asserted: `INVALID_QUERY` when unknown).
+* @param src - The source operand (`"$path"`), or `"*"` for `count(*)`.
+* @param where - Row predicate of a conditional aggregate.
+* @param path - Error path of the re-assertion.
+*/
+function buildAccumulator(fn, src, where, path) {
+	(0, _atscript_db_agg.assertAggregateFn)(fn, path);
+	if (fn === "count") {
+		if (src === "*") return { $sum: where ? { $cond: [
+			where,
+			1,
+			0
+		] } : 1 };
+		return { $sum: { $cond: [
+			where ? { $and: [where, notNullExpr(src)] } : notNullExpr(src),
+			1,
+			0
+		] } };
+	}
+	const value = where ? { $cond: [
+		where,
+		src,
+		null
+	] } : src;
+	return fn === "countDistinct" ? { $addToSet: { $ifNull: [value, "$$REMOVE"] } } : { [`$${fn}`]: value };
+}
+/**
+* The size of a `countDistinct` set (`"$alias"`) — the value the accumulator
+* stands for, projected right after `$group` so later stages (`$having`,
+* `$sort`) see a number.
+*/
+function distinctCountExpr(set) {
+	return { $size: set };
+}
+//#endregion
+Object.defineProperty(exports, "buildAccumulator", {
+	enumerable: true,
+	get: function() {
+		return buildAccumulator;
+	}
+});
+Object.defineProperty(exports, "buildMongoFilter", {
+	enumerable: true,
+	get: function() {
+		return buildMongoFilter;
+	}
+});
+Object.defineProperty(exports, "distinctCountExpr", {
+	enumerable: true,
+	get: function() {
+		return distinctCountExpr;
+	}
+});
+Object.defineProperty(exports, "orNull", {
+	enumerable: true,
+	get: function() {
+		return orNull;
+	}
+});
+Object.defineProperty(exports, "queryNodeToExpr", {
+	enumerable: true,
+	get: function() {
+		return queryNodeToExpr;
+	}
+});