@classytic/mongokit 3.39.0 → 3.40.0

package/dist/{update-c_01A0if.mjs → update-DG0fCwRJ.mjs}

@@ -95,6 +95,122 @@ async function upsert(Model, query, data, options = {}) {
 	});
 }
 //#endregion
+//#region src/filter/cast-schema.ts
+/** Operators whose operand is a single scalar to cast. */
+const SCALAR_OPS = /* @__PURE__ */ new Set([
+	"$eq",
+	"$ne",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte"
+]);
+/** Operators whose operand is an array of scalars to cast element-wise. */
+const ARRAY_OPS = /* @__PURE__ */ new Set(["$in", "$nin"]);
+/** Logical operators whose operand is an ARRAY of sub-filters. */
+const LOGICAL_ARRAY_OPS$1 = /* @__PURE__ */ new Set([
+	"$and",
+	"$or",
+	"$nor"
+]);
+/** Logical operators whose operand is a SINGLE nested sub-filter. */
+const LOGICAL_OBJECT_OPS = /* @__PURE__ */ new Set(["$not"]);
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+/**
+* Cast one value through a schema path. Returns the original value when the
+* path is unknown, the value is nullish, or the cast throws — never raises.
+*/
+function castValue(schema, field, value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value === "object" && !(value instanceof Date)) return value;
+	let schemaType;
+	try {
+		schemaType = schema.path(field);
+	} catch {
+		return value;
+	}
+	if (!schemaType || typeof schemaType.cast !== "function") return value;
+	try {
+		return schemaType.cast(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Cast the operand(s) of a field-level operator object, leaving operators we
+* don't understand (`$regex`, `$exists`, `$size`, `$elemMatch`, …) alone.
+*/
+function castOperatorObject(schema, field, ops) {
+	let changed = false;
+	const out = {};
+	for (const [op, operand] of Object.entries(ops)) if (SCALAR_OPS.has(op)) {
+		const next = castValue(schema, field, operand);
+		out[op] = next;
+		if (next !== operand) changed = true;
+	} else if (ARRAY_OPS.has(op) && Array.isArray(operand)) {
+		const arr = operand.map((entry) => castValue(schema, field, entry));
+		out[op] = arr;
+		if (arr.some((v, i) => v !== operand[i])) changed = true;
+	} else out[op] = operand;
+	return changed ? out : ops;
+}
+/**
+* Cast a record-shape Mongo filter against a Mongoose schema so it is safe to
+* hand to a `$match` stage. Recurses `$and` / `$or` / `$nor` / `$not`, since a
+* policy/tenant scope conjoined with a caller filter nests one level down.
+*
+* Filter IR nodes and non-objects pass through untouched — IR values are built
+* in code (already correctly typed) and carry no schema paths to resolve.
+*
+* @example
+* ```ts
+* // organizationId is an ObjectId column; arc supplies the scope id as a string
+* castFilterToSchema({ organizationId: '6a6a…' }, Order.schema)
+* // → { organizationId: ObjectId('6a6a…') }
+* ```
+*/
+function castFilterToSchema(filter, schema) {
+	if (!isPlainObject(filter)) return filter;
+	if (typeof filter.op === "string") return filter;
+	let changed = false;
+	const out = {};
+	for (const [key, value] of Object.entries(filter)) {
+		if (LOGICAL_ARRAY_OPS$1.has(key) && Array.isArray(value)) {
+			const arr = value.map((entry) => castFilterToSchema(entry, schema));
+			out[key] = arr;
+			if (arr.some((v, i) => v !== value[i])) changed = true;
+			continue;
+		}
+		if (LOGICAL_OBJECT_OPS.has(key) && isPlainObject(value)) {
+			const nested = castFilterToSchema(value, schema);
+			out[key] = nested;
+			if (nested !== value) changed = true;
+			continue;
+		}
+		if (key.startsWith("$")) {
+			out[key] = value;
+			continue;
+		}
+		if (isPlainObject(value)) {
+			const keys = Object.keys(value);
+			if (keys.length > 0 && keys.every((k) => k.startsWith("$"))) {
+				const nextOps = castOperatorObject(schema, key, value);
+				out[key] = nextOps;
+				if (nextOps !== value) changed = true;
+				continue;
+			}
+			out[key] = value;
+			continue;
+		}
+		const next = castValue(schema, key, value);
+		out[key] = next;
+		if (next !== value) changed = true;
+	}
+	return changed ? out : filter;
+}
+//#endregion
 //#region src/filter/compile.ts
 /**
 * Compile a Filter IR node to a MongoDB query object. Returns `{}`
@@ -114,6 +230,12 @@ async function upsert(Model, query, data, options = {}) {
 * handles them"). This set covers every operator the arc aggregation
 * guard accepts in `parseDateRange` and `hasFilterOnField`.
 */
+/**
+* The query-shorthand vocabulary, shared with `compileFilterToMongoExpr` so
+* both filter surfaces recognise the same operator names. Exported because a
+* second private copy is how the two compilers drifted apart in the first
+* place: one accepted `{ f: { eq: 'x' } }` and the other read it as a literal.
+*/
 const SHORTHAND_OPS = /* @__PURE__ */ new Set([
 	"eq",
 	"ne",
@@ -191,7 +313,10 @@ function schemaDateOracle(schema) {
 }
 function compileFilterToMongo(input, schema) {
 	if (!input) return {};
-	if (!isFilter(input)) return coerceFilterDates(expandShorthands(input), schema ? { isDateField: schemaDateOracle(schema) } : void 0);
+	if (!isFilter(input)) {
+		const expanded = expandShorthands(input);
+		return coerceFilterDates(schema ? castFilterToSchema(expanded, schema) : expanded, schema ? { isDateField: schemaDateOracle(schema) } : void 0);
+	}
 	return compile(input);
 }
 function compile(filter) {
@@ -199,7 +324,7 @@ function compile(filter) {
 		case "true": return {};
 		case "false": return { $expr: false };
 		case "eq": return { [filter.field]: filter.value };
-		case "ne": return filter.value === null ? { [filter.field]: { $ne: null } } : { $and: [{ [filter.field]: { $ne: filter.value } }, { [filter.field]: { $ne: null } }] };
+		case "ne": return filter.value === null ? { [filter.field]: { $ne: null } } : { [filter.field]: { $nin: [filter.value, null] } };
 		case "gt": return { [filter.field]: { $gt: filter.value } };
 		case "gte": return { [filter.field]: { $gte: filter.value } };
 		case "lt": return { [filter.field]: { $lt: filter.value } };
@@ -209,7 +334,7 @@ function compile(filter) {
 			return { [filter.field]: { $in: [...filter.values] } };
 		case "nin":
 			if (filter.values.length === 0) return {};
-			return { [filter.field]: { $nin: [...filter.values] } };
+			return { [filter.field]: { $nin: filter.values.includes(null) ? [...filter.values] : [...filter.values, null] } };
 		case "exists": return filter.exists ? { [filter.field]: { $ne: null } } : { [filter.field]: null };
 		case "like": return { [filter.field]: likeToRegex(filter.pattern, filter.caseSensitivity) };
 		/**
@@ -233,10 +358,10 @@ function compile(filter) {
 			$options: filter.flags
 		} : { $regex: filter.pattern } };
 		case "and": {
-			if (filter.children.length === 0) return {};
-			const parts = filter.children.map(compile);
+			const parts = filter.children.map(compile).filter((part) => Object.keys(part).length > 0);
+			if (parts.length === 0) return {};
 			if (parts.length === 1) return parts[0];
-			return { $and: parts };
+			return mergeConjunction(parts) ?? { $and: parts };
 		}
 		case "or": {
 			if (filter.children.length === 0) return { $expr: false };
@@ -268,7 +393,7 @@ function compile(filter) {
 * same way sqlitekit's `LIKE` semantically does.
 */
 function likeToRegex(pattern, caseSensitivity) {
-	let out = "^";
+	let out = "";
 	for (let i = 0; i < pattern.length; i++) {
 		const ch = pattern[i];
 		if (ch === "\\" && i + 1 < pattern.length) {
@@ -283,12 +408,44 @@ function likeToRegex(pattern, caseSensitivity) {
 		else if (ch === "_") out += ".";
 		else out += escapeRegexChar(ch);
 	}
-	out += "$";
-	return caseSensitivity === "sensitive" ? { $regex: out } : {
-		$regex: out,
+	const source = `${out.startsWith(".*") ? out.slice(2) : `^${out}`}`;
+	const anchored = source.endsWith(".*") && !source.endsWith("\\.*") ? source.slice(0, -2) : `${source}$`;
+	return caseSensitivity === "sensitive" ? { $regex: anchored } : {
+		$regex: anchored,
 		$options: "i"
 	};
 }
+/**
+* Merge an AND of field conditions into one object (`{ price: { $gte, $lte } }`) when no field
+* repeats an operator; `undefined` when a merge would change meaning, so the caller keeps `$and`.
+*/
+function mergeConjunction(parts) {
+	const merged = {};
+	for (const part of parts) for (const [field, condition] of Object.entries(part)) {
+		if (field.startsWith("$")) return void 0;
+		if (!(field in merged)) {
+			merged[field] = condition;
+			continue;
+		}
+		const left = asOperators(merged[field]);
+		const right = asOperators(condition);
+		if (!left || !right || Object.keys(right).some((op) => op in left)) return void 0;
+		merged[field] = {
+			...left,
+			...right
+		};
+	}
+	return merged;
+}
+/** A field condition as an operator object — an equality value becomes `{ $eq }`. */
+function asOperators(condition) {
+	if (condition instanceof RegExp || Array.isArray(condition)) return void 0;
+	if (condition !== null && typeof condition === "object" && !(condition instanceof Date)) {
+		const keys = Object.keys(condition);
+		return keys.length > 0 && keys.every((k) => k.startsWith("$")) ? condition : void 0;
+	}
+	return condition === null ? void 0 : { $eq: condition };
+}
 function escapeRegexChar(ch) {
 	return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
 }
@@ -1257,4 +1414,4 @@ async function pullFromArray(Model, id, field, value, options = {}) {
 	return update(Model, id, { $pull: { [field]: value } }, options);
 }
 //#endregion
-export { upsert as S, compileFilterToMongo as _, count as a, create_exports as b, getByQuery as c, deleteById as d, deleteByQuery as f, LookupBuilder as g, distinct as h, update_exports as i, getOrCreate as l, aggregate_exports as m, update as n, exists as o, delete_exports as p, updateByQuery as r, getById as s, findOneAndUpdate as t, read_exports as u, create as v, isCreateManyPartialError as x, createMany as y };
+export { isCreateManyPartialError as C, create_exports as S, SHORTHAND_OPS as _, count as a, create as b, getByQuery as c, deleteById as d, deleteByQuery as f, LookupBuilder as g, distinct as h, update_exports as i, getOrCreate as l, aggregate_exports as m, update as n, exists as o, delete_exports as p, updateByQuery as r, getById as s, findOneAndUpdate as t, read_exports as u, compileFilterToMongo as v, upsert as w, createMany as x, castFilterToSchema as y };

package/dist/utils/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as getMongooseProjection, a as createMemoryCache, b as createError, c as IdType, d as isObjectIdInstance, f as isValidIdForType, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, l as getSchemaIdType, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, p as toObjectId, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, v as CreateErrorOptions, y as ParseDuplicateKeyOptions } from "../to-plain-B8ufk3Qz.mjs";
+import { _ as getMongooseProjection, a as createMemoryCache, b as createError, c as IdType, d as isObjectIdInstance, f as isValidIdForType, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, l as getSchemaIdType, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, p as toObjectId, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, v as CreateErrorOptions, y as ParseDuplicateKeyOptions } from "../to-plain-k7SjNlSS.mjs";
 import { ClientSession, Model } from "mongoose";
 //#region src/utils/id-chunks.d.ts
 /**