@warlock.js/cascade 4.0.171 → 4.1.1

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

@@ -1,1351 +0,0 @@
-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.data.fields) {
-                const fieldNames = this.extractGroupFieldNames(op.data.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].data.value };
-            case "$skip":
-                return { $skip: operations[0].data.value };
-            case "$setWindowFields":
-                return {
-                    $setWindowFields: operations[0].data.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.data);
-                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.data);
-                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.data.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.data);
-                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.data);
-                    if (nestedCondition) {
-                        pushOr(nestedCondition);
-                    }
-                    continue;
-                }
-                if (op.type === "where:object" || op.type === "orWhere:object") {
-                    pushOr(op.data);
-                    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.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);
-                }
-            }
-        }
-        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.data;
-        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]: {
-                        $gte: op.data.range[0],
-                        $lte: op.data.range[1],
-                    },
-                };
-            case "whereNotBetween":
-                return {
-                    [field]: {
-                        $not: {
-                            $gte: op.data.range[0],
-                            $lte: op.data.range[1],
-                        },
-                    },
-                };
-            case "whereLike": {
-                const pattern = typeof op.data.pattern === "string" ? op.data.pattern : op.data.pattern.source;
-                return { [field]: { $regex: pattern, $options: "i" } };
-            }
-            case "whereNotLike": {
-                const notPattern = typeof op.data.pattern === "string" ? op.data.pattern : op.data.pattern.source;
-                return { [field]: { $not: { $regex: notPattern, $options: "i" } } };
-            }
-            case "whereStartsWith":
-                return { [field]: { $regex: `^${op.data.value}`, $options: "i" } };
-            case "whereNotStartsWith":
-                return {
-                    [field]: { $not: { $regex: `^${op.data.value}`, $options: "i" } },
-                };
-            case "whereEndsWith":
-                return { [field]: { $regex: `${op.data.value}$`, $options: "i" } };
-            case "whereNotEndsWith":
-                return {
-                    [field]: { $not: { $regex: `${op.data.value}$`, $options: "i" } },
-                };
-            case "whereExists":
-                return { [field]: { $exists: true } };
-            case "whereNotExists":
-                return { [field]: { $exists: false } };
-            case "whereSize":
-                if (op.data.operator === "=") {
-                    return { [field]: { $size: op.data.size } };
-                }
-                else {
-                    const mongoOp = this.getMongoOperator(op.data.operator);
-                    return {
-                        $expr: {
-                            [mongoOp]: [{ $size: `$${field}` }, op.data.size],
-                        },
-                    };
-                }
-            case "textSearch":
-                return {
-                    $text: { $search: op.data.query },
-                    ...(op.data.filters || {}),
-                };
-            case "whereRaw":
-            case "orWhereRaw":
-                return this.resolveRawExpression(op.data.expression, op.data.bindings);
-            case "whereColumn":
-            case "orWhereColumn":
-                return this.buildColumnComparison(op.data.first, op.data.operator, op.data.second);
-            case "whereBetweenColumns":
-                return this.buildBetweenColumnsCondition(op.data.field, op.data.lowerColumn, op.data.upperColumn);
-            case "whereDate":
-            case "whereDateEquals":
-                return this.buildDateEqualityCondition(op.data.field, op.data.value);
-            case "whereDateBefore":
-                return this.buildDateBeforeCondition(op.data.field, op.data.value);
-            case "whereDateAfter":
-                return this.buildDateAfterCondition(op.data.field, op.data.value);
-            case "whereTime":
-                return this.buildTimeCondition(op.data.field, op.data.value);
-            case "whereDay":
-                return this.buildDatePartCondition(op.data.field, "$dayOfMonth", op.data.value);
-            case "whereMonth":
-                return this.buildDatePartCondition(op.data.field, "$month", op.data.value);
-            case "whereYear":
-                return this.buildDatePartCondition(op.data.field, "$year", op.data.value);
-            case "whereJsonContains":
-                return this.buildJsonContainsCondition(op.data.path, op.data.value);
-            case "whereJsonDoesntContain":
-                return this.buildJsonDoesntContainCondition(op.data.path, op.data.value);
-            case "whereJsonContainsKey":
-                return this.buildJsonContainsKeyCondition(op.data.path);
-            case "whereJsonLength":
-                return this.buildJsonLengthCondition(op.data.path, op.data.operator, op.data.value);
-            case "whereJsonIsArray":
-                return this.buildJsonTypeCondition(op.data.path, "array");
-            case "whereJsonIsObject":
-                return this.buildJsonTypeCondition(op.data.path, "object");
-            case "whereArrayLength":
-                return this.buildArrayLengthCondition(op.data.field, op.data.operator, op.data.value);
-            case "whereFullText":
-            case "orWhereFullText":
-                return { $text: { $search: op.data.query } };
-            case "whereSearch":
-                return {
-                    [op.data.field]: {
-                        $regex: op.data.query,
-                        $options: "i",
-                    },
-                };
-            case "where:not":
-            case "orWhere:not": {
-                const nestedNot = this.buildCallbackCondition(op.data.callback);
-                return nestedNot ? { $nor: [nestedNot] } : null;
-            }
-            case "where:exists":
-                return this.buildCallbackCondition(op.data.callback);
-            case "where:notExists": {
-                const nestedExists = this.buildCallbackCondition(op.data.callback);
-                return nestedExists ? { $nor: [nestedExists] } : null;
-            }
-            case "whereArrayContains":
-                if (op.data.key) {
-                    return {
-                        [field]: {
-                            $elemMatch: { [op.data.key]: op.data.value },
-                        },
-                    };
-                }
-                else {
-                    return { [field]: op.data.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.data.projection) {
-                        this.applyProjectionObject(projection, op.data.projection);
-                    }
-                    else if (op.data.fields) {
-                        this.applyProjectionFields(projection, op.data.fields, 1);
-                    }
-                    break;
-                case "deselect":
-                    this.applyProjectionFields(projection, op.data.fields, 0);
-                    break;
-                case "addSelect":
-                    this.applyProjectionFields(projection, op.data.fields, 1);
-                    break;
-                case "selectRaw":
-                    this.applyRawProjection(projection, op.data.expression, op.data.bindings);
-                    break;
-                case "selectSub":
-                case "addSelectSub": {
-                    const expr = this.resolveProjectionExpression(op.data.expression, op.data.bindings);
-                    if (expr !== undefined) {
-                        projection[op.data.alias] = expr;
-                    }
-                    break;
-                }
-                case "selectAggregate":
-                    projection[op.data.alias] = this.buildAggregateProjection(op.data.field, op.data.aggregate);
-                    break;
-                case "selectExists":
-                    projection[op.data.alias] = this.buildExistsProjection(op.data.field);
-                    break;
-                case "selectCount":
-                    projection[op.data.alias] = this.buildArraySizeExpression(op.data.field);
-                    break;
-                case "selectCase":
-                    projection[op.data.alias] = this.buildCaseExpression(op.data.cases, op.data.otherwise);
-                    break;
-                case "selectWhen":
-                    projection[op.data.alias] = this.buildCondExpression(op.data.condition, op.data.thenValue, op.data.elseValue);
-                    break;
-                case "selectDriverProjection":
-                    driverCallbacks.push(op.data.callback);
-                    break;
-                case "selectJson": {
-                    const alias = op.data.alias ?? this.inferJsonAlias(op.data.path);
-                    projection[alias] = this.normalizeFieldReference(`$${this.normalizePath(op.data.path)}`);
-                    break;
-                }
-                case "selectJsonRaw": {
-                    projection[op.data.alias] = this.resolveProjectionExpression(op.data.expression);
-                    break;
-                }
-                case "deselectJson":
-                    projection[this.normalizePath(op.data.path)] = 0;
-                    break;
-                case "selectConcat":
-                    projection[op.data.alias] = this.buildConcatExpression(op.data.fields);
-                    break;
-                case "selectCoalesce":
-                    projection[op.data.alias] = this.buildCoalesceExpression(op.data.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.data.field] = op.data.direction === "asc" ? 1 : -1;
-                    break;
-                case "orderByRandom":
-                    return { $sample: { size: op.data.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.data.fields);
-                if (stage) {
-                    return stage;
-                }
-                break;
-            }
-            case "groupByWithAggregates": {
-                const stage = this.buildGroupByWithAggregatesStage(op.data.fields, op.data.aggregates);
-                if (stage) {
-                    return stage;
-                }
-                break;
-            }
-            case "groupByRaw": {
-                const expression = op.data.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.data.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.data;
-        return {
-            $lookup: {
-                from: options.table,
-                localField: options.localField,
-                foreignField: options.foreignField,
-                as: options.alias || options.table,
-            },
-        };
-    }
-}export{MongoQueryParser};//# sourceMappingURL=mongodb-query-parser.js.map