sqlstack 1.0.17 → 1.0.19

package/dist/cjs/binders/sqlBinder.js

@@ -281,6 +281,767 @@ function createBinder(dialect) {
                         i = updateEnd;
                         continue;
                     }
+                    // Check for :insert(...) syntax (case-insensitive)
+                    const insertMatch = /^:insert\s*\(/i.exec(sql.slice(i));
+                    if (insertMatch) {
+                        if (isArrayArgs) {
+                            throw new Error(':insert() syntax only works with named parameters');
+                        }
+                        // Parse the column list inside parentheses
+                        let j = i + insertMatch[0].length; // Skip ':insert('
+                        const columnStart = j;
+                        let parenDepth = 1;
+                        let inString = false;
+                        let stringChar = '';
+                        // Find matching closing parenthesis
+                        while (j < len && parenDepth > 0) {
+                            const c = sql[j];
+                            const cNext = j + 1 < len ? sql[j + 1] : '';
+                            if (!inString) {
+                                if (c === "'" || c === '"') {
+                                    inString = true;
+                                    stringChar = c;
+                                }
+                                else if (c === '(') {
+                                    parenDepth++;
+                                }
+                                else if (c === ')') {
+                                    parenDepth--;
+                                }
+                            }
+                            else {
+                                if (c === stringChar) {
+                                    // Check for escaped quote
+                                    if (cNext === stringChar) {
+                                        j++; // Skip escaped quote
+                                    }
+                                    else {
+                                        inString = false;
+                                    }
+                                }
+                            }
+                            if (parenDepth > 0)
+                                j++;
+                        }
+                        if (parenDepth > 0) {
+                            throw new Error('Unclosed :insert() parentheses');
+                        }
+                        // Extract column list (between the parentheses)
+                        const columnList = sql.slice(columnStart, j).trim();
+                        const insertEnd = j + 1; // Include closing ')'
+                        // Parse column list (split by comma, respecting quotes and parentheses)
+                        const items = [];
+                        let current = '';
+                        let inSQ = false; // single quote string
+                        let inDQ = false; // double quote identifier
+                        let itemParenDepth = 0;
+                        for (let k = 0; k < columnList.length; k++) {
+                            const ch = columnList[k];
+                            const next = k + 1 < columnList.length ? columnList[k + 1] : '';
+                            if (inSQ) {
+                                current += ch;
+                                if (ch === "'" && next === "'") {
+                                    current += next;
+                                    k++;
+                                }
+                                else if (ch === "'") {
+                                    inSQ = false;
+                                }
+                                continue;
+                            }
+                            if (inDQ) {
+                                current += ch;
+                                if (ch === '"' && next === '"') {
+                                    current += next;
+                                    k++;
+                                }
+                                else if (ch === '"') {
+                                    inDQ = false;
+                                }
+                                continue;
+                            }
+                            if (ch === "'") {
+                                current += ch;
+                                inSQ = true;
+                                continue;
+                            }
+                            if (ch === '"') {
+                                current += ch;
+                                inDQ = true;
+                                continue;
+                            }
+                            if (ch === '(') {
+                                current += ch;
+                                itemParenDepth++;
+                                continue;
+                            }
+                            if (ch === ')') {
+                                current += ch;
+                                itemParenDepth--;
+                                continue;
+                            }
+                            if (ch === ',' && itemParenDepth === 0) {
+                                const trimmed = current.trim();
+                                if (trimmed.length > 0) {
+                                    items.push(trimmed);
+                                }
+                                current = '';
+                                continue;
+                            }
+                            current += ch;
+                        }
+                        // Add the last item
+                        const trimmed = current.trim();
+                        if (trimmed.length > 0) {
+                            items.push(trimmed);
+                        }
+                        if (items.length === 0) {
+                            throw new Error(':insert() requires at least one column name');
+                        }
+                        // Build column list and VALUES clause
+                        const obj = args;
+                        const columnNames = [];
+                        const valueParts = [];
+                        const insertParams = [];
+                        let hasParameterized = false;
+                        for (const item of items) {
+                            const trimmed = item.trim();
+                            // Check if this is a literal expression (contains = not inside quotes)
+                            let isLiteral = false;
+                            let eqIndex = -1;
+                            let inString = false;
+                            let stringChar = '';
+                            for (let k = 0; k < trimmed.length; k++) {
+                                const ch = trimmed[k];
+                                const next = k + 1 < trimmed.length ? trimmed[k + 1] : '';
+                                if (!inString && (ch === "'" || ch === '"')) {
+                                    inString = true;
+                                    stringChar = ch;
+                                }
+                                else if (inString) {
+                                    if (ch === stringChar) {
+                                        if (next === stringChar) {
+                                            k++; // Skip escaped quote
+                                        }
+                                        else {
+                                            inString = false;
+                                        }
+                                    }
+                                }
+                                else if (ch === '=') {
+                                    eqIndex = k;
+                                    isLiteral = true;
+                                    break;
+                                }
+                            }
+                            if (isLiteral && eqIndex >= 0) {
+                                // Literal SQL expression - extract column name and value
+                                const colName = trimmed.slice(0, eqIndex).trim();
+                                const literalValue = trimmed.slice(eqIndex + 1).trim();
+                                columnNames.push(colName);
+                                valueParts.push(literalValue);
+                            }
+                            else {
+                                // Parameterized column - check if defined in args
+                                hasParameterized = true;
+                                if (Object.prototype.hasOwnProperty.call(obj, trimmed) && obj[trimmed] !== undefined) {
+                                    columnNames.push(trimmed);
+                                    valueParts.push(placeholder(pgIndex));
+                                    insertParams.push(obj[trimmed]);
+                                }
+                            }
+                        }
+                        // Only throw error if all parameterized columns are undefined (literals are always included)
+                        if (hasParameterized && columnNames.length === 0) {
+                            throw new Error('All columns in :insert() are undefined');
+                        }
+                        if (columnNames.length === 0) {
+                            throw new Error(':insert() requires at least one column name');
+                        }
+                        // Replace :insert(...) with column list and VALUES clause
+                        out.push('(', columnNames.join(', '), ') VALUES (', valueParts.join(', '), ')');
+                        params.push(...insertParams);
+                        i = insertEnd;
+                        continue;
+                    }
+                    // Check for :batch_insert(...) syntax (case-insensitive)
+                    const batchInsertMatch = /^:batch_insert\s*\(/i.exec(sql.slice(i));
+                    if (batchInsertMatch) {
+                        if (isArrayArgs) {
+                            throw new Error(':batch_insert() syntax only works with named parameters');
+                        }
+                        // Parse the argument list inside parentheses
+                        let j = i + batchInsertMatch[0].length; // Skip ':batch_insert('
+                        const argStart = j;
+                        let parenDepth = 1;
+                        let inString = false;
+                        let stringChar = '';
+                        // Find matching closing parenthesis
+                        while (j < len && parenDepth > 0) {
+                            const c = sql[j];
+                            const cNext = j + 1 < len ? sql[j + 1] : '';
+                            if (!inString) {
+                                if (c === "'" || c === '"') {
+                                    inString = true;
+                                    stringChar = c;
+                                }
+                                else if (c === '(') {
+                                    parenDepth++;
+                                }
+                                else if (c === ')') {
+                                    parenDepth--;
+                                }
+                            }
+                            else {
+                                if (c === stringChar) {
+                                    // Check for escaped quote
+                                    if (cNext === stringChar) {
+                                        j++; // Skip escaped quote
+                                    }
+                                    else {
+                                        inString = false;
+                                    }
+                                }
+                            }
+                            if (parenDepth > 0)
+                                j++;
+                        }
+                        if (parenDepth > 0) {
+                            throw new Error('Unclosed :batch_insert() parentheses');
+                        }
+                        // Extract argument list (between the parentheses)
+                        const argList = sql.slice(argStart, j).trim();
+                        const batchInsertEnd = j + 1; // Include closing ')'
+                        // Parse argument list (split by comma, respecting quotes and parentheses)
+                        const items = [];
+                        let current = '';
+                        let inSQ = false; // single quote string
+                        let inDQ = false; // double quote identifier
+                        let itemParenDepth = 0;
+                        for (let k = 0; k < argList.length; k++) {
+                            const ch2 = argList[k];
+                            const next2 = k + 1 < argList.length ? argList[k + 1] : '';
+                            if (inSQ) {
+                                current += ch2;
+                                if (ch2 === "'" && next2 === "'") {
+                                    current += next2;
+                                    k++;
+                                }
+                                else if (ch2 === "'") {
+                                    inSQ = false;
+                                }
+                                continue;
+                            }
+                            if (inDQ) {
+                                current += ch2;
+                                if (ch2 === '"' && next2 === '"') {
+                                    current += next2;
+                                    k++;
+                                }
+                                else if (ch2 === '"') {
+                                    inDQ = false;
+                                }
+                                continue;
+                            }
+                            if (ch2 === "'") {
+                                current += ch2;
+                                inSQ = true;
+                                continue;
+                            }
+                            if (ch2 === '"') {
+                                current += ch2;
+                                inDQ = true;
+                                continue;
+                            }
+                            if (ch2 === '(') {
+                                current += ch2;
+                                itemParenDepth++;
+                                continue;
+                            }
+                            if (ch2 === ')') {
+                                current += ch2;
+                                itemParenDepth--;
+                                continue;
+                            }
+                            if (ch2 === ',' && itemParenDepth === 0) {
+                                const trimmedItem = current.trim();
+                                if (trimmedItem.length > 0) {
+                                    items.push(trimmedItem);
+                                }
+                                current = '';
+                                continue;
+                            }
+                            current += ch2;
+                        }
+                        // Add the last item
+                        const trimmedItem = current.trim();
+                        if (trimmedItem.length > 0) {
+                            items.push(trimmedItem);
+                        }
+                        if (items.length === 0) {
+                            throw new Error(':batch_insert() requires at least one argument');
+                        }
+                        const obj = args;
+                        const batchArgs = [];
+                        const resolvePath = (root, path) => {
+                            const segments = path.split('.').map((s) => s.trim()).filter((s) => s.length > 0);
+                            if (segments.length === 0) {
+                                throw new Error(`Invalid path "${path}" in :batch_insert()`);
+                            }
+                            const nestedArrayError = () => {
+                                throw new Error('Nested arrays are not supported in :batch_insert()');
+                            };
+                            const descend = (value, idx) => {
+                                if (idx >= segments.length) {
+                                    if (Array.isArray(value)) {
+                                        // At leaf: array-of-arrays is not allowed
+                                        for (const v of value) {
+                                            if (Array.isArray(v))
+                                                nestedArrayError();
+                                        }
+                                        return { isArray: true, values: value.slice() };
+                                    }
+                                    return { isArray: false, values: [value] };
+                                }
+                                const key = segments[idx];
+                                if (Array.isArray(value)) {
+                                    // We are traversing through an array: map remaining path over each element
+                                    const rowValues = [];
+                                    for (const element of value) {
+                                        const sub = descend(element, idx);
+                                        if (sub.isArray)
+                                            nestedArrayError();
+                                        rowValues.push(sub.values[0]);
+                                    }
+                                    return { isArray: true, values: rowValues };
+                                }
+                                let nextVal;
+                                if (value && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, key)) {
+                                    nextVal = value[key];
+                                }
+                                else {
+                                    nextVal = undefined;
+                                }
+                                return descend(nextVal, idx + 1);
+                            };
+                            return descend(root, 0);
+                        };
+                        for (const item of items) {
+                            const path = item.trim();
+                            const firstSeg = path.split('.')[0];
+                            if (!Object.prototype.hasOwnProperty.call(obj, firstSeg)) {
+                                throw new Error(`Path "${path}" in :batch_insert() refers to a missing key`);
+                            }
+                            const { isArray, values } = resolvePath(obj, path);
+                            // Undefined is not allowed for any value
+                            for (const v of values) {
+                                if (v === undefined) {
+                                    throw new Error(`Path "${path}" in :batch_insert() resolved to undefined`);
+                                }
+                            }
+                            batchArgs.push({ path, isArray, values });
+                        }
+                        const arrayArgs = batchArgs.filter((b) => b.isArray);
+                        if (arrayArgs.length === 0) {
+                            throw new Error(':batch_insert() requires at least one array argument');
+                        }
+                        const rowCount = arrayArgs[0].values.length;
+                        if (rowCount === 0) {
+                            throw new Error(':batch_insert() array arguments must not be empty');
+                        }
+                        for (const argInfo of arrayArgs) {
+                            if (argInfo.values.length !== rowCount) {
+                                throw new Error(':batch_insert() arrays must share the same length');
+                            }
+                        }
+                        // Build VALUES clause
+                        const valueTuples = [];
+                        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                            const placeholders = [];
+                            for (const argInfo of batchArgs) {
+                                const value = argInfo.isArray ? argInfo.values[rowIndex] : argInfo.values[0];
+                                placeholders.push(placeholder(pgIndex));
+                                params.push(value);
+                            }
+                            valueTuples.push(`(${placeholders.join(', ')})`);
+                        }
+                        out.push('VALUES ', valueTuples.join(', '));
+                        i = batchInsertEnd;
+                        continue;
+                    }
+                    // Check for :filter(...) syntax (case-insensitive)
+                    const filterMatch = /^:filter\s*\(/i.exec(sql.slice(i));
+                    if (filterMatch) {
+                        if (isArrayArgs) {
+                            throw new Error(':filter() syntax only works with named parameters');
+                        }
+                        // Parse the condition list inside parentheses
+                        let j = i + filterMatch[0].length; // Skip ':filter('
+                        const conditionStart = j;
+                        let parenDepth = 1;
+                        let inString = false;
+                        let stringChar = '';
+                        // Find matching closing parenthesis
+                        while (j < len && parenDepth > 0) {
+                            const c = sql[j];
+                            const cNext = j + 1 < len ? sql[j + 1] : '';
+                            if (!inString) {
+                                if (c === "'" || c === '"') {
+                                    inString = true;
+                                    stringChar = c;
+                                }
+                                else if (c === '(') {
+                                    parenDepth++;
+                                }
+                                else if (c === ')') {
+                                    parenDepth--;
+                                }
+                            }
+                            else {
+                                if (c === stringChar) {
+                                    // Check for escaped quote
+                                    if (cNext === stringChar) {
+                                        j++; // Skip escaped quote
+                                    }
+                                    else {
+                                        inString = false;
+                                    }
+                                }
+                            }
+                            if (parenDepth > 0)
+                                j++;
+                        }
+                        if (parenDepth > 0) {
+                            throw new Error('Unclosed :filter() parentheses');
+                        }
+                        // Extract condition list (between the parentheses)
+                        const conditionList = sql.slice(conditionStart, j).trim();
+                        const filterEnd = j + 1; // Include closing ')'
+                        // Parse condition list (split by comma, respecting quotes and parentheses)
+                        const items = [];
+                        let current = '';
+                        let inSQ = false; // single quote string
+                        let inDQ = false; // double quote identifier
+                        let itemParenDepth = 0;
+                        for (let k = 0; k < conditionList.length; k++) {
+                            const ch = conditionList[k];
+                            const next = k + 1 < conditionList.length ? conditionList[k + 1] : '';
+                            if (inSQ) {
+                                current += ch;
+                                if (ch === "'" && next === "'") {
+                                    current += next;
+                                    k++;
+                                }
+                                else if (ch === "'") {
+                                    inSQ = false;
+                                }
+                                continue;
+                            }
+                            if (inDQ) {
+                                current += ch;
+                                if (ch === '"' && next === '"') {
+                                    current += next;
+                                    k++;
+                                }
+                                else if (ch === '"') {
+                                    inDQ = false;
+                                }
+                                continue;
+                            }
+                            if (ch === "'") {
+                                current += ch;
+                                inSQ = true;
+                                continue;
+                            }
+                            if (ch === '"') {
+                                current += ch;
+                                inDQ = true;
+                                continue;
+                            }
+                            if (ch === '(') {
+                                current += ch;
+                                itemParenDepth++;
+                                continue;
+                            }
+                            if (ch === ')') {
+                                current += ch;
+                                itemParenDepth--;
+                                continue;
+                            }
+                            if (ch === ',' && itemParenDepth === 0) {
+                                const trimmed = current.trim();
+                                if (trimmed.length > 0) {
+                                    items.push(trimmed);
+                                }
+                                current = '';
+                                continue;
+                            }
+                            current += ch;
+                        }
+                        // Add the last item
+                        const trimmed = current.trim();
+                        if (trimmed.length > 0) {
+                            items.push(trimmed);
+                        }
+                        if (items.length === 0) {
+                            throw new Error(':filter() requires at least one condition');
+                        }
+                        // Build WHERE/HAVING conditions
+                        const obj = args;
+                        const conditions = [];
+                        const filterParams = [];
+                        let hasParameterized = false;
+                        // Helper function to expand :or(:param) patterns
+                        const expandOr = (expr) => {
+                            // Find all :or(:param) patterns
+                            const orPattern = /:or\s*\(\s*:(\w+)\s*\)/gi;
+                            const matches = [];
+                            let match;
+                            while ((match = orPattern.exec(expr)) !== null) {
+                                matches.push({
+                                    fullMatch: match[0],
+                                    paramName: match[1],
+                                    index: match.index
+                                });
+                            }
+                            if (matches.length === 0) {
+                                return { condition: '', params: [] };
+                            }
+                            // Check if all parameters are defined
+                            let shouldInclude = true;
+                            const replacements = [];
+                            for (const m of matches) {
+                                if (!Object.prototype.hasOwnProperty.call(obj, m.paramName) || obj[m.paramName] === undefined) {
+                                    shouldInclude = false;
+                                    break;
+                                }
+                                const arr = obj[m.paramName];
+                                if (!Array.isArray(arr) || arr.length === 0) {
+                                    shouldInclude = false;
+                                    break;
+                                }
+                                // Find the column expression for this :or() pattern
+                                // Look backwards from the match to find the column name and operator
+                                const beforeOr = expr.slice(0, m.index);
+                                const afterOr = expr.slice(m.index + m.fullMatch.length);
+                                // Try to match column name and operator pattern
+                                // Match patterns like "col =", "col >", "col <=", "col LIKE", etc.
+                                const beforeTrimmed = beforeOr.trim();
+                                const operatorMatch = beforeTrimmed.match(/(\w+)\s+([=<>!]+|>=|<=|!=|<>|LIKE|IN|BETWEEN|IS(?:\s+NOT)?)\s*$/i);
+                                if (operatorMatch) {
+                                    const colName = operatorMatch[1];
+                                    const operator = operatorMatch[2];
+                                    const parts = [];
+                                    const params = [];
+                                    for (const val of arr) {
+                                        if (val === undefined)
+                                            continue;
+                                        parts.push(`${colName} ${operator} ${placeholder(pgIndex)}`);
+                                        params.push(val);
+                                    }
+                                    if (parts.length > 0) {
+                                        // Replace the column/operator and :or() together
+                                        // Find the operator text in the original expr by searching backwards
+                                        const operatorText = operatorMatch[0];
+                                        // Find the last occurrence of this pattern before m.index
+                                        let operatorStart = -1;
+                                        for (let pos = m.index - operatorText.length; pos >= 0; pos--) {
+                                            if (expr.slice(pos, pos + operatorText.length) === operatorText) {
+                                                operatorStart = pos;
+                                                break;
+                                            }
+                                        }
+                                        if (operatorStart === -1) {
+                                            // Fallback: use m.index - operatorText.length
+                                            operatorStart = Math.max(0, m.index - operatorText.length);
+                                        }
+                                        replacements.push({
+                                            index: operatorStart,
+                                            length: m.index + m.fullMatch.length - operatorStart,
+                                            replacement: parts.join(' OR '),
+                                            params
+                                        });
+                                    }
+                                    else {
+                                        shouldInclude = false;
+                                        break;
+                                    }
+                                }
+                                else {
+                                    // Fallback: use the entire before/after context
+                                    const parts = [];
+                                    const params = [];
+                                    for (const val of arr) {
+                                        if (val === undefined)
+                                            continue;
+                                        parts.push(`${beforeTrimmed}${placeholder(pgIndex)}${afterOr.trim()}`);
+                                        params.push(val);
+                                    }
+                                    if (parts.length > 0) {
+                                        replacements.push({
+                                            index: m.index,
+                                            length: m.fullMatch.length,
+                                            replacement: parts.join(' OR '),
+                                            params
+                                        });
+                                    }
+                                    else {
+                                        shouldInclude = false;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (!shouldInclude || replacements.length === 0) {
+                                return { condition: '', params: [] };
+                            }
+                            // Replace from end to start to preserve indices
+                            let resultExpr = expr;
+                            const allParams = [];
+                            for (const rep of replacements.reverse()) {
+                                const before = resultExpr.slice(0, rep.index);
+                                const after = resultExpr.slice(rep.index + rep.length);
+                                resultExpr = before + rep.replacement + after;
+                                allParams.unshift(...rep.params);
+                            }
+                            // Check if the original expression was already wrapped in parentheses
+                            const trimmedExpr = expr.trim();
+                            const alreadyWrapped = trimmedExpr.startsWith('(') && trimmedExpr.endsWith(')');
+                            const wrappedCondition = alreadyWrapped ? resultExpr : `(${resultExpr})`;
+                            return { condition: wrappedCondition, params: allParams };
+                        };
+                        for (const item of items) {
+                            const trimmed = item.trim();
+                            // Check for :or(:param) pattern first
+                            const orResult = expandOr(trimmed);
+                            if (orResult.condition) {
+                                conditions.push(orResult.condition);
+                                filterParams.push(...orResult.params);
+                                continue;
+                            }
+                            // Check if this is a simple column name (no operators, no :param)
+                            let hasOperator = false;
+                            let hasParam = false;
+                            let inString = false;
+                            let stringChar = '';
+                            for (let k = 0; k < trimmed.length; k++) {
+                                const ch = trimmed[k];
+                                const next = k + 1 < trimmed.length ? trimmed[k + 1] : '';
+                                if (!inString && (ch === "'" || ch === '"')) {
+                                    inString = true;
+                                    stringChar = ch;
+                                }
+                                else if (inString) {
+                                    if (ch === stringChar) {
+                                        if (next === stringChar) {
+                                            k++; // Skip escaped quote
+                                        }
+                                        else {
+                                            inString = false;
+                                        }
+                                    }
+                                }
+                                else {
+                                    // Check for operators (outside strings)
+                                    if ((ch === '>' || ch === '<' || ch === '=' || ch === '!') ||
+                                        (ch === 'L' && trimmed.slice(k, k + 4).toUpperCase() === 'LIKE') ||
+                                        (ch === 'I' && trimmed.slice(k, k + 2).toUpperCase() === 'IN') ||
+                                        (ch === 'B' && trimmed.slice(k, k + 7).toUpperCase() === 'BETWEEN') ||
+                                        (ch === 'I' && trimmed.slice(k, k + 2).toUpperCase() === 'IS')) {
+                                        hasOperator = true;
+                                    }
+                                    // Check for :param pattern
+                                    if (ch === ':' && next && /[a-zA-Z_]/.test(next)) {
+                                        hasParam = true;
+                                    }
+                                }
+                            }
+                            if (!hasOperator && !hasParam) {
+                                // Simple column name → equality
+                                hasParameterized = true;
+                                if (Object.prototype.hasOwnProperty.call(obj, trimmed) && obj[trimmed] !== undefined) {
+                                    conditions.push(`${trimmed} = ${placeholder(pgIndex)}`);
+                                    filterParams.push(obj[trimmed]);
+                                }
+                            }
+                            else if (hasParam) {
+                                // Parameterized expression → extract and bind parameters
+                                hasParameterized = true;
+                                // Extract all :param patterns and check if they're defined
+                                let shouldInclude = true;
+                                const paramMatches = [];
+                                let searchStart = 0;
+                                while (true) {
+                                    const paramMatch = /:([a-zA-Z_][a-zA-Z0-9_]*)/g.exec(trimmed.slice(searchStart));
+                                    if (!paramMatch)
+                                        break;
+                                    const paramName = paramMatch[1];
+                                    const fullIndex = searchStart + paramMatch.index;
+                                    paramMatches.push({ name: paramName, index: fullIndex });
+                                    if (!Object.prototype.hasOwnProperty.call(obj, paramName) || obj[paramName] === undefined) {
+                                        shouldInclude = false;
+                                        break;
+                                    }
+                                    searchStart = fullIndex + paramMatch[0].length;
+                                }
+                                if (shouldInclude && paramMatches.length > 0) {
+                                    // Replace :param with placeholders (from end to start to preserve indices)
+                                    let conditionExpr = trimmed;
+                                    const orderedParams = [];
+                                    for (const pm of paramMatches.reverse()) {
+                                        const paramValue = obj[pm.name];
+                                        const before = conditionExpr.slice(0, pm.index);
+                                        const after = conditionExpr.slice(pm.index + pm.name.length + 1);
+                                        // Check if this is an array parameter (for IN clauses)
+                                        if (Array.isArray(paramValue)) {
+                                            if (paramValue.length === 0) {
+                                                shouldInclude = false;
+                                                break;
+                                            }
+                                            // Expand array: replace :ids with ?, ?, ?
+                                            const placeholders = paramValue.map(() => placeholder(pgIndex)).join(', ');
+                                            conditionExpr = before + placeholders + after;
+                                            orderedParams.unshift(...paramValue);
+                                        }
+                                        else {
+                                            conditionExpr = before + placeholder(pgIndex) + after;
+                                            orderedParams.unshift(paramValue);
+                                        }
+                                    }
+                                    if (shouldInclude) {
+                                        // Add params in original order
+                                        const finalParams = [];
+                                        for (const pm of paramMatches.reverse()) {
+                                            const paramValue = obj[pm.name];
+                                            if (Array.isArray(paramValue)) {
+                                                finalParams.push(...paramValue);
+                                            }
+                                            else {
+                                                finalParams.push(paramValue);
+                                            }
+                                        }
+                                        conditions.push(conditionExpr);
+                                        filterParams.push(...finalParams);
+                                    }
+                                }
+                            }
+                            else {
+                                // Literal expression → include as-is
+                                conditions.push(trimmed);
+                            }
+                        }
+                        // Only throw error if all parameterized conditions are undefined (literals are always included)
+                        if (hasParameterized && conditions.length === 0) {
+                            throw new Error('All conditions in :filter() are undefined');
+                        }
+                        if (conditions.length === 0) {
+                            throw new Error(':filter() requires at least one condition');
+                        }
+                        // Replace :filter(...) with conditions joined by AND
+                        out.push(conditions.join(' AND '));
+                        params.push(...filterParams);
+                        i = filterEnd;
+                        continue;
+                    }
                     // Attempt to parse a parameter token
                     let j = i + 1;
                     const start = j;