@tinqerjs/tinqer 0.0.21 → 0.0.23

package/dist/policies/row-filters.js

@@ -0,0 +1,811 @@
+import { isValueExpression } from "../expressions/expression.js";
+import { parseJavaScript } from "../parser/oxc-parser.js";
+import { createBaseContext } from "../visitors/types.js";
+import { visitWhereOperation } from "../visitors/where/index.js";
+const ROW_FILTER_CONTEXT_PARAM_PREFIX = "__tinqer_row_filter_ctx__";
+export function applyRowFiltersToSelectOperation(operation, rowFilters, params, autoParamCounterStart) {
+    if (!rowFilters) {
+        return { operation, params };
+    }
+    const filters = rowFilters.filters;
+    const context = rowFilters.context;
+    if (!context) {
+        throw new Error("Row filters require context binding. Call schema.withContext(context).");
+    }
+    let autoParamCounter = autoParamCounterStart;
+    const filterCache = new Map();
+    const filterAutoParams = {};
+    const requiredContextKeys = new Set();
+    function getParsedFilter(table, schema, kind) {
+        const resolved = resolveTableConfig(filters, table, schema);
+        const cacheKey = `${resolved.key}|${kind}`;
+        const cached = filterCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const predicateFn = resolvePredicateForOperation(resolved.config, kind);
+        if (!predicateFn) {
+            filterCache.set(cacheKey, null);
+            return null;
+        }
+        const parsed = parseRowFilter(predicateFn, resolved.key, kind, autoParamCounter);
+        autoParamCounter = parsed.autoParamCounter;
+        Object.assign(filterAutoParams, parsed.autoParams);
+        for (const key of parsed.contextKeys) {
+            requiredContextKeys.add(key);
+        }
+        filterCache.set(cacheKey, parsed);
+        return parsed;
+    }
+    function transform(current) {
+        switch (current.operationType) {
+            case "from": {
+                const fromOp = current;
+                if (fromOp.subquery) {
+                    const nextSubquery = transform(fromOp.subquery);
+                    if (nextSubquery === fromOp.subquery) {
+                        return fromOp;
+                    }
+                    const nextFrom = { ...fromOp, subquery: nextSubquery };
+                    return nextFrom;
+                }
+                if (!fromOp.table) {
+                    return fromOp;
+                }
+                const parsed = getParsedFilter(fromOp.table, fromOp.schema, "select");
+                if (!parsed) {
+                    return fromOp;
+                }
+                const baseFrom = {
+                    type: "queryOperation",
+                    operationType: "from",
+                    table: fromOp.table,
+                    ...(fromOp.schema ? { schema: fromOp.schema } : {}),
+                };
+                const whereOp = {
+                    type: "queryOperation",
+                    operationType: "where",
+                    source: baseFrom,
+                    predicate: parsed.predicate,
+                };
+                const wrappedFrom = {
+                    type: "queryOperation",
+                    operationType: "from",
+                    subquery: whereOp,
+                    aliasHint: fromOp.aliasHint ?? fromOp.table,
+                };
+                return wrappedFrom;
+            }
+            case "where": {
+                const whereOp = current;
+                const nextSource = transform(whereOp.source);
+                if (nextSource === whereOp.source) {
+                    return whereOp;
+                }
+                const nextWhere = { ...whereOp, source: nextSource };
+                return nextWhere;
+            }
+            case "select": {
+                const selectOp = current;
+                const nextSource = transform(selectOp.source);
+                if (nextSource === selectOp.source) {
+                    return selectOp;
+                }
+                const nextSelect = { ...selectOp, source: nextSource };
+                return nextSelect;
+            }
+            case "join": {
+                const joinOp = current;
+                const nextSource = transform(joinOp.source);
+                const nextInner = transform(joinOp.inner);
+                if (nextSource === joinOp.source && nextInner === joinOp.inner) {
+                    return joinOp;
+                }
+                const nextJoin = { ...joinOp, source: nextSource, inner: nextInner };
+                return nextJoin;
+            }
+            case "groupJoin": {
+                const groupJoinOp = current;
+                const nextSource = transform(groupJoinOp.source);
+                const nextInner = transform(groupJoinOp.inner);
+                if (nextSource === groupJoinOp.source && nextInner === groupJoinOp.inner) {
+                    return groupJoinOp;
+                }
+                const nextGroupJoin = {
+                    ...groupJoinOp,
+                    source: nextSource,
+                    inner: nextInner,
+                };
+                return nextGroupJoin;
+            }
+            case "selectMany": {
+                const selectManyOp = current;
+                const nextSource = transform(selectManyOp.source);
+                const nextCollection = typeof selectManyOp.collection === "object" &&
+                    selectManyOp.collection !== null &&
+                    "operationType" in selectManyOp.collection
+                    ? transform(selectManyOp.collection)
+                    : selectManyOp.collection;
+                if (nextSource === selectManyOp.source && nextCollection === selectManyOp.collection) {
+                    return selectManyOp;
+                }
+                const nextSelectMany = {
+                    ...selectManyOp,
+                    source: nextSource,
+                    collection: nextCollection,
+                };
+                return nextSelectMany;
+            }
+            case "defaultIfEmpty": {
+                const defaultIfEmptyOp = current;
+                const nextSource = transform(defaultIfEmptyOp.source);
+                if (nextSource === defaultIfEmptyOp.source) {
+                    return defaultIfEmptyOp;
+                }
+                const nextDefaultIfEmpty = {
+                    ...defaultIfEmptyOp,
+                    source: nextSource,
+                };
+                return nextDefaultIfEmpty;
+            }
+            case "groupBy": {
+                const groupByOp = current;
+                const nextSource = transform(groupByOp.source);
+                if (nextSource === groupByOp.source) {
+                    return groupByOp;
+                }
+                const nextGroupBy = { ...groupByOp, source: nextSource };
+                return nextGroupBy;
+            }
+            case "orderBy": {
+                const orderByOp = current;
+                const nextSource = transform(orderByOp.source);
+                if (nextSource === orderByOp.source) {
+                    return orderByOp;
+                }
+                const nextOrderBy = { ...orderByOp, source: nextSource };
+                return nextOrderBy;
+            }
+            case "thenBy": {
+                const thenByOp = current;
+                const nextSource = transform(thenByOp.source);
+                if (nextSource === thenByOp.source) {
+                    return thenByOp;
+                }
+                const nextThenBy = { ...thenByOp, source: nextSource };
+                return nextThenBy;
+            }
+            case "distinct": {
+                const distinctOp = current;
+                const nextSource = transform(distinctOp.source);
+                if (nextSource === distinctOp.source) {
+                    return distinctOp;
+                }
+                const nextDistinct = { ...distinctOp, source: nextSource };
+                return nextDistinct;
+            }
+            case "take": {
+                const takeOp = current;
+                const nextSource = transform(takeOp.source);
+                if (nextSource === takeOp.source) {
+                    return takeOp;
+                }
+                const nextTake = { ...takeOp, source: nextSource };
+                return nextTake;
+            }
+            case "skip": {
+                const skipOp = current;
+                const nextSource = transform(skipOp.source);
+                if (nextSource === skipOp.source) {
+                    return skipOp;
+                }
+                const nextSkip = { ...skipOp, source: nextSource };
+                return nextSkip;
+            }
+            case "reverse": {
+                const reverseOp = current;
+                const nextSource = transform(reverseOp.source);
+                if (nextSource === reverseOp.source) {
+                    return reverseOp;
+                }
+                const nextReverse = { ...reverseOp, source: nextSource };
+                return nextReverse;
+            }
+            case "first":
+            case "firstOrDefault": {
+                const op = current;
+                const nextSource = transform(op.source);
+                if (nextSource === op.source) {
+                    return op;
+                }
+                const nextOp = { ...op, source: nextSource };
+                return nextOp;
+            }
+            case "single":
+            case "singleOrDefault": {
+                const op = current;
+                const nextSource = transform(op.source);
+                if (nextSource === op.source) {
+                    return op;
+                }
+                const nextOp = { ...op, source: nextSource };
+                return nextOp;
+            }
+            case "last":
+            case "lastOrDefault": {
+                const op = current;
+                const nextSource = transform(op.source);
+                if (nextSource === op.source) {
+                    return op;
+                }
+                const nextOp = { ...op, source: nextSource };
+                return nextOp;
+            }
+            case "contains": {
+                const containsOp = current;
+                const nextSource = transform(containsOp.source);
+                if (nextSource === containsOp.source) {
+                    return containsOp;
+                }
+                const nextContains = { ...containsOp, source: nextSource };
+                return nextContains;
+            }
+            case "any": {
+                const anyOp = current;
+                const nextSource = transform(anyOp.source);
+                if (nextSource === anyOp.source) {
+                    return anyOp;
+                }
+                const nextAny = { ...anyOp, source: nextSource };
+                return nextAny;
+            }
+            case "all": {
+                const allOp = current;
+                const nextSource = transform(allOp.source);
+                if (nextSource === allOp.source) {
+                    return allOp;
+                }
+                const nextAll = { ...allOp, source: nextSource };
+                return nextAll;
+            }
+            case "count":
+            case "longCount": {
+                const op = current;
+                const nextSource = transform(op.source);
+                if (nextSource === op.source) {
+                    return op;
+                }
+                const nextOp = { ...op, source: nextSource };
+                return nextOp;
+            }
+            case "sum": {
+                const sumOp = current;
+                const nextSource = transform(sumOp.source);
+                if (nextSource === sumOp.source) {
+                    return sumOp;
+                }
+                const nextSum = { ...sumOp, source: nextSource };
+                return nextSum;
+            }
+            case "average": {
+                const averageOp = current;
+                const nextSource = transform(averageOp.source);
+                if (nextSource === averageOp.source) {
+                    return averageOp;
+                }
+                const nextAverage = { ...averageOp, source: nextSource };
+                return nextAverage;
+            }
+            case "min": {
+                const minOp = current;
+                const nextSource = transform(minOp.source);
+                if (nextSource === minOp.source) {
+                    return minOp;
+                }
+                const nextMin = { ...minOp, source: nextSource };
+                return nextMin;
+            }
+            case "max": {
+                const maxOp = current;
+                const nextSource = transform(maxOp.source);
+                if (nextSource === maxOp.source) {
+                    return maxOp;
+                }
+                const nextMax = { ...maxOp, source: nextSource };
+                return nextMax;
+            }
+            case "toDictionary": {
+                const toDictionaryOp = current;
+                const nextSource = transform(toDictionaryOp.source);
+                if (nextSource === toDictionaryOp.source) {
+                    return toDictionaryOp;
+                }
+                const nextToDictionary = {
+                    ...toDictionaryOp,
+                    source: nextSource,
+                };
+                return nextToDictionary;
+            }
+            case "toLookup": {
+                const toLookupOp = current;
+                const nextSource = transform(toLookupOp.source);
+                if (nextSource === toLookupOp.source) {
+                    return toLookupOp;
+                }
+                const nextToLookup = { ...toLookupOp, source: nextSource };
+                return nextToLookup;
+            }
+            default:
+                return current;
+        }
+    }
+    const nextOperation = transform(operation);
+    const contextParams = buildContextParams(context, requiredContextKeys);
+    const withAutoParams = mergeParamsStrict(params, filterAutoParams, "Row filter auto-params");
+    const nextParams = mergeParamsStrict(withAutoParams, contextParams, "Row filter context params");
+    return { operation: nextOperation, params: nextParams };
+}
+export function applyRowFiltersToUpdateOperation(operation, rowFilters, params, autoParamCounterStart) {
+    if (!rowFilters) {
+        return { operation, params };
+    }
+    const context = rowFilters.context;
+    if (!context) {
+        throw new Error("Row filters require context binding. Call schema.withContext(context).");
+    }
+    const resolved = resolveTableConfig(rowFilters.filters, operation.table, operation.schema);
+    const predicateFn = resolvePredicateForOperation(resolved.config, "update");
+    if (!predicateFn) {
+        return { operation, params };
+    }
+    const parsed = parseRowFilter(predicateFn, resolved.key, "update", autoParamCounterStart);
+    const contextParams = buildContextParams(context, parsed.contextKeys);
+    const withAutoParams = mergeParamsStrict(params, parsed.autoParams, "Row filter auto-params");
+    const nextParams = mergeParamsStrict(withAutoParams, contextParams, "Row filter context params");
+    const includedAssignments = selectIncludedAssignments(operation.assignments, nextParams);
+    const checkPredicate = substituteUpdatedColumnsInPredicate(parsed.predicate, includedAssignments);
+    const nextPredicate = andPredicates(andPredicates(operation.predicate, parsed.predicate), checkPredicate);
+    return {
+        operation: {
+            ...operation,
+            predicate: nextPredicate ?? operation.predicate,
+        },
+        params: nextParams,
+    };
+}
+export function applyRowFiltersToDeleteOperation(operation, rowFilters, params, autoParamCounterStart) {
+    if (!rowFilters) {
+        return { operation, params };
+    }
+    const context = rowFilters.context;
+    if (!context) {
+        throw new Error("Row filters require context binding. Call schema.withContext(context).");
+    }
+    const resolved = resolveTableConfig(rowFilters.filters, operation.table, operation.schema);
+    const predicateFn = resolvePredicateForOperation(resolved.config, "delete");
+    if (!predicateFn) {
+        return { operation, params };
+    }
+    const parsed = parseRowFilter(predicateFn, resolved.key, "delete", autoParamCounterStart);
+    const contextParams = buildContextParams(context, parsed.contextKeys);
+    const withAutoParams = mergeParamsStrict(params, parsed.autoParams, "Row filter auto-params");
+    const nextParams = mergeParamsStrict(withAutoParams, contextParams, "Row filter context params");
+    const nextPredicate = andPredicates(operation.predicate, parsed.predicate);
+    return {
+        operation: {
+            ...operation,
+            predicate: nextPredicate ?? operation.predicate,
+        },
+        params: nextParams,
+    };
+}
+function resolveTableConfig(filters, table, schema) {
+    const schemaQualified = schema ? `${schema}.${table}` : null;
+    if (schemaQualified && Object.prototype.hasOwnProperty.call(filters, schemaQualified)) {
+        return {
+            key: schemaQualified,
+            config: filters[schemaQualified],
+        };
+    }
+    if (Object.prototype.hasOwnProperty.call(filters, table)) {
+        return {
+            key: table,
+            config: filters[table],
+        };
+    }
+    throw new Error(`Row filter schema is missing configuration for table "${schemaQualified || table}".`);
+}
+function resolvePredicateForOperation(config, kind) {
+    if (config === null) {
+        return null;
+    }
+    if (typeof config === "function") {
+        return config;
+    }
+    const opConfig = config;
+    const value = opConfig[kind];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== "function") {
+        throw new Error(`Row filter config for ${kind} must be a function or null.`);
+    }
+    return value;
+}
+function parseRowFilter(predicateFn, table, kind, autoParamCounterStart) {
+    const lambda = parseArrowFunctionExpression(predicateFn, `${table}.${kind}`);
+    const ctxParamName = getIdentifierParamName(lambda, 1);
+    const helpersParamName = getIdentifierParamName(lambda, 2);
+    const visitorContext = createBaseContext();
+    visitorContext.autoParamCounter = autoParamCounterStart;
+    visitorContext.currentTable = table;
+    visitorContext.helpersParam = helpersParamName;
+    const source = {
+        type: "queryOperation",
+        operationType: "from",
+        table,
+    };
+    const call = createMethodCall("where", lambda);
+    const result = visitWhereOperation(call, source, visitorContext);
+    if (!result) {
+        throw new Error(`Failed to parse row filter for ${table}.${kind}.`);
+    }
+    const contextKeys = new Set();
+    const predicate = bindContextParams(result.operation.predicate, ctxParamName, contextKeys);
+    return {
+        predicate,
+        autoParams: result.autoParams,
+        contextKeys,
+        autoParamCounter: visitorContext.autoParamCounter,
+    };
+}
+function bindContextParams(expr, ctxParamName, contextKeys) {
+    return rewriteExpression(expr, ctxParamName, contextKeys);
+}
+function rewriteExpression(expr, ctxParamName, contextKeys) {
+    switch (expr.type) {
+        case "param": {
+            const paramExpr = expr;
+            if (!ctxParamName || paramExpr.param !== ctxParamName) {
+                return paramExpr;
+            }
+            if (!paramExpr.property || paramExpr.index !== undefined) {
+                throw new Error("Row filter context parameters must use direct property access (ctx.key).");
+            }
+            contextKeys.add(paramExpr.property);
+            return {
+                type: "param",
+                param: `${ROW_FILTER_CONTEXT_PARAM_PREFIX}${paramExpr.property}`,
+            };
+        }
+        case "column":
+        case "constant":
+        case "reference":
+        case "allColumns":
+        case "booleanColumn":
+        case "booleanConstant":
+            return expr;
+        case "comparison": {
+            return {
+                ...expr,
+                left: rewriteExpression(expr.left, ctxParamName, contextKeys),
+                right: rewriteExpression(expr.right, ctxParamName, contextKeys),
+            };
+        }
+        case "logical": {
+            return {
+                ...expr,
+                left: rewriteExpression(expr.left, ctxParamName, contextKeys),
+                right: rewriteExpression(expr.right, ctxParamName, contextKeys),
+            };
+        }
+        case "not": {
+            return {
+                ...expr,
+                expression: rewriteExpression(expr.expression, ctxParamName, contextKeys),
+            };
+        }
+        case "booleanMethod": {
+            return {
+                ...expr,
+                object: rewriteExpression(expr.object, ctxParamName, contextKeys),
+                arguments: expr.arguments.map((arg) => rewriteExpression(arg, ctxParamName, contextKeys)),
+            };
+        }
+        case "caseInsensitiveFunction": {
+            return {
+                ...expr,
+                arguments: expr.arguments.map((arg) => rewriteExpression(arg, ctxParamName, contextKeys)),
+            };
+        }
+        case "in": {
+            return {
+                ...expr,
+                value: rewriteExpression(expr.value, ctxParamName, contextKeys),
+                list: Array.isArray(expr.list)
+                    ? expr.list.map((item) => rewriteExpression(item, ctxParamName, contextKeys))
+                    : rewriteExpression(expr.list, ctxParamName, contextKeys),
+            };
+        }
+        case "isNull": {
+            return {
+                ...expr,
+                expression: rewriteExpression(expr.expression, ctxParamName, contextKeys),
+            };
+        }
+        case "arithmetic":
+        case "concat": {
+            return {
+                ...expr,
+                left: rewriteExpression(expr.left, ctxParamName, contextKeys),
+                right: rewriteExpression(expr.right, ctxParamName, contextKeys),
+            };
+        }
+        case "stringMethod": {
+            return {
+                ...expr,
+                object: rewriteExpression(expr.object, ctxParamName, contextKeys),
+                arguments: expr.arguments
+                    ? expr.arguments.map((arg) => rewriteExpression(arg, ctxParamName, contextKeys))
+                    : undefined,
+            };
+        }
+        case "case": {
+            return {
+                ...expr,
+                conditions: expr.conditions.map((c) => ({
+                    when: rewriteExpression(c.when, ctxParamName, contextKeys),
+                    then: rewriteExpression(c.then, ctxParamName, contextKeys),
+                })),
+                else: expr.else
+                    ? rewriteExpression(expr.else, ctxParamName, contextKeys)
+                    : undefined,
+            };
+        }
+        case "coalesce": {
+            return {
+                ...expr,
+                expressions: expr.expressions.map((e) => rewriteExpression(e, ctxParamName, contextKeys)),
+            };
+        }
+        case "aggregate": {
+            return {
+                ...expr,
+                expression: expr.expression
+                    ? rewriteExpression(expr.expression, ctxParamName, contextKeys)
+                    : undefined,
+            };
+        }
+        case "windowFunction": {
+            return {
+                ...expr,
+                partitionBy: expr.partitionBy.map((e) => rewriteExpression(e, ctxParamName, contextKeys)),
+                orderBy: expr.orderBy.map((o) => ({
+                    ...o,
+                    expression: rewriteExpression(o.expression, ctxParamName, contextKeys),
+                })),
+            };
+        }
+        case "object": {
+            const nextProperties = {};
+            for (const [key, value] of Object.entries(expr.properties)) {
+                nextProperties[key] = rewriteExpression(value, ctxParamName, contextKeys);
+            }
+            return { ...expr, properties: nextProperties };
+        }
+        case "array": {
+            return {
+                ...expr,
+                elements: expr.elements.map((e) => rewriteExpression(e, ctxParamName, contextKeys)),
+            };
+        }
+        case "memberAccess": {
+            return {
+                ...expr,
+                object: rewriteExpression(expr.object, ctxParamName, contextKeys),
+            };
+        }
+        case "methodCall": {
+            return {
+                ...expr,
+                object: rewriteExpression(expr.object, ctxParamName, contextKeys),
+                arguments: expr.arguments.map((a) => rewriteExpression(a, ctxParamName, contextKeys)),
+            };
+        }
+        case "conditional": {
+            return {
+                ...expr,
+                condition: rewriteExpression(expr.condition, ctxParamName, contextKeys),
+                then: rewriteExpression(expr.then, ctxParamName, contextKeys),
+                else: rewriteExpression(expr.else, ctxParamName, contextKeys),
+            };
+        }
+        case "functionCall": {
+            return {
+                ...expr,
+                arguments: expr.arguments.map((a) => rewriteExpression(a, ctxParamName, contextKeys)),
+            };
+        }
+        case "new": {
+            return {
+                ...expr,
+                arguments: expr.arguments.map((a) => rewriteExpression(a, ctxParamName, contextKeys)),
+            };
+        }
+        case "lambda": {
+            return {
+                ...expr,
+                body: rewriteExpression(expr.body, ctxParamName, contextKeys),
+            };
+        }
+        default:
+            return expr;
+    }
+}
+function buildContextParams(context, requiredKeys) {
+    const params = {};
+    for (const key of requiredKeys) {
+        if (!Object.prototype.hasOwnProperty.call(context, key)) {
+            throw new Error(`Row filter context is missing required key "${key}".`);
+        }
+        const value = context[key];
+        if (value === undefined) {
+            throw new Error(`Row filter context key "${key}" must not be undefined.`);
+        }
+        params[`${ROW_FILTER_CONTEXT_PARAM_PREFIX}${key}`] = value;
+    }
+    return params;
+}
+function mergeParamsStrict(base, additions, label) {
+    for (const key of Object.keys(additions)) {
+        if (Object.prototype.hasOwnProperty.call(base, key)) {
+            throw new Error(`${label} collided with existing parameter "${key}".`);
+        }
+    }
+    return { ...base, ...additions };
+}
+function andPredicates(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return {
+        type: "logical",
+        operator: "and",
+        left,
+        right,
+    };
+}
+function selectIncludedAssignments(assignments, params) {
+    if (assignments.type !== "object") {
+        return {};
+    }
+    const included = {};
+    for (const [column, valueExpr] of Object.entries(assignments.properties)) {
+        if (shouldSkipAssignment(valueExpr, params)) {
+            continue;
+        }
+        included[column] = valueExpr;
+    }
+    return included;
+}
+function shouldSkipAssignment(valueExpr, params) {
+    if (valueExpr.type === "param") {
+        const paramExpr = valueExpr;
+        const paramName = paramExpr.property || paramExpr.param;
+        if (Object.prototype.hasOwnProperty.call(params, paramName)) {
+            return params[paramName] === undefined;
+        }
+        return true;
+    }
+    if (valueExpr.type === "constant") {
+        const constant = valueExpr;
+        return constant.value === undefined;
+    }
+    return false;
+}
+function substituteUpdatedColumnsInPredicate(predicate, assignments) {
+    function rewriteValue(value) {
+        if (value.type !== "column") {
+            return rewriteExpression(value, undefined, new Set());
+        }
+        const colExpr = value;
+        if (colExpr.table || colExpr.source) {
+            return colExpr;
+        }
+        const replacement = assignments[colExpr.name];
+        if (!replacement) {
+            return colExpr;
+        }
+        if (!isValueExpression(replacement)) {
+            throw new Error(`Row filter column "${colExpr.name}" cannot be substituted with a non-value assignment.`);
+        }
+        return replacement;
+    }
+    function rewriteBoolean(expr) {
+        switch (expr.type) {
+            case "comparison":
+                return {
+                    ...expr,
+                    left: rewriteValue(expr.left),
+                    right: rewriteValue(expr.right),
+                };
+            case "logical":
+                return {
+                    ...expr,
+                    left: rewriteBoolean(expr.left),
+                    right: rewriteBoolean(expr.right),
+                };
+            case "not":
+                return { ...expr, expression: rewriteBoolean(expr.expression) };
+            case "booleanMethod":
+                return {
+                    ...expr,
+                    object: rewriteValue(expr.object),
+                    arguments: expr.arguments.map((a) => rewriteValue(a)),
+                };
+            case "caseInsensitiveFunction":
+                return {
+                    ...expr,
+                    arguments: [rewriteValue(expr.arguments[0]), rewriteValue(expr.arguments[1])],
+                };
+            case "in":
+                return {
+                    ...expr,
+                    value: rewriteValue(expr.value),
+                    list: Array.isArray(expr.list)
+                        ? expr.list.map((item) => rewriteValue(item))
+                        : rewriteExpression(expr.list, undefined, new Set()),
+                };
+            case "isNull":
+                return {
+                    ...expr,
+                    expression: rewriteValue(expr.expression),
+                };
+            default:
+                return expr;
+        }
+    }
+    return rewriteBoolean(predicate);
+}
+function parseArrowFunctionExpression(lambda, label) {
+    const source = lambda.toString();
+    const program = parseJavaScript(source);
+    const body = program.body?.[0];
+    if (!body || body.type !== "ExpressionStatement") {
+        throw new Error(`${label} expects an arrow function expression`);
+    }
+    const expression = body.expression;
+    if (expression.type !== "ArrowFunctionExpression") {
+        throw new Error(`${label} expects an arrow function expression`);
+    }
+    return expression;
+}
+function getIdentifierParamName(lambda, index) {
+    const param = lambda.params?.[index];
+    if (!param || param.type !== "Identifier") {
+        return undefined;
+    }
+    return param.name;
+}
+function createMethodCall(methodName, argument) {
+    return {
+        type: "CallExpression",
+        callee: {
+            type: "MemberExpression",
+            object: {
+                type: "Identifier",
+                name: "__plan",
+            },
+            property: {
+                type: "Identifier",
+                name: methodName,
+            },
+            computed: false,
+            optional: false,
+        },
+        arguments: argument ? [argument] : [],
+        optional: false,
+    };
+}
+//# sourceMappingURL=row-filters.js.map