@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/database/operators/aggregation-builder.js

@@ -0,0 +1,841 @@
+"use strict";
+/**
+ * Aggregation Builder
+ *
+ * Builds database aggregation queries from the uniform ORM interface.
+ * Translates aggregation options to database-specific SQL or aggregation pipelines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationOperators = exports.AggregationBuilder = void 0;
+const enums_1 = require("../types/enums");
+/**
+ * Aggregation builder for translating ORM aggregations to database-specific formats
+ */
+class AggregationBuilder {
+    constructor(databaseType) {
+        this.databaseType = databaseType;
+    }
+    /**
+     * Build an aggregation query
+     * @param options Aggregation options
+     * @returns Built aggregation ready for execution
+     */
+    buildAggregation(options) {
+        switch (this.databaseType) {
+            case enums_1.DatabaseType.POSTGRESQL:
+                return this.buildPostgresAggregation(options);
+            case enums_1.DatabaseType.MYSQL:
+            case enums_1.DatabaseType.MARIADB:
+                return this.buildMySQLAggregation(options);
+            case enums_1.DatabaseType.MONGODB:
+                return this.buildMongoAggregation(options);
+            case enums_1.DatabaseType.DYNAMODB:
+                return this.buildDynamoAggregation(options);
+            case enums_1.DatabaseType.CASSANDRA:
+                return this.buildCassandraAggregation(options);
+            default:
+                throw new Error(`Unsupported database type: ${this.databaseType}`);
+        }
+    }
+    /**
+     * Build a group by aggregation query
+     * @param options Group by options
+     * @returns Built aggregation ready for execution
+     */
+    buildGroupBy(options) {
+        switch (this.databaseType) {
+            case enums_1.DatabaseType.POSTGRESQL:
+                return this.buildPostgresGroupBy(options);
+            case enums_1.DatabaseType.MYSQL:
+            case enums_1.DatabaseType.MARIADB:
+                return this.buildMySQLGroupBy(options);
+            case enums_1.DatabaseType.MONGODB:
+                return this.buildMongoGroupBy(options);
+            case enums_1.DatabaseType.DYNAMODB:
+                return this.buildDynamoGroupBy(options);
+            case enums_1.DatabaseType.CASSANDRA:
+                return this.buildCassandraGroupBy(options);
+            default:
+                throw new Error(`Unsupported database type: ${this.databaseType}`);
+        }
+    }
+    // ==================== POSTGRESQL AGGREGATION ====================
+    buildPostgresAggregation(options) {
+        const params = [];
+        let paramIndex = 1;
+        // Build SELECT clause with aggregations
+        const selectClauses = this.buildAggregationSelectClauses(options.operations, 'postgresql');
+        let sql = `SELECT ${selectClauses.join(', ')} FROM ${this.escapeIdentifier(options.table, 'postgresql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'postgresql', paramIndex);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+            paramIndex += whereResult.params.length;
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    buildPostgresGroupBy(options) {
+        const params = [];
+        let paramIndex = 1;
+        // Build SELECT clause with group columns and aggregations
+        const groupColumns = options.groupBy.map(col => this.escapeIdentifier(col, 'postgresql'));
+        const aggClauses = this.buildAggregationSelectClauses(options.operations, 'postgresql');
+        let sql = `SELECT ${[...groupColumns, ...aggClauses].join(', ')} FROM ${this.escapeIdentifier(options.table, 'postgresql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'postgresql', paramIndex);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+            paramIndex += whereResult.params.length;
+        }
+        // GROUP BY clause
+        sql += ` GROUP BY ${groupColumns.join(', ')}`;
+        // HAVING clause
+        if (options.having) {
+            const havingResult = this.buildHavingClause(options.having, 'postgresql', paramIndex);
+            sql += ` HAVING ${havingResult.clause}`;
+            params.push(...havingResult.params);
+            paramIndex += havingResult.params.length;
+        }
+        // ORDER BY clause
+        if (options.orderBy) {
+            const orderClauses = options.orderBy.map(order => {
+                const direction = order.order === 'DESC' ? 'DESC' : 'ASC';
+                return `${this.escapeIdentifier(order.column, 'postgresql')} ${direction}`;
+            });
+            sql += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit !== undefined) {
+            sql += ` LIMIT $${paramIndex}`;
+            params.push(options.limit);
+            paramIndex++;
+        }
+        // OFFSET clause
+        if (options.offset !== undefined) {
+            sql += ` OFFSET $${paramIndex}`;
+            params.push(options.offset);
+            paramIndex++;
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    // ==================== MYSQL/MARIADB AGGREGATION ====================
+    buildMySQLAggregation(options) {
+        const params = [];
+        // Build SELECT clause with aggregations
+        const selectClauses = this.buildAggregationSelectClauses(options.operations, 'mysql');
+        let sql = `SELECT ${selectClauses.join(', ')} FROM ${this.escapeIdentifier(options.table, 'mysql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'mysql', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    buildMySQLGroupBy(options) {
+        const params = [];
+        // Build SELECT clause with group columns and aggregations
+        const groupColumns = options.groupBy.map(col => this.escapeIdentifier(col, 'mysql'));
+        const aggClauses = this.buildAggregationSelectClauses(options.operations, 'mysql');
+        let sql = `SELECT ${[...groupColumns, ...aggClauses].join(', ')} FROM ${this.escapeIdentifier(options.table, 'mysql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'mysql', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        // GROUP BY clause
+        sql += ` GROUP BY ${groupColumns.join(', ')}`;
+        // HAVING clause
+        if (options.having) {
+            const havingResult = this.buildHavingClause(options.having, 'mysql', 0);
+            sql += ` HAVING ${havingResult.clause}`;
+            params.push(...havingResult.params);
+        }
+        // ORDER BY clause
+        if (options.orderBy) {
+            const orderClauses = options.orderBy.map(order => {
+                const direction = order.order === 'DESC' ? 'DESC' : 'ASC';
+                return `${this.escapeIdentifier(order.column, 'mysql')} ${direction}`;
+            });
+            sql += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        // OFFSET clause
+        if (options.offset !== undefined) {
+            sql += ' OFFSET ?';
+            params.push(options.offset);
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    // ==================== MONGODB AGGREGATION ====================
+    buildMongoAggregation(options) {
+        const pipeline = [];
+        // $match stage (WHERE equivalent)
+        if (options.where) {
+            const matchStage = this.buildMongoMatch(options.where);
+            pipeline.push({ $match: matchStage });
+        }
+        // $group stage for aggregations (without grouping columns)
+        const groupStage = { _id: null };
+        for (const [alias, operation] of Object.entries(options.operations)) {
+            Object.assign(groupStage, this.buildMongoAggregationField(alias, operation));
+        }
+        pipeline.push({ $group: groupStage });
+        // $project to remove _id
+        const projectStage = { _id: 0 };
+        for (const alias of Object.keys(options.operations)) {
+            projectStage[alias] = 1;
+        }
+        pipeline.push({ $project: projectStage });
+        return {
+            options,
+            pipeline,
+        };
+    }
+    buildMongoGroupBy(options) {
+        const pipeline = [];
+        // $match stage (WHERE equivalent)
+        if (options.where) {
+            const matchStage = this.buildMongoMatch(options.where);
+            pipeline.push({ $match: matchStage });
+        }
+        // $group stage
+        const groupId = {};
+        for (const col of options.groupBy) {
+            groupId[col] = `$${col}`;
+        }
+        const groupStage = { _id: groupId };
+        for (const [alias, operation] of Object.entries(options.operations)) {
+            Object.assign(groupStage, this.buildMongoAggregationField(alias, operation));
+        }
+        pipeline.push({ $group: groupStage });
+        // $match stage for HAVING
+        if (options.having) {
+            const havingMatch = this.buildMongoHaving(options.having);
+            pipeline.push({ $match: havingMatch });
+        }
+        // $sort stage
+        if (options.orderBy) {
+            const sortStage = {};
+            for (const order of options.orderBy) {
+                // Check if sorting by a group column or an aggregate
+                const isGroupColumn = options.groupBy.includes(order.column);
+                const sortKey = isGroupColumn ? `_id.${order.column}` : order.column;
+                sortStage[sortKey] = order.order === 'DESC' ? -1 : 1;
+            }
+            pipeline.push({ $sort: sortStage });
+        }
+        // $skip stage
+        if (options.offset !== undefined) {
+            pipeline.push({ $skip: options.offset });
+        }
+        // $limit stage
+        if (options.limit !== undefined) {
+            pipeline.push({ $limit: options.limit });
+        }
+        // $project stage to flatten the result
+        const projectStage = { _id: 0 };
+        for (const col of options.groupBy) {
+            projectStage[col] = `$_id.${col}`;
+        }
+        for (const alias of Object.keys(options.operations)) {
+            projectStage[alias] = 1;
+        }
+        pipeline.push({ $project: projectStage });
+        return {
+            options,
+            pipeline,
+        };
+    }
+    buildMongoAggregationField(alias, operation) {
+        // Support both lowercase (new) and uppercase (legacy) operators
+        const count = operation.$count;
+        const sum = operation.$sum;
+        const avg = operation.$avg;
+        const min = operation.$min;
+        const max = operation.$max;
+        const arrayAgg = operation.$arrayAgg;
+        const stringAgg = operation.$stringAgg;
+        const groupConcat = operation.$groupConcat;
+        if (count !== undefined) {
+            if (count === '*') {
+                return { [alias]: { $sum: 1 } };
+            }
+            return { [alias]: { $sum: { $cond: [{ $ne: [`$${count}`, null] }, 1, 0] } } };
+        }
+        if (sum !== undefined) {
+            return { [alias]: { $sum: `$${sum}` } };
+        }
+        if (avg !== undefined) {
+            return { [alias]: { $avg: `$${avg}` } };
+        }
+        if (min !== undefined) {
+            return { [alias]: { $min: `$${min}` } };
+        }
+        if (max !== undefined) {
+            return { [alias]: { $max: `$${max}` } };
+        }
+        if (arrayAgg !== undefined) {
+            return { [alias]: { $push: `$${arrayAgg}` } };
+        }
+        if (stringAgg !== undefined || groupConcat !== undefined) {
+            const opts = (stringAgg || groupConcat);
+            // MongoDB doesn't have direct string aggregation, collect as array and join later
+            return { [alias]: { $push: `$${opts.column}` } };
+        }
+        return {};
+    }
+    buildMongoMatch(where) {
+        const match = {};
+        for (const [key, value] of Object.entries(where)) {
+            // Normalize key to lowercase for comparison (support both cases for backwards compatibility)
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === '$and') {
+                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                const andConditions = conditions.map((cond) => this.buildMongoMatch(cond));
+                match.$and = andConditions;
+                continue;
+            }
+            if (normalizedKey === '$or') {
+                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                const orConditions = conditions.map((cond) => this.buildMongoMatch(cond));
+                match.$or = orConditions;
+                continue;
+            }
+            if (normalizedKey === '$not') {
+                const notCondition = this.buildMongoMatch(value);
+                // Wrap each condition in $not
+                for (const [field, cond] of Object.entries(notCondition)) {
+                    match[field] = { $not: cond };
+                }
+                continue;
+            }
+            if (normalizedKey === '$nor') {
+                const conditions = Array.isArray(value) ? value : [value];
+                const norConditions = conditions.map((cond) => this.buildMongoMatch(cond));
+                match.$nor = norConditions;
+                continue;
+            }
+            if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                match[key] = this.translateMongoOperators(value);
+            }
+            else {
+                match[key] = value;
+            }
+        }
+        return match;
+    }
+    translateMongoOperators(conditions) {
+        const result = {};
+        for (const [op, val] of Object.entries(conditions)) {
+            // Normalize operator to lowercase for comparison (support both cases for backwards compatibility)
+            const normalizedOp = op.toLowerCase();
+            switch (normalizedOp) {
+                case '$eq':
+                    result.$eq = val;
+                    break;
+                case '$ne':
+                case '$not':
+                    result.$ne = val;
+                    break;
+                case '$gt':
+                    result.$gt = val;
+                    break;
+                case '$gte':
+                    result.$gte = val;
+                    break;
+                case '$lt':
+                    result.$lt = val;
+                    break;
+                case '$lte':
+                    result.$lte = val;
+                    break;
+                case '$in':
+                    result.$in = val;
+                    break;
+                case '$nin':
+                case '$not_in':
+                    result.$nin = val;
+                    break;
+                case '$like':
+                    // Convert SQL LIKE to MongoDB regex
+                    const likePattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');
+                    result.$regex = `^${likePattern}$`;
+                    break;
+                case '$ilike':
+                    const ilikePattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');
+                    result.$regex = `^${ilikePattern}$`;
+                    result.$options = 'i';
+                    break;
+                case '$isnull':
+                case '$is_null':
+                    if (val) {
+                        result.$eq = null;
+                    }
+                    else {
+                        result.$ne = null;
+                    }
+                    break;
+                case '$isnotnull':
+                case '$is_not_null':
+                    if (val) {
+                        result.$ne = null;
+                    }
+                    else {
+                        result.$eq = null;
+                    }
+                    break;
+                case '$between':
+                    const [min, max] = val;
+                    result.$gte = min;
+                    result.$lte = max;
+                    break;
+                case '$contains':
+                    result.$elemMatch = { $eq: val };
+                    break;
+                case '$regex':
+                    if (typeof val === 'string') {
+                        result.$regex = val;
+                    }
+                    else if (val instanceof RegExp) {
+                        result.$regex = val.source;
+                        if (val.flags) {
+                            result.$options = val.flags;
+                        }
+                    }
+                    break;
+                case '$exists':
+                    result.$exists = val;
+                    break;
+                default:
+                    result[op] = val;
+            }
+        }
+        return result;
+    }
+    buildMongoHaving(having) {
+        const match = {};
+        for (const [alias, condition] of Object.entries(having)) {
+            match[alias] = this.translateMongoOperators(condition);
+        }
+        return match;
+    }
+    // ==================== DYNAMODB AGGREGATION ====================
+    buildDynamoAggregation(options) {
+        // DynamoDB doesn't support server-side aggregations
+        // Return the options and handle in the adapter (client-side aggregation)
+        return {
+            options,
+        };
+    }
+    buildDynamoGroupBy(options) {
+        // DynamoDB doesn't support server-side group by
+        // Return the options and handle in the adapter (client-side grouping)
+        return {
+            options,
+        };
+    }
+    // ==================== CASSANDRA AGGREGATION ====================
+    buildCassandraAggregation(options) {
+        const params = [];
+        // Build SELECT clause with aggregations (Cassandra supports limited aggregations)
+        const selectClauses = this.buildAggregationSelectClauses(options.operations, 'cassandra');
+        let sql = `SELECT ${selectClauses.join(', ')} FROM ${this.escapeIdentifier(options.table, 'cassandra')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'cassandra', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    buildCassandraGroupBy(options) {
+        const params = [];
+        // Build SELECT clause with group columns and aggregations
+        const groupColumns = options.groupBy.map(col => this.escapeIdentifier(col, 'cassandra'));
+        const aggClauses = this.buildAggregationSelectClauses(options.operations, 'cassandra');
+        let sql = `SELECT ${[...groupColumns, ...aggClauses].join(', ')} FROM ${this.escapeIdentifier(options.table, 'cassandra')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'cassandra', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        // GROUP BY clause (Cassandra 3.10+)
+        sql += ` GROUP BY ${groupColumns.join(', ')}`;
+        // Note: Cassandra doesn't support HAVING - would need client-side filtering
+        // ORDER BY clause (limited in Cassandra)
+        if (options.orderBy) {
+            const orderClauses = options.orderBy.map(order => {
+                const direction = order.order === 'DESC' ? 'DESC' : 'ASC';
+                return `${order.column} ${direction}`;
+            });
+            sql += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        // Note: Cassandra doesn't support OFFSET natively
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    // ==================== HELPER METHODS ====================
+    buildAggregationSelectClauses(operations, dbType) {
+        const clauses = [];
+        for (const [alias, operation] of Object.entries(operations)) {
+            const clause = this.buildSingleAggregation(alias, operation, dbType);
+            if (clause) {
+                clauses.push(clause);
+            }
+        }
+        return clauses;
+    }
+    buildSingleAggregation(alias, operation, dbType) {
+        const escapedAlias = this.escapeIdentifier(alias, dbType);
+        // Support lowercase operators (Mongoose/MongoDB style)
+        if (operation.$count !== undefined) {
+            const col = operation.$count === '*' ? '*' : this.escapeIdentifier(operation.$count, dbType);
+            return `COUNT(${col}) AS ${escapedAlias}`;
+        }
+        if (operation.$sum !== undefined) {
+            return `SUM(${this.escapeIdentifier(operation.$sum, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$avg !== undefined) {
+            return `AVG(${this.escapeIdentifier(operation.$avg, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$min !== undefined) {
+            return `MIN(${this.escapeIdentifier(operation.$min, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$max !== undefined) {
+            return `MAX(${this.escapeIdentifier(operation.$max, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$stringAgg !== undefined) {
+            return this.buildStringAggregation(alias, operation.$stringAgg, dbType);
+        }
+        if (operation.$groupConcat !== undefined) {
+            return this.buildStringAggregation(alias, operation.$groupConcat, dbType);
+        }
+        if (operation.$arrayAgg !== undefined) {
+            if (dbType === 'postgresql') {
+                return `ARRAY_AGG(${this.escapeIdentifier(operation.$arrayAgg, dbType)}) AS ${escapedAlias}`;
+            }
+            // Not supported in MySQL/Cassandra
+            throw new Error(`$arrayAgg is not supported for ${dbType}`);
+        }
+        return null;
+    }
+    buildStringAggregation(alias, options, dbType) {
+        const escapedAlias = this.escapeIdentifier(alias, dbType);
+        const escapedColumn = this.escapeIdentifier(options.column, dbType);
+        const separator = options.separator || ',';
+        if (dbType === 'postgresql') {
+            let agg = options.distinct
+                ? `STRING_AGG(DISTINCT ${escapedColumn}, '${separator}'`
+                : `STRING_AGG(${escapedColumn}, '${separator}'`;
+            if (options.orderBy) {
+                agg += ` ORDER BY ${this.escapeIdentifier(options.orderBy, dbType)}`;
+            }
+            agg += ')';
+            return `${agg} AS ${escapedAlias}`;
+        }
+        if (dbType === 'mysql' || dbType === 'mariadb') {
+            let agg = options.distinct
+                ? `GROUP_CONCAT(DISTINCT ${escapedColumn}`
+                : `GROUP_CONCAT(${escapedColumn}`;
+            if (options.orderBy) {
+                agg += ` ORDER BY ${this.escapeIdentifier(options.orderBy, dbType)}`;
+            }
+            agg += ` SEPARATOR '${separator}')`;
+            return `${agg} AS ${escapedAlias}`;
+        }
+        throw new Error(`String aggregation is not supported for ${dbType}`);
+    }
+    buildWhereClause(where, dbType, startIndex) {
+        const clauses = [];
+        const params = [];
+        let paramIndex = startIndex;
+        for (const [key, value] of Object.entries(where)) {
+            // Normalize key to lowercase for comparison (support both cases for backwards compatibility)
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === '$and') {
+                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                const andResults = conditions.map((cond) => this.buildWhereClause(cond, dbType, paramIndex));
+                const andClauses = andResults.map(r => r.clause);
+                andResults.forEach(r => {
+                    params.push(...r.params);
+                    paramIndex += r.params.length;
+                });
+                clauses.push(`(${andClauses.join(' AND ')})`);
+                continue;
+            }
+            if (normalizedKey === '$or') {
+                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                const orResults = conditions.map((cond) => this.buildWhereClause(cond, dbType, paramIndex));
+                const orClauses = orResults.map(r => r.clause);
+                orResults.forEach(r => {
+                    params.push(...r.params);
+                    paramIndex += r.params.length;
+                });
+                clauses.push(`(${orClauses.join(' OR ')})`);
+                continue;
+            }
+            if (normalizedKey === '$not') {
+                const notResult = this.buildWhereClause(value, dbType, paramIndex);
+                clauses.push(`NOT (${notResult.clause})`);
+                params.push(...notResult.params);
+                paramIndex += notResult.params.length;
+                continue;
+            }
+            if (normalizedKey === '$nor') {
+                const conditions = Array.isArray(value) ? value : [value];
+                const norResults = conditions.map((cond) => this.buildWhereClause(cond, dbType, paramIndex));
+                const norClauses = norResults.map(r => r.clause);
+                norResults.forEach(r => {
+                    params.push(...r.params);
+                    paramIndex += r.params.length;
+                });
+                clauses.push(`NOT (${norClauses.join(' OR ')})`);
+                continue;
+            }
+            if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                for (const [op, opValue] of Object.entries(value)) {
+                    const result = this.buildComparisonClause(key, op, opValue, dbType, paramIndex);
+                    clauses.push(result.clause);
+                    if (result.params.length > 0) {
+                        params.push(...result.params);
+                        paramIndex += result.params.length;
+                    }
+                }
+            }
+            else {
+                const placeholder = this.getPlaceholder(dbType, paramIndex);
+                clauses.push(`${this.escapeIdentifier(key, dbType)} = ${placeholder}`);
+                params.push(value);
+                paramIndex++;
+            }
+        }
+        return {
+            clause: clauses.join(' AND '),
+            params,
+        };
+    }
+    buildComparisonClause(field, operator, value, dbType, paramIndex) {
+        const escapedField = this.escapeIdentifier(field, dbType);
+        const placeholder = this.getPlaceholder(dbType, paramIndex);
+        // Normalize operator to lowercase for comparison (support both cases for backwards compatibility)
+        const op = operator.toLowerCase();
+        switch (op) {
+            case '$eq':
+                return { clause: `${escapedField} = ${placeholder}`, params: [value] };
+            case '$ne':
+                return { clause: `${escapedField} != ${placeholder}`, params: [value] };
+            case '$gt':
+                return { clause: `${escapedField} > ${placeholder}`, params: [value] };
+            case '$gte':
+                return { clause: `${escapedField} >= ${placeholder}`, params: [value] };
+            case '$lt':
+                return { clause: `${escapedField} < ${placeholder}`, params: [value] };
+            case '$lte':
+                return { clause: `${escapedField} <= ${placeholder}`, params: [value] };
+            case '$in':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} = ANY(${placeholder})`, params: [value] };
+                }
+                else if (dbType === 'cassandra') {
+                    return { clause: `${escapedField} IN ${placeholder}`, params: [value] };
+                }
+                return { clause: `${escapedField} IN (${placeholder})`, params: [value] };
+            case '$nin':
+            case '$not_in':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} != ALL(${placeholder})`, params: [value] };
+                }
+                return { clause: `${escapedField} NOT IN (${placeholder})`, params: [value] };
+            case '$like':
+                return { clause: `${escapedField} LIKE ${placeholder}`, params: [value] };
+            case '$ilike':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} ILIKE ${placeholder}`, params: [value] };
+                }
+                return { clause: `LOWER(${escapedField}) LIKE LOWER(${placeholder})`, params: [value] };
+            case '$isnull':
+            case '$is_null':
+                return { clause: `${escapedField} IS ${value ? 'NULL' : 'NOT NULL'}`, params: [] };
+            case '$isnotnull':
+            case '$is_not_null':
+                return { clause: `${escapedField} IS ${value ? 'NOT NULL' : 'NULL'}`, params: [] };
+            case '$between':
+                const [min, max] = value;
+                if (dbType === 'postgresql') {
+                    return {
+                        clause: `${escapedField} BETWEEN $${paramIndex} AND $${paramIndex + 1}`,
+                        params: [min, max],
+                    };
+                }
+                return {
+                    clause: `${escapedField} BETWEEN ? AND ?`,
+                    params: [min, max],
+                };
+            case '$contains':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} @> ${placeholder}`, params: [value] };
+                }
+                else if (dbType === 'cassandra') {
+                    return { clause: `${escapedField} CONTAINS ${placeholder}`, params: [value] };
+                }
+                return { clause: `JSON_CONTAINS(${escapedField}, ${placeholder})`, params: [JSON.stringify(value)] };
+            case '$containedby':
+            case '$contained_by':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} <@ ${placeholder}`, params: [value] };
+                }
+                throw new Error(`$containedBy is not supported for ${dbType}`);
+            case '$overlaps':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} && ${placeholder}`, params: [value] };
+                }
+                throw new Error(`$overlaps is not supported for ${dbType}`);
+            case '$regex':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} ~ ${placeholder}`, params: [value] };
+                }
+                else if (dbType === 'mysql' || dbType === 'mariadb') {
+                    return { clause: `${escapedField} REGEXP ${placeholder}`, params: [value] };
+                }
+                throw new Error(`$regex is not supported for ${dbType}`);
+            case '$exists':
+                return { clause: `${escapedField} IS ${value ? 'NOT NULL' : 'NULL'}`, params: [] };
+            default:
+                throw new Error(`Unknown operator: ${operator}`);
+        }
+    }
+    buildHavingClause(having, dbType, startIndex) {
+        const clauses = [];
+        const params = [];
+        let paramIndex = startIndex;
+        for (const [alias, condition] of Object.entries(having)) {
+            for (const [op, value] of Object.entries(condition)) {
+                const result = this.buildHavingCondition(alias, op, value, dbType, paramIndex);
+                clauses.push(result.clause);
+                params.push(...result.params);
+                paramIndex += result.params.length;
+            }
+        }
+        return {
+            clause: clauses.join(' AND '),
+            params,
+        };
+    }
+    buildHavingCondition(alias, operator, value, dbType, paramIndex) {
+        const escapedAlias = this.escapeIdentifier(alias, dbType);
+        const placeholder = this.getPlaceholder(dbType, paramIndex);
+        // Normalize operator to lowercase for comparison (support both cases for backwards compatibility)
+        const op = operator.toLowerCase();
+        switch (op) {
+            case '$gt':
+                return { clause: `${escapedAlias} > ${placeholder}`, params: [value] };
+            case '$gte':
+                return { clause: `${escapedAlias} >= ${placeholder}`, params: [value] };
+            case '$lt':
+                return { clause: `${escapedAlias} < ${placeholder}`, params: [value] };
+            case '$lte':
+                return { clause: `${escapedAlias} <= ${placeholder}`, params: [value] };
+            case '$eq':
+                return { clause: `${escapedAlias} = ${placeholder}`, params: [value] };
+            case '$ne':
+                return { clause: `${escapedAlias} != ${placeholder}`, params: [value] };
+            case '$between':
+                const [min, max] = value;
+                if (dbType === 'postgresql') {
+                    return {
+                        clause: `${escapedAlias} BETWEEN $${paramIndex} AND $${paramIndex + 1}`,
+                        params: [min, max],
+                    };
+                }
+                return {
+                    clause: `${escapedAlias} BETWEEN ? AND ?`,
+                    params: [min, max],
+                };
+            default:
+                throw new Error(`Unknown HAVING operator: ${operator}`);
+        }
+    }
+    escapeIdentifier(identifier, dbType) {
+        switch (dbType) {
+            case 'postgresql':
+                return `"${identifier.replace(/"/g, '""')}"`;
+            case 'mysql':
+            case 'mariadb':
+                return `\`${identifier.replace(/`/g, '``')}\``;
+            case 'cassandra':
+                if (/[^a-zA-Z0-9_]/.test(identifier)) {
+                    return `"${identifier.replace(/"/g, '""')}"`;
+                }
+                return identifier;
+            default:
+                return identifier;
+        }
+    }
+    getPlaceholder(dbType, index) {
+        switch (dbType) {
+            case 'postgresql':
+                return `$${index}`;
+            case 'mysql':
+            case 'mariadb':
+            case 'cassandra':
+                return '?';
+            default:
+                return '?';
+        }
+    }
+}
+exports.AggregationBuilder = AggregationBuilder;
+/**
+ * Export aggregation operators for external use
+ * Uses lowercase naming convention to match Mongoose/MongoDB style
+ */
+exports.AggregationOperators = {
+    $count: '$count',
+    $sum: '$sum',
+    $avg: '$avg',
+    $min: '$min',
+    $max: '$max',
+    $stringAgg: '$stringAgg',
+    $groupConcat: '$groupConcat',
+    $arrayAgg: '$arrayAgg',
+    $first: '$first',
+    $last: '$last',
+};
+//# sourceMappingURL=aggregation-builder.js.map