mongo.do 0.1.0

package/dist/translator/update-translator.js

@@ -0,0 +1,819 @@
+/**
+ * UpdateTranslator - Translates MongoDB-style update operations to SQLite SQL
+ * using json_set, json_remove, and related functions for JSON document updates.
+ *
+ * REFACTORED: Optimized with combined json_set calls, validation, and CTE-based array operations.
+ */
+import { validateFieldPath } from '../utils/sql-safety.js';
+/**
+ * Parses arrayFilters option into ArrayFilter objects.
+ *
+ * @param arrayFilters - Array of filter objects from MongoDB update options
+ * @returns Parsed ArrayFilter array
+ *
+ * @example
+ * parseArrayFilters([{ "elem.status": "pending" }])
+ * // Returns: [{ identifier: "elem", conditions: { status: "pending" } }]
+ */
+export function parseArrayFilters(arrayFilters) {
+    const result = [];
+    for (const filter of arrayFilters) {
+        // Each filter object should have keys like "elem.field" or "elem.field.nested"
+        // The identifier is the first part before the dot
+        const entries = Object.entries(filter);
+        if (entries.length === 0)
+            continue;
+        // Group by identifier
+        const byIdentifier = new Map();
+        for (const [key, value] of entries) {
+            const dotIndex = key.indexOf('.');
+            if (dotIndex === -1) {
+                // No dot - the key itself is the identifier with a direct condition
+                // This handles cases like { elem: { $gt: 5 } }
+                const identifier = key;
+                if (!byIdentifier.has(identifier)) {
+                    byIdentifier.set(identifier, {});
+                }
+                // Store the condition directly - this is a condition on the element itself
+                byIdentifier.get(identifier)['$elemCondition'] = value;
+            }
+            else {
+                const identifier = key.substring(0, dotIndex);
+                const field = key.substring(dotIndex + 1);
+                if (!byIdentifier.has(identifier)) {
+                    byIdentifier.set(identifier, {});
+                }
+                byIdentifier.get(identifier)[field] = value;
+            }
+        }
+        for (const [identifier, conditions] of byIdentifier) {
+            result.push({ identifier, conditions });
+        }
+    }
+    return result;
+}
+/**
+ * Parses a field path to detect positional operators.
+ * Returns information about any positional operators found.
+ *
+ * @example
+ * parsePositionalPath("items.$.price")  // { type: 'first', arrayPath: 'items' }
+ * parsePositionalPath("items.$[].qty")  // { type: 'all', arrayPath: 'items' }
+ * parsePositionalPath("items.$[elem].status")  // { type: 'filtered', identifier: 'elem', arrayPath: 'items' }
+ */
+function parsePositionalPath(path) {
+    const segments = path.split('.');
+    const operators = [];
+    let currentArrayPath = '';
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (segment === '$') {
+            // $ - positional operator for first matching element
+            operators.push({
+                type: 'first',
+                pathIndex: i,
+                arrayPath: currentArrayPath
+            });
+        }
+        else if (segment === '$[]') {
+            // $[] - update all array elements
+            operators.push({
+                type: 'all',
+                pathIndex: i,
+                arrayPath: currentArrayPath
+            });
+        }
+        else if (segment.startsWith('$[') && segment.endsWith(']')) {
+            // $[identifier] - filtered positional operator
+            const identifier = segment.slice(2, -1);
+            if (identifier) {
+                operators.push({
+                    type: 'filtered',
+                    identifier,
+                    pathIndex: i,
+                    arrayPath: currentArrayPath
+                });
+            }
+        }
+        else {
+            // Regular field - add to array path
+            currentArrayPath = currentArrayPath ? `${currentArrayPath}.${segment}` : segment;
+        }
+    }
+    return { operators, segments };
+}
+/**
+ * Checks if a field path contains positional operators.
+ */
+function hasPositionalOperator(path) {
+    return path.includes('.$') || path.includes('.$[');
+}
+/**
+ * Validates a field path segment, skipping positional operators.
+ * Positional operators ($, $[], $[identifier]) are not validated.
+ */
+function validateFieldPathSegment(segment) {
+    // Skip validation for positional operators
+    if (segment === '$' || segment === '$[]' || (segment.startsWith('$[') && segment.endsWith(']'))) {
+        return;
+    }
+    // Skip validation for numeric indices
+    if (/^\d+$/.test(segment)) {
+        return;
+    }
+    // Validate regular field names - allow alphanumeric, underscore, and hyphen
+    if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(segment) && segment !== '') {
+        throw new Error(`Invalid field path segment: ${segment}`);
+    }
+}
+/**
+ * Converts a MongoDB-style field path to a JSONPath expression.
+ * Handles nested paths and array indices.
+ *
+ * Examples:
+ * - "name" -> "$.name"
+ * - "address.city" -> "$.address.city"
+ * - "items.0.name" -> "$.items[0].name"
+ *
+ * SECURITY: Validates field path to prevent SQL injection attacks.
+ * @throws Error if field path contains invalid characters
+ */
+function toJsonPath(fieldPath) {
+    // Check if path has positional operators - if so, use the specialized function
+    if (hasPositionalOperator(fieldPath)) {
+        // Don't validate the whole path at once; validate segments individually
+        const parts = fieldPath.split('.');
+        for (const part of parts) {
+            validateFieldPathSegment(part);
+        }
+    }
+    else {
+        // Validate the entire field path to prevent SQL injection
+        validateFieldPath(fieldPath);
+    }
+    const parts = fieldPath.split('.');
+    let result = '$';
+    for (const part of parts) {
+        // Check if this part is a numeric array index
+        if (/^\d+$/.test(part)) {
+            result += `[${part}]`;
+        }
+        else if (part === '$' || part === '$[]' || (part.startsWith('$[') && part.endsWith(']'))) {
+            // Positional operators are kept as-is for later processing
+            result += `.${part}`;
+        }
+        else {
+            result += `.${part}`;
+        }
+    }
+    return result;
+}
+/**
+ * Converts a field path with a resolved positional index to JSONPath.
+ * Used when we know the specific array index to update.
+ *
+ * @param fieldPath - The original path with positional operator
+ * @param _arrayPath - The path to the array (e.g., "items") - unused but part of API
+ * @param index - The resolved array index
+ * @returns JSONPath with the index substituted
+ */
+function toJsonPathWithIndex(fieldPath, _arrayPath, index) {
+    const { operators, segments } = parsePositionalPath(fieldPath);
+    if (operators.length === 0) {
+        return toJsonPath(fieldPath);
+    }
+    // Reconstruct the path with the index substituted
+    let result = '$';
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (segment === '$') {
+            result += `[${index}]`;
+        }
+        else if (/^\d+$/.test(segment)) {
+            result += `[${segment}]`;
+        }
+        else if (segment === '$[]' || (segment.startsWith('$[') && segment.endsWith(']'))) {
+            // For $[] and $[identifier], we'll handle in a different way
+            result += `.${segment}`;
+        }
+        else {
+            result += `.${segment}`;
+        }
+    }
+    return result;
+}
+// Export to avoid unused function warning
+export { toJsonPathWithIndex };
+/**
+ * Validates that a value is a valid number for arithmetic operations.
+ */
+function validateNumericValue(value, operator) {
+    if (typeof value !== 'number') {
+        throw new Error(`${operator} requires numeric values, got ${typeof value}`);
+    }
+    if (!Number.isFinite(value)) {
+        throw new Error(`${operator} requires finite numeric values`);
+    }
+}
+/**
+ * Validates that an operator's fields are valid.
+ */
+function validateOperatorFields(operator, fields) {
+    if (typeof fields !== 'object' || fields === null || Array.isArray(fields)) {
+        throw new Error(`${operator} requires an object argument`);
+    }
+    const fieldPaths = Object.keys(fields);
+    if (fieldPaths.length === 0) {
+        throw new Error(`${operator} requires at least one field`);
+    }
+    // Validate specific operators
+    switch (operator) {
+        case '$inc':
+        case '$mul':
+            for (const [, value] of Object.entries(fields)) {
+                validateNumericValue(value, operator);
+            }
+            break;
+        case '$min':
+        case '$max':
+            for (const [, value] of Object.entries(fields)) {
+                if (value === null || value === undefined) {
+                    throw new Error(`${operator} cannot use null or undefined values`);
+                }
+            }
+            break;
+        case '$rename':
+            for (const [oldPath, newPath] of Object.entries(fields)) {
+                if (typeof newPath !== 'string') {
+                    throw new Error(`$rename target must be a string, got ${typeof newPath}`);
+                }
+                if (oldPath === newPath) {
+                    throw new Error(`$rename source and target cannot be the same: ${oldPath}`);
+                }
+            }
+            break;
+        case '$pop':
+            for (const [, value] of Object.entries(fields)) {
+                if (value !== 1 && value !== -1) {
+                    throw new Error(`$pop requires 1 (last) or -1 (first), got ${value}`);
+                }
+            }
+            break;
+    }
+}
+/**
+ * Detects conflicts between update operators.
+ * MongoDB does not allow updating the same field with multiple operators.
+ */
+function detectConflicts(update) {
+    const updatedPaths = new Map(); // path -> operator
+    for (const [operator, fields] of Object.entries(update)) {
+        if (!operator.startsWith('$'))
+            continue;
+        if (typeof fields !== 'object' || fields === null)
+            continue;
+        for (const path of Object.keys(fields)) {
+            // For $rename, check both source and target
+            if (operator === '$rename') {
+                const targetPath = fields[path];
+                if (updatedPaths.has(path)) {
+                    throw new Error(`Conflicting update: ${path} is modified by both ${updatedPaths.get(path)} and ${operator}`);
+                }
+                if (updatedPaths.has(targetPath)) {
+                    throw new Error(`Conflicting update: ${targetPath} is modified by both ${updatedPaths.get(targetPath)} and ${operator}`);
+                }
+                updatedPaths.set(path, operator);
+                updatedPaths.set(targetPath, operator);
+            }
+            else {
+                // Check for conflicts with existing updates
+                if (updatedPaths.has(path)) {
+                    const existingOp = updatedPaths.get(path);
+                    // Allow $min and $max on same field as they're complementary
+                    if (!((operator === '$min' && existingOp === '$max') ||
+                        (operator === '$max' && existingOp === '$min'))) {
+                        throw new Error(`Conflicting update: ${path} is modified by both ${existingOp} and ${operator}`);
+                    }
+                }
+                updatedPaths.set(path, operator);
+            }
+        }
+    }
+}
+/**
+ * Creates a SQL value expression for a given value.
+ * Returns the SQL fragment and any parameters needed.
+ */
+function createValueExpression(value) {
+    if (value === null) {
+        return { sql: "json('null')", params: [] };
+    }
+    if (typeof value === 'boolean') {
+        return { sql: 'json(?)', params: [value.toString()] };
+    }
+    if (typeof value === 'object') {
+        return { sql: 'json(?)', params: [JSON.stringify(value)] };
+    }
+    return { sql: '?', params: [value] };
+}
+export class UpdateTranslator {
+    static SUPPORTED_OPERATORS = new Set([
+        '$set', '$unset', '$inc', '$mul', '$min', '$max', '$rename',
+        '$push', '$pull', '$addToSet', '$pop', '$bit', '$pullAll', '$setOnInsert'
+    ]);
+    // Operator processing order - ensures proper nesting and conflict resolution
+    // $setOnInsert is handled specially and not processed here (it requires upsert context)
+    static OPERATOR_ORDER = [
+        '$rename', '$unset', '$set', '$setOnInsert', '$inc', '$mul', '$min', '$max', '$bit',
+        '$push', '$addToSet', '$pull', '$pullAll', '$pop'
+    ];
+    /**
+     * Translates a MongoDB-style update object to SQLite SQL.
+     * Returns the SQL expression and parameters for updating the data column.
+     *
+     * @param update - MongoDB update document with operators like $set, $inc, etc.
+     * @returns Translated SQL expression and parameters
+     * @throws Error if operators are invalid or conflicting
+     */
+    translate(update) {
+        const operators = Object.keys(update);
+        // Handle empty update - return data as-is
+        if (operators.length === 0) {
+            return { sql: 'data', params: [] };
+        }
+        // Validate all operators
+        for (const op of operators) {
+            if (!op.startsWith('$')) {
+                throw new Error(`Invalid update operator: ${op}. Update operators must start with $`);
+            }
+            if (!UpdateTranslator.SUPPORTED_OPERATORS.has(op)) {
+                throw new Error(`Unknown update operator: ${op}`);
+            }
+            validateOperatorFields(op, update[op]);
+        }
+        // Detect conflicts between operators
+        detectConflicts(update);
+        // Process updates in defined order
+        let currentSql = 'data';
+        let currentParams = [];
+        for (const op of UpdateTranslator.OPERATOR_ORDER) {
+            if (update[op]) {
+                const result = this.translateOperator(op, update[op], currentSql, currentParams);
+                currentSql = result.sql;
+                currentParams = result.params;
+            }
+        }
+        return { sql: currentSql, params: currentParams };
+    }
+    translateOperator(operator, fields, baseSql, baseParams) {
+        switch (operator) {
+            case '$set':
+                return this.translateSet(fields, baseSql, baseParams);
+            case '$unset':
+                return this.translateUnset(fields, baseSql, baseParams);
+            case '$inc':
+                return this.translateInc(fields, baseSql, baseParams);
+            case '$mul':
+                return this.translateMul(fields, baseSql, baseParams);
+            case '$min':
+                return this.translateMin(fields, baseSql, baseParams);
+            case '$max':
+                return this.translateMax(fields, baseSql, baseParams);
+            case '$rename':
+                return this.translateRename(fields, baseSql, baseParams);
+            case '$push':
+                return this.translatePush(fields, baseSql, baseParams);
+            case '$pull':
+                return this.translatePull(fields, baseSql, baseParams);
+            case '$addToSet':
+                return this.translateAddToSet(fields, baseSql, baseParams);
+            case '$pop':
+                return this.translatePop(fields, baseSql, baseParams);
+            case '$bit':
+                // $bit is not commonly used and not yet implemented
+                throw new Error('$bit operator is not yet implemented');
+            case '$pullAll':
+                // $pullAll removes all matching values - can use same logic as $pull with $in
+                throw new Error('$pullAll operator is not yet implemented');
+            case '$setOnInsert':
+                // $setOnInsert only applies during upserts - just treat as $set for now
+                return this.translateSet(fields, baseSql, baseParams);
+            default:
+                throw new Error(`Unsupported operator: ${operator}`);
+        }
+    }
+    // ============================================================
+    // FIELD UPDATE OPERATORS
+    // ============================================================
+    /**
+     * Translates $set operator using optimized multi-path json_set.
+     *
+     * OPTIMIZATION: SQLite's json_set supports multiple path-value pairs in a single call:
+     * json_set(data, '$.a', 1, '$.b', 2) instead of json_set(json_set(data, '$.a', 1), '$.b', 2)
+     */
+    translateSet(fields, baseSql, baseParams) {
+        const entries = Object.entries(fields);
+        if (entries.length === 0) {
+            return { sql: baseSql, params: baseParams };
+        }
+        // Build optimized multi-path json_set
+        const pathValuePairs = [];
+        const params = [...baseParams];
+        for (const [path, value] of entries) {
+            const jsonPath = toJsonPath(path);
+            const valueExpr = createValueExpression(value);
+            pathValuePairs.push(`'${jsonPath}'`);
+            pathValuePairs.push(valueExpr.sql);
+            params.push(...valueExpr.params);
+        }
+        return {
+            sql: `json_set(${baseSql}, ${pathValuePairs.join(', ')})`,
+            params
+        };
+    }
+    /**
+     * Translates $unset operator using optimized multi-path json_remove.
+     *
+     * OPTIMIZATION: SQLite's json_remove supports multiple paths in a single call.
+     */
+    translateUnset(fields, baseSql, baseParams) {
+        const paths = Object.keys(fields);
+        if (paths.length === 0) {
+            return { sql: baseSql, params: baseParams };
+        }
+        // Build optimized multi-path json_remove
+        const jsonPaths = paths.map(p => `'${toJsonPath(p)}'`).join(', ');
+        return {
+            sql: `json_remove(${baseSql}, ${jsonPaths})`,
+            params: baseParams
+        };
+    }
+    /**
+     * Translates $inc operator to json_set with addition.
+     * Uses COALESCE to handle missing fields (defaulting to 0).
+     */
+    translateInc(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        let params = [...baseParams];
+        for (const [path, increment] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            sql = `json_set(${sql}, '${jsonPath}', COALESCE(json_extract(data, '${jsonPath}'), 0) + ?)`;
+            params.push(increment);
+        }
+        return { sql, params };
+    }
+    /**
+     * Translates $mul operator to json_set with multiplication.
+     * Uses COALESCE to handle missing fields (defaulting to 0, which means result is 0).
+     */
+    translateMul(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        let params = [...baseParams];
+        for (const [path, multiplier] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            sql = `json_set(${sql}, '${jsonPath}', COALESCE(json_extract(data, '${jsonPath}'), 0) * ?)`;
+            params.push(multiplier);
+        }
+        return { sql, params };
+    }
+    /**
+     * Translates $min operator to conditional update.
+     * Sets the field to the smaller of current value or specified value.
+     * If field doesn't exist, sets it to the specified value.
+     */
+    translateMin(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        let params = [...baseParams];
+        for (const [path, value] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            sql = `json_set(${sql}, '${jsonPath}', CASE WHEN json_extract(data, '${jsonPath}') IS NULL OR ? < json_extract(data, '${jsonPath}') THEN ? ELSE json_extract(data, '${jsonPath}') END)`;
+            params.push(value, value);
+        }
+        return { sql, params };
+    }
+    /**
+     * Translates $max operator to conditional update.
+     * Sets the field to the larger of current value or specified value.
+     * If field doesn't exist, sets it to the specified value.
+     */
+    translateMax(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        let params = [...baseParams];
+        for (const [path, value] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            sql = `json_set(${sql}, '${jsonPath}', CASE WHEN json_extract(data, '${jsonPath}') IS NULL OR ? > json_extract(data, '${jsonPath}') THEN ? ELSE json_extract(data, '${jsonPath}') END)`;
+            params.push(value, value);
+        }
+        return { sql, params };
+    }
+    /**
+     * Translates $rename operator to json_set + json_remove combination.
+     * Moves a field from one location to another.
+     */
+    translateRename(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        const params = [...baseParams];
+        for (const [oldPath, newPath] of Object.entries(fields)) {
+            const oldJsonPath = toJsonPath(oldPath);
+            const newJsonPath = toJsonPath(newPath);
+            // Extract value, remove old path, set new path
+            sql = `json_set(json_remove(${sql}, '${oldJsonPath}'), '${newJsonPath}', json_extract(data, '${oldJsonPath}'))`;
+        }
+        return { sql, params };
+    }
+    // ============================================================
+    // ARRAY UPDATE OPERATORS
+    // ============================================================
+    /**
+     * Translates $push operator to append values to an array.
+     * Supports $each and $slice modifiers.
+     */
+    translatePush(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        let params = [...baseParams];
+        for (const [path, value] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            // Check for $each and $slice modifiers
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                const modifiers = value;
+                if ('$each' in modifiers) {
+                    const result = this.translatePushEach(path, modifiers, sql, params);
+                    sql = result.sql;
+                    params = result.params;
+                    continue;
+                }
+            }
+            // Simple push - append single value
+            const valueExpr = createValueExpression(value);
+            sql = `json_set(${sql}, '${jsonPath}', json_insert(COALESCE(json_extract(data, '${jsonPath}'), '[]'), '$[#]', ${valueExpr.sql}))`;
+            params.push(...valueExpr.params);
+        }
+        return { sql, params };
+    }
+    /**
+     * Handles $push with $each modifier for batch appending.
+     * Uses CTE for efficient array building when $slice is present.
+     */
+    translatePushEach(path, modifiers, baseSql, baseParams) {
+        const jsonPath = toJsonPath(path);
+        const values = modifiers.$each;
+        const slice = modifiers.$slice;
+        if (values.length === 0) {
+            // No values to push - ensure array exists
+            if (slice !== undefined) {
+                return this.applySliceWithCTE(baseSql, jsonPath, slice, baseParams);
+            }
+            return {
+                sql: `json_set(${baseSql}, '${jsonPath}', COALESCE(json_extract(data, '${jsonPath}'), '[]'))`,
+                params: baseParams
+            };
+        }
+        let params = [...baseParams];
+        // Build nested json_insert calls for batch append
+        let insertChain = `COALESCE(json_extract(data, '${jsonPath}'), '[]')`;
+        for (const value of values) {
+            const valueExpr = createValueExpression(value);
+            insertChain = `json_insert(${insertChain}, '$[#]', ${valueExpr.sql})`;
+            params.push(...valueExpr.params);
+        }
+        let sql = `json_set(${baseSql}, '${jsonPath}', ${insertChain})`;
+        // Apply $slice with CTE optimization
+        if (slice !== undefined) {
+            return this.applySliceWithCTE(sql, jsonPath, slice, params);
+        }
+        return { sql, params };
+    }
+    /**
+     * Applies $slice modifier using CTE for efficient array slicing.
+     * CTE provides better performance for large arrays.
+     */
+    applySliceWithCTE(baseSql, jsonPath, slice, baseParams) {
+        if (slice === 0) {
+            // Empty array result
+            return {
+                sql: `json_set(${baseSql}, '${jsonPath}', json('[]'))`,
+                params: baseParams
+            };
+        }
+        const params = [...baseParams];
+        if (slice > 0) {
+            // Keep first N elements using CTE
+            return {
+                sql: `json_set(${baseSql}, '${jsonPath}', (
+          WITH array_elements AS (
+            SELECT value, CAST(key AS INTEGER) as idx
+            FROM json_each(json_extract(${baseSql}, '${jsonPath}'))
+          )
+          SELECT COALESCE(json_group_array(value), '[]')
+          FROM (
+            SELECT value FROM array_elements
+            ORDER BY idx
+            LIMIT ${slice}
+          )
+        ))`,
+                params
+            };
+        }
+        else {
+            // Keep last N elements (slice is negative) using CTE
+            const limit = Math.abs(slice);
+            return {
+                sql: `json_set(${baseSql}, '${jsonPath}', (
+          WITH array_elements AS (
+            SELECT value, CAST(key AS INTEGER) as idx
+            FROM json_each(json_extract(${baseSql}, '${jsonPath}'))
+          ),
+          total AS (SELECT COUNT(*) as cnt FROM array_elements),
+          filtered AS (
+            SELECT value, idx FROM array_elements, total
+            WHERE idx >= (cnt - ${limit})
+          )
+          SELECT COALESCE(json_group_array(value), '[]')
+          FROM (SELECT value FROM filtered ORDER BY idx)
+        ))`,
+                params
+            };
+        }
+    }
+    /**
+     * Translates $pull operator to remove matching elements.
+     * Uses CTE for efficient filtering.
+     */
+    translatePull(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        let params = [...baseParams];
+        for (const [path, condition] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            // Check if condition is a simple value or a query
+            if (typeof condition === 'object' && condition !== null && !Array.isArray(condition)) {
+                // Query condition - use CTE for complex filtering
+                const result = this.translatePullWithQueryCTE(path, condition, sql, params);
+                sql = result.sql;
+                params = result.params;
+            }
+            else {
+                // Simple value match using CTE
+                sql = `json_set(${sql}, '${jsonPath}', (
+          WITH array_elements AS (
+            SELECT value, CAST(key AS INTEGER) as idx
+            FROM json_each(json_extract(data, '${jsonPath}'))
+          )
+          SELECT COALESCE(json_group_array(value), '[]')
+          FROM (
+            SELECT value FROM array_elements
+            WHERE value != json(?)
+            ORDER BY idx
+          )
+        ))`;
+                // JSON stringify for comparison
+                params.push(JSON.stringify(condition));
+            }
+        }
+        return { sql, params };
+    }
+    /**
+     * Handles $pull with query conditions using CTE.
+     */
+    translatePullWithQueryCTE(path, condition, baseSql, baseParams) {
+        const jsonPath = toJsonPath(path);
+        const params = [...baseParams];
+        // Build WHERE clause for the condition
+        const conditions = [];
+        for (const [field, value] of Object.entries(condition)) {
+            // Validate field name to prevent SQL injection
+            validateFieldPath(field);
+            if (typeof value === 'object' && value !== null) {
+                // Handle operators like $gte, $lte, etc.
+                for (const [op, opValue] of Object.entries(value)) {
+                    const sqlOp = this.mongoOpToSql(op);
+                    conditions.push(`json_extract(value, '$.${field}') ${sqlOp} ?`);
+                    params.push(opValue);
+                }
+            }
+            else {
+                conditions.push(`json_extract(value, '$.${field}') = ?`);
+                params.push(value);
+            }
+        }
+        const whereClause = conditions.length > 0 ? `NOT (${conditions.join(' AND ')})` : '1=1';
+        return {
+            sql: `json_set(${baseSql}, '${jsonPath}', (
+        WITH array_elements AS (
+          SELECT value, CAST(key AS INTEGER) as idx
+          FROM json_each(json_extract(data, '${jsonPath}'))
+        )
+        SELECT COALESCE(json_group_array(value), '[]')
+        FROM (
+          SELECT value FROM array_elements
+          WHERE ${whereClause}
+          ORDER BY idx
+        )
+      ))`,
+            params
+        };
+    }
+    mongoOpToSql(op) {
+        switch (op) {
+            case '$eq': return '=';
+            case '$ne': return '!=';
+            case '$gt': return '>';
+            case '$gte': return '>=';
+            case '$lt': return '<';
+            case '$lte': return '<=';
+            default: throw new Error(`Unsupported operator in $pull: ${op}`);
+        }
+    }
+    /**
+     * Translates $addToSet operator to push if value doesn't exist.
+     * Uses CTE for efficient uniqueness check.
+     */
+    translateAddToSet(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        let params = [...baseParams];
+        for (const [path, value] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            // Check for $each modifier
+            if (value && typeof value === 'object' && !Array.isArray(value) && '$each' in value) {
+                const values = value.$each;
+                for (const v of values) {
+                    const result = this.translateAddToSetSingleWithCTE(jsonPath, v, sql, params);
+                    sql = result.sql;
+                    params = result.params;
+                }
+                continue;
+            }
+            const result = this.translateAddToSetSingleWithCTE(jsonPath, value, sql, params);
+            sql = result.sql;
+            params = result.params;
+        }
+        return { sql, params };
+    }
+    /**
+     * Single value $addToSet using CTE for uniqueness check.
+     */
+    translateAddToSetSingleWithCTE(jsonPath, value, baseSql, baseParams) {
+        const params = [...baseParams];
+        const valueExpr = createValueExpression(value);
+        // Check if value exists in array, if not add it
+        const sql = `json_set(${baseSql}, '${jsonPath}',
+      CASE
+        WHEN EXISTS (
+          SELECT 1 FROM json_each(COALESCE(json_extract(data, '${jsonPath}'), '[]'))
+          WHERE value = json(?)
+        )
+        THEN COALESCE(json_extract(data, '${jsonPath}'), '[]')
+        ELSE json_insert(COALESCE(json_extract(data, '${jsonPath}'), '[]'), '$[#]', ${valueExpr.sql})
+      END
+    )`;
+        // First param is for the EXISTS check (needs JSON stringification)
+        params.push(JSON.stringify(value));
+        // Subsequent params are for the value expression
+        params.push(...valueExpr.params);
+        return { sql, params };
+    }
+    /**
+     * Translates $pop operator to remove first or last element.
+     * Uses CTE for efficient element removal.
+     */
+    translatePop(fields, baseSql, baseParams) {
+        let sql = baseSql;
+        const params = [...baseParams];
+        for (const [path, direction] of Object.entries(fields)) {
+            const jsonPath = toJsonPath(path);
+            const dir = direction;
+            if (dir === 1) {
+                // Remove last element using CTE
+                sql = `json_set(${sql}, '${jsonPath}', (
+          WITH array_elements AS (
+            SELECT value, CAST(key AS INTEGER) as idx
+            FROM json_each(COALESCE(json_extract(data, '${jsonPath}'), '[]'))
+          ),
+          total AS (SELECT COUNT(*) as cnt FROM array_elements)
+          SELECT COALESCE(json_group_array(value), '[]')
+          FROM (
+            SELECT value FROM array_elements, total
+            WHERE idx < cnt - 1
+            ORDER BY idx
+          )
+        ))`;
+            }
+            else {
+                // Remove first element using CTE
+                sql = `json_set(${sql}, '${jsonPath}', (
+          WITH array_elements AS (
+            SELECT value, CAST(key AS INTEGER) as idx
+            FROM json_each(COALESCE(json_extract(data, '${jsonPath}'), '[]'))
+          )
+          SELECT COALESCE(json_group_array(value), '[]')
+          FROM (
+            SELECT value FROM array_elements
+            WHERE idx > 0
+            ORDER BY idx
+          )
+        ))`;
+            }
+        }
+        return { sql, params };
+    }
+}
+//# sourceMappingURL=update-translator.js.map