@warlock.js/cascade 5.20.0 → 5.21.0

package/esm/drivers/mongodb/mongodb-query-parser.d.mts

@@ -71,6 +71,11 @@ declare class MongoQueryParser {
    * ```
    */
   parse(): any[];
+  /**
+   * Atlas requires `$vectorSearch` as the first stage. Any `$match` emitted
+   * before it (where clauses, scopes) moves into its `filter` instead.
+   */
+  private hoistVectorSearch;
   /**
    * Apply a raw escape-hatch operation to the pipeline built so far.
    *
@@ -224,6 +229,7 @@ declare class MongoQueryParser {
    * @returns The MongoDB filter condition
    */
   private buildOperatorCondition;
+  private assertArrayOperand;
   /**
    * Get MongoDB operator from comparison operator.
    *

package/esm/drivers/mongodb/mongodb-query-parser.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mongodb-query-parser.d.mts","names":[],"sources":["../../../../../../../../cascade/src/drivers/mongodb/mongodb-query-parser.ts"],"mappings":";;;;;;;AAkBA;KAAY,uBAAA;6CAEV,UAAA,EAAY,UAAA,EAEA;EAAZ,UAAA,EAAY,SAAA,IAE6B;EAAzC,gBAAA,QAAwB,iBAAA;AAAA;;;;;;;AAAiB;AAW3C;cAAa,gBAAA;;;;mBAIM,UAAA;EAUA;;;EAAA,iBALA,UAAA;EA0BW;;;EAAA,iBArBX,gBAAA;EA4KT;;;;EAAA,iBAtKS,eAAA;EAsXV;;;;;;EAAA,iBA9WU,oBAAA;EAg/BT;;;;;cAz+BW,OAAA,EAAS,uBAAuB;EA2lC3C;;;;;;;;;;;;;;;;;;;;EAjkCD,KAAA;EAqxCC;;;;;;;;;;EAAA,QA3rCA,iBAAA;EAm2CA;;;;;;;;;;;;AA6dgB;EA7dhB,QAh0CA,yBAAA;;;;;;;;;;;;;;;;;;UAuDA,WAAA;;;;UAkCA,oBAAA;;;;;;UAkCA,yBAAA;;;;;;;;;;UAyBA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;EA4DD,cAAA;;;;;;;;UAmCC,eAAA;;;;;;;;UAoDA,UAAA;;;;;;;;;;;UAyEA,eAAA;EAAA,QA8KA,iBAAA;;;;;;;;;UAkBA,sBAAA;;;;;;;UA8EA,mBAAA;;;;;;;;;;;;;UAoNA,oBAAA;;;;;;;;;UAgBA,sBAAA;;;;;;;UAyBA,gBAAA;EAAA,QAYA,oBAAA;;;;;;;;UA2BA,4BAAA;EAAA,QAsBA,aAAA;EAAA,QAYA,qBAAA;EAAA,QASA,4BAAA;EAAA,QAWA,UAAA;EAAA,QAIA,0BAAA;EAAA,QAOA,wBAAA;EAAA,QAKA,uBAAA;EAAA,QAKA,kBAAA;EAAA,QAgBA,sBAAA;EAAA,QAiBA,0BAAA;EAAA,QAQA,+BAAA;EAAA,QAMA,6BAAA;EAAA,QAMA,wBAAA;EAAA,QASA,sBAAA;EAAA,QAQA,yBAAA;EAAA,QASA,kBAAA;EAAA,QAWA,UAAA;EAAA,QAMA,QAAA;EAAA,QAMA,aAAA;EAAA,QAIA,qBAAA;;;;;;UAeA,qBAAA;EAAA,QAmCA,kBAAA;EAAA,QAeA,2BAAA;EAAA,QA0BA,uBAAA;EAAA,QAoBA,wBAAA;EAAA,QAwBA,qBAAA;EAAA,QAMA,wBAAA;EAAA,QAMA,mBAAA;EAAA,QAeA,mBAAA;;;;;UAkBA,0BAAA;EAAA,QAaA,cAAA;EAAA,QAYA,qBAAA;EAAA,QAMA,uBAAA;;;;;;;UAsBA,iBAAA;;;;;;;UAgHA,cAAA;;;;;;;UA2BA,eAAA;EAAA,QA6DA,iBAAA;;;;;;;;UAgBA,+BAAA;;;;;;;;;;UAoCA,qBAAA;;;;;;;UA0BA,sBAAA;;;;;;;UA4BA,4BAAA;;;;;;;;;;;;;UAuFA,uBAAA;EAAA,QAoCA,YAAA;;;;;;;UAgDA,gBAAA;AAAA"}
+{"version":3,"file":"mongodb-query-parser.d.mts","names":[],"sources":["../../../../../../../../cascade/src/drivers/mongodb/mongodb-query-parser.ts"],"mappings":";;;;;;;AAyDA;KAAY,uBAAA;6CAEV,UAAA,EAAY,UAAA,EAEA;EAAZ,UAAA,EAAY,SAAA,IAE6B;EAAzC,gBAAA,QAAwB,iBAAA;AAAA;AAuB1B;;;;;;;;AAAA,cAAa,gBAAA;;;;mBAIM,UAAA;EAkJT;;;EAAA,iBA7IS,UAAA;EAwTT;;;EAAA,iBAnTS,gBAAA;EA6cT;;;;EAAA,iBAvcS,eAAA;EA20BT;;;;;;EAAA,iBAn0BS,oBAAA;EAyqCT;;;;;cAlqCW,OAAA,EAAS,uBAAuB;EAktC3C;;;;;;;;;;;;;;;;;;;;EAxrCD,KAAA;EA07CC;;;;EAAA,QAj2CA,iBAAA;EAi6CA;;;;;;;;;;EAAA,QAl3CA,iBAAA;EAo2DA;;AAAgB;;;;;;;;;;;EAAhB,QAj0DA,yBAAA;;;;;;;;;;;;;;;;;;UAuDA,WAAA;;;;UAkCA,oBAAA;;;;;;UAkCA,yBAAA;;;;;;;;;;UAyBA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;EA4DD,cAAA;;;;;;;;UAmCC,eAAA;;;;;;;;UAoDA,UAAA;;;;;;;;;;;UAyEA,eAAA;EAAA,QAqKA,iBAAA;;;;;;;;;UAkBA,sBAAA;;;;;;;UAgFA,mBAAA;;;;;;;;;;;;;UAyNA,oBAAA;;;;;;;;;UAgBA,sBAAA;EAAA,QAkDA,kBAAA;;;;;;;UAcA,gBAAA;EAAA,QAYA,oBAAA;;;;;;;;UA2BA,4BAAA;EAAA,QAsBA,aAAA;EAAA,QAYA,qBAAA;EAAA,QASA,4BAAA;EAAA,QAWA,UAAA;EAAA,QAIA,0BAAA;EAAA,QAOA,wBAAA;EAAA,QAKA,uBAAA;EAAA,QAKA,kBAAA;EAAA,QAgBA,sBAAA;EAAA,QAiBA,0BAAA;EAAA,QAQA,+BAAA;EAAA,QAMA,6BAAA;EAAA,QAMA,wBAAA;EAAA,QASA,sBAAA;EAAA,QAQA,yBAAA;EAAA,QASA,kBAAA;EAAA,QAWA,UAAA;EAAA,QAMA,QAAA;EAAA,QAMA,aAAA;EAAA,QAIA,qBAAA;;;;;;UAeA,qBAAA;EAAA,QAmCA,kBAAA;EAAA,QAeA,2BAAA;EAAA,QA0BA,uBAAA;EAAA,QAoBA,wBAAA;EAAA,QAwBA,qBAAA;EAAA,QAMA,wBAAA;EAAA,QAMA,mBAAA;EAAA,QAeA,mBAAA;;;;;UAkBA,0BAAA;EAAA,QAaA,cAAA;EAAA,QAYA,qBAAA;EAAA,QAMA,uBAAA;;;;;;;UAsBA,iBAAA;;;;;;;UAgHA,cAAA;;;;;;;UA0BA,eAAA;EAAA,QA6DA,iBAAA;;;;;;;;UAgBA,+BAAA;;;;;;;;;;UAoCA,qBAAA;;;;;;;UA0BA,sBAAA;;;;;;;UA4BA,4BAAA;;;;;;;;;;;;;UAuFA,uBAAA;EAAA,QAoCA,YAAA;;;;;;;UAgDA,gBAAA;AAAA"}

package/esm/drivers/mongodb/mongodb-query-parser.mjs

@@ -1,11 +1,48 @@
 import { UnsafeRawExpressionError } from "../../errors/unsafe-raw-expression.error.mjs";
 import { UnsupportedQueryOperationError } from "../../errors/unsupported-query-operation.error.mjs";
 import { isAggregateExpression } from "../../expressions/aggregate-expressions.mjs";
-import { escapeRegex, resolveLikePattern } from "../../utils/escape-regex.mjs";
+import { escapeRegex } from "../../utils/escape-regex.mjs";
 import { isPipelineStageObject } from "./pipeline-stage-object.mjs";
 import { colors } from "@mongez/copper";
 
 //#region ../cascade/src/drivers/mongodb/mongodb-query-parser.ts
+const isPlainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+/**
+* AND one `key: value` condition into `target`. Operators on the same field
+* with distinct keys are merged (`{ age: { $gt, $lt } }`); any other collision
+* (same operator, `$expr`, `$nor`, ...) is pushed into `$and` so neither
+* side is overwritten.
+*/
+const mergeConditionEntry = (target, key, value) => {
+	if (!(key in target)) {
+		target[key] = value;
+		return;
+	}
+	if (key === "$and" && Array.isArray(target.$and) && Array.isArray(value)) {
+		target.$and.push(...value);
+		return;
+	}
+	const existing = target[key];
+	if (!key.startsWith("$") && isPlainObject(existing) && isPlainObject(value) && !Object.keys(value).some((operator) => operator in existing)) {
+		target[key] = {
+			...existing,
+			...value
+		};
+		return;
+	}
+	if (!Array.isArray(target.$and)) target.$and = [];
+	target.$and.push({ [key]: value });
+};
+/**
+* Compile a LIKE argument to regex source with the same wildcards as SQL/pg:
+* `%` matches any run of characters and `_` exactly one. Every other regex
+* metacharacter in a string is escaped, so `a.b*` matches literally. An explicit
+* `RegExp` is developer-authored and used verbatim.
+*/
+function resolveMongoLikePattern(pattern) {
+	if (pattern instanceof RegExp) return pattern.source;
+	return escapeRegex(pattern).replace(/%+/g, ".*").replace(/_/g, ".");
+}
 /**
 * Parses query builder operations into MongoDB aggregation pipeline.
 *
@@ -96,6 +133,7 @@ var MongoQueryParser = class {
 			this.trackGroupFieldNames(stage, operations, stageIndex);
 			const renameStage = this.buildGroupRenameStage(builtStage, stageIndex);
 			if (renameStage) pipeline.push(renameStage);
+			if (stage === "$lookup" && builtStage.$lookup && operations[0]?.data?.type === "inner") pipeline.push({ $match: { [builtStage.$lookup.as]: { $ne: [] } } });
 		};
 		for (const op of this.orderStages(this.operations)) {
 			if (op.mergeable && op.stage === currentStage) {
@@ -115,7 +153,23 @@ var MongoQueryParser = class {
 			}
 		}
 		if (currentBuffer.length > 0) emit(currentStage, currentBuffer);
-		return pipeline;
+		return this.hoistVectorSearch(pipeline);
+	}
+	/**
+	* Atlas requires `$vectorSearch` as the first stage. Any `$match` emitted
+	* before it (where clauses, scopes) moves into its `filter` instead.
+	*/
+	hoistVectorSearch(pipeline) {
+		const index = pipeline.findIndex((stage) => stage.$vectorSearch);
+		if (index <= 0) return pipeline;
+		const before = pipeline.slice(0, index).filter((stage) => !stage.$limit);
+		if (!before.every((stage) => stage.$match)) throw new UnsupportedQueryOperationError("similarTo", "mongodb", "$vectorSearch must be the first pipeline stage; only where() filters can precede similarTo().");
+		const vectorStage = pipeline[index].$vectorSearch;
+		const filters = [...before.map((stage) => stage.$match), ...vectorStage.filter ? [vectorStage.filter] : []];
+		return [{ $vectorSearch: {
+			...vectorStage,
+			...filters.length === 0 ? {} : { filter: filters.length === 1 ? filters[0] : { $and: filters } }
+		} }, ...pipeline.slice(index + 1)];
 	}
 	/**
 	* Apply a raw escape-hatch operation to the pipeline built so far.
@@ -411,11 +465,7 @@ var MongoQueryParser = class {
 					pushOr(value);
 					return;
 				}
-				if (value && typeof value === "object" && !Array.isArray(value) && andFilter[key] && typeof andFilter[key] === "object" && !Array.isArray(andFilter[key])) andFilter[key] = {
-					...andFilter[key],
-					...value
-				};
-				else andFilter[key] = value;
+				mergeConditionEntry(andFilter, key, value);
 			});
 		};
 		const queueSimpleWhere = (condition) => {
@@ -426,10 +476,9 @@ var MongoQueryParser = class {
 		const enterTopLevelOrMode = () => {
 			if (topLevelOrMode) return;
 			topLevelOrMode = true;
-			while (pendingSimpleWhere.length > 0) {
-				const condition = pendingSimpleWhere.shift();
-				if (condition) pushOr(condition);
-			}
+			const pending = pendingSimpleWhere.splice(0).filter(Boolean);
+			if (pending.length === 1) pushOr(pending[0]);
+			else if (pending.length > 1) pushOr({ $and: pending });
 		};
 		const flushPendingSimpleWhere = () => {
 			if (pendingSimpleWhere.length === 0) return;
@@ -528,14 +577,13 @@ var MongoQueryParser = class {
 			}
 			return orClauses.length > 0 ? { $or: orClauses } : null;
 		}
-		for (const op of matchOps) if (op.type === "where:callback") {
-			const nestedCondition = this.buildCallbackCondition(op.data);
-			if (nestedCondition) Object.assign(andFilter, nestedCondition);
-		} else if (op.type === "where:object") Object.assign(andFilter, op.data);
-		else {
-			const condition = this.buildWhereCondition(op);
-			if (condition) Object.assign(andFilter, condition);
-		}
+		const mergeInto = (condition) => {
+			if (!condition) return;
+			Object.entries(condition).forEach(([key, value]) => mergeConditionEntry(andFilter, key, value));
+		};
+		for (const op of matchOps) if (op.type === "where:callback") mergeInto(this.buildCallbackCondition(op.data));
+		else if (op.type === "where:object") mergeInto(op.data);
+		else mergeInto(this.buildWhereCondition(op));
 		return Object.keys(andFilter).length > 0 ? andFilter : null;
 	}
 	/**
@@ -549,11 +597,16 @@ var MongoQueryParser = class {
 		switch (op.type) {
 			case "where":
 			case "orWhere": return this.buildOperatorCondition(field, operator, value);
-			case "whereIn": return { [field]: { $in: value || op.data.values } };
-			case "whereNotIn": return { [field]: { $nin: value || op.data.values } };
-			case "whereNull": return { [field]: null };
-			case "whereNotNull": return { [field]: { $ne: null } };
-			case "whereBetween": return { [field]: {
+			case "whereIn":
+			case "orWhereIn": return { [field]: { $in: value || op.data.values } };
+			case "whereNotIn":
+			case "orWhereNotIn": return { [field]: { $nin: value || op.data.values } };
+			case "whereNull":
+			case "orWhereNull": return { [field]: null };
+			case "whereNotNull":
+			case "orWhereNotNull": return { [field]: { $ne: null } };
+			case "whereBetween":
+			case "orWhereBetween": return { [field]: {
 				$gte: op.data.range[0],
 				$lte: op.data.range[1]
 			} };
@@ -648,7 +701,7 @@ var MongoQueryParser = class {
 	*/
 	buildLikeRegexSource(data) {
 		if (data.isRegExp === true && typeof data.pattern === "string") return data.pattern;
-		return resolveLikePattern(data.pattern);
+		return resolveMongoLikePattern(data.pattern);
 	}
 	/**
 	* Build a condition based on the operator.
@@ -661,14 +714,59 @@ var MongoQueryParser = class {
 	buildOperatorCondition(field, operator, value) {
 		switch (operator) {
 			case "=": return { [field]: value };
-			case "!=": return { [field]: { $ne: value } };
+			case "!=":
+			case "<>": return { [field]: { $ne: value } };
+			case "in": return { [field]: { $in: this.assertArrayOperand(operator, value) } };
+			case "notIn":
+			case "not in": return { [field]: { $nin: this.assertArrayOperand(operator, value) } };
+			case "between":
+			case "notBetween":
+			case "not between": {
+				const range = this.assertArrayOperand(operator, value);
+				if (range.length !== 2) throw new Error(`Operator "${operator}" requires a [min, max] pair.`);
+				const bounds = {
+					$gte: range[0],
+					$lte: range[1]
+				};
+				return { [field]: operator === "between" ? bounds : { $not: bounds } };
+			}
+			case "like": return { [field]: {
+				$regex: resolveMongoLikePattern(value),
+				$options: "i"
+			} };
+			case "notLike":
+			case "not like": return { [field]: { $not: {
+				$regex: resolveMongoLikePattern(value),
+				$options: "i"
+			} } };
+			case "startsWith": return { [field]: {
+				$regex: `^${escapeRegex(String(value))}`,
+				$options: "i"
+			} };
+			case "notStartsWith": return { [field]: { $not: {
+				$regex: `^${escapeRegex(String(value))}`,
+				$options: "i"
+			} } };
+			case "endsWith": return { [field]: {
+				$regex: `${escapeRegex(String(value))}$`,
+				$options: "i"
+			} };
+			case "notEndsWith": return { [field]: { $not: {
+				$regex: `${escapeRegex(String(value))}$`,
+				$options: "i"
+			} } };
+			case "exists": return { [field]: { $exists: value !== false } };
 			case ">": return { [field]: { $gt: value } };
 			case ">=": return { [field]: { $gte: value } };
 			case "<": return { [field]: { $lt: value } };
 			case "<=": return { [field]: { $lte: value } };
-			default: return { [field]: value };
+			default: throw new Error(`Unsupported where operator "${operator}" on the MongoDB driver.`);
 		}
 	}
+	assertArrayOperand(operator, value) {
+		if (!Array.isArray(value)) throw new Error(`Operator "${operator}" requires an array operand.`);
+		return value;
+	}
 	/**
 	* Get MongoDB operator from comparison operator.
 	*
@@ -784,12 +882,12 @@ var MongoQueryParser = class {
 	}
 	startOfDay(date) {
 		const copy = new Date(date);
-		copy.setHours(0, 0, 0, 0);
+		copy.setUTCHours(0, 0, 0, 0);
 		return copy;
 	}
 	endOfDay(date) {
 		const copy = new Date(date);
-		copy.setHours(23, 59, 59, 999);
+		copy.setUTCHours(23, 59, 59, 999);
 		return copy;
 	}
 	normalizePath(path) {
@@ -989,7 +1087,7 @@ var MongoQueryParser = class {
 				sort[op.data.field] = op.data.direction === "asc" ? 1 : -1;
 				break;
 			case "orderByRandom": return { $sample: { size: op.data.limit } };
-			case "orderByRaw": break;
+			case "orderByRaw": throw new Error("orderByRaw() is not supported by the MongoDB driver; use orderBy() instead.");
 		}
 		return Object.keys(sort).length > 0 ? { $sort: sort } : null;
 	}