@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,841 +0,0 @@
-"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