@cerbos/orm-prisma 4.1.0 → 5.0.0

package/lib/relations.d.ts

@@ -0,0 +1,58 @@
+import type { PlanExpressionOperand } from "@cerbos/core";
+import type { PrismaFilter } from "./index";
+import type { RelationConfig, TranslationContext } from "./mapping";
+/** The Prisma operator that reaches into a relation for an existence test. */
+export declare function relationOperator(relation: RelationConfig): string;
+/**
+ * One relation-scoped filter (`{ tags: { some: … } }`), narrowed by the store-side predicate the
+ * caller declared on the mapping.
+ *
+ * Every nested relation filter the adapter emits goes through here, so a declared
+ * `subqueryFilter` reaches the collection macros, the membership shapes, the emptiness checks and
+ * the hop-existence guard alike. Adding a new relation shape means routing it through here, or
+ * the declaration silently stops applying to it.
+ *
+ * `every` is the one operator that cannot simply absorb the predicate. `{ every: AND(W, P) }`
+ * would REQUIRE every record to satisfy W, which is the opposite of "ignore the records W hides",
+ * so it is rewritten to `{ none: AND(W, NOT P) }` — no visible record violates P. Both agree with
+ * `every` when nothing is declared, and both stay vacuously true over an empty relation.
+ */
+export declare function relationFilter(relation: RelationConfig, operator: string, inner: PrismaFilter): PrismaFilter;
+/**
+ * `filter` nested through every relation in `relations`, outermost first, each reached with its
+ * existence operator (`is` for to-one, `some` for to-many). No relations leaves it unchanged.
+ */
+export declare function wrapInRelations(relations: RelationConfig[] | undefined, filter: PrismaFilter): PrismaFilter;
+/**
+ * "Every intermediate hop of a dotted path exists", as a Prisma filter.
+ *
+ * CEL cannot dot through a list, so each intermediate segment of `a.b.c` is a to-ONE
+ * parent: absent, the caller sends no attribute and CEL raises a missing-path error, which
+ * denies. `NOT { categories: { some: { subCategories: { some: P } } } }` is TRUE for a row
+ * with no category at all, so the negation returns rows the PDP denies — the parent must be
+ * required separately (cerbos/query-plan-adapters#309).
+ *
+ * Returns undefined when the reference has no intermediate hop, so a direct relation keeps
+ * its empty-collection semantics (`!tags.exists(...)` over zero tags is still TRUE).
+ */
+export declare function buildLeadingHopsExistFilter(head: RelationConfig, restRelations: RelationConfig[]): PrismaFilter | undefined;
+/**
+ * `{ NOT: filter }` for a filter translated from a plan sub-expression.
+ *
+ * An unconditional filter (`{}`, which the hierarchy operators return for a relationship that
+ * holds between two constants) cannot be negated this way: Prisma drops an empty condition, so
+ * `{ NOT: {} }` is true and matches every row, where the negation of an unconditional condition
+ * matches none. Prisma has no field-free false condition to emit instead, so the shape is refused.
+ */
+export declare function negateFilter(filter: PrismaFilter): PrismaFilter;
+/**
+ * `{ NOT: filter }`, with every to-one hop `operand` dots through required OUTSIDE the
+ * negation so an absent parent stays denied (see buildExpressionHopsExistFilter).
+ */
+export declare function negateRequiringHops(operand: PlanExpressionOperand, filter: PrismaFilter, context: TranslationContext): PrismaFilter;
+/**
+ * Whether negating `expr` needs a hop requirement (see buildExpressionHopsExistFilter): it dots
+ * through at least one to-one hop, which is absent on a parentless row.
+ */
+export declare function referencesRequiredHop(expr: PlanExpressionOperand, context: TranslationContext): boolean;
+//# sourceMappingURL=relations.d.ts.map

package/lib/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAIpE,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAEjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,YAAY,GAClB,YAAY,CAoBd;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,cAAc,EAAE,GAAG,SAAS,EACvC,MAAM,EAAE,YAAY,GACnB,YAAY,CAQd;AAYD;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,cAAc,EACpB,aAAa,EAAE,cAAc,EAAE,GAC9B,YAAY,GAAG,SAAS,CAO1B;AA6ED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAS/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,kBAAkB,GAC1B,YAAY,CAKd;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAET"}

package/lib/relations.js

@@ -0,0 +1,175 @@
+"use strict";
+// Nesting a filter through the relations a reference crosses, and the hop-existence guards that
+// keep an absent to-one parent denied under negation.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationOperator = relationOperator;
+exports.relationFilter = relationFilter;
+exports.wrapInRelations = wrapInRelations;
+exports.buildLeadingHopsExistFilter = buildLeadingHopsExistFilter;
+exports.negateFilter = negateFilter;
+exports.negateRequiringHops = negateRequiringHops;
+exports.referencesRequiredHop = referencesRequiredHop;
+const mapping_1 = require("./mapping");
+const plan_1 = require("./plan");
+const errors_1 = require("./errors");
+/** The Prisma operator that reaches into a relation for an existence test. */
+function relationOperator(relation) {
+    return relation.type === "one" ? "is" : "some";
+}
+/**
+ * One relation-scoped filter (`{ tags: { some: … } }`), narrowed by the store-side predicate the
+ * caller declared on the mapping.
+ *
+ * Every nested relation filter the adapter emits goes through here, so a declared
+ * `subqueryFilter` reaches the collection macros, the membership shapes, the emptiness checks and
+ * the hop-existence guard alike. Adding a new relation shape means routing it through here, or
+ * the declaration silently stops applying to it.
+ *
+ * `every` is the one operator that cannot simply absorb the predicate. `{ every: AND(W, P) }`
+ * would REQUIRE every record to satisfy W, which is the opposite of "ignore the records W hides",
+ * so it is rewritten to `{ none: AND(W, NOT P) }` — no visible record violates P. Both agree with
+ * `every` when nothing is declared, and both stay vacuously true over an empty relation.
+ */
+function relationFilter(relation, operator, inner) {
+    const declared = relation.subqueryFilter;
+    if (declared === undefined) {
+        return { [relation.name]: { [operator]: inner } };
+    }
+    const isEmpty = Object.keys(inner).length === 0;
+    if (operator === "every") {
+        return isEmpty
+            ? { [relation.name]: { every: inner } }
+            : { [relation.name]: { none: { AND: [declared, { NOT: inner }] } } };
+    }
+    return {
+        [relation.name]: {
+            [operator]: isEmpty ? declared : { AND: [declared, inner] },
+        },
+    };
+}
+/**
+ * `filter` nested through every relation in `relations`, outermost first, each reached with its
+ * existence operator (`is` for to-one, `some` for to-many). No relations leaves it unchanged.
+ */
+function wrapInRelations(relations, filter) {
+    let current = filter;
+    for (const relation of [...(relations ?? [])].reverse()) {
+        current = relationFilter(relation, relationOperator(relation), current);
+    }
+    return current;
+}
+/**
+ * "Every one of these relations exists", as a nested Prisma filter with an empty innermost
+ * predicate — `{ parent: { is: { inner: { is: {} } } } }`.
+ */
+function buildHopsExistFilter(hops) {
+    return hops.length === 0 ? undefined : wrapInRelations(hops, {});
+}
+/**
+ * "Every intermediate hop of a dotted path exists", as a Prisma filter.
+ *
+ * CEL cannot dot through a list, so each intermediate segment of `a.b.c` is a to-ONE
+ * parent: absent, the caller sends no attribute and CEL raises a missing-path error, which
+ * denies. `NOT { categories: { some: { subCategories: { some: P } } } }` is TRUE for a row
+ * with no category at all, so the negation returns rows the PDP denies — the parent must be
+ * required separately (cerbos/query-plan-adapters#309).
+ *
+ * Returns undefined when the reference has no intermediate hop, so a direct relation keeps
+ * its empty-collection semantics (`!tags.exists(...)` over zero tags is still TRUE).
+ */
+function buildLeadingHopsExistFilter(head, restRelations) {
+    if (restRelations.length === 0) {
+        return undefined;
+    }
+    // The last entry is the collection being iterated; everything before it is a hop.
+    return buildHopsExistFilter([head, ...restRelations.slice(0, -1)]);
+}
+/**
+ * "Every to-one hop this expression dots through exists", as a Prisma filter, or undefined
+ * when it dots through none.
+ *
+ * Prisma has no UNKNOWN: a chained relation filter is exact under the POSITIVE polarity —
+ * `categories: { some: { subCategories: { some: P } } }` cannot hold without the category —
+ * but `NOT` inverts the hop requirement along with the predicate, so every operator built on
+ * a chain readmits the parentless rows once negated. #309 fixed that inside the collection
+ * macros, which left the sibling operators reached through the same chain unguarded:
+ * membership and `hasIntersection` (cerbos/query-plan-adapters#315), and the negated count
+ * spelling `!(size(chain) > 0)` (#316), all of which the macros' guard never saw.
+ *
+ * Requiring the hops OUTSIDE the negation is what fixes all of them at once, and it is
+ * unconditionally faithful to CEL rather than a per-operator patch: a missing hop is a
+ * missing-path error, which denies under BOTH polarities, so the requirement never depends
+ * on which operator sits above the chain.
+ *
+ * Lambda bodies are deliberately not walked — their references resolve against a scoped
+ * mapper, and a negated macro carries its own guard through the negated collection operators.
+ */
+function buildExpressionHopsExistFilter(operand, context) {
+    const hops = [];
+    const seen = new Set();
+    const visit = (expr) => {
+        if ((0, plan_1.isNamedOperand)(expr)) {
+            if (seen.has(expr.name)) {
+                return;
+            }
+            seen.add(expr.name);
+            const { relations } = (0, mapping_1.resolveFieldReference)(expr.name, context);
+            if (!relations || relations.length === 0) {
+                return;
+            }
+            const last = relations[relations.length - 1];
+            // Every to-ONE relation on the path is a hop that must EXIST — including a TRAILING one,
+            // which is the case a chain of to-many relations never produces. `parent.aBool` resolves
+            // to a single to-one relation, and `NOT { parent: { is: { aBool: true } } }` is TRUE for
+            // a row with no parent at all, so the negation returns rows the PDP denies. A trailing
+            // to-MANY relation is the collection being iterated rather than a hop, and keeps its
+            // empty-collection semantics (`!tags.exists(...)` over zero tags is still TRUE).
+            const hopFilter = buildHopsExistFilter(last.type === "one" ? relations : relations.slice(0, -1));
+            if (hopFilter !== undefined) {
+                hops.push(hopFilter);
+            }
+            return;
+        }
+        if (!(0, plan_1.isOperatorOperand)(expr) || expr.operator === "lambda") {
+            return;
+        }
+        expr.operands.forEach(visit);
+    };
+    visit(operand);
+    if (hops.length === 0) {
+        return undefined;
+    }
+    return hops.length === 1 ? hops[0] : { AND: hops };
+}
+/**
+ * `{ NOT: filter }` for a filter translated from a plan sub-expression.
+ *
+ * An unconditional filter (`{}`, which the hierarchy operators return for a relationship that
+ * holds between two constants) cannot be negated this way: Prisma drops an empty condition, so
+ * `{ NOT: {} }` is true and matches every row, where the negation of an unconditional condition
+ * matches none. Prisma has no field-free false condition to emit instead, so the shape is refused.
+ */
+function negateFilter(filter) {
+    if (Object.keys(filter).length === 0) {
+        throw new errors_1.UnsupportedQueryPlanError("Cannot negate an unconditional filter: Prisma evaluates { NOT: {} } as true and matches " +
+            "every row, where the negated condition matches none");
+    }
+    return { NOT: filter };
+}
+/**
+ * `{ NOT: filter }`, with every to-one hop `operand` dots through required OUTSIDE the
+ * negation so an absent parent stays denied (see buildExpressionHopsExistFilter).
+ */
+function negateRequiringHops(operand, filter, context) {
+    const hops = buildExpressionHopsExistFilter(operand, context);
+    const negated = negateFilter(filter);
+    return hops === undefined ? negated : { AND: [hops, negated] };
+}
+/**
+ * Whether negating `expr` needs a hop requirement (see buildExpressionHopsExistFilter): it dots
+ * through at least one to-one hop, which is absent on a parentless row.
+ */
+function referencesRequiredHop(expr, context) {
+    return buildExpressionHopsExistFilter(expr, context) !== undefined;
+}
+//# sourceMappingURL=relations.js.map

package/lib/relations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.js","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"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"}

package/lib/rewrite.d.ts

@@ -0,0 +1,36 @@
+import type { PlanExpressionOperand, Value } from "@cerbos/core";
+/** The boolean collection macros: each takes a collection and a lambda. */
+export declare const COLLECTION_OPERATORS: Set<string>;
+export declare function containsCollectionOperator(expr: PlanExpressionOperand): boolean;
+/**
+ * Substitute a lambda iteration variable with a concrete collection element
+ * inside a lambda body. A bare reference to the variable becomes the element
+ * itself; a `variable.path.to.field` reference drills into the element. A
+ * nested collection macro whose lambda rebinds the same variable name shadows
+ * the outer variable, so substitution only descends into its collection
+ * operand.
+ */
+export declare function substituteLambdaVariable(operand: PlanExpressionOperand, variableName: string, element: Value): PlanExpressionOperand;
+/**
+ * Rewrites lambda bodies that reference columns of an ENCLOSING scope (the root row, or an
+ * outer lambda's element) so that every filter lands on the model it belongs to. Without this,
+ * an outer column referenced inside `tags.exists(t, ...)` would be emitted as a field of the
+ * tag model. Two sound transforms, applied bottom-up:
+ *
+ * - Conjunct hoisting (exists only): `exists(c, P(c) && Q)` with row-constant Q becomes
+ *   `exists(c, P(c)) && Q`. Valid in three-valued logic (AND distributes over the per-element
+ *   OR), including the empty-collection case (both sides are FALSE).
+ * - Case split (any collection op): a bare outer boolean reference Q in a boolean position
+ *   becomes `(Q && op[Q:=true]) || (!Q && op[Q:=false]) || (Q && !Q && exists(c, true))`. The
+ *   contradiction arm keeps the whole expression UNKNOWN (not FALSE) when Q is NULL-derived and
+ *   the collection has elements, mirroring the guarded-ternary encoding.
+ */
+export declare function hoistOuterScopeReferences(expr: PlanExpressionOperand, enclosingVariables: string[]): PlanExpressionOperand;
+/**
+ * Bottom-up constant folding over the plan AST. Only shapes the case-split transform can
+ * produce need folding (constant ternary conditions, comparisons between two constants,
+ * logical operators with constant operands, collection macros with constant bodies); real
+ * planner output arrives pre-folded.
+ */
+export declare function constantFoldExpression(expr: PlanExpressionOperand): PlanExpressionOperand;
+//# sourceMappingURL=rewrite.d.ts.map

package/lib/rewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite.d.ts","sourceRoot":"","sources":["../src/rewrite.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAkBjE,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,aAM/B,CAAC;AAKH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAU/E;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,qBAAqB,EAC9B,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,KAAK,GACb,qBAAqB,CAsEvB;AA4HD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,qBAAqB,EAC3B,kBAAkB,EAAE,MAAM,EAAE,GAC3B,qBAAqB,CAoGvB;AAyBD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,qBAAqB,GAC1B,qBAAqB,CA0HvB"}

package/lib/rewrite.js

@@ -0,0 +1,366 @@
+"use strict";
+// Plan-to-plan rewrites that run before translation. None of them knows about Prisma: each takes
+// an expression tree and returns an equivalent one that the translator can lower more directly.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLECTION_OPERATORS = void 0;
+exports.containsCollectionOperator = containsCollectionOperator;
+exports.substituteLambdaVariable = substituteLambdaVariable;
+exports.hoistOuterScopeReferences = hoistOuterScopeReferences;
+exports.constantFoldExpression = constantFoldExpression;
+const evaluate_1 = require("./evaluate");
+const plan_1 = require("./plan");
+const errors_1 = require("./errors");
+const narrowing_1 = require("./narrowing");
+/** The boolean collection macros: each takes a collection and a lambda. */
+exports.COLLECTION_OPERATORS = new Set([
+    "exists",
+    "exists_one",
+    "all",
+    "except",
+    "filter",
+]);
+// Operators whose second operand is a lambda that binds an iteration variable.
+const LAMBDA_BINDING_OPERATORS = new Set([...exports.COLLECTION_OPERATORS, "map"]);
+function containsCollectionOperator(expr) {
+    if (!(0, plan_1.isOperatorOperand)(expr)) {
+        return false;
+    }
+    if (exports.COLLECTION_OPERATORS.has(expr.operator)) {
+        return true;
+    }
+    return expr.operands.some(containsCollectionOperator);
+}
+/**
+ * Substitute a lambda iteration variable with a concrete collection element
+ * inside a lambda body. A bare reference to the variable becomes the element
+ * itself; a `variable.path.to.field` reference drills into the element. A
+ * nested collection macro whose lambda rebinds the same variable name shadows
+ * the outer variable, so substitution only descends into its collection
+ * operand.
+ */
+function substituteLambdaVariable(operand, variableName, element) {
+    if ((0, plan_1.isNamedOperand)(operand)) {
+        if (operand.name === variableName) {
+            return { value: element };
+        }
+        if (operand.name.startsWith(`${variableName}.`)) {
+            let current = element;
+            for (const segment of operand.name
+                .slice(variableName.length + 1)
+                .split(".")) {
+                if (!(0, narrowing_1.isObject)(current) ||
+                    Array.isArray(current) ||
+                    !(segment in current) ||
+                    current[segment] === undefined) {
+                    throw new errors_1.UnsupportedQueryPlanError(`Cannot resolve "${operand.name}": collection element has no field "${segment}"`);
+                }
+                current = current[segment];
+            }
+            return { value: current };
+        }
+        return operand;
+    }
+    if (!(0, plan_1.isOperatorOperand)(operand)) {
+        return operand;
+    }
+    const [nestedCollection, nestedLambda] = operand.operands;
+    if (LAMBDA_BINDING_OPERATORS.has(operand.operator) &&
+        operand.operands.length === 2 &&
+        nestedCollection !== undefined &&
+        nestedLambda !== undefined &&
+        (0, plan_1.isOperatorOperand)(nestedLambda) &&
+        nestedLambda.operator === "lambda") {
+        const nestedVariable = nestedLambda.operands[1];
+        if (nestedVariable !== undefined &&
+            (0, plan_1.isNamedOperand)(nestedVariable) &&
+            nestedVariable.name === variableName) {
+            // The nested lambda shadows our variable: substitute only in the collection operand.
+            return {
+                operator: operand.operator,
+                operands: [
+                    substituteLambdaVariable(nestedCollection, variableName, element),
+                    nestedLambda,
+                ],
+            };
+        }
+    }
+    return {
+        operator: operand.operator,
+        operands: operand.operands.map((o) => substituteLambdaVariable(o, variableName, element)),
+    };
+}
+function mentionsVariable(expr, variableName) {
+    if ((0, plan_1.isNamedOperand)(expr)) {
+        return (expr.name === variableName || expr.name.startsWith(variableName + "."));
+    }
+    if ((0, plan_1.isOperatorOperand)(expr)) {
+        return expr.operands.some((operand) => mentionsVariable(operand, variableName));
+    }
+    return false;
+}
+function isOuterScopeName(name, enclosingVariables) {
+    return !enclosingVariables.some((variable) => name === variable || name.startsWith(variable + "."));
+}
+/** Replaces every occurrence of the bare named operand `name` with a boolean constant. */
+function substituteNamedOperand(expr, name, value) {
+    if ((0, plan_1.isNamedOperand)(expr)) {
+        return expr.name === name ? { value } : expr;
+    }
+    if ((0, plan_1.isOperatorOperand)(expr)) {
+        return {
+            operator: expr.operator,
+            operands: expr.operands.map((operand) => substituteNamedOperand(operand, name, value)),
+        };
+    }
+    return expr;
+}
+const BOOLEAN_POSITION_OPERATORS = new Set(["and", "or", "not", "if"]);
+/**
+ * Finds a bare boolean reference to an OUTER column (root or enclosing lambda scope) in a
+ * boolean position of a lambda body: a direct operand of and/or/not, a ternary condition, or
+ * the body itself.
+ */
+function findOuterBooleanReference(expr, enclosingVariables) {
+    if ((0, plan_1.isNamedOperand)(expr)) {
+        return isOuterScopeName(expr.name, enclosingVariables)
+            ? expr.name
+            : undefined;
+    }
+    if (!(0, plan_1.isOperatorOperand)(expr)) {
+        return undefined;
+    }
+    const booleanPositions = BOOLEAN_POSITION_OPERATORS.has(expr.operator)
+        ? expr.operands
+        : // Comparisons wrapping a ternary keep the outer reference in the ternary condition.
+            expr.operands.filter((operand) => (0, plan_1.isOperatorOperand)(operand) &&
+                BOOLEAN_POSITION_OPERATORS.has(operand.operator));
+    for (const operand of booleanPositions) {
+        const found = findOuterBooleanReference(operand, enclosingVariables);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}
+/**
+ * The parts of `macro(collection, lambda(body, variable))` when `expr` is a boolean collection
+ * macro over a single-variable lambda, or undefined for any other shape.
+ */
+function parseLambdaMacro(expr) {
+    const [collection, lambda] = expr.operands;
+    if (!exports.COLLECTION_OPERATORS.has(expr.operator) ||
+        expr.operands.length !== 2 ||
+        collection === undefined ||
+        lambda === undefined ||
+        !(0, plan_1.isOperatorOperand)(lambda) ||
+        lambda.operator !== "lambda" ||
+        lambda.operands.length !== 2) {
+        return undefined;
+    }
+    const variable = lambda.operands[1];
+    if (variable === undefined || !(0, plan_1.isNamedOperand)(variable)) {
+        return undefined;
+    }
+    return { collection, lambda, variable };
+}
+/**
+ * Rewrites lambda bodies that reference columns of an ENCLOSING scope (the root row, or an
+ * outer lambda's element) so that every filter lands on the model it belongs to. Without this,
+ * an outer column referenced inside `tags.exists(t, ...)` would be emitted as a field of the
+ * tag model. Two sound transforms, applied bottom-up:
+ *
+ * - Conjunct hoisting (exists only): `exists(c, P(c) && Q)` with row-constant Q becomes
+ *   `exists(c, P(c)) && Q`. Valid in three-valued logic (AND distributes over the per-element
+ *   OR), including the empty-collection case (both sides are FALSE).
+ * - Case split (any collection op): a bare outer boolean reference Q in a boolean position
+ *   becomes `(Q && op[Q:=true]) || (!Q && op[Q:=false]) || (Q && !Q && exists(c, true))`. The
+ *   contradiction arm keeps the whole expression UNKNOWN (not FALSE) when Q is NULL-derived and
+ *   the collection has elements, mirroring the guarded-ternary encoding.
+ */
+function hoistOuterScopeReferences(expr, enclosingVariables) {
+    if (!(0, plan_1.isOperatorOperand)(expr)) {
+        return expr;
+    }
+    const macro = parseLambdaMacro(expr);
+    if (macro === undefined) {
+        return {
+            operator: expr.operator,
+            operands: expr.operands.map((operand) => hoistOuterScopeReferences(operand, enclosingVariables)),
+        };
+    }
+    const { collection, lambda, variable } = macro;
+    const scopeVariables = [...enclosingVariables, variable.name];
+    const body = hoistOuterScopeReferences((0, plan_1.assertDefined)(lambda.operands[0], "Lambda requires a condition"), scopeVariables);
+    const rebuild = (newBody) => ({
+        operator: expr.operator,
+        operands: [collection, { operator: "lambda", operands: [newBody, variable] }],
+    });
+    // Conjunct hoisting out of exists().
+    if (expr.operator === "exists" &&
+        (0, plan_1.isOperatorOperand)(body) &&
+        body.operator === "and") {
+        const elementConjuncts = body.operands.filter((operand) => mentionsVariable(operand, variable.name));
+        const outerConjuncts = body.operands.filter((operand) => !mentionsVariable(operand, variable.name));
+        if (outerConjuncts.length > 0 && elementConjuncts.length > 0) {
+            const innerBody = elementConjuncts.length === 1
+                ? elementConjuncts[0]
+                : { operator: "and", operands: elementConjuncts };
+            return {
+                operator: "and",
+                operands: [rebuild(innerBody), ...outerConjuncts],
+            };
+        }
+    }
+    // Case split on a bare outer boolean reference.
+    const outerRef = findOuterBooleanReference(body, scopeVariables);
+    if (outerRef !== undefined) {
+        const q = { name: outerRef };
+        const notQ = { operator: "not", operands: [q] };
+        const arms = [
+            {
+                operator: "and",
+                operands: [q, rebuild(substituteNamedOperand(body, outerRef, true))],
+            },
+            {
+                operator: "and",
+                operands: [notQ, rebuild(substituteNamedOperand(body, outerRef, false))],
+            },
+            // Contradiction arm: UNKNOWN when the reference is NULL-derived, never TRUE. CEL never
+            // evaluates the body over an empty collection, so there the arm is FALSE, not UNKNOWN.
+            {
+                operator: "and",
+                operands: [
+                    q,
+                    notQ,
+                    {
+                        operator: "exists",
+                        operands: [collection, { operator: "lambda", operands: [{ value: true }, variable] }],
+                    },
+                ],
+            },
+        ];
+        // all() over an empty collection never evaluates its body, so CEL holds it TRUE even when
+        // the reference is missing; the arms above are all UNKNOWN on that row. `all(c, false)` is
+        // TRUE exactly when the collection is empty, and definite, so it restores that row without
+        // touching any other (#488).
+        if (expr.operator === "all") {
+            arms.push(rebuild({ value: false }));
+        }
+        return { operator: "or", operands: arms };
+    }
+    return rebuild(body);
+}
+/**
+ * `and`/`or` over already-folded operands: a dominating constant decides the whole expression,
+ * and the other constants drop out.
+ */
+function foldLogical(operator, operands) {
+    const dominant = operator === "or";
+    if (operands.some((o) => (0, plan_1.isValueOperand)(o) && o.value === dominant)) {
+        return { value: dominant };
+    }
+    const remaining = operands.filter((o) => !(0, plan_1.isValueOperand)(o));
+    if (remaining.length === 0)
+        return { value: !dominant };
+    if (remaining.length === 1)
+        return remaining[0];
+    return { operator, operands: remaining };
+}
+/**
+ * Bottom-up constant folding over the plan AST. Only shapes the case-split transform can
+ * produce need folding (constant ternary conditions, comparisons between two constants,
+ * logical operators with constant operands, collection macros with constant bodies); real
+ * planner output arrives pre-folded.
+ */
+function constantFoldExpression(expr) {
+    if (!(0, plan_1.isOperatorOperand)(expr)) {
+        return expr;
+    }
+    (0, plan_1.assertLogicalOperands)(expr.operator, expr.operands);
+    const operands = expr.operands.map(constantFoldExpression);
+    const folded = { operator: expr.operator, operands };
+    const [first, second] = operands;
+    const bothConstant = first !== undefined &&
+        second !== undefined &&
+        (0, plan_1.isValueOperand)(first) &&
+        (0, plan_1.isValueOperand)(second);
+    switch (expr.operator) {
+        case "if": {
+            const [condition, thenBranch, elseBranch] = operands;
+            if (condition !== undefined && (0, plan_1.isValueOperand)(condition)) {
+                if (!(0, narrowing_1.isBoolean)(condition.value)) {
+                    throw new errors_1.UnsupportedQueryPlanError("if (ternary) condition must be a boolean expression");
+                }
+                return (0, plan_1.assertDefined)(condition.value ? thenBranch : elseBranch, "if (ternary) requires branch operands");
+            }
+            return folded;
+        }
+        case "and":
+        case "or":
+            return foldLogical(expr.operator, operands);
+        case "not":
+            if (first !== undefined && (0, plan_1.isValueOperand)(first)) {
+                return { value: first.value !== true };
+            }
+            return folded;
+        case "add":
+        case "sub":
+        case "mult":
+        case "div":
+            return bothConstant
+                ? { value: (0, evaluate_1.foldArithmetic)(expr.operator, first.value, second.value) }
+                : folded;
+        case "contains":
+        case "startsWith":
+        case "endsWith": {
+            if (bothConstant &&
+                (0, narrowing_1.isString)(first.value) &&
+                (0, narrowing_1.isString)(second.value)) {
+                const receiver = first.value;
+                const needle = second.value;
+                return {
+                    value: expr.operator === "contains"
+                        ? receiver.includes(needle)
+                        : expr.operator === "startsWith"
+                            ? receiver.startsWith(needle)
+                            : receiver.endsWith(needle),
+                };
+            }
+            return folded;
+        }
+        case "exists":
+        case "all": {
+            const lambda = second;
+            if (first !== undefined &&
+                lambda !== undefined &&
+                (0, plan_1.isOperatorOperand)(lambda) &&
+                lambda.operator === "lambda" &&
+                lambda.operands[0] !== undefined &&
+                (0, plan_1.isValueOperand)(lambda.operands[0])) {
+                const bodyValue = lambda.operands[0].value === true;
+                if (expr.operator === "exists" && !bodyValue)
+                    return { value: false };
+                if (expr.operator === "all" && bodyValue)
+                    return { value: true };
+                const sizeExpr = {
+                    operator: "size",
+                    operands: [first],
+                };
+                // exists(c, true) is "collection is non-empty"; all(c, false) is "collection is empty".
+                return expr.operator === "exists"
+                    ? { operator: "gt", operands: [sizeExpr, { value: 0 }] }
+                    : { operator: "eq", operands: [sizeExpr, { value: 0 }] };
+            }
+            return folded;
+        }
+        default:
+            if (plan_1.COMPARISON_OPERATORS.has(expr.operator) &&
+                bothConstant) {
+                return {
+                    value: (0, evaluate_1.evaluateConstantComparison)(expr.operator, first.value, second.value),
+                };
+            }
+            return folded;
+    }
+}
+//# sourceMappingURL=rewrite.js.map