@warlock.js/cascade 4.0.47 → 4.0.58

package/esm/drivers/mongo/mongo-query-parser.js

@@ -0,0 +1,1351 @@
+import {colors}from'@mongez/copper';import {isAggregateExpression}from'../../expressions/aggregate-expressions.js';/**
+ * Parses query builder operations into MongoDB aggregation pipeline.
+ *
+ * This parser is responsible for converting the abstract operations collected
+ * by the query builder into a concrete MongoDB aggregation pipeline. It handles
+ * intelligent grouping of mergeable operations (like multiple where clauses)
+ * into single pipeline stages for optimal performance.
+ */
+class MongoQueryParser {
+    /**
+     * The MongoDB collection being queried.
+     */
+    collection;
+    /**
+     * The ordered list of operations to parse.
+     */
+    operations;
+    /**
+     * Factory for creating sub-builders (used when resolving callbacks).
+     */
+    createSubBuilder;
+    /**
+     * Track group field names for automatic _id renaming.
+     * Maps pipeline index to field names.
+     */
+    groupFieldNames = new Map();
+    /**
+     * Create a new MongoDB query parser.
+     *
+     * @param options - Configuration options for the parser
+     */
+    constructor(options) {
+        this.collection = options.collection;
+        this.operations = options.operations;
+        this.createSubBuilder = options.createSubBuilder;
+    }
+    /**
+     * Parse the operations into a MongoDB aggregation pipeline.
+     *
+     * This method intelligently groups mergeable operations (e.g., multiple where
+     * clauses) into single pipeline stages while maintaining the correct execution
+     * order for non-mergeable operations.
+     *
+     * @returns The MongoDB aggregation pipeline
+     *
+     * @example
+     * ```typescript
+     * const parser = new MongoQueryParser({ collection, operations });
+     * const pipeline = parser.parse();
+     * // [
+     * //   { $match: { status: 'active', age: { $gt: 18 } } },
+     * //   { $sort: { createdAt: -1 } },
+     * //   { $limit: 10 }
+     * // ]
+     * ```
+     */
+    parse() {
+        const pipeline = [];
+        let currentStage = null;
+        let currentBuffer = [];
+        for (const op of this.operations) {
+            if (op.mergeable && op.stage === currentStage) {
+                // Same mergeable stage, add to buffer
+                currentBuffer.push(op);
+            }
+            else {
+                // Different stage or non-mergeable, flush buffer
+                if (currentBuffer.length > 0) {
+                    const builtStage = this.buildStage(currentStage, currentBuffer);
+                    if (builtStage) {
+                        const stageIndex = pipeline.length;
+                        pipeline.push(builtStage);
+                        // Track field names for group stages with aggregates
+                        this.trackGroupFieldNames(currentStage, currentBuffer, stageIndex);
+                    }
+                    currentBuffer = [];
+                }
+                if (op.mergeable) {
+                    // Start new buffer
+                    currentStage = op.stage;
+                    currentBuffer.push(op);
+                }
+                else {
+                    // Non-mergeable, add directly
+                    const builtStage = this.buildStage(op.stage, [op]);
+                    if (builtStage) {
+                        const stageIndex = pipeline.length;
+                        pipeline.push(builtStage);
+                        // Track field names for group stages with aggregates
+                        this.trackGroupFieldNames(op.stage, [op], stageIndex);
+                    }
+                    currentStage = null;
+                }
+            }
+        }
+        // Flush remaining buffer
+        if (currentBuffer.length > 0) {
+            const builtStage = this.buildStage(currentStage, currentBuffer);
+            if (builtStage) {
+                const stageIndex = pipeline.length;
+                pipeline.push(builtStage);
+                // Track field names for group stages with aggregates
+                this.trackGroupFieldNames(currentStage, currentBuffer, stageIndex);
+            }
+        }
+        // Post-process: Rename _id to actual field names after $group stages with aggregates
+        return this.postProcessGroupStages(pipeline);
+    }
+    /**
+     * Track field names for group stages that need _id renaming.
+     */
+    trackGroupFieldNames(stage, operations, stageIndex) {
+        if (stage === "$group") {
+            const op = operations[0];
+            if (op.type === "groupByWithAggregates" && op.payload.fields) {
+                const fieldNames = this.extractGroupFieldNames(op.payload.fields);
+                if (fieldNames) {
+                    this.groupFieldNames.set(stageIndex, fieldNames);
+                }
+            }
+        }
+    }
+    /**
+     * Post-process pipeline to rename _id fields after $group stages.
+     *
+     * This automatically renames MongoDB's `_id` field to the actual field name(s)
+     * used for grouping, making the results more intuitive.
+     *
+     * @param pipeline - The aggregation pipeline
+     * @returns The processed pipeline
+     */
+    postProcessGroupStages(pipeline) {
+        const processed = [];
+        for (let i = 0; i < pipeline.length; i++) {
+            const stage = pipeline[i];
+            // Check if this is a $group stage that needs _id renaming
+            if (stage.$group && this.groupFieldNames.has(i)) {
+                const fieldNames = this.groupFieldNames.get(i);
+                // Add the $group stage
+                processed.push(stage);
+                // Add a $project stage to rename _id
+                const projection = {};
+                if (typeof fieldNames === "string") {
+                    // Single field: rename _id to field name
+                    projection[fieldNames] = "$_id";
+                }
+                else if (Array.isArray(fieldNames) && fieldNames.length > 0) {
+                    // Multiple fields: _id is an object, spread it
+                    for (const fieldName of fieldNames) {
+                        projection[fieldName] = `$_id.${fieldName}`;
+                    }
+                }
+                // Include all aggregate fields
+                const aggregateFields = Object.keys(stage.$group).filter((key) => key !== "_id");
+                for (const field of aggregateFields) {
+                    projection[field] = 1;
+                }
+                if (Object.keys(projection).length > 0) {
+                    // now unselect the _id field
+                    projection._id = 0;
+                    processed.push({ $project: projection });
+                }
+            }
+            else {
+                // Regular stage, add as-is
+                processed.push(stage);
+            }
+        }
+        return processed;
+    }
+    /**
+     * Convert the parsed pipeline to a pretty-printed string for debugging.
+     *
+     * This method formats the MongoDB aggregation pipeline in a human-readable
+     * way, making it easier to understand and debug complex queries.
+     *
+     * @returns A formatted string representation of the pipeline
+     *
+     * @example
+     * ```typescript
+     * const parser = new MongoQueryParser({ collection, operations });
+     * console.log(parser.toPrettyString());
+     * // Output:
+     * // MongoDB Aggregation Pipeline:
+     * // ════════════════════════════
+     * // Stage 1: $match
+     * //   status: "active"
+     * //   age: { $gt: 18 }
+     * //
+     * // Stage 2: $sort
+     * //   createdAt: -1
+     * ```
+     */
+    toPrettyString() {
+        const pipeline = this.parse();
+        if (pipeline.length === 0) {
+            return "MongoDB Aggregation Pipeline: (empty)";
+        }
+        let output = "MongoDB Aggregation Pipeline:\n";
+        output += "═".repeat(50) + "\n";
+        pipeline.forEach((stage, index) => {
+            const stageName = Object.keys(stage)[0];
+            const stageData = stage[stageName];
+            if (index > 0) {
+                output += "\n";
+            }
+            output += `Stage ${index + 1}: ${colors.redBright(stageName)}\n`;
+            output += this.formatStageData(stageData, 2);
+        });
+        return output;
+    }
+    /**
+     * Format stage data with proper indentation.
+     *
+     * @param data - The stage data to format
+     * @param indent - The indentation level
+     * @returns Formatted string
+     */
+    formatStageData(data, indent = 0) {
+        const spaces = " ".repeat(indent);
+        if (typeof data !== "object" || data === null) {
+            return `${spaces}${JSON.stringify(data)}\n`;
+        }
+        if (Array.isArray(data)) {
+            if (data.length === 0)
+                return `${spaces}[]`;
+            let result = "";
+            data.forEach((item, index) => {
+                result += `${spaces}[${colors.magenta(index)}]:\n`;
+                result += this.formatStageData(item, indent + 2);
+            });
+            return result;
+        }
+        let result = "";
+        Object.entries(data).forEach(([key, value]) => {
+            const isOperator = key.startsWith("$");
+            const coloredKey = isOperator ? colors.magentaBright(key) : colors.blue(key);
+            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                result += `${spaces}${coloredKey}:\n`;
+                result += this.formatStageData(value, indent + 2);
+            }
+            else if (Array.isArray(value)) {
+                result += `${spaces}${coloredKey}:\n`;
+                result += this.formatStageData(value, indent + 2);
+            }
+            else {
+                const formattedValue = typeof value === "number"
+                    ? colors.yellowBright(value)
+                    : typeof value === "boolean"
+                        ? colors.cyanBright(value.toString())
+                        : typeof value === "string"
+                            ? colors.greenBright(JSON.stringify(value))
+                            : colors.greenBright(String(value));
+                result += `${spaces}${coloredKey}: ${formattedValue}\n`;
+            }
+        });
+        return result.endsWith("\n") ? result : `${result}\n`;
+    }
+    /**
+     * Build a single pipeline stage from a group of operations.
+     *
+     * @param stage - The pipeline stage type
+     * @param operations - The operations to build the stage from
+     * @returns The built pipeline stage or null if no stage should be added
+     */
+    buildStage(stage, operations) {
+        switch (stage) {
+            case "$match":
+                return this.buildMatchStage(operations);
+            case "$project":
+                return this.buildProjectStage(operations);
+            case "$sort":
+                return this.buildSortStage(operations);
+            case "$group":
+                return this.buildGroupStage(operations);
+            case "$lookup":
+                return this.buildLookupStage(operations);
+            case "$limit":
+                return { $limit: operations[0].payload.value };
+            case "$skip":
+                return { $skip: operations[0].payload.value };
+            case "$setWindowFields":
+                return {
+                    $setWindowFields: operations[0].payload.spec,
+                };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Build a $match stage from where operations.
+     *
+     * Query building strategy:
+     * - Top-level where() + orWhere() = Pure OR
+     * - Use callbacks for AND + OR grouping
+     *
+     * @param operations - The where operations
+     * @returns The $match stage or null
+     */
+    buildMatchStage(operations) {
+        const andFilter = {};
+        const orClauses = [];
+        const pendingSimpleWhere = [];
+        let topLevelOrMode = false;
+        const pushOr = (clause) => {
+            if (!clause) {
+                return;
+            }
+            if (this.isPureOrCondition(clause)) {
+                orClauses.push(...clause.$or);
+                return;
+            }
+            if (Array.isArray(clause)) {
+                orClauses.push(...clause);
+                return;
+            }
+            orClauses.push(clause);
+        };
+        const mergeAnd = (condition) => {
+            if (!condition) {
+                return;
+            }
+            Object.entries(condition).forEach(([key, value]) => {
+                if (key === "$or") {
+                    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;
+                }
+            });
+        };
+        const queueSimpleWhere = (condition) => {
+            if (!condition) {
+                return;
+            }
+            if (topLevelOrMode) {
+                pushOr(condition);
+            }
+            else {
+                pendingSimpleWhere.push(condition);
+            }
+        };
+        const enterTopLevelOrMode = () => {
+            if (topLevelOrMode) {
+                return;
+            }
+            topLevelOrMode = true;
+            while (pendingSimpleWhere.length > 0) {
+                const condition = pendingSimpleWhere.shift();
+                if (condition) {
+                    pushOr(condition);
+                }
+            }
+        };
+        const flushPendingSimpleWhere = () => {
+            if (pendingSimpleWhere.length === 0) {
+                return;
+            }
+            if (topLevelOrMode) {
+                pendingSimpleWhere.forEach(pushOr);
+            }
+            else {
+                pendingSimpleWhere.forEach(mergeAnd);
+            }
+            pendingSimpleWhere.length = 0;
+        };
+        for (const op of operations) {
+            if (op.type === "where:callback" || op.type === "orWhere:callback") {
+                flushPendingSimpleWhere();
+                const callbackCondition = this.buildCallbackCondition(op.payload);
+                if (!callbackCondition) {
+                    continue;
+                }
+                const treatAsOr = op.type === "orWhere:callback" ||
+                    (topLevelOrMode && !this.isPureOrCondition(callbackCondition)) ||
+                    this.isPureOrCondition(callbackCondition);
+                if (treatAsOr) {
+                    if (op.type === "orWhere:callback") {
+                        enterTopLevelOrMode();
+                    }
+                    pushOr(callbackCondition);
+                }
+                else {
+                    mergeAnd(callbackCondition);
+                }
+                continue;
+            }
+            if (op.type === "where:object") {
+                queueSimpleWhere(op.payload);
+                continue;
+            }
+            if (op.type === "where:not" ||
+                op.type === "orWhere:not" ||
+                op.type === "where:exists" ||
+                op.type === "where:notExists") {
+                const negated = op.type === "where:not" || op.type === "where:notExists";
+                const nested = this.buildCallbackCondition(op.payload.callback);
+                if (nested) {
+                    const condition = negated ? { $nor: [nested] } : nested;
+                    if (op.type.startsWith("orWhere")) {
+                        enterTopLevelOrMode();
+                        pushOr(condition);
+                    }
+                    else {
+                        queueSimpleWhere(condition);
+                    }
+                }
+                continue;
+            }
+            if (op.type === "orWhere:object") {
+                enterTopLevelOrMode();
+                pushOr(op.payload);
+                continue;
+            }
+            const condition = this.buildWhereCondition(op);
+            if (!condition) {
+                continue;
+            }
+            if (op.type.startsWith("orWhere")) {
+                enterTopLevelOrMode();
+                pushOr(condition);
+            }
+            else {
+                queueSimpleWhere(condition);
+            }
+        }
+        flushPendingSimpleWhere();
+        const hasAnd = Object.keys(andFilter).length > 0;
+        const hasOr = orClauses.length > 0;
+        if (!hasAnd && !hasOr) {
+            return null;
+        }
+        const match = {};
+        if (hasAnd) {
+            Object.assign(match, andFilter);
+        }
+        if (hasOr) {
+            match.$or = orClauses;
+        }
+        return { $match: match };
+    }
+    isPureOrCondition(condition) {
+        return (condition &&
+            typeof condition === "object" &&
+            !Array.isArray(condition) &&
+            Object.keys(condition).length === 1 &&
+            Array.isArray(condition.$or));
+    }
+    /**
+     * Build a condition from a callback-based where clause.
+     * Creates a sub-builder, executes the callback, and extracts the conditions.
+     * If callback has orWhere, all conditions become OR.
+     *
+     * @param callback - The callback function
+     * @returns The built condition or null
+     */
+    buildCallbackCondition(callback) {
+        // Create a temporary sub-builder
+        const subBuilder = this.createSubBuilder();
+        // Execute the callback with the sub-builder
+        callback(subBuilder);
+        // Extract only match operations from the sub-builder
+        const matchOps = subBuilder.operations.filter((op) => op.stage === "$match");
+        if (matchOps.length === 0) {
+            return null;
+        }
+        const andFilter = {};
+        const orClauses = [];
+        const hasInternalOr = matchOps.some((op) => op.type.startsWith("orWhere"));
+        const pushOr = (clause) => {
+            if (!clause) {
+                return;
+            }
+            if (this.isPureOrCondition(clause)) {
+                orClauses.push(...clause.$or);
+                return;
+            }
+            orClauses.push(clause);
+        };
+        if (hasInternalOr) {
+            for (const op of matchOps) {
+                if (op.type === "where:callback" || op.type === "orWhere:callback") {
+                    const nestedCondition = this.buildCallbackCondition(op.payload);
+                    if (nestedCondition) {
+                        pushOr(nestedCondition);
+                    }
+                    continue;
+                }
+                if (op.type === "where:object" || op.type === "orWhere:object") {
+                    pushOr(op.payload);
+                    continue;
+                }
+                const condition = this.buildWhereCondition(op);
+                if (condition) {
+                    pushOr(condition);
+                }
+            }
+            return orClauses.length > 0 ? { $or: orClauses } : null;
+        }
+        for (const op of matchOps) {
+            if (op.type === "where:callback") {
+                const nestedCondition = this.buildCallbackCondition(op.payload);
+                if (nestedCondition) {
+                    Object.assign(andFilter, nestedCondition);
+                }
+            }
+            else if (op.type === "where:object") {
+                Object.assign(andFilter, op.payload);
+            }
+            else {
+                const condition = this.buildWhereCondition(op);
+                if (condition) {
+                    Object.assign(andFilter, condition);
+                }
+            }
+        }
+        return Object.keys(andFilter).length > 0 ? andFilter : null;
+    }
+    /**
+     * Build a MongoDB filter condition from a where operation.
+     *
+     * @param op - The operation to build
+     * @returns The MongoDB filter condition
+     */
+    buildWhereCondition(op) {
+        const { field, operator, value } = op.payload;
+        switch (op.type) {
+            case "where":
+            case "orWhere":
+                return this.buildOperatorCondition(field, operator, value);
+            case "whereIn":
+                return { [field]: { $in: value || op.payload.values } };
+            case "whereNotIn":
+                return { [field]: { $nin: value || op.payload.values } };
+            case "whereNull":
+                return { [field]: null };
+            case "whereNotNull":
+                return { [field]: { $ne: null } };
+            case "whereBetween":
+                return {
+                    [field]: {
+                        $gte: op.payload.range[0],
+                        $lte: op.payload.range[1],
+                    },
+                };
+            case "whereNotBetween":
+                return {
+                    [field]: {
+                        $not: {
+                            $gte: op.payload.range[0],
+                            $lte: op.payload.range[1],
+                        },
+                    },
+                };
+            case "whereLike": {
+                const pattern = typeof op.payload.pattern === "string" ? op.payload.pattern : op.payload.pattern.source;
+                return { [field]: { $regex: pattern, $options: "i" } };
+            }
+            case "whereNotLike": {
+                const notPattern = typeof op.payload.pattern === "string" ? op.payload.pattern : op.payload.pattern.source;
+                return { [field]: { $not: { $regex: notPattern, $options: "i" } } };
+            }
+            case "whereStartsWith":
+                return { [field]: { $regex: `^${op.payload.value}`, $options: "i" } };
+            case "whereNotStartsWith":
+                return {
+                    [field]: { $not: { $regex: `^${op.payload.value}`, $options: "i" } },
+                };
+            case "whereEndsWith":
+                return { [field]: { $regex: `${op.payload.value}$`, $options: "i" } };
+            case "whereNotEndsWith":
+                return {
+                    [field]: { $not: { $regex: `${op.payload.value}$`, $options: "i" } },
+                };
+            case "whereExists":
+                return { [field]: { $exists: true } };
+            case "whereNotExists":
+                return { [field]: { $exists: false } };
+            case "whereSize":
+                if (op.payload.operator === "=") {
+                    return { [field]: { $size: op.payload.size } };
+                }
+                else {
+                    const mongoOp = this.getMongoOperator(op.payload.operator);
+                    return {
+                        $expr: {
+                            [mongoOp]: [{ $size: `$${field}` }, op.payload.size],
+                        },
+                    };
+                }
+            case "textSearch":
+                return {
+                    $text: { $search: op.payload.query },
+                    ...(op.payload.filters || {}),
+                };
+            case "whereRaw":
+            case "orWhereRaw":
+                return this.resolveRawExpression(op.payload.expression, op.payload.bindings);
+            case "whereColumn":
+            case "orWhereColumn":
+                return this.buildColumnComparison(op.payload.first, op.payload.operator, op.payload.second);
+            case "whereBetweenColumns":
+                return this.buildBetweenColumnsCondition(op.payload.field, op.payload.lowerColumn, op.payload.upperColumn);
+            case "whereDate":
+            case "whereDateEquals":
+                return this.buildDateEqualityCondition(op.payload.field, op.payload.value);
+            case "whereDateBefore":
+                return this.buildDateBeforeCondition(op.payload.field, op.payload.value);
+            case "whereDateAfter":
+                return this.buildDateAfterCondition(op.payload.field, op.payload.value);
+            case "whereTime":
+                return this.buildTimeCondition(op.payload.field, op.payload.value);
+            case "whereDay":
+                return this.buildDatePartCondition(op.payload.field, "$dayOfMonth", op.payload.value);
+            case "whereMonth":
+                return this.buildDatePartCondition(op.payload.field, "$month", op.payload.value);
+            case "whereYear":
+                return this.buildDatePartCondition(op.payload.field, "$year", op.payload.value);
+            case "whereJsonContains":
+                return this.buildJsonContainsCondition(op.payload.path, op.payload.value);
+            case "whereJsonDoesntContain":
+                return this.buildJsonDoesntContainCondition(op.payload.path, op.payload.value);
+            case "whereJsonContainsKey":
+                return this.buildJsonContainsKeyCondition(op.payload.path);
+            case "whereJsonLength":
+                return this.buildJsonLengthCondition(op.payload.path, op.payload.operator, op.payload.value);
+            case "whereJsonIsArray":
+                return this.buildJsonTypeCondition(op.payload.path, "array");
+            case "whereJsonIsObject":
+                return this.buildJsonTypeCondition(op.payload.path, "object");
+            case "whereArrayLength":
+                return this.buildArrayLengthCondition(op.payload.field, op.payload.operator, op.payload.value);
+            case "whereFullText":
+            case "orWhereFullText":
+                return { $text: { $search: op.payload.query } };
+            case "whereSearch":
+                return {
+                    [op.payload.field]: {
+                        $regex: op.payload.query,
+                        $options: "i",
+                    },
+                };
+            case "where:not":
+            case "orWhere:not": {
+                const nestedNot = this.buildCallbackCondition(op.payload.callback);
+                return nestedNot ? { $nor: [nestedNot] } : null;
+            }
+            case "where:exists":
+                return this.buildCallbackCondition(op.payload.callback);
+            case "where:notExists": {
+                const nestedExists = this.buildCallbackCondition(op.payload.callback);
+                return nestedExists ? { $nor: [nestedExists] } : null;
+            }
+            case "whereArrayContains":
+                if (op.payload.key) {
+                    return {
+                        [field]: {
+                            $elemMatch: { [op.payload.key]: op.payload.value },
+                        },
+                    };
+                }
+                else {
+                    return { [field]: op.payload.value };
+                }
+            default:
+                return null;
+        }
+    }
+    /**
+     * Build a condition based on the operator.
+     *
+     * @param field - The field name
+     * @param operator - The comparison operator
+     * @param value - The value to compare
+     * @returns The MongoDB filter condition
+     */
+    buildOperatorCondition(field, operator, value) {
+        switch (operator) {
+            case "=":
+                return { [field]: value };
+            case "!=":
+                return { [field]: { $ne: value } };
+            case ">":
+                return { [field]: { $gt: value } };
+            case ">=":
+                return { [field]: { $gte: value } };
+            case "<":
+                return { [field]: { $lt: value } };
+            case "<=":
+                return { [field]: { $lte: value } };
+            default:
+                return { [field]: value };
+        }
+    }
+    /**
+     * Get MongoDB operator from comparison operator.
+     *
+     * @param operator - The comparison operator
+     * @returns The MongoDB operator
+     */
+    getMongoOperator(operator) {
+        const map = {
+            "=": "$eq",
+            "!=": "$ne",
+            ">": "$gt",
+            ">=": "$gte",
+            "<": "$lt",
+            "<=": "$lte",
+        };
+        return map[operator] || "$eq";
+    }
+    resolveRawExpression(expression, bindings) {
+        if (typeof expression === "string") {
+            const bound = this.bindRawString(expression, bindings);
+            return { $where: bound };
+        }
+        if (typeof expression === "object" && expression !== null) {
+            return expression;
+        }
+        return null;
+    }
+    bindRawString(expression, bindings) {
+        if (!bindings || bindings.length === 0) {
+            return expression;
+        }
+        let index = 0;
+        return expression.replace(/\?/g, () => {
+            const value = bindings[index++];
+            return value === undefined ? "?" : JSON.stringify(value);
+        });
+    }
+    buildColumnComparison(first, operator, second) {
+        const mongoOperator = this.getMongoOperator(operator);
+        return {
+            $expr: {
+                [mongoOperator]: [this.wrapColumn(first), this.wrapColumn(second)],
+            },
+        };
+    }
+    buildBetweenColumnsCondition(field, lower, upper) {
+        return {
+            $expr: {
+                $and: [
+                    { $gte: [this.wrapColumn(field), this.wrapColumn(lower)] },
+                    { $lte: [this.wrapColumn(field), this.wrapColumn(upper)] },
+                ],
+            },
+        };
+    }
+    wrapColumn(column) {
+        return column.startsWith("$") ? column : `$${column}`;
+    }
+    buildDateEqualityCondition(field, value) {
+        const target = this.normalizeDateInput(value);
+        const start = this.startOfDay(target);
+        const end = this.endOfDay(target);
+        return { [field]: { $gte: start, $lte: end } };
+    }
+    buildDateBeforeCondition(field, value) {
+        const target = this.startOfDay(this.normalizeDateInput(value));
+        return { [field]: { $lt: target } };
+    }
+    buildDateAfterCondition(field, value) {
+        const target = this.endOfDay(this.normalizeDateInput(value));
+        return { [field]: { $gt: target } };
+    }
+    buildTimeCondition(field, value) {
+        return {
+            $expr: {
+                $eq: [
+                    {
+                        $dateToString: {
+                            format: "%H:%M",
+                            date: `$${field}`,
+                        },
+                    },
+                    value,
+                ],
+            },
+        };
+    }
+    buildDatePartCondition(field, operator, value) {
+        return {
+            $expr: {
+                $eq: [
+                    {
+                        [operator]: `$${field}`,
+                    },
+                    value,
+                ],
+            },
+        };
+    }
+    buildJsonContainsCondition(path, value) {
+        const fieldPath = this.normalizePath(path);
+        if (Array.isArray(value)) {
+            return { [fieldPath]: { $all: value } };
+        }
+        return { [fieldPath]: value };
+    }
+    buildJsonDoesntContainCondition(path, value) {
+        const fieldPath = this.normalizePath(path);
+        const values = Array.isArray(value) ? value : [value];
+        return { [fieldPath]: { $nin: values } };
+    }
+    buildJsonContainsKeyCondition(path) {
+        return {
+            [this.normalizePath(path)]: { $exists: true },
+        };
+    }
+    buildJsonLengthCondition(path, operator, value) {
+        const mongoOperator = this.getMongoOperator(operator);
+        return {
+            $expr: {
+                [mongoOperator]: [{ $size: { $ifNull: [`$${this.normalizePath(path)}`, []] } }, value],
+            },
+        };
+    }
+    buildJsonTypeCondition(path, type) {
+        return {
+            $expr: {
+                $eq: [{ $type: `$${this.normalizePath(path)}` }, type],
+            },
+        };
+    }
+    buildArrayLengthCondition(field, operator, value) {
+        const mongoOperator = this.getMongoOperator(operator);
+        return {
+            $expr: {
+                [mongoOperator]: [{ $size: { $ifNull: [`$${field}`, []] } }, value],
+            },
+        };
+    }
+    normalizeDateInput(value) {
+        if (value instanceof Date) {
+            return value;
+        }
+        const parsed = new Date(value);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`Invalid date value: ${value}`);
+        }
+        return parsed;
+    }
+    startOfDay(date) {
+        const copy = new Date(date);
+        copy.setHours(0, 0, 0, 0);
+        return copy;
+    }
+    endOfDay(date) {
+        const copy = new Date(date);
+        copy.setHours(23, 59, 59, 999);
+        return copy;
+    }
+    normalizePath(path) {
+        return path.replace(/->/g, ".");
+    }
+    applyProjectionFields(projection, fields, value) {
+        for (const field of fields) {
+            projection[field] = value;
+        }
+    }
+    /**
+     * Apply projection object with aliases and inclusion/exclusion.
+     * @param projection - The projection object to modify
+     * @param projectionObj - The projection specification
+     */
+    applyProjectionObject(projection, projectionObj) {
+        for (const [field, value] of Object.entries(projectionObj)) {
+            // Handle boolean values (true = 1, false = 0)
+            if (typeof value === "boolean") {
+                projection[field] = value ? 1 : 0;
+                continue;
+            }
+            // Handle numeric values (0 or 1)
+            if (typeof value === "number") {
+                projection[field] = value;
+                continue;
+            }
+            // Handle string values (aliases)
+            if (typeof value === "string") {
+                // Alias: project the field with a new name
+                projection[value] = `$${field}`;
+                continue;
+            }
+            // Handle complex expressions (objects)
+            if (typeof value === "object" && value !== null) {
+                projection[field] = value;
+                continue;
+            }
+            // Default: include the field
+            projection[field] = 1;
+        }
+    }
+    applyRawProjection(projection, expression, bindings) {
+        const resolved = this.resolveProjectionExpression(expression, bindings);
+        if (!resolved) {
+            return;
+        }
+        if (typeof resolved === "object" && resolved !== null && !Array.isArray(resolved)) {
+            Object.assign(projection, resolved);
+        }
+    }
+    resolveProjectionExpression(expression, bindings) {
+        if (typeof expression === "string") {
+            const source = bindings && expression.includes("?")
+                ? this.bindRawString(expression, bindings)
+                : expression;
+            if (source.startsWith(":")) {
+                return source.slice(1);
+            }
+            return this.normalizeFieldReference(source);
+        }
+        if (typeof expression === "object" && expression !== null && !(expression instanceof Date)) {
+            return expression;
+        }
+        if (typeof expression === "number" || typeof expression === "boolean") {
+            return expression;
+        }
+        return expression;
+    }
+    normalizeFieldReference(value) {
+        if (typeof value === "string") {
+            if (value.startsWith(":")) {
+                return value.slice(1);
+            }
+            // If already a field reference, return as-is
+            if (value.startsWith("$")) {
+                return value;
+            }
+            // Check if it's a string literal (contains spaces or special chars)
+            // Field paths are typically: alphanumeric, underscore, dot only
+            if (!/^[a-zA-Z0-9_.]+$/.test(value)) {
+                return value; // Return as literal
+            }
+            // Otherwise, treat as field reference
+            return `$${value}`;
+        }
+        return value;
+    }
+    buildAggregateProjection(field, aggregate) {
+        if (aggregate === "count") {
+            return this.buildArraySizeExpression(field);
+        }
+        const map = {
+            sum: "$sum",
+            avg: "$avg",
+            min: "$min",
+            max: "$max",
+            first: "$first",
+            last: "$last",
+        };
+        const operator = map[aggregate];
+        if (!operator) {
+            return null;
+        }
+        return {
+            [operator]: this.normalizeFieldReference(field),
+        };
+    }
+    buildExistsProjection(field) {
+        return {
+            $ne: [{ $type: `$${field}` }, "missing"],
+        };
+    }
+    buildArraySizeExpression(field) {
+        return {
+            $size: { $ifNull: [`$${field}`, []] },
+        };
+    }
+    buildCaseExpression(cases, otherwise) {
+        return {
+            $switch: {
+                branches: cases.map((item) => ({
+                    case: this.resolveProjectionExpression(item.when),
+                    then: this.resolveLiteralOrExpression(item.then),
+                })),
+                default: this.resolveLiteralOrExpression(otherwise),
+            },
+        };
+    }
+    buildCondExpression(condition, thenValue, elseValue) {
+        return {
+            $cond: [
+                this.resolveProjectionExpression(condition),
+                this.resolveLiteralOrExpression(thenValue),
+                this.resolveLiteralOrExpression(elseValue),
+            ],
+        };
+    }
+    /**
+     * Resolve a value as a literal (if it's a plain string) or as an expression.
+     * Used for `then`/`default` values in CASE/WHEN expressions.
+     */
+    resolveLiteralOrExpression(value) {
+        // If it's a string that starts with $, treat as field reference
+        if (typeof value === "string" && value.startsWith("$")) {
+            return value;
+        }
+        // If it's a plain string (not starting with $), treat as literal
+        if (typeof value === "string") {
+            return value;
+        }
+        // For objects (expressions), numbers, booleans, etc., use normal resolution
+        return this.resolveProjectionExpression(value);
+    }
+    inferJsonAlias(path) {
+        const normalized = this.normalizePath(path);
+        const segments = normalized.split(".");
+        return segments[segments.length - 1];
+    }
+    buildConcatExpression(values) {
+        return {
+            $concat: values.map((value) => this.normalizeFieldReference(value)),
+        };
+    }
+    buildCoalesceExpression(values) {
+        if (values.length === 0) {
+            return null;
+        }
+        let expression = this.normalizeFieldReference(values[values.length - 1]);
+        for (let index = values.length - 2; index >= 0; index--) {
+            expression = {
+                $ifNull: [this.normalizeFieldReference(values[index]), expression],
+            };
+        }
+        return expression;
+    }
+    /**
+     * Build a $project stage from select operations.
+     *
+     * @param operations - The select operations
+     * @returns The $project stage or null
+     */
+    buildProjectStage(operations) {
+        if (operations.length === 0) {
+            return null;
+        }
+        const projection = {};
+        const driverCallbacks = [];
+        for (const op of operations) {
+            switch (op.type) {
+                case "select":
+                    // Handle new projection format with aliases
+                    if (op.payload.projection) {
+                        this.applyProjectionObject(projection, op.payload.projection);
+                    }
+                    else if (op.payload.fields) {
+                        this.applyProjectionFields(projection, op.payload.fields, 1);
+                    }
+                    break;
+                case "deselect":
+                    this.applyProjectionFields(projection, op.payload.fields, 0);
+                    break;
+                case "addSelect":
+                    this.applyProjectionFields(projection, op.payload.fields, 1);
+                    break;
+                case "selectRaw":
+                    this.applyRawProjection(projection, op.payload.expression, op.payload.bindings);
+                    break;
+                case "selectSub":
+                case "addSelectSub": {
+                    const expr = this.resolveProjectionExpression(op.payload.expression, op.payload.bindings);
+                    if (expr !== undefined) {
+                        projection[op.payload.alias] = expr;
+                    }
+                    break;
+                }
+                case "selectAggregate":
+                    projection[op.payload.alias] = this.buildAggregateProjection(op.payload.field, op.payload.aggregate);
+                    break;
+                case "selectExists":
+                    projection[op.payload.alias] = this.buildExistsProjection(op.payload.field);
+                    break;
+                case "selectCount":
+                    projection[op.payload.alias] = this.buildArraySizeExpression(op.payload.field);
+                    break;
+                case "selectCase":
+                    projection[op.payload.alias] = this.buildCaseExpression(op.payload.cases, op.payload.otherwise);
+                    break;
+                case "selectWhen":
+                    projection[op.payload.alias] = this.buildCondExpression(op.payload.condition, op.payload.thenValue, op.payload.elseValue);
+                    break;
+                case "selectDriverProjection":
+                    driverCallbacks.push(op.payload.callback);
+                    break;
+                case "selectJson": {
+                    const alias = op.payload.alias ?? this.inferJsonAlias(op.payload.path);
+                    projection[alias] = this.normalizeFieldReference(`$${this.normalizePath(op.payload.path)}`);
+                    break;
+                }
+                case "selectJsonRaw": {
+                    projection[op.payload.alias] = this.resolveProjectionExpression(op.payload.expression);
+                    break;
+                }
+                case "deselectJson":
+                    projection[this.normalizePath(op.payload.path)] = 0;
+                    break;
+                case "selectConcat":
+                    projection[op.payload.alias] = this.buildConcatExpression(op.payload.fields);
+                    break;
+                case "selectCoalesce":
+                    projection[op.payload.alias] = this.buildCoalesceExpression(op.payload.fields);
+                    break;
+            }
+        }
+        for (const callback of driverCallbacks) {
+            callback(projection);
+        }
+        return Object.keys(projection).length > 0 ? { $project: projection } : null;
+    }
+    /**
+     * Build a $sort stage from order operations.
+     *
+     * @param operations - The order operations
+     * @returns The $sort stage or null
+     */
+    buildSortStage(operations) {
+        const sort = {};
+        for (const op of operations) {
+            switch (op.type) {
+                case "orderBy":
+                    sort[op.payload.field] = op.payload.direction === "asc" ? 1 : -1;
+                    break;
+                case "orderByRandom":
+                    return { $sample: { size: op.payload.limit } };
+            }
+        }
+        return Object.keys(sort).length > 0 ? { $sort: sort } : null;
+    }
+    /**
+     * Build a $group stage from group operations.
+     *
+     * @param operations - The group operations
+     * @returns The $group stage or null
+     */
+    buildGroupStage(operations) {
+        const op = operations[0];
+        switch (op.type) {
+            case "groupBy": {
+                const stage = this.buildGroupByStage(op.payload.fields);
+                if (stage) {
+                    return stage;
+                }
+                break;
+            }
+            case "groupByWithAggregates": {
+                const stage = this.buildGroupByWithAggregatesStage(op.payload.fields, op.payload.aggregates);
+                if (stage) {
+                    return stage;
+                }
+                break;
+            }
+            case "groupByRaw": {
+                const expression = op.payload.expression;
+                if (expression && typeof expression === "object") {
+                    return { $group: expression };
+                }
+                // If expression is not an object, it might be a string or other type
+                // In that case, we should still return it as a $group stage
+                if (expression) {
+                    return { $group: { _id: expression } };
+                }
+                break;
+            }
+            case "distinct": {
+                const stage = this.buildGroupByStage(op.payload.fields);
+                if (stage) {
+                    return stage;
+                }
+                break;
+            }
+        }
+        return null;
+    }
+    buildGroupByStage(fields) {
+        const groupId = this.buildGroupId(fields);
+        if (!groupId) {
+            return null;
+        }
+        return { $group: { _id: groupId } };
+    }
+    /**
+     * Build a $group stage with aggregates from group operations.
+     *
+     * @param fields - Fields to group by
+     * @param aggregates - Aggregate operations (abstract or raw)
+     * @returns The $group stage or null
+     */
+    buildGroupByWithAggregatesStage(fields, aggregates) {
+        const groupId = this.buildGroupId(fields);
+        if (!groupId) {
+            return null;
+        }
+        const groupStage = {
+            _id: groupId,
+        };
+        // Translate each aggregate expression
+        for (const [alias, expression] of Object.entries(aggregates)) {
+            if (isAggregateExpression(expression)) {
+                // Translate abstract expression to MongoDB format
+                groupStage[alias] = this.translateAggregateExpression(expression);
+            }
+            else {
+                // Use raw expression as-is (already in MongoDB format)
+                groupStage[alias] = expression;
+            }
+        }
+        return { $group: groupStage };
+    }
+    /**
+     * Extract field names from GroupByInput for renaming _id.
+     *
+     * @param fields - The grouping fields
+     * @returns Field name(s) to use for renaming _id
+     */
+    extractGroupFieldNames(fields) {
+        if (typeof fields === "string") {
+            return fields;
+        }
+        if (Array.isArray(fields)) {
+            const allStrings = fields.every((field) => typeof field === "string");
+            if (allStrings) {
+                return fields;
+            }
+            // For complex arrays, return null (don't rename)
+            return null;
+        }
+        if (typeof fields === "object" && fields !== null) {
+            // For object syntax, use the keys as field names
+            return Object.keys(fields);
+        }
+        return null;
+    }
+    /**
+     * Translate an abstract aggregate expression to MongoDB format.
+     *
+     * @param expr - Abstract aggregate expression
+     * @returns MongoDB aggregation expression
+     */
+    translateAggregateExpression(expr) {
+        switch (expr.__agg) {
+            case "count":
+                return { $sum: 1 };
+            case "sum":
+                if (!expr.__field) {
+                    throw new Error("Sum aggregate requires a field name");
+                }
+                return { $sum: `$${expr.__field}` };
+            case "avg":
+                if (!expr.__field) {
+                    throw new Error("Average aggregate requires a field name");
+                }
+                return { $avg: `$${expr.__field}` };
+            case "min":
+                if (!expr.__field) {
+                    throw new Error("Min aggregate requires a field name");
+                }
+                return { $min: `$${expr.__field}` };
+            case "max":
+                if (!expr.__field) {
+                    throw new Error("Max aggregate requires a field name");
+                }
+                return { $max: `$${expr.__field}` };
+            case "first":
+                if (!expr.__field) {
+                    throw new Error("First aggregate requires a field name");
+                }
+                return { $first: `$${expr.__field}` };
+            case "last":
+                if (!expr.__field) {
+                    throw new Error("Last aggregate requires a field name");
+                }
+                return { $last: `$${expr.__field}` };
+            case "distinct":
+                if (!expr.__field) {
+                    throw new Error("Distinct aggregate requires a field name");
+                }
+                return { $distinct: `$${expr.__field}` };
+            case "floor":
+                if (!expr.__field) {
+                    throw new Error("Floor aggregate requires a field name");
+                }
+                return { $floor: `$${expr.__field}` };
+            default:
+                throw new Error(`Unknown aggregate function: ${expr.__agg}`);
+        }
+    }
+    buildGroupId(fields) {
+        if (!fields) {
+            return null;
+        }
+        if (typeof fields === "string") {
+            return `$${fields}`;
+        }
+        if (Array.isArray(fields)) {
+            if (fields.length === 0) {
+                return null;
+            }
+            const allStrings = fields.every((field) => typeof field === "string");
+            if (allStrings) {
+                const result = {};
+                for (const field of fields) {
+                    result[field] = `$${field}`;
+                }
+                return result;
+            }
+            // Array of objects - merge them to build complex _id structures
+            return fields.reduce((acc, item) => ({ ...acc, ...item }), {});
+        }
+        if (typeof fields === "object") {
+            const normalized = {};
+            Object.entries(fields).forEach(([key, value]) => {
+                if (typeof value === "string" && !value.startsWith("$")) {
+                    normalized[key] = `$${value}`;
+                }
+                else {
+                    normalized[key] = value;
+                }
+            });
+            return normalized;
+        }
+        return null;
+    }
+    /**
+     * Build a $lookup stage from join operations.
+     *
+     * @param operations - The join operations
+     * @returns The $lookup stage or null
+     */
+    buildLookupStage(operations) {
+        const op = operations[0];
+        const options = op.payload;
+        return {
+            $lookup: {
+                from: options.table,
+                localField: options.localField,
+                foreignField: options.foreignField,
+                as: options.alias || options.table,
+            },
+        };
+    }
+}export{MongoQueryParser};//# sourceMappingURL=mongo-query-parser.js.map