@cerbos/orm-prisma 2.0.0-alpha.1 → 2.0.0

package/lib/cjs/index.js

@@ -10,12 +10,9 @@ Object.defineProperty(exports, "PlanKind", { enumerable: true, get: function ()
  * @returns {QueryPlanToPrismaResult} The result containing the kind and filters.
  */
 function queryPlanToPrisma({ queryPlan, mapper = {}, }) {
-    // Choose filter conversion based on plan kind
     switch (queryPlan.kind) {
         case core_1.PlanKind.ALWAYS_ALLOWED:
-            return {
-                kind: core_1.PlanKind.ALWAYS_ALLOWED,
-            };
+            return { kind: core_1.PlanKind.ALWAYS_ALLOWED };
         case core_1.PlanKind.ALWAYS_DENIED:
             return { kind: core_1.PlanKind.ALWAYS_DENIED };
         case core_1.PlanKind.CONDITIONAL:
@@ -28,248 +25,365 @@ function queryPlanToPrisma({ queryPlan, mapper = {}, }) {
     }
 }
 /**
- * Resolves a field reference considering relations.
- * @param {string} reference - The field reference.
- * @param {Mapper} mapper - The mapper configuration.
- * @returns {object} The resolved field reference with path and relation.
+ * Resolves a field reference considering relations and nested fields.
+ * Handles both direct field mappings and relation mappings with support for nested structures.
+ *
+ * @param {string} reference - The field reference from Cerbos
+ * @param {Mapper} mapper - Configuration for field/relation mapping
+ * @returns {Object} Resolved reference with path and optional relations
  */
 const resolveFieldReference = (reference, mapper) => {
     const parts = reference.split(".");
-    const lastPart = parts[parts.length - 1];
-    // First try exact match
     const config = typeof mapper === "function" ? mapper(reference) : mapper[reference];
-    if (config) {
-        if (config.relation) {
-            const { name, type, field, fields } = config.relation;
-            return {
-                path: [name, field].filter(Boolean),
-                relation: { name, type, field, nestedMapper: fields },
-            };
+    let matchedPrefix = "";
+    let matchedConfig;
+    if (!config) {
+        for (let i = parts.length - 1; i >= 0; i--) {
+            const prefix = parts.slice(0, i + 1).join(".");
+            const prefixConfig = typeof mapper === "function" ? mapper(prefix) : mapper[prefix];
+            if (prefixConfig) {
+                matchedPrefix = prefix;
+                matchedConfig = prefixConfig;
+                break;
+            }
         }
-        return { path: [config.field || reference] };
     }
-    // Check for parent relation with multiple parts
-    if (parts.length > 1) {
-        const parentPath = parts.slice(0, -1).join(".");
-        const parentConfig = typeof mapper === "function" ? mapper(parentPath) : mapper[parentPath];
-        if (parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.relation) {
-            const { name, type, fields } = parentConfig.relation;
-            const fieldConfig = fields === null || fields === void 0 ? void 0 : fields[lastPart];
-            const fieldName = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.field) || lastPart;
-            return {
-                path: [name],
-                relation: { name, type, field: fieldName, nestedMapper: fields },
-            };
+    const activeConfig = config || matchedConfig;
+    if (activeConfig === null || activeConfig === void 0 ? void 0 : activeConfig.relation) {
+        const { name, type, fields } = activeConfig.relation;
+        const matchedParts = matchedPrefix ? matchedPrefix.split(".") : [];
+        const remainingParts = matchedPrefix
+            ? parts.slice(matchedParts.length)
+            : parts.slice(1);
+        let field;
+        const relations = [
+            { name, type, field: activeConfig.relation.field, nestedMapper: fields },
+        ];
+        if (fields && remainingParts.length > 0) {
+            let currentMapper = fields;
+            let currentParts = remainingParts;
+            while (currentParts.length > 0) {
+                const nextConfig = currentMapper[currentParts[0]];
+                if (nextConfig === null || nextConfig === void 0 ? void 0 : nextConfig.relation) {
+                    relations.push({
+                        name: nextConfig.relation.name,
+                        type: nextConfig.relation.type,
+                        field: nextConfig.relation.field,
+                        nestedMapper: nextConfig.relation.fields,
+                    });
+                    currentMapper = nextConfig.relation.fields || {};
+                    currentParts = currentParts.slice(1);
+                }
+                else {
+                    field = (nextConfig === null || nextConfig === void 0 ? void 0 : nextConfig.field) || currentParts[currentParts.length - 1];
+                    break;
+                }
+            }
         }
+        return { path: field ? [field] : remainingParts, relations };
     }
-    // Fallback to raw reference if no mapper fits
-    return { path: [reference] };
+    return { path: [(activeConfig === null || activeConfig === void 0 ? void 0 : activeConfig.field) || reference] };
 };
 /**
  * Determines the appropriate Prisma operator based on relation type.
- * @param {object} relation - The relation configuration.
- * @returns {string} The Prisma relation operator.
+ * Used for building relation filters in Prisma queries.
+ *
+ * @param {Object} relation - Relation configuration
+ * @param {string} relation.name - Name of the relation
+ * @param {('one'|'many')} relation.type - Type of relation
+ * @returns {string} Prisma relation operator ('is' for one-to-one, 'some' for one-to-many)
  */
 const getPrismaRelationOperator = (relation) => (relation.type === "one" ? "is" : "some");
 /**
- * Builds Prisma WHERE conditions from a Cerbos expression.
- * @param {PlanExpressionOperand} expression - The Cerbos expression.
- * @param {Mapper} mapper - The mapper configuration.
- * @returns {PrismaFilter} The Prisma filter.
+ * Builds a nested relation filter for Prisma queries.
+ * Handles multiple levels of relations and applies appropriate operators.
+ *
+ * @param {Array} relations - Array of relation configurations
+ * @param {Object} fieldFilter - Base filter to apply at the deepest level
+ * @returns {Object} Nested Prisma filter structure
+ */
+const buildNestedRelationFilter = (relations, fieldFilter) => {
+    if (relations.length === 0)
+        return fieldFilter;
+    let currentFilter = fieldFilter;
+    for (let i = relations.length - 1; i >= 0; i--) {
+        const relation = relations[i];
+        const relationOperator = getPrismaRelationOperator(relation);
+        if (relation.field && i === relations.length - 1) {
+            const [, filterValue] = Object.entries(currentFilter)[0];
+            currentFilter = { [relation.field]: filterValue };
+        }
+        currentFilter = { [relation.name]: { [relationOperator]: currentFilter } };
+    }
+    return currentFilter;
+};
+/**
+ * Type guard to check if an operand is a resolved field reference.
+ * @param {ResolvedOperand} operand - Operand to check
+ * @returns {boolean} True if operand is a field reference
+ */
+function isResolvedFieldReference(operand) {
+    return "path" in operand;
+}
+/**
+ * Type guard to check if an operand is a resolved value.
+ * @param {ResolvedOperand} operand - Operand to check
+ * @returns {boolean} True if operand is a value
+ */
+function isResolvedValue(operand) {
+    return "value" in operand;
+}
+/**
+ * Type guard for PlanExpressionOperand with name property.
+ * @param {PlanExpressionOperand} operand - Operand to check
+ * @returns {boolean} True if operand has name property
+ */
+function isPlanExpressionWithName(operand) {
+    return "name" in operand && typeof operand.name === "string";
+}
+/**
+ * Type guard for PlanExpressionOperand with value property.
+ * @param {PlanExpressionOperand} operand - Operand to check
+ * @returns {boolean} True if operand has value property
+ */
+function isPlanExpressionWithValue(operand) {
+    return "value" in operand && operand.value !== undefined;
+}
+/**
+ * Type guard for PlanExpressionOperand with operator property.
+ * @param {PlanExpressionOperand} operand - Operand to check
+ * @returns {boolean} True if operand has operator and operands properties
+ */
+function isPlanExpressionWithOperator(operand) {
+    return ("operator" in operand &&
+        typeof operand.operator === "string" &&
+        "operands" in operand &&
+        Array.isArray(operand.operands));
+}
+/**
+ * Resolves a PlanExpressionOperand into a ResolvedOperand.
+ * Handles field references, values, and nested expressions.
+ *
+ * @param {PlanExpressionOperand} operand - Operand to resolve
+ * @param {Mapper} mapper - Field mapping configuration
+ * @returns {ResolvedOperand} Resolved operand
+ * @throws {Error} If operand is invalid
+ */
+const resolveOperand = (operand, mapper) => {
+    if (isPlanExpressionWithName(operand)) {
+        return resolveFieldReference(operand.name, mapper);
+    }
+    else if (isPlanExpressionWithValue(operand)) {
+        return { value: operand.value };
+    }
+    else if (isPlanExpressionWithOperator(operand)) {
+        const nestedResult = buildPrismaFilterFromCerbosExpression(operand, mapper);
+        return { value: nestedResult };
+    }
+    throw new Error("Operand must have name, value, or be an expression");
+};
+/**
+ * Builds a Prisma filter from a Cerbos expression.
+ * Main function for converting Cerbos query conditions to Prisma filters.
+ *
+ * @param {PlanExpressionOperand} expression - Cerbos expression to convert
+ * @param {Mapper} mapper - Field mapping configuration
+ * @returns {PrismaFilter} Prisma compatible filter
+ * @throws {Error} If expression is invalid or operator is unsupported
  */
 const buildPrismaFilterFromCerbosExpression = (expression, mapper) => {
+    // Validate expression structure
     if (!("operator" in expression) || !("operands" in expression)) {
         throw new Error("Invalid Cerbos expression structure");
     }
     const { operator, operands } = expression;
     /**
-     * Helper function to resolve an operand.
-     * @param {PlanExpressionOperand} operand - The operand from expression.
-     * @returns {any} An object with a field reference or value.
+     * Helper function to process relational operators (eq, ne, lt, etc.)
+     * @param {string} operator - Relational operator
+     * @param {ResolvedOperand} left - Left operand
+     * @param {ResolvedOperand} right - Right operand
+     * @returns {PrismaFilter} Prisma filter for the relation
      */
-    const resolveOperand = (operand) => {
-        if ("name" in operand && operand.name) {
-            return resolveFieldReference(operand.name, mapper);
+    const processRelationalOperator = (operator, left, right) => {
+        const prismaOperator = {
+            eq: "equals",
+            ne: "not",
+            lt: "lt",
+            le: "lte",
+            gt: "gt",
+            ge: "gte",
+        }[operator];
+        if (isResolvedFieldReference(left)) {
+            const { path, relations } = left;
+            if (!isResolvedValue(right)) {
+                throw new Error("Right operand must be a value");
+            }
+            if (!prismaOperator) {
+                throw new Error(`Unsupported operator: ${operator}`);
+            }
+            const filterValue = { [prismaOperator]: right.value };
+            const fieldFilter = { [path[path.length - 1]]: filterValue };
+            if (relations && relations.length > 0) {
+                return buildNestedRelationFilter(relations, fieldFilter);
+            }
+            return fieldFilter;
         }
-        else if ("value" in operand && operand.value !== undefined) {
-            return { value: operand.value };
+        if (!isResolvedValue(right)) {
+            throw new Error("Right operand must be a value");
         }
-        else if ("operator" in operand) {
-            // Nested expression resolution
-            const nestedResult = buildPrismaFilterFromCerbosExpression(operand, mapper);
-            return { value: nestedResult };
+        if (!prismaOperator) {
+            throw new Error(`Unsupported operator: ${operator}`);
         }
-        throw new Error("Operand must have name, value, or be an expression");
+        return { [prismaOperator]: right.value };
     };
-    // Process the operator type
+    // Process different operator types
     switch (operator) {
-        case "and": {
-            // Combine operands with logical AND
+        case "and":
             return {
                 AND: operands.map((operand) => buildPrismaFilterFromCerbosExpression(operand, mapper)),
             };
-        }
-        case "or": {
-            // Combine operands with logical OR
+        case "or":
             return {
                 OR: operands.map((operand) => buildPrismaFilterFromCerbosExpression(operand, mapper)),
             };
-        }
-        case "not": {
-            // Negate the operand filter
+        case "not":
             return {
                 NOT: buildPrismaFilterFromCerbosExpression(operands[0], mapper),
             };
-        }
         case "eq":
         case "ne":
         case "lt":
         case "le":
         case "gt":
         case "ge": {
-            // Relational operators: find left and right operands
-            const leftOperand = operands.find((o) => "name" in o || "operator" in o);
+            const leftOperand = operands.find((o) => isPlanExpressionWithName(o) || isPlanExpressionWithOperator(o));
             if (!leftOperand)
                 throw new Error("No valid left operand found");
             const rightOperand = operands.find((o) => o !== leftOperand);
             if (!rightOperand)
                 throw new Error("No valid right operand found");
-            const left = resolveOperand(leftOperand);
-            const right = resolveOperand(rightOperand);
-            const prismaOperator = {
-                eq: "equals",
-                ne: "not",
-                lt: "lt",
-                le: "lte",
-                gt: "gt",
-                ge: "gte",
-            }[operator];
-            if ("path" in left) {
-                const { path, relation } = left;
-                if (relation) {
-                    const relationOperator = getPrismaRelationOperator(relation);
-                    if (relation.field) {
-                        return {
-                            [relation.name]: {
-                                [relationOperator]: {
-                                    [relation.field]: { [prismaOperator]: right.value },
-                                },
-                            },
-                        };
-                    }
-                    return {
-                        [relation.name]: {
-                            [relationOperator]: { [prismaOperator]: right.value },
-                        },
-                    };
-                }
-                // Create nested filter for field path
-                return path.reduceRight((acc, key, index) => index === path.length - 1
-                    ? { [key]: { [prismaOperator]: right.value } }
-                    : { [key]: acc }, {});
-            }
-            return { [prismaOperator]: right.value };
+            const left = resolveOperand(leftOperand, mapper);
+            const right = resolveOperand(rightOperand, mapper);
+            return processRelationalOperator(operator, left, right);
         }
         case "in": {
-            // Inclusion operator for lists
-            const { path, relation } = resolveOperand(operands.find((o) => "name" in o));
-            const { value } = resolveOperand(operands.find((o) => "value" in o));
-            if (relation) {
-                const relationOperator = getPrismaRelationOperator(relation);
-                return {
-                    [relation.name]: { [relationOperator]: { [relation.field]: value } },
-                };
+            const nameOperand = operands.find(isPlanExpressionWithName);
+            if (!nameOperand)
+                throw new Error("Name operand is undefined");
+            const valueOperand = operands.find(isPlanExpressionWithValue);
+            if (!valueOperand)
+                throw new Error("Value operand is undefined");
+            const resolved = resolveOperand(nameOperand, mapper);
+            if (!isResolvedFieldReference(resolved))
+                throw new Error("Name operand must resolve to a field reference");
+            const { path, relations } = resolved;
+            const resolvedValue = resolveOperand(valueOperand, mapper);
+            if (!isResolvedValue(resolvedValue))
+                throw new Error("Value operand must resolve to a value");
+            const { value } = resolvedValue;
+            if (relations && relations.length > 0) {
+                const fieldFilter = { [path[path.length - 1]]: value };
+                return buildNestedRelationFilter(relations, fieldFilter);
             }
-            return path.reduceRight((acc, key, index) => index === path.length - 1 ? { [key]: { in: value } } : { [key]: acc }, {});
+            return { [path[path.length - 1]]: { in: value } };
         }
         case "contains":
         case "startsWith":
         case "endsWith": {
-            // String operators; ensure value is a string
-            const leftOperand = operands.find((o) => "name" in o);
-            if (!leftOperand)
-                throw new Error("No operand with 'name' found");
-            const rightOperand = operands.find((o) => "value" in o);
-            if (!rightOperand)
-                throw new Error("No operand with 'value' found");
-            const { path, relation } = resolveOperand(leftOperand);
-            const { value } = resolveOperand(rightOperand);
+            const nameOperand = operands.find(isPlanExpressionWithName);
+            if (!nameOperand)
+                throw new Error("Name operand is undefined");
+            const resolved = resolveOperand(nameOperand, mapper);
+            if (!isResolvedFieldReference(resolved))
+                throw new Error("Name operand must resolve to a field reference");
+            const { path, relations } = resolved;
+            const valueOperand = operands.find(isPlanExpressionWithValue);
+            if (!valueOperand)
+                throw new Error("Value operand is undefined");
+            const resolvedValue = resolveOperand(valueOperand, mapper);
+            if (!isResolvedValue(resolvedValue))
+                throw new Error("Value operand must resolve to a value");
+            const { value } = resolvedValue;
             if (typeof value !== "string")
                 throw new Error(`${operator} operator requires string value`);
-            if (relation) {
-                const relationOperator = getPrismaRelationOperator(relation);
-                return {
-                    [relation.name]: {
-                        [relationOperator]: { [relation.field]: { [operator]: value } },
-                    },
-                };
+            const fieldFilter = { [path[path.length - 1]]: { [operator]: value } };
+            if (relations && relations.length > 0) {
+                return buildNestedRelationFilter(relations, fieldFilter);
             }
-            return path.reduceRight((acc, key, index) => index === path.length - 1
-                ? { [key]: { [operator]: value } }
-                : { [key]: acc }, {});
+            return fieldFilter;
         }
         case "isSet": {
-            // Check if a field is set (not null) or unset (null)
-            const leftOperand = operands.find((o) => "name" in o);
-            if (!leftOperand)
-                throw new Error("No operand with 'name' found");
-            const rightOperand = operands.find((o) => "value" in o);
-            if (!rightOperand)
-                throw new Error("No operand with 'value' found");
-            const { path, relation } = resolveOperand(leftOperand);
-            const { value } = resolveOperand(rightOperand);
-            if (relation) {
-                const relationOperator = getPrismaRelationOperator(relation);
-                return {
-                    [relation.name]: {
-                        [relationOperator]: {
-                            [relation.field]: value ? { not: null } : { equals: null },
-                        },
-                    },
-                };
+            const nameOperand = operands.find(isPlanExpressionWithName);
+            if (!nameOperand)
+                throw new Error("Name operand is undefined");
+            const resolved = resolveOperand(nameOperand, mapper);
+            if (!isResolvedFieldReference(resolved))
+                throw new Error("Name operand must resolve to a field reference");
+            const { path, relations } = resolved;
+            const valueOperand = operands.find(isPlanExpressionWithValue);
+            if (!valueOperand)
+                throw new Error("Value operand is undefined");
+            const resolvedValue = resolveOperand(valueOperand, mapper);
+            const fieldFilter = {
+                [path[path.length - 1]]: resolvedValue
+                    ? { not: null }
+                    : { equals: null },
+            };
+            if (relations && relations.length > 0) {
+                return buildNestedRelationFilter(relations, fieldFilter);
             }
-            return path.reduceRight((acc, key, index) => index === path.length - 1
-                ? { [key]: value ? { not: null } : { equals: null } }
-                : { [key]: acc }, {});
+            return fieldFilter;
         }
         case "hasIntersection": {
-            // Ensure exactly two operands for intersection check
             if (operands.length !== 2)
                 throw new Error("hasIntersection requires exactly two operands");
             const [leftOperand, rightOperand] = operands;
-            // Handle map expressions as first operand
             if ("operator" in leftOperand && leftOperand.operator === "map") {
-                const mapResult = buildPrismaFilterFromCerbosExpression(leftOperand, mapper);
-                const relationKey = Object.keys(mapResult)[0];
-                const relation = mapResult[relationKey];
-                const selectKey = Object.keys(relation[Object.keys(relation)[0]].select)[0];
                 if (!("value" in rightOperand))
                     throw new Error("Second operand of hasIntersection must be a value");
-                return {
-                    [relationKey]: { some: { [selectKey]: { in: rightOperand.value } } },
-                };
+                const [collection, lambda] = leftOperand.operands;
+                if (!("name" in collection))
+                    throw new Error("First operand of map must be a collection reference");
+                // Get variable name from lambda
+                if (!isPlanExpressionWithOperator(lambda)) {
+                    throw new Error("Lambda expression must have operands");
+                }
+                const [, variable] = lambda.operands;
+                if (!("name" in variable))
+                    throw new Error("Lambda variable must have a name");
+                // Create scoped mapper for the collection
+                const scopedMapper = createScopedMapper(collection.name, variable.name, mapper);
+                const { relations } = resolveFieldReference(collection.name, mapper);
+                if (!relations || relations.length === 0)
+                    throw new Error("Map operation requires relations");
+                if (!("operands" in lambda))
+                    throw new Error("Invalid lambda expression structure");
+                const [projection] = lambda.operands;
+                if (!("name" in projection))
+                    throw new Error("Invalid map lambda expression structure");
+                // Use scoped mapper for resolving the projection
+                const resolved = resolveFieldReference(projection.name, scopedMapper);
+                const fieldName = resolved.path[resolved.path.length - 1];
+                return buildNestedRelationFilter(relations, {
+                    [fieldName]: { in: rightOperand.value },
+                });
             }
-            // Handle direct field reference
             if (!("name" in leftOperand))
                 throw new Error("First operand of hasIntersection must be a field reference or map expression");
             if (!("value" in rightOperand))
                 throw new Error("Second operand of hasIntersection must be a value");
-            const { path, relation } = resolveFieldReference(leftOperand.name, mapper);
+            const { path, relations } = resolveFieldReference(leftOperand.name, mapper);
             if (!Array.isArray(rightOperand.value))
                 throw new Error("hasIntersection requires an array value");
-            if (relation) {
-                return {
-                    [relation.name]: {
-                        some: { [relation.field]: { in: rightOperand.value } },
-                    },
+            if (relations && relations.length > 0) {
+                const fieldFilter = {
+                    [path[path.length - 1]]: { in: rightOperand.value },
                 };
+                return buildNestedRelationFilter(relations, fieldFilter);
             }
-            return path.reduceRight((acc, key, index) => index === path.length - 1
-                ? { [key]: { hasSome: rightOperand.value } }
-                : { [key]: acc }, {});
+            return { [path[path.length - 1]]: { some: rightOperand.value } };
         }
         case "lambda": {
-            // Handle lambda expressions by replacing variable prefix on keys
             const [condition, variable] = operands;
             if (!("name" in variable))
                 throw new Error("Lambda variable must have a name");
@@ -280,7 +394,6 @@ const buildPrismaFilterFromCerbosExpression = (expression, mapper) => {
         case "all":
         case "except":
         case "filter": {
-            // Operators applying conditions on collections via lambda expressions
             if (operands.length !== 2)
                 throw new Error(`${operator} requires exactly two operands`);
             const [collection, lambda] = operands;
@@ -288,34 +401,55 @@ const buildPrismaFilterFromCerbosExpression = (expression, mapper) => {
                 throw new Error("First operand of exists/all/except must be a collection reference");
             if (!("operator" in lambda))
                 throw new Error("Second operand of exists/all/except must be a lambda expression");
-            const { relation } = resolveFieldReference(collection.name, mapper);
-            if (!relation)
+            // Get variable name from lambda
+            const [, variable] = lambda.operands;
+            if (!("name" in variable))
+                throw new Error("Lambda variable must have a name");
+            // Create scoped mapper for the collection
+            const scopedMapper = createScopedMapper(collection.name, variable.name, mapper);
+            const { relations } = resolveFieldReference(collection.name, mapper);
+            if (!relations)
                 throw new Error(`${operator} operator requires a relation mapping`);
-            const lambdaCondition = buildPrismaFilterFromCerbosExpression(lambda, mapper);
+            const lambdaCondition = buildPrismaFilterFromCerbosExpression(lambda.operands[0], // Use the condition part of the lambda
+            scopedMapper);
+            const relation = relations[0];
+            let filterValue = lambdaCondition;
+            // If the lambda condition already has a relation structure, merge it
+            if (lambdaCondition.AND || lambdaCondition.OR) {
+                filterValue = lambdaCondition;
+            }
+            else {
+                const filterField = relation.field || Object.keys(lambdaCondition)[0];
+                filterValue = {
+                    [filterField]: lambdaCondition[Object.keys(lambdaCondition)[0]],
+                };
+            }
             switch (operator) {
                 case "exists":
-                    return { [relation.name]: { some: lambdaCondition } };
+                case "filter":
+                    return { [relation.name]: { some: filterValue } };
                 case "exists_one":
                     return {
-                        [relation.name]: { some: lambdaCondition },
+                        [relation.name]: {
+                            some: filterValue,
+                        },
                         AND: [
                             {
                                 [relation.name]: {
-                                    every: { OR: [lambdaCondition, { NOT: lambdaCondition }] },
+                                    every: {
+                                        OR: [filterValue, { NOT: filterValue }],
+                                    },
                                 },
                             },
                         ],
                     };
                 case "all":
-                    return { [relation.name]: { every: lambdaCondition } };
-                case "filter":
-                    return { [relation.name]: { some: lambdaCondition } };
+                    return { [relation.name]: { every: filterValue } };
                 default:
                     throw new Error(`Unexpected operator: ${operator}`);
             }
         }
         case "map": {
-            // Process map operator to project field values
             if (operands.length !== 2)
                 throw new Error("map requires exactly two operands");
             const [collection, lambda] = operands;
@@ -323,23 +457,61 @@ const buildPrismaFilterFromCerbosExpression = (expression, mapper) => {
                 throw new Error("First operand of map must be a collection reference");
             if (!("operator" in lambda) || lambda.operator !== "lambda")
                 throw new Error("Second operand of map must be a lambda expression");
-            const { relation } = resolveFieldReference(collection.name, mapper);
-            if (!relation)
-                throw new Error("map operator requires a relation mapping");
+            // Get variable name from lambda
             const [projection, variable] = lambda.operands;
             if (!("name" in projection) || !("name" in variable))
                 throw new Error("Invalid map lambda expression structure");
-            return {
-                [relation.name]: {
-                    [getPrismaRelationOperator(relation)]: {
-                        select: {
-                            [projection.name.replace(`${variable.name}.`, "")]: true,
-                        },
-                    },
+            // Create scoped mapper for the collection
+            const scopedMapper = createScopedMapper(collection.name, variable.name, mapper);
+            const { relations } = resolveFieldReference(collection.name, mapper);
+            if (!relations)
+                throw new Error("map operator requires a relation mapping");
+            // Use scoped mapper for resolving the projection
+            const resolved = resolveFieldReference(projection.name, scopedMapper);
+            const fieldName = resolved.path[resolved.path.length - 1];
+            return buildNestedRelationFilter(relations, {
+                [getPrismaRelationOperator(relations[relations.length - 1])]: {
+                    select: { [fieldName]: true },
                 },
-            };
+            });
         }
         default:
             throw new Error(`Unsupported operator: ${operator}`);
     }
 };
+/**
+ * Creates a scoped mapper for collection operations that preserves access to parent scope
+ * and handles nested collections
+ */
+const createScopedMapper = (collectionPath, variableName, fullMapper) => (key) => {
+    var _a, _b, _c;
+    // If the key starts with the variable name, it's accessing the collection item
+    if (key.startsWith(variableName + ".")) {
+        const strippedKey = key.replace(variableName + ".", "");
+        const parts = strippedKey.split(".");
+        // Get the collection's relation config
+        const collectionConfig = typeof fullMapper === "function"
+            ? fullMapper(collectionPath)
+            : fullMapper[collectionPath];
+        if ((_a = collectionConfig === null || collectionConfig === void 0 ? void 0 : collectionConfig.relation) === null || _a === void 0 ? void 0 : _a.fields) {
+            // For nested paths, traverse the fields configuration
+            let currentConfig = collectionConfig.relation.fields;
+            let field = parts[0];
+            for (let i = 0; i < parts.length - 1; i++) {
+                const part = parts[i];
+                if ((_c = (_b = currentConfig[part]) === null || _b === void 0 ? void 0 : _b.relation) === null || _c === void 0 ? void 0 : _c.fields) {
+                    currentConfig = currentConfig[part].relation.fields;
+                    field = parts[i + 1];
+                }
+                else {
+                    break;
+                }
+            }
+            // Return the field config if it exists, otherwise create a default one
+            return currentConfig[field] || { field };
+        }
+        return { field: strippedKey };
+    }
+    // For keys not referencing the collection item, use the full mapper
+    return typeof fullMapper === "function" ? fullMapper(key) : fullMapper[key];
+};