@atscript/db-mongo 0.1.135 → 0.1.137

package/dist/mongo-accumulator-BalE9LkU.cjs

@@ -0,0 +1,265 @@
+let _atscript_db = require("@atscript/db");
+let _atscript_db_agg = require("@atscript/db/agg");
+//#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] };
+}
+/**
+* Field-to-field comparison `x <op> y` (`$eq` … `$lte`): both operands must
+* be non-null (SQL `NULL = NULL` is UNKNOWN) — view predicates and
+* `buildMongoFilter`'s field operands.
+* @since 0.1.137
+*/
+function fieldCompareExpr(op, x, y) {
+	return guarded([x, y], { [op]: [x, y] });
+}
+/**
+* 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)) return fieldCompareExpr(op, x, pathOf(comp.right));
+	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-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`), null-guarded like SQL ({@link fieldCompareExpr}).
+*/
+const fieldOperandVisitor = {
+	...mongoVisitor,
+	comparison(field, op, value) {
+		return isFieldOperand(value) ? { $expr: fieldCompareExpr(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-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;
+	}
+});

package/dist/mongo-accumulator-Dc0w4t0l.mjs

@@ -0,0 +1,236 @@
+import { isFieldRef, walkFilter } from "@atscript/db";
+import { assertAggregateFn } from "@atscript/db/agg";
+//#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] };
+}
+/**
+* Field-to-field comparison `x <op> y` (`$eq` … `$lte`): both operands must
+* be non-null (SQL `NULL = NULL` is UNKNOWN) — view predicates and
+* `buildMongoFilter`'s field operands.
+* @since 0.1.137
+*/
+function fieldCompareExpr(op, x, y) {
+	return guarded([x, y], { [op]: [x, y] });
+}
+/**
+* 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 (isFieldRef(comp.right)) return fieldCompareExpr(op, x, pathOf(comp.right));
+	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-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`), null-guarded like SQL ({@link fieldCompareExpr}).
+*/
+const fieldOperandVisitor = {
+	...mongoVisitor,
+	comparison(field, op, value) {
+		return isFieldOperand(value) ? { $expr: fieldCompareExpr(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 walkFilter(filter, fieldOperands ? fieldOperandVisitor : mongoVisitor) ?? EMPTY;
+}
+//#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) {
+	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
+export { queryNodeToExpr as a, orNull as i, distinctCountExpr as n, buildMongoFilter as r, buildAccumulator as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db-mongo",
-  "version": "0.1.135",
+  "version": "0.1.137",
   "description": "Mongodb plugin for atscript.",
   "keywords": [
     "atscript",
@@ -58,7 +58,7 @@
     "@atscript/typescript": "^0.1.92",
     "@uniqu/core": "^0.1.11",
     "mongodb": "^6.17.0",
-    "@atscript/db": "^0.1.135"
+    "@atscript/db": "^0.1.137"
   },
   "scripts": {
     "postinstall": "asc -f dts",

package/dist/mongo-filter-Bf5rWV4P.cjs

@@ -1,73 +0,0 @@
-let _atscript_db = require("@atscript/db");
-//#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] };
-	}
-};
-/**
-* 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.
-*/
-function buildMongoFilter(filter) {
-	if (!filter || Object.keys(filter).length === 0) return EMPTY;
-	return (0, _atscript_db.walkFilter)(filter, mongoVisitor) ?? EMPTY;
-}
-//#endregion
-Object.defineProperty(exports, "buildMongoFilter", {
-	enumerable: true,
-	get: function() {
-		return buildMongoFilter;
-	}
-});

package/dist/mongo-filter-CtyITmZM.mjs

@@ -1,68 +0,0 @@
-import { walkFilter } from "@atscript/db";
-//#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] };
-	}
-};
-/**
-* 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.
-*/
-function buildMongoFilter(filter) {
-	if (!filter || Object.keys(filter).length === 0) return EMPTY;
-	return walkFilter(filter, mongoVisitor) ?? EMPTY;
-}
-//#endregion
-export { buildMongoFilter as t };