@cerbos/orm-prisma 2.0.0 → 3.0.1

package/lib/index.js

@@ -1,19 +1,59 @@
-import { PlanKind, } from "@cerbos/core";
-export { PlanKind };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanKind = void 0;
+exports.queryPlanToPrisma = queryPlanToPrisma;
+const core_1 = require("@cerbos/core");
+Object.defineProperty(exports, "PlanKind", { enumerable: true, get: function () { return core_1.PlanKind; } });
+function isNamedOperand(operand) {
+    return "name" in operand && typeof operand.name === "string";
+}
+function isValueOperand(operand) {
+    return "value" in operand && operand.value !== undefined;
+}
+function isOperatorOperand(operand) {
+    return ("operator" in operand &&
+        typeof operand.operator === "string" &&
+        "operands" in operand &&
+        Array.isArray(operand.operands));
+}
+function assertDefined(value, message) {
+    if (value === undefined) {
+        throw new Error(message);
+    }
+    return value;
+}
+function getLeafField(path) {
+    const fieldName = path[path.length - 1];
+    if (!fieldName) {
+        throw new Error("Field path cannot be empty");
+    }
+    return fieldName;
+}
+function getFilterEntry(filter) {
+    const entry = Object.entries(filter)[0];
+    if (!entry) {
+        throw new Error("Filter must contain at least one entry");
+    }
+    return entry;
+}
+function isResolvedFieldReference(operand) {
+    return "path" in operand;
+}
+function isResolvedValue(operand) {
+    return "value" in operand;
+}
 /**
  * Converts a Cerbos query plan to a Prisma filter.
- * @param {QueryPlanToPrismaArgs} args - The arguments containing the query plan and mapper.
- * @returns {QueryPlanToPrismaResult} The result containing the kind and filters.
  */
-export function queryPlanToPrisma({ queryPlan, mapper = {}, }) {
+function queryPlanToPrisma({ queryPlan, mapper = {}, }) {
     switch (queryPlan.kind) {
-        case PlanKind.ALWAYS_ALLOWED:
-            return { kind: PlanKind.ALWAYS_ALLOWED };
-        case PlanKind.ALWAYS_DENIED:
-            return { kind: PlanKind.ALWAYS_DENIED };
-        case PlanKind.CONDITIONAL:
+        case 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:
             return {
-                kind: PlanKind.CONDITIONAL,
+                kind: core_1.PlanKind.CONDITIONAL,
                 filters: buildPrismaFilterFromCerbosExpression(queryPlan.condition, mapper),
             };
         default:
@@ -22,17 +62,13 @@ export function queryPlanToPrisma({ queryPlan, mapper = {}, }) {
 }
 /**
  * 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) => {
+function resolveFieldReference(reference, mapper) {
     const parts = reference.split(".");
     const config = typeof mapper === "function" ? mapper(reference) : mapper[reference];
     let matchedPrefix = "";
     let matchedConfig;
+    // If no direct match, look for partial matches
     if (!config) {
         for (let i = parts.length - 1; i >= 0; i--) {
             const prefix = parts.slice(0, i + 1).join(".");
@@ -44,8 +80,9 @@ const resolveFieldReference = (reference, mapper) => {
             }
         }
     }
-    const activeConfig = config || matchedConfig;
-    if (activeConfig === null || activeConfig === void 0 ? void 0 : activeConfig.relation) {
+    const activeConfig = config ?? matchedConfig;
+    // Handle relation mapping
+    if (activeConfig?.relation) {
         const { name, type, fields } = activeConfig.relation;
         const matchedParts = matchedPrefix ? matchedPrefix.split(".") : [];
         const remainingParts = matchedPrefix
@@ -53,14 +90,27 @@ const resolveFieldReference = (reference, mapper) => {
             : parts.slice(1);
         let field;
         const relations = [
-            { name, type, field: activeConfig.relation.field, nestedMapper: fields },
+            {
+                name,
+                type,
+                field: activeConfig.relation.field,
+                nestedMapper: fields,
+            },
         ];
+        // Process nested relations
         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) {
+                if (!currentMapper) {
+                    break;
+                }
+                const currentPart = currentParts[0];
+                if (!currentPart) {
+                    break;
+                }
+                const nextConfig = currentMapper[currentPart];
+                if (nextConfig?.relation) {
                     relations.push({
                         name: nextConfig.relation.name,
                         type: nextConfig.relation.type,
@@ -71,167 +121,130 @@ const resolveFieldReference = (reference, mapper) => {
                     currentParts = currentParts.slice(1);
                 }
                 else {
-                    field = (nextConfig === null || nextConfig === void 0 ? void 0 : nextConfig.field) || currentParts[currentParts.length - 1];
+                    const lastPart = currentParts[currentParts.length - 1];
+                    if (!lastPart) {
+                        break;
+                    }
+                    field = nextConfig?.field || lastPart;
                     break;
                 }
             }
         }
         return { path: field ? [field] : remainingParts, relations };
     }
-    return { path: [(activeConfig === null || activeConfig === void 0 ? void 0 : activeConfig.field) || reference] };
-};
+    // Simple field mapping
+    return { path: [activeConfig?.field || reference] };
+}
 /**
  * Determines the appropriate Prisma operator based on relation type.
- * 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");
+function getPrismaRelationOperator(relation) {
+    return relation.type === "one" ? "is" : "some";
+}
 /**
  * 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) => {
+function buildNestedRelationFilter(relations, fieldFilter) {
     if (relations.length === 0)
         return fieldFilter;
     let currentFilter = fieldFilter;
+    // Build nested structure from inside out
     for (let i = relations.length - 1; i >= 0; i--) {
         const relation = relations[i];
+        if (!relation) {
+            throw new Error("Relation mapping is missing");
+        }
         const relationOperator = getPrismaRelationOperator(relation);
+        // Handle special case for the deepest relation
         if (relation.field && i === relations.length - 1) {
-            const [, filterValue] = Object.entries(currentFilter)[0];
-            currentFilter = { [relation.field]: filterValue };
+            const [key, filterValue] = getFilterEntry(currentFilter);
+            if (key === "NOT") {
+                currentFilter = { NOT: { [relation.field]: filterValue } };
+            }
+            else {
+                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)) {
+function resolveOperand(operand, mapper) {
+    if (isNamedOperand(operand)) {
         return resolveFieldReference(operand.name, mapper);
     }
-    else if (isPlanExpressionWithValue(operand)) {
+    else if (isValueOperand(operand)) {
         return { value: operand.value };
     }
-    else if (isPlanExpressionWithOperator(operand)) {
+    else if (isOperatorOperand(operand)) {
         const nestedResult = buildPrismaFilterFromCerbosExpression(operand, mapper);
         return { value: nestedResult };
     }
     throw new Error("Operand must have name, value, or be an expression");
-};
+}
+/**
+ * Creates a scoped mapper for collection operations
+ */
+function createScopedMapper(collectionPath, variableName, fullMapper) {
+    return (key) => {
+        // 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 (collectionConfig?.relation?.fields) {
+                // For nested paths, traverse the fields configuration
+                const baseConfig = collectionConfig.relation.fields;
+                if (!baseConfig) {
+                    return { field: strippedKey };
+                }
+                let currentConfig = baseConfig;
+                let field = parts[0] || strippedKey;
+                for (let i = 0; i < parts.length - 1; i++) {
+                    const part = parts[i];
+                    const nextPart = parts[i + 1];
+                    if (!part || !nextPart) {
+                        break;
+                    }
+                    const nextConfig = currentConfig[part];
+                    if (nextConfig?.relation?.fields) {
+                        currentConfig = nextConfig.relation.fields;
+                        field = nextPart;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (!field) {
+                    field = strippedKey;
+                }
+                // 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
+        if (typeof fullMapper === "function") {
+            return fullMapper(key);
+        }
+        return fullMapper[key] || { field: key };
+    };
+}
 /**
  * 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) => {
+function buildPrismaFilterFromCerbosExpression(expression, mapper) {
     // Validate expression structure
-    if (!("operator" in expression) || !("operands" in expression)) {
+    if (!isOperatorOperand(expression)) {
         throw new Error("Invalid Cerbos expression structure");
     }
     const { operator, operands } = expression;
-    /**
-     * 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 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;
-        }
-        if (!isResolvedValue(right)) {
-            throw new Error("Right operand must be a value");
-        }
-        if (!prismaOperator) {
-            throw new Error(`Unsupported operator: ${operator}`);
-        }
-        return { [prismaOperator]: right.value };
-    };
     // Process different operator types
     switch (operator) {
         case "and":
@@ -242,272 +255,375 @@ const buildPrismaFilterFromCerbosExpression = (expression, mapper) => {
             return {
                 OR: operands.map((operand) => buildPrismaFilterFromCerbosExpression(operand, mapper)),
             };
-        case "not":
+        case "not": {
+            const operand = operands[0];
+            if (!operand) {
+                throw new Error("not operator requires an operand");
+            }
             return {
-                NOT: buildPrismaFilterFromCerbosExpression(operands[0], mapper),
+                NOT: buildPrismaFilterFromCerbosExpression(operand, mapper),
             };
+        }
         case "eq":
         case "ne":
         case "lt":
         case "le":
         case "gt":
         case "ge": {
-            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, mapper);
-            const right = resolveOperand(rightOperand, mapper);
-            return processRelationalOperator(operator, left, right);
+            return handleRelationalOperator(operator, operands, mapper);
         }
         case "in": {
-            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[path.length - 1]]: { in: value } };
+            return handleInOperator(operands, mapper);
         }
         case "contains":
         case "startsWith":
         case "endsWith": {
-            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`);
-            const fieldFilter = { [path[path.length - 1]]: { [operator]: value } };
-            if (relations && relations.length > 0) {
-                return buildNestedRelationFilter(relations, fieldFilter);
-            }
-            return fieldFilter;
+            return handleStringOperator(operator, operands, mapper);
         }
         case "isSet": {
-            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 fieldFilter;
+            return handleIsSetOperator(operands, mapper);
         }
         case "hasIntersection": {
-            if (operands.length !== 2)
-                throw new Error("hasIntersection requires exactly two operands");
-            const [leftOperand, rightOperand] = operands;
-            if ("operator" in leftOperand && leftOperand.operator === "map") {
-                if (!("value" in rightOperand))
-                    throw new Error("Second operand of hasIntersection must be a 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 },
-                });
-            }
-            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, relations } = resolveFieldReference(leftOperand.name, mapper);
-            if (!Array.isArray(rightOperand.value))
-                throw new Error("hasIntersection requires an array value");
-            if (relations && relations.length > 0) {
-                const fieldFilter = {
-                    [path[path.length - 1]]: { in: rightOperand.value },
-                };
-                return buildNestedRelationFilter(relations, fieldFilter);
-            }
-            return { [path[path.length - 1]]: { some: rightOperand.value } };
+            return handleHasIntersectionOperator(operands, mapper);
         }
         case "lambda": {
-            const [condition, variable] = operands;
-            if (!("name" in variable))
-                throw new Error("Lambda variable must have a name");
-            return buildPrismaFilterFromCerbosExpression(condition, (key) => ({ field: key.replace(`${variable.name}.`, "") }));
+            return handleLambdaOperator(operands);
         }
         case "exists":
         case "exists_one":
         case "all":
         case "except":
         case "filter": {
-            if (operands.length !== 2)
-                throw new Error(`${operator} requires exactly two operands`);
-            const [collection, lambda] = operands;
-            if (!("name" in collection))
-                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");
-            // 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.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":
-                case "filter":
-                    return { [relation.name]: { some: filterValue } };
-                case "exists_one":
-                    return {
-                        [relation.name]: {
-                            some: filterValue,
-                        },
-                        AND: [
-                            {
-                                [relation.name]: {
-                                    every: {
-                                        OR: [filterValue, { NOT: filterValue }],
-                                    },
-                                },
-                            },
-                        ],
-                    };
-                case "all":
-                    return { [relation.name]: { every: filterValue } };
-                default:
-                    throw new Error(`Unexpected operator: ${operator}`);
-            }
+            return handleCollectionOperator(operator, operands, mapper);
         }
         case "map": {
-            if (operands.length !== 2)
-                throw new Error("map requires exactly two operands");
-            const [collection, lambda] = operands;
-            if (!("name" in collection))
-                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");
-            // 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");
-            // 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 },
-                },
-            });
+            return handleMapOperator(operands, mapper);
         }
         default:
             throw new Error(`Unsupported operator: ${operator}`);
     }
-};
+}
 /**
- * Creates a scoped mapper for collection operations that preserves access to parent scope
- * and handles nested collections
+ * Helper function to process relational operators (eq, ne, lt, etc.)
  */
-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 };
+function handleRelationalOperator(operator, operands, mapper) {
+    const prismaOperator = {
+        eq: "equals",
+        ne: "not",
+        lt: "lt",
+        le: "lte",
+        gt: "gt",
+        ge: "gte",
+    }[operator];
+    if (!prismaOperator) {
+        throw new Error(`Unsupported operator: ${operator}`);
+    }
+    const leftOperand = operands.find((o) => isNamedOperand(o) || isOperatorOperand(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, mapper);
+    const right = resolveOperand(rightOperand, mapper);
+    if (isResolvedFieldReference(left)) {
+        const { path, relations } = left;
+        if (!isResolvedValue(right)) {
+            throw new Error("Right operand must be a value");
+        }
+        const filterValue = { [prismaOperator]: right.value };
+        const fieldName = getLeafField(path);
+        const fieldFilter = { [fieldName]: filterValue };
+        if (relations && relations.length > 0) {
+            return buildNestedRelationFilter(relations, fieldFilter);
         }
-        return { field: strippedKey };
+        return fieldFilter;
     }
-    // For keys not referencing the collection item, use the full mapper
-    return typeof fullMapper === "function" ? fullMapper(key) : fullMapper[key];
-};
+    if (!isResolvedValue(right)) {
+        throw new Error("Right operand must be a value");
+    }
+    return { [prismaOperator]: right.value };
+}
+/**
+ * Helper function to handle "in" operator
+ */
+function handleInOperator(operands, mapper) {
+    const nameOperand = operands.find(isNamedOperand);
+    if (!nameOperand)
+        throw new Error("Name operand is undefined");
+    const valueOperand = operands.find(isValueOperand);
+    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;
+    const values = Array.isArray(value) ? value : [value];
+    const fieldName = getLeafField(path);
+    if (relations && relations.length > 0) {
+        const fieldFilter = values.length === 1
+            ? { [fieldName]: values[0] }
+            : { [fieldName]: { in: values } };
+        return buildNestedRelationFilter(relations, fieldFilter);
+    }
+    return values.length === 1
+        ? { [fieldName]: values[0] }
+        : { [fieldName]: { in: values } };
+}
+/**
+ * Helper function to handle string operators (contains, startsWith, endsWith)
+ */
+function handleStringOperator(operator, operands, mapper) {
+    const nameOperand = operands.find(isNamedOperand);
+    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(isValueOperand);
+    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`);
+    }
+    const fieldName = getLeafField(path);
+    const fieldFilter = { [fieldName]: { [operator]: value } };
+    if (relations && relations.length > 0) {
+        return buildNestedRelationFilter(relations, fieldFilter);
+    }
+    return fieldFilter;
+}
+/**
+ * Helper function to handle "isSet" operator
+ */
+function handleIsSetOperator(operands, mapper) {
+    const nameOperand = operands.find(isNamedOperand);
+    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(isValueOperand);
+    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 fieldName = getLeafField(path);
+    const fieldFilter = {
+        [fieldName]: resolvedValue.value ? { not: null } : { equals: null },
+    };
+    if (relations && relations.length > 0) {
+        return buildNestedRelationFilter(relations, fieldFilter);
+    }
+    return fieldFilter;
+}
+/**
+ * Helper function to handle "hasIntersection" operator
+ */
+function handleHasIntersectionOperator(operands, mapper) {
+    if (operands.length !== 2) {
+        throw new Error("hasIntersection requires exactly two operands");
+    }
+    const leftOperand = assertDefined(operands[0], "hasIntersection requires a left operand");
+    const rightOperand = assertDefined(operands[1], "hasIntersection requires a right operand");
+    // Check if left operand is a map operation
+    if (isOperatorOperand(leftOperand) && leftOperand.operator === "map") {
+        if (!isValueOperand(rightOperand)) {
+            throw new Error("Second operand of hasIntersection must be a value");
+        }
+        const collection = assertDefined(leftOperand.operands[0], "Map expression must include a collection reference");
+        const lambda = assertDefined(leftOperand.operands[1], "Map expression must include a lambda expression");
+        if (!isNamedOperand(collection)) {
+            throw new Error("First operand of map must be a collection reference");
+        }
+        // Get variable name from lambda
+        if (!isOperatorOperand(lambda)) {
+            throw new Error("Lambda expression must have operands");
+        }
+        const variable = assertDefined(lambda.operands[1], "Lambda variable must have a name");
+        if (!isNamedOperand(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");
+        }
+        const projection = assertDefined(lambda.operands[0], "Invalid map lambda expression structure");
+        if (!isNamedOperand(projection)) {
+            throw new Error("Invalid map lambda expression structure");
+        }
+        // Use scoped mapper for resolving the projection
+        const resolved = resolveFieldReference(projection.name, scopedMapper);
+        const fieldName = getLeafField(resolved.path);
+        return buildNestedRelationFilter(relations, {
+            [fieldName]: { in: rightOperand.value },
+        });
+    }
+    // Handle regular field reference
+    if (!isNamedOperand(leftOperand)) {
+        throw new Error("First operand of hasIntersection must be a field reference or map expression");
+    }
+    if (!isValueOperand(rightOperand)) {
+        throw new Error("Second operand of hasIntersection must be a value");
+    }
+    const { path, relations } = resolveFieldReference(leftOperand.name, mapper);
+    if (!Array.isArray(rightOperand.value)) {
+        throw new Error("hasIntersection requires an array value");
+    }
+    if (relations && relations.length > 0) {
+        const fieldName = getLeafField(path);
+        const fieldFilter = {
+            [fieldName]: { in: rightOperand.value },
+        };
+        return buildNestedRelationFilter(relations, fieldFilter);
+    }
+    const fieldName = getLeafField(path);
+    return { [fieldName]: { some: rightOperand.value } };
+}
+/**
+ * Helper function to handle "lambda" operator
+ */
+function handleLambdaOperator(operands) {
+    const condition = assertDefined(operands[0], "Lambda requires a condition operand");
+    const variable = assertDefined(operands[1], "Lambda requires a variable operand");
+    if (!isNamedOperand(variable)) {
+        throw new Error("Lambda variable must have a name");
+    }
+    return buildPrismaFilterFromCerbosExpression(condition, (key) => ({
+        field: key.replace(`${variable.name}.`, ""),
+    }));
+}
+/**
+ * Helper function to handle collection operators (exists, all, except, filter)
+ */
+function handleCollectionOperator(operator, operands, mapper) {
+    if (operands.length !== 2) {
+        throw new Error(`${operator} requires exactly two operands`);
+    }
+    const collection = assertDefined(operands[0], `${operator} requires a collection operand`);
+    const lambda = assertDefined(operands[1], `${operator} requires a lambda operand`);
+    if (!isNamedOperand(collection)) {
+        throw new Error(`First operand of ${operator} must be a collection reference`);
+    }
+    if (!isOperatorOperand(lambda)) {
+        throw new Error(`Second operand of ${operator} must be a lambda expression`);
+    }
+    // Get variable name from lambda
+    const variable = assertDefined(lambda.operands[1], "Lambda variable must have a name");
+    if (!isNamedOperand(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(`${operator} operator requires a relation mapping`);
+    }
+    const lambdaConditionOperand = assertDefined(lambda.operands[0], "Lambda expression must provide a condition");
+    const lambdaCondition = buildPrismaFilterFromCerbosExpression(lambdaConditionOperand, // Use the condition part of the lambda
+    scopedMapper);
+    const relation = assertDefined(relations[0], `${operator} operator requires a relation mapping`);
+    let filterValue = lambdaCondition;
+    // If the lambda condition already has a relation structure, merge it
+    if (lambdaCondition["AND"] || lambdaCondition["OR"]) {
+        filterValue = lambdaCondition;
+    }
+    else {
+        const lambdaKeys = Object.keys(lambdaCondition);
+        const defaultKey = lambdaKeys[0];
+        if (!defaultKey) {
+            throw new Error("Lambda condition must have at least one field");
+        }
+        const lambdaFieldValue = lambdaCondition[defaultKey];
+        if (lambdaFieldValue === undefined) {
+            throw new Error("Lambda condition field value cannot be undefined");
+        }
+        const filterField = relation.field || defaultKey;
+        filterValue = {
+            [filterField]: lambdaFieldValue,
+        };
+    }
+    switch (operator) {
+        case "exists":
+        case "filter":
+            return { [relation.name]: { some: filterValue } };
+        case "except":
+            return { [relation.name]: { some: { NOT: filterValue } } };
+        case "exists_one":
+            return {
+                [relation.name]: {
+                    some: filterValue,
+                },
+                AND: [
+                    {
+                        [relation.name]: {
+                            every: {
+                                OR: [filterValue, { NOT: filterValue }],
+                            },
+                        },
+                    },
+                ],
+            };
+        case "all":
+            return { [relation.name]: { every: filterValue } };
+        default:
+            throw new Error(`Unexpected operator: ${operator}`);
+    }
+}
+/**
+ * Helper function to handle "map" operator
+ */
+function handleMapOperator(operands, mapper) {
+    if (operands.length !== 2) {
+        throw new Error("map requires exactly two operands");
+    }
+    const collection = assertDefined(operands[0], "map requires a collection operand");
+    const lambda = assertDefined(operands[1], "map requires a lambda operand");
+    if (!isNamedOperand(collection)) {
+        throw new Error("First operand of map must be a collection reference");
+    }
+    if (!isOperatorOperand(lambda) || lambda.operator !== "lambda") {
+        throw new Error("Second operand of map must be a lambda expression");
+    }
+    // Get variable name from lambda
+    const projection = assertDefined(lambda.operands[0], "Map lambda expression must provide a projection");
+    const variable = assertDefined(lambda.operands[1], "Map lambda expression must provide a variable");
+    if (!isNamedOperand(projection) || !isNamedOperand(variable)) {
+        throw new Error("Invalid map lambda expression structure");
+    }
+    // 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 operator requires a relation mapping");
+    }
+    // Use scoped mapper for resolving the projection
+    const resolved = resolveFieldReference(projection.name, scopedMapper);
+    const fieldName = getLeafField(resolved.path);
+    const lastRelation = assertDefined(relations[relations.length - 1], "Relation mapping must contain at least one relation");
+    return buildNestedRelationFilter(relations, {
+        [getPrismaRelationOperator(lastRelation)]: {
+            select: { [fieldName]: true },
+        },
+    });
+}
+//# sourceMappingURL=index.js.map