@cerbos/orm-prisma 2.0.1 → 3.0.1

package/lib/index.test.js

@@ -0,0 +1,4093 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const globals_1 = require("@jest/globals");
+const client_1 = require("@prisma/client");
+const grpc_1 = require("@cerbos/grpc");
+const prisma = new client_1.PrismaClient();
+const cerbos = new grpc_1.GRPC("127.0.0.1:3593", { tls: false });
+function createConditionalPlan(condition) {
+    return {
+        kind: _1.PlanKind.CONDITIONAL,
+        condition,
+        cerbosCallId: "",
+        requestId: "",
+        validationErrors: [],
+        metadata: undefined,
+    };
+}
+function getExpressionOperand(expression, index) {
+    const operand = expression.operands[index];
+    if (!operand) {
+        throw new Error(`Missing operand at index ${index}`);
+    }
+    return operand;
+}
+const fixtureUsers = [
+    {
+        id: "user1",
+        aBool: true,
+        aNumber: 1,
+        aString: "string",
+    },
+    {
+        id: "user2",
+        aBool: true,
+        aNumber: 2,
+        aString: "string",
+    },
+];
+const fixtureNextLevelResources = [
+    {
+        id: "nextLevel1",
+        aBool: true,
+        aNumber: 1,
+        aString: "string",
+    },
+    {
+        id: "nextLevel2",
+        aBool: false,
+        aNumber: 1,
+        aString: "string",
+    },
+    {
+        id: "nextLevel3",
+        aBool: true,
+        aNumber: 1,
+        aString: "string",
+    },
+];
+const fixtureTags = [
+    {
+        id: "tag1",
+        name: "public",
+    },
+    {
+        id: "tag2",
+        name: "private",
+    },
+    {
+        id: "tag3",
+        name: "draft",
+    },
+];
+const fixtureNestedResources = [
+    {
+        id: "nested1",
+        aBool: true,
+        aNumber: 1,
+        aString: "string",
+        nextlevel: {
+            connect: {
+                id: "nextLevel1",
+            },
+        },
+    },
+    {
+        id: "nested2",
+        aBool: false,
+        aNumber: 1,
+        aString: "string",
+        nextlevel: {
+            connect: {
+                id: "nextLevel2",
+            },
+        },
+    },
+    {
+        id: "nested3",
+        aBool: true,
+        aNumber: 1,
+        aString: "string",
+        nextlevel: {
+            connect: {
+                id: "nextLevel3",
+            },
+        },
+    },
+];
+const fixtureLabels = [
+    { id: "label1", name: "important" },
+    { id: "label2", name: "archived" },
+    { id: "label3", name: "flagged" },
+];
+const fixtureSubCategories = [
+    {
+        id: "sub1",
+        name: "finance",
+        labels: {
+            connect: [{ id: "label1" }, { id: "label2" }],
+        },
+    },
+    {
+        id: "sub2",
+        name: "tech",
+        labels: {
+            connect: [{ id: "label2" }, { id: "label3" }],
+        },
+    },
+];
+const fixtureCategories = [
+    {
+        id: "cat1",
+        name: "business",
+        subCategories: {
+            connect: [{ id: "sub1" }],
+        },
+    },
+    {
+        id: "cat2",
+        name: "development",
+        subCategories: {
+            connect: [{ id: "sub2" }],
+        },
+    },
+];
+const fixtureResources = [
+    {
+        id: "resource1",
+        aBool: true,
+        aNumber: 1,
+        aString: "string",
+        aOptionalString: "optionalString",
+        createdBy: {
+            connect: {
+                id: "user1",
+            },
+        },
+        ownedBy: {
+            connect: [
+                {
+                    id: "user1",
+                },
+            ],
+        },
+        nested: {
+            connect: {
+                id: "nested1",
+            },
+        },
+        tags: {
+            connect: [
+                { id: "tag1" }, // public
+            ],
+        },
+        categories: {
+            connect: [{ id: "cat1" }],
+        },
+    },
+    {
+        id: "resource2",
+        aBool: false,
+        aNumber: 2,
+        aString: "string2",
+        createdBy: {
+            connect: {
+                id: "user2",
+            },
+        },
+        ownedBy: {
+            connect: [
+                {
+                    id: "user2",
+                },
+            ],
+        },
+        nested: {
+            connect: {
+                id: "nested3",
+            },
+        },
+        tags: {
+            connect: [
+                { id: "tag2" }, // private
+            ],
+        },
+        categories: {
+            connect: [{ id: "cat2" }],
+        },
+    },
+    {
+        id: "resource3",
+        aBool: false,
+        aNumber: 3,
+        aString: "string3",
+        createdBy: {
+            connect: {
+                id: "user1",
+            },
+        },
+        ownedBy: {
+            connect: [
+                {
+                    id: "user1",
+                },
+                {
+                    id: "user2",
+                },
+            ],
+        },
+        nested: {
+            connect: {
+                id: "nested3",
+            },
+        },
+        tags: {
+            connect: [
+                { id: "tag1" }, // public
+                { id: "tag3" }, // draft
+            ],
+        },
+        categories: {
+            connect: [{ id: "cat1" }, { id: "cat2" }],
+        },
+    },
+];
+(0, globals_1.beforeAll)(async () => {
+    await prisma.resource.deleteMany();
+    await prisma.nextLevelNestedResource.deleteMany();
+    await prisma.nestedResource.deleteMany();
+    await prisma.tag.deleteMany();
+    await prisma.user.deleteMany();
+});
+(0, globals_1.beforeEach)(async () => {
+    for (const tag of fixtureTags) {
+        await prisma.tag.create({ data: tag });
+    }
+    for (const user of fixtureUsers) {
+        await prisma.user.create({ data: user });
+    }
+    for (const resource of fixtureNextLevelResources) {
+        await prisma.nextLevelNestedResource.create({ data: resource });
+    }
+    for (const resource of fixtureNestedResources) {
+        await prisma.nestedResource.create({ data: resource });
+    }
+    for (const label of fixtureLabels) {
+        await prisma.label.create({ data: label });
+    }
+    for (const subCategory of fixtureSubCategories) {
+        await prisma.subCategory.create({ data: subCategory });
+    }
+    for (const category of fixtureCategories) {
+        await prisma.category.create({ data: category });
+    }
+    for (const resource of fixtureResources) {
+        await prisma.resource.create({ data: resource });
+    }
+});
+(0, globals_1.afterEach)(async () => {
+    await prisma.resource.deleteMany();
+    await prisma.nestedResource.deleteMany();
+    await prisma.nextLevelNestedResource.deleteMany();
+    await prisma.tag.deleteMany();
+    await prisma.user.deleteMany();
+    await prisma.category.deleteMany();
+    await prisma.subCategory.deleteMany();
+    await prisma.label.deleteMany();
+});
+// Core Functionality
+(0, globals_1.describe)("Basic Plan Types", () => {
+    (0, globals_1.test)("always allowed", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "always-allow",
+        });
+        (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.ALWAYS_ALLOWED);
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.ALWAYS_ALLOWED,
+        });
+        const query = await prisma.resource.findMany({});
+        (0, globals_1.expect)(query.length).toEqual(fixtureResources.length);
+    });
+    (0, globals_1.test)("always denied", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "always-deny",
+        });
+        (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.ALWAYS_DENIED);
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {},
+        });
+        (0, globals_1.expect)(result).toEqual({
+            kind: _1.PlanKind.ALWAYS_DENIED,
+        });
+    });
+});
+// Field Operations
+(0, globals_1.describe)("Field Operations", () => {
+    (0, globals_1.describe)("Basic Field Tests", () => {
+        (0, globals_1.test)("conditional - eq", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "equal",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "eq",
+                operands: [{ name: "request.resource.attr.aBool" }, { value: true }],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aBool": { field: "aBool" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aBool: { equals: true } },
+            });
+            const query = await prisma.resource.findMany({
+                where: result.kind === _1.PlanKind.CONDITIONAL ? { ...result.filters } : {},
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources.filter((a) => a.aBool).map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - eq - inverted order", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "equal",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "eq",
+                operands: [{ name: "request.resource.attr.aBool" }, { value: true }],
+            });
+            const typeQp = queryPlan;
+            const invertedQueryPlan = {
+                ...typeQp,
+                condition: {
+                    ...typeQp.condition,
+                    operands: [
+                        getExpressionOperand(typeQp.condition, 1),
+                        getExpressionOperand(typeQp.condition, 0),
+                    ],
+                },
+            };
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan: invertedQueryPlan,
+                mapper: {
+                    "request.resource.attr.aBool": { field: "aBool" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aBool: { equals: true } },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources.filter((a) => a.aBool).map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - ne", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "ne",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "ne",
+                operands: [
+                    { name: "request.resource.attr.aString" },
+                    { value: "string" },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aString: { not: "string" } },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources.filter((a) => a.aString != "string").map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - explicit-deny", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "explicit-deny",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "not",
+                operands: [
+                    {
+                        operator: "eq",
+                        operands: [
+                            { name: "request.resource.attr.aBool" },
+                            { value: true },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aBool": { field: "aBool" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { NOT: { aBool: { equals: true } } },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources.filter((a) => !a.aBool).map((r) => r.id));
+        });
+    });
+    (0, globals_1.describe)("Comparison Tests", () => {
+        (0, globals_1.test)("conditional - gt", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "gt",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "gt",
+                operands: [{ name: "request.resource.attr.aNumber" }, { value: 1 }],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aNumber": { field: "aNumber" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    aNumber: { gt: 1 },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                return r.aNumber > 1;
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - lt", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "lt",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "lt",
+                operands: [{ name: "request.resource.attr.aNumber" }, { value: 2 }],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aNumber": { field: "aNumber" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    aNumber: { lt: 2 },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                return r.aNumber < 2;
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - gte", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "gte",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "ge",
+                operands: [{ name: "request.resource.attr.aNumber" }, { value: 1 }],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aNumber": { field: "aNumber" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    aNumber: { gte: 1 },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                return r.aNumber >= 1;
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - lte", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "lte",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "le",
+                operands: [{ name: "request.resource.attr.aNumber" }, { value: 2 }],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aNumber": { field: "aNumber" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    aNumber: { lte: 2 },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                return r.aNumber <= 2;
+            })
+                .map((r) => r.id));
+        });
+    });
+    (0, globals_1.describe)("String Tests", () => {
+        (0, globals_1.test)("conditional - contains", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "contains",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operands: [
+                    {
+                        name: "request.resource.attr.aString",
+                    },
+                    {
+                        value: "str",
+                    },
+                ],
+                operator: "contains",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aString: { contains: "str" } },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => a.aString.includes("str"))
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - startsWith", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "starts-with",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operands: [
+                    {
+                        name: "request.resource.attr.aString",
+                    },
+                    {
+                        value: "str",
+                    },
+                ],
+                operator: "startsWith",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aString: { startsWith: "str" } },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => a.aString.startsWith("str"))
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - endsWith", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "ends-with",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operands: [
+                    {
+                        name: "request.resource.attr.aString",
+                    },
+                    {
+                        value: "ing",
+                    },
+                ],
+                operator: "endsWith",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aString: { endsWith: "ing" } },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => a.aString.endsWith("ing"))
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - isSet", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "is-set",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operands: [
+                    {
+                        name: "request.resource.attr.aOptionalString",
+                    },
+                    {
+                        value: null,
+                    },
+                ],
+                operator: "ne",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aOptionalString": { field: "aOptionalString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aOptionalString: { not: null } },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources.filter((a) => a.aOptionalString).map((r) => r.id));
+        });
+    });
+});
+// Collection Operations
+(0, globals_1.describe)("Collection Operations", () => {
+    (0, globals_1.describe)("Basic Collections", () => {
+        (0, globals_1.test)("conditional - in", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "in",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "in",
+                operands: [
+                    { name: "request.resource.attr.aString" },
+                    { value: ["string", "anotherString"] },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    aString: { in: ["string", "anotherString"] },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                return ["string", "anotherString"].includes(r.aString);
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - in - scalar value", async () => {
+            const queryPlan = createConditionalPlan({
+                operator: "in",
+                operands: [
+                    { name: "request.resource.attr.aString" },
+                    { value: "string" },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: { aString: "string" },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(fixtureResources
+                .filter((r) => r.aString === "string")
+                .map((r) => r.id)
+                .sort());
+        });
+        (0, globals_1.test)("conditional - relation in", async () => {
+            const queryPlan = createConditionalPlan({
+                operator: "in",
+                operands: [
+                    { name: "request.resource.attr.categories.name" },
+                    { value: ["business"] },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                name: { field: "name" },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            name: "business",
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(fixtureResources
+                .filter((resource) => {
+                const categoryRefs = resource.categories?.connect ??
+                    [];
+                return categoryRefs.some((categoryRef) => {
+                    const category = fixtureCategories.find((fc) => fc.id === categoryRef.id);
+                    return category?.name === "business";
+                });
+            })
+                .map((r) => r.id)
+                .sort());
+        });
+        (0, globals_1.test)("conditional - relation in multiple values", async () => {
+            const queryPlan = createConditionalPlan({
+                operator: "in",
+                operands: [
+                    { name: "request.resource.attr.categories.name" },
+                    { value: ["business", "development"] },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                name: { field: "name" },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            name: { in: ["business", "development"] },
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(fixtureResources
+                .filter((resource) => {
+                const categoryRefs = resource.categories?.connect ??
+                    [];
+                return categoryRefs.some((categoryRef) => {
+                    const category = fixtureCategories.find((fc) => fc.id === categoryRef.id);
+                    return ["business", "development"].includes(category?.name ?? "");
+                });
+            })
+                .map((r) => r.id)
+                .sort());
+        });
+        (0, globals_1.test)("conditional - except relation subset", async () => {
+            const queryPlan = createConditionalPlan({
+                operator: "except",
+                operands: [
+                    { name: "request.resource.attr.categories" },
+                    {
+                        operator: "lambda",
+                        operands: [
+                            {
+                                operator: "eq",
+                                operands: [
+                                    { name: "cat.name" },
+                                    { value: "business" },
+                                ],
+                            },
+                            { name: "cat" },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                name: { field: "name" },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            NOT: {
+                                name: { equals: "business" },
+                            },
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(fixtureResources
+                .filter((resource) => {
+                const categoryRefs = resource.categories?.connect ??
+                    [];
+                return categoryRefs.some((categoryRef) => {
+                    const category = fixtureCategories.find((fc) => fc.id === categoryRef.id);
+                    return category?.name !== "business";
+                });
+            })
+                .map((r) => r.id)
+                .sort());
+        });
+        (0, globals_1.test)("conditional - except nested relation subset", async () => {
+            const queryPlan = createConditionalPlan({
+                operator: "except",
+                operands: [
+                    { name: "request.resource.attr.categories" },
+                    {
+                        operator: "lambda",
+                        operands: [
+                            {
+                                operator: "exists",
+                                operands: [
+                                    { name: "cat.subCategories" },
+                                    {
+                                        operator: "lambda",
+                                        operands: [
+                                            {
+                                                operator: "eq",
+                                                operands: [
+                                                    { name: "sub.name" },
+                                                    { value: "finance" },
+                                                ],
+                                            },
+                                            { name: "sub" },
+                                        ],
+                                    },
+                                ],
+                            },
+                            { name: "cat" },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                subCategories: {
+                                    relation: {
+                                        name: "subCategories",
+                                        type: "many",
+                                        fields: {
+                                            name: { field: "name" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            NOT: {
+                                subCategories: {
+                                    some: {
+                                        name: { equals: "finance" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(fixtureResources
+                .filter((resource) => {
+                const categoryRefs = resource.categories?.connect ??
+                    [];
+                return categoryRefs.some((categoryRef) => {
+                    const category = fixtureCategories.find((fc) => fc.id === categoryRef.id);
+                    if (!category) {
+                        return false;
+                    }
+                    const subCategoryRefs = category.subCategories?.connect ??
+                        [];
+                    return !subCategoryRefs.some((subCategoryRef) => {
+                        const subCategory = fixtureSubCategories.find((fsc) => fsc.id === subCategoryRef.id);
+                        return subCategory?.name === "finance";
+                    });
+                });
+            })
+                .map((r) => r.id)
+                .sort());
+        });
+        (0, globals_1.test)("conditional - exists single", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "exists-single",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "exists",
+                operands: [
+                    {
+                        name: "request.resource.attr.tags",
+                    },
+                    {
+                        operator: "lambda",
+                        operands: [
+                            {
+                                operator: "eq",
+                                operands: [
+                                    {
+                                        name: "tag.id",
+                                    },
+                                    {
+                                        value: "tag1",
+                                    },
+                                ],
+                            },
+                            {
+                                name: "tag",
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.tags": {
+                        relation: {
+                            name: "tags",
+                            type: "many",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    tags: {
+                        some: {
+                            id: {
+                                equals: "tag1",
+                            },
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => Array.isArray(a.tags?.connect) &&
+                a.tags?.connect
+                    .map((t) => {
+                    return fixtureTags.find((f) => f.id === t.id);
+                })
+                    .filter((t) => t?.id == "tag1").length > 0)
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - exists multiple", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "exists-multiple",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "exists",
+                operands: [
+                    {
+                        name: "request.resource.attr.tags",
+                    },
+                    {
+                        operator: "lambda",
+                        operands: [
+                            {
+                                operator: "and",
+                                operands: [
+                                    {
+                                        operator: "eq",
+                                        operands: [
+                                            {
+                                                name: "tag.id",
+                                            },
+                                            {
+                                                value: "tag1",
+                                            },
+                                        ],
+                                    },
+                                    {
+                                        operator: "eq",
+                                        operands: [
+                                            {
+                                                name: "tag.name",
+                                            },
+                                            {
+                                                value: "public",
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                            {
+                                name: "tag",
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.tags": {
+                        relation: {
+                            name: "tags",
+                            type: "many",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    tags: {
+                        some: {
+                            AND: [
+                                {
+                                    id: {
+                                        equals: "tag1",
+                                    },
+                                },
+                                {
+                                    name: {
+                                        equals: "public",
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => Array.isArray(a.tags?.connect) &&
+                a.tags?.connect
+                    .map((t) => {
+                    return fixtureTags.find((f) => f.id === t.id);
+                })
+                    .filter((t) => t?.id === "tag1" && t?.name === "public")
+                    .length > 0)
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - exists_one", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "exists-one",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "exists_one",
+                operands: [
+                    {
+                        name: "request.resource.attr.tags",
+                    },
+                    {
+                        operator: "lambda",
+                        operands: [
+                            {
+                                operator: "eq",
+                                operands: [
+                                    {
+                                        name: "tag.name",
+                                    },
+                                    {
+                                        value: "public",
+                                    },
+                                ],
+                            },
+                            {
+                                name: "tag",
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.tags": {
+                        relation: {
+                            name: "tags",
+                            type: "many",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    tags: {
+                        some: {
+                            name: { equals: "public" },
+                        },
+                    },
+                    AND: [
+                        {
+                            tags: {
+                                every: {
+                                    OR: [
+                                        { name: { equals: "public" } },
+                                        { NOT: { name: { equals: "public" } } },
+                                    ],
+                                },
+                            },
+                        },
+                    ],
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => Array.isArray(a.tags?.connect) &&
+                a.tags?.connect
+                    .map((t) => {
+                    return fixtureTags.find((f) => f.id === t.id);
+                })
+                    .filter((t) => t?.id === "tag1" && t?.name === "public")
+                    .length > 0)
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - all", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "all",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "all",
+                operands: [
+                    {
+                        name: "request.resource.attr.tags",
+                    },
+                    {
+                        operator: "lambda",
+                        operands: [
+                            {
+                                operator: "eq",
+                                operands: [
+                                    {
+                                        name: "tag.name",
+                                    },
+                                    {
+                                        value: "public",
+                                    },
+                                ],
+                            },
+                            {
+                                name: "tag",
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.tags": {
+                        relation: {
+                            name: "tags",
+                            type: "many",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    tags: {
+                        every: {
+                            name: { equals: "public" },
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => Array.isArray(a.tags?.connect) &&
+                a.tags?.connect
+                    .map((t) => {
+                    return fixtureTags.find((f) => f.id === t.id);
+                })
+                    .every((t) => t?.name === "public"))
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - filter", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "filter",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "filter",
+                operands: [
+                    {
+                        name: "request.resource.attr.tags",
+                    },
+                    {
+                        operator: "lambda",
+                        operands: [
+                            {
+                                operator: "eq",
+                                operands: [
+                                    {
+                                        name: "tag.name",
+                                    },
+                                    {
+                                        value: "public",
+                                    },
+                                ],
+                            },
+                            {
+                                name: "tag",
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.tags": {
+                        relation: {
+                            name: "tags",
+                            type: "many",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    tags: {
+                        some: {
+                            name: { equals: "public" },
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((a) => Array.isArray(a.tags?.connect) &&
+                a.tags?.connect
+                    .map((t) => {
+                    return fixtureTags.find((f) => f.id === t.id);
+                })
+                    .filter((t) => t?.name === "public").length > 0)
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - map collection", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "map-collection",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "hasIntersection",
+                operands: [
+                    {
+                        operator: "map",
+                        operands: [
+                            { name: "request.resource.attr.tags" },
+                            {
+                                operator: "lambda",
+                                operands: [{ name: "tag.name" }, { name: "tag" }],
+                            },
+                        ],
+                    },
+                    { value: ["public", "private"] },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.tags": {
+                        relation: {
+                            name: "tags",
+                            type: "many",
+                            fields: {
+                                name: { field: "name" },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    tags: {
+                        some: {
+                            name: { in: ["public", "private"] },
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            // Should return resources that have either "public" or "private" tags
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                const tagNames = Array.isArray(r.tags?.connect)
+                    ? r.tags.connect.map((t) => fixtureTags.find((ft) => ft.id === t.id)?.name) || []
+                    : [];
+                return tagNames.some((name) => ["public", "private"].includes(name || ""));
+            })
+                .map((r) => r.id));
+        });
+    });
+});
+// Relations
+(0, globals_1.describe)("Relations", () => {
+    (0, globals_1.describe)("Simple Relations", () => {
+        (0, globals_1.describe)("One-to-One", () => {
+            (0, globals_1.test)("conditional - relation is", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-is",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "eq",
+                    operands: [
+                        { name: "request.resource.attr.createdBy" },
+                        { value: "user1" },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.createdBy": {
+                            relation: {
+                                name: "createdBy",
+                                type: "one",
+                                field: "id",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        createdBy: {
+                            is: {
+                                id: {
+                                    equals: "user1",
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    if (!r.createdBy?.connect)
+                        return false;
+                    return r.createdBy.connect.id == "user1";
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation is not", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-is-not",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "not",
+                    operands: [
+                        {
+                            operator: "eq",
+                            operands: [
+                                { name: "request.resource.attr.createdBy" },
+                                { value: "user1" },
+                            ],
+                        },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.createdBy": {
+                            relation: {
+                                name: "createdBy",
+                                type: "one",
+                                field: "id",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        NOT: {
+                            createdBy: {
+                                is: {
+                                    id: {
+                                        equals: "user1",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    if (!r.createdBy?.connect)
+                        return false;
+                    return r.createdBy.connect.id != "user1";
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation is without field", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-is",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "eq",
+                    operands: [
+                        { name: "request.resource.attr.createdBy" },
+                        { value: "user1" },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.createdBy": {
+                            relation: {
+                                name: "createdBy",
+                                type: "one",
+                                field: "id",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        createdBy: {
+                            is: {
+                                id: { equals: "user1" },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    if (!r.createdBy?.connect)
+                        return false;
+                    return r.createdBy.connect.id == "user1";
+                })
+                    .map((r) => r.id));
+            });
+        });
+        (0, globals_1.describe)("One-to-Many/Many-to-Many", () => {
+            (0, globals_1.test)("conditional - relation some", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-some",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "in",
+                    operands: [
+                        { value: "user1" },
+                        { name: "request.resource.attr.ownedBy" },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.ownedBy": {
+                            relation: {
+                                name: "ownedBy",
+                                type: "many",
+                                field: "id",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        ownedBy: {
+                            some: {
+                                id: "user1",
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    if (!r.ownedBy?.connect)
+                        return false;
+                    return (r.ownedBy.connect.filter((o) => o.id == "user1").length > 0);
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation none", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-none",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "not",
+                    operands: [
+                        {
+                            operator: "in",
+                            operands: [
+                                { value: "user1" },
+                                { name: "request.resource.attr.ownedBy" },
+                            ],
+                        },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.ownedBy": {
+                            relation: {
+                                name: "ownedBy",
+                                type: "many",
+                                field: "id",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        NOT: {
+                            ownedBy: {
+                                some: {
+                                    id: "user1",
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    if (!r.ownedBy?.connect)
+                        return false;
+                    return (r.ownedBy.connect.filter((o) => o.id == "user1").length == 0);
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - has-tag", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "has-tag",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                (0, globals_1.expect)(queryPlan.condition).toEqual({
+                    operator: "in",
+                    operands: [
+                        { value: "public" },
+                        { name: "request.resource.attr.tags" },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.tags": {
+                            relation: {
+                                name: "tags",
+                                type: "many", // This indicates a many-to-many relationship
+                                field: "name",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        tags: {
+                            some: {
+                                name: "public",
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                    include: { tags: true },
+                });
+                const expectedIds = fixtureResources
+                    .filter((resource) => {
+                    const tagRefs = resource.tags?.connect ?? [];
+                    return tagRefs.some((tagRef) => {
+                        const tag = fixtureTags.find((ft) => ft.id === tagRef.id);
+                        return tag?.name === "public";
+                    });
+                })
+                    .map((r) => r.id)
+                    .sort();
+                (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(expectedIds);
+            });
+            (0, globals_1.test)("conditional - has-no-tag", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "has-no-tag",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                (0, globals_1.expect)(queryPlan.condition).toEqual({
+                    operator: "not",
+                    operands: [
+                        {
+                            operator: "in",
+                            operands: [
+                                { value: "private" },
+                                { name: "request.resource.attr.tags" },
+                            ],
+                        },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.tags": {
+                            relation: {
+                                name: "tags",
+                                type: "many",
+                                field: "name",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        NOT: {
+                            tags: {
+                                some: {
+                                    name: "private",
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                    include: { tags: true },
+                });
+                const expectedIds = fixtureResources
+                    .filter((resource) => {
+                    const tagRefs = resource.tags?.connect ?? [];
+                    return tagRefs.every((tagRef) => {
+                        const tag = fixtureTags.find((ft) => ft.id === tagRef.id);
+                        return tag?.name !== "private";
+                    });
+                })
+                    .map((r) => r.id)
+                    .sort();
+                (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(expectedIds);
+            });
+            (0, globals_1.test)("conditional - has-intersection", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: {
+                        id: "user1",
+                        roles: ["USER"],
+                        attr: { tags: ["public", "draft"] },
+                    },
+                    resource: { kind: "resource" },
+                    action: "has-intersection",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                // expect((queryPlan as PlanResourcesConditionalResponse).condition).toEqual({
+                //   operator: "hasIntersection",
+                //   operands: [
+                //     { name: "request.resource.attr.tags" },
+                //     { value: ["public", "draft"] },
+                //   ],
+                // });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.tags": {
+                            relation: {
+                                name: "tags",
+                                type: "many",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        tags: {
+                            some: {
+                                name: { in: ["public", "draft"] },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                const expectedIds = fixtureResources
+                    .filter((resource) => {
+                    const tagRefs = resource.tags?.connect ?? [];
+                    return tagRefs.some((tagRef) => {
+                        const tag = fixtureTags.find((ft) => ft.id === tagRef.id);
+                        return ["public", "draft"].includes(tag?.name ?? "");
+                    });
+                })
+                    .map((r) => r.id)
+                    .sort();
+                (0, globals_1.expect)(query.map((r) => r.id).sort()).toEqual(expectedIds);
+            });
+            (0, globals_1.test)("conditional - hasIntersection with direct value", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "has-intersection-direct",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                (0, globals_1.expect)(queryPlan.condition).toEqual({
+                    operator: "hasIntersection",
+                    operands: [
+                        { name: "request.resource.attr.tags" },
+                        { value: ["public", "draft"] },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.tags": {
+                            relation: {
+                                name: "tags",
+                                type: "many",
+                                field: "name",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        tags: {
+                            some: {
+                                name: { in: ["public", "draft"] },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => Array.isArray(r.tags?.connect) &&
+                    r.tags?.connect
+                        .map((t) => fixtureTags.find((ft) => ft.id === t.id)?.name)
+                        .some((name) => ["public", "draft"].includes(name ?? "")))
+                    .map((r) => r.id));
+            });
+        });
+    });
+    (0, globals_1.describe)("Nested Relations", () => {
+        (0, globals_1.describe)("Single Level", () => {
+            (0, globals_1.test)("conditional - nested eq", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "equal-nested",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "eq",
+                    operands: [
+                        { name: "request.resource.attr.nested.aBool" },
+                        { value: true },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                                fields: {
+                                    aBool: { field: "aBool" },
+                                },
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: { nested: { is: { aBool: { equals: true } } } },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((a) => fixtureNestedResources.find((f) => f.id === a.nested.connect?.id)?.aBool)
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation eq with number", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-eq-number",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "eq",
+                    operands: [
+                        { name: "request.resource.attr.nested.aNumber" },
+                        { value: 1 },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                aNumber: { equals: 1 },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nestedResource = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    return (nestedResource?.aNumber ?? 0) == 1;
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation eq with number without field", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-eq-number",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "eq",
+                    operands: [
+                        { name: "request.resource.attr.nested.aNumber" },
+                        { value: 1 },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                aNumber: {
+                                    equals: 1,
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nestedResource = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    return nestedResource && nestedResource.aNumber === 1;
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation lt with number", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-lt-number",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "lt",
+                    operands: [
+                        { name: "request.resource.attr.nested.aNumber" },
+                        { value: 2 },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                aNumber: { lt: 2 },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nestedResource = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    return (nestedResource?.aNumber ?? 0) < 2;
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation lte with number", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-lte-number",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "le",
+                    operands: [
+                        { name: "request.resource.attr.nested.aNumber" },
+                        { value: 2 },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                aNumber: { lte: 2 },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nestedResource = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    return (nestedResource?.aNumber ?? 0) <= 2;
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation gte with number", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-gte-number",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "ge",
+                    operands: [
+                        { name: "request.resource.attr.nested.aNumber" },
+                        { value: 1 },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                aNumber: { gte: 1 },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nestedResource = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    return (nestedResource?.aNumber ?? 0) >= 1;
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - relation-gt-number", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "relation-gt-number",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "gt",
+                    operands: [
+                        { name: "request.resource.attr.nested.aNumber" },
+                        { value: 1 },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                aNumber: { gt: 1 },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nestedResource = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    return (nestedResource?.aNumber ?? 0) > 1;
+                })
+                    .map((r) => r.id));
+            });
+        });
+        (0, globals_1.describe)("Deep Nesting", () => {
+            (0, globals_1.test)("conditional - deeply nested eq", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "equal-deeply-nested",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                const conditions = queryPlan
+                    .condition;
+                (0, globals_1.expect)(conditions).toEqual({
+                    operator: "eq",
+                    operands: [
+                        { name: "request.resource.attr.nested.nextlevel.aBool" },
+                        { value: true },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                                fields: {
+                                    nextlevel: {
+                                        relation: {
+                                            name: "nextlevel",
+                                            type: "one",
+                                            fields: {
+                                                aBool: { field: "aBool" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                nextlevel: {
+                                    is: {
+                                        aBool: {
+                                            equals: true,
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((a) => {
+                    const nestedResource = fixtureNestedResources.find((f) => f.id === a.nested.connect?.id);
+                    const nextLevelResource = fixtureNextLevelResources.find((f) => f.id === nestedResource?.nextlevel.connect?.id);
+                    return nextLevelResource?.aBool === true;
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - deeply nested many to many category label", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "deep-nested-category-label",
+                });
+                (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+                (0, globals_1.expect)(queryPlan.condition).toEqual({
+                    operator: "exists",
+                    operands: [
+                        {
+                            name: "request.resource.attr.categories",
+                        },
+                        {
+                            operator: "lambda",
+                            operands: [
+                                {
+                                    operator: "exists",
+                                    operands: [
+                                        {
+                                            name: "cat.subCategories",
+                                        },
+                                        {
+                                            operator: "lambda",
+                                            operands: [
+                                                {
+                                                    operator: "exists",
+                                                    operands: [
+                                                        {
+                                                            name: "sub.labels",
+                                                        },
+                                                        {
+                                                            operator: "lambda",
+                                                            operands: [
+                                                                {
+                                                                    operator: "eq",
+                                                                    operands: [
+                                                                        {
+                                                                            name: "label.name",
+                                                                        },
+                                                                        {
+                                                                            value: "important",
+                                                                        },
+                                                                    ],
+                                                                },
+                                                                {
+                                                                    name: "label",
+                                                                },
+                                                            ],
+                                                        },
+                                                    ],
+                                                },
+                                                {
+                                                    name: "sub",
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    name: "cat",
+                                },
+                            ],
+                        },
+                    ],
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.categories": {
+                            relation: {
+                                name: "categories",
+                                type: "many",
+                                fields: {
+                                    subCategories: {
+                                        relation: {
+                                            name: "subCategories",
+                                            type: "many",
+                                            fields: {
+                                                labels: {
+                                                    relation: {
+                                                        name: "labels",
+                                                        type: "many",
+                                                        fields: {
+                                                            name: { field: "name" },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        categories: {
+                            some: {
+                                subCategories: {
+                                    some: {
+                                        labels: {
+                                            some: {
+                                                name: { equals: "important" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                    include: {
+                        categories: {
+                            include: {
+                                subCategories: {
+                                    include: {
+                                        labels: true,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    return (r.categories?.connect)
+                        .map((c) => {
+                        return fixtureCategories.find((fc) => fc.id === c.id);
+                    })
+                        .some((c) => {
+                        return (c?.subCategories
+                            ?.connect)
+                            .map((sc) => {
+                            return fixtureSubCategories.find((fsc) => fsc.id === sc.id);
+                        })
+                            .some((sc) => {
+                            return (sc?.labels?.connect)
+                                .map((l) => {
+                                return fixtureLabels.find((fl) => fl.id === l.id);
+                            })
+                                .some((l) => l?.name === "important");
+                        });
+                    });
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - deep nested exists with multiple conditions", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "deep-nested-exists",
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.categories": {
+                            relation: {
+                                name: "categories",
+                                type: "many",
+                                fields: {
+                                    subCategories: {
+                                        relation: {
+                                            name: "subCategories",
+                                            type: "many",
+                                            field: "name",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        categories: {
+                            some: {
+                                AND: [
+                                    { name: { equals: "business" } },
+                                    {
+                                        subCategories: {
+                                            some: {
+                                                name: { equals: "finance" },
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const categoryConnections = r.categories
+                        ?.connect;
+                    return (categoryConnections?.some((categoryConnection) => {
+                        const category = fixtureCategories.find((fc) => fc.id === categoryConnection.id);
+                        return (category?.name === "business" &&
+                            (category?.subCategories
+                                ?.connect).some((sc) => fixtureSubCategories.find((fsc) => fsc.id === sc.id)
+                                ?.name === "finance"));
+                    }) ?? false);
+                })
+                    .map((r) => r.id));
+            });
+        });
+        (0, globals_1.describe)("Nested String Operations", () => {
+            (0, globals_1.test)("conditional - nested contains", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "nested-contains",
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                                fields: {
+                                    aString: { field: "aString" },
+                                },
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                aString: { contains: "str" },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nested = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    return nested?.aString.includes("str");
+                })
+                    .map((r) => r.id));
+            });
+            (0, globals_1.test)("conditional - deeply nested startsWith", async () => {
+                const queryPlan = await cerbos.planResources({
+                    principal: { id: "user1", roles: ["USER"] },
+                    resource: { kind: "resource" },
+                    action: "deeply-nested-starts-with",
+                });
+                const result = (0, _1.queryPlanToPrisma)({
+                    queryPlan,
+                    mapper: {
+                        "request.resource.attr.nested": {
+                            relation: {
+                                name: "nested",
+                                type: "one",
+                                fields: {
+                                    nextlevel: {
+                                        relation: {
+                                            name: "nextlevel",
+                                            type: "one",
+                                            fields: {
+                                                aString: { field: "aString" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                (0, globals_1.expect)(result).toStrictEqual({
+                    kind: _1.PlanKind.CONDITIONAL,
+                    filters: {
+                        nested: {
+                            is: {
+                                nextlevel: {
+                                    is: {
+                                        aString: { startsWith: "str" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                    throw new Error("Expected CONDITIONAL result");
+                }
+                const query = await prisma.resource.findMany({
+                    where: { ...result.filters },
+                });
+                (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                    .filter((r) => {
+                    const nested = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                    const nextLevel = fixtureNextLevelResources.find((nl) => nl.id === nested?.nextlevel.connect?.id);
+                    return nextLevel?.aString.startsWith("str");
+                })
+                    .map((r) => r.id));
+            });
+        });
+    });
+});
+// Complex Operations
+(0, globals_1.describe)("Complex Operations", () => {
+    (0, globals_1.describe)("Logical Operations", () => {
+        (0, globals_1.test)("conditional - and", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "and",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "and",
+                operands: [
+                    {
+                        operator: "eq",
+                        operands: [
+                            { name: "request.resource.attr.aBool" },
+                            { value: true },
+                        ],
+                    },
+                    {
+                        operator: "ne",
+                        operands: [
+                            { name: "request.resource.attr.aString" },
+                            { value: "string" },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aBool": { field: "aBool" },
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    AND: [
+                        {
+                            aBool: { equals: true },
+                        },
+                        {
+                            aString: { not: "string" },
+                        },
+                    ],
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query).toEqual(fixtureResources
+                .filter((r) => {
+                return r.aBool && r.aString != "string";
+            })
+                .map((f) => ({ ...f, owners: undefined })));
+        });
+        (0, globals_1.test)("conditional - or", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "or",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "or",
+                operands: [
+                    {
+                        operator: "eq",
+                        operands: [
+                            { name: "request.resource.attr.aBool" },
+                            { value: true },
+                        ],
+                    },
+                    {
+                        operator: "ne",
+                        operands: [
+                            { name: "request.resource.attr.aString" },
+                            { value: "string" },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.aBool": { field: "aBool" },
+                    "request.resource.attr.aString": { field: "aString" },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    OR: [
+                        {
+                            aBool: { equals: true },
+                        },
+                        {
+                            aString: { not: "string" },
+                        },
+                    ],
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                return r.aBool || r.aString != "string";
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - relation multiple all", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "relation-multiple-all",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "and",
+                operands: [
+                    {
+                        operator: "gt",
+                        operands: [
+                            { name: "request.resource.attr.nested.aNumber" },
+                            { value: 1 },
+                        ],
+                    },
+                    {
+                        operator: "lt",
+                        operands: [
+                            { name: "request.resource.attr.nested.aNumber" },
+                            { value: 3 },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.nested": {
+                        relation: {
+                            name: "nested",
+                            type: "one",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    AND: [
+                        {
+                            nested: {
+                                is: {
+                                    aNumber: { gt: 1 },
+                                },
+                            },
+                        },
+                        {
+                            nested: {
+                                is: {
+                                    aNumber: { lt: 3 },
+                                },
+                            },
+                        },
+                    ],
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                const nestedResource = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+                return ((nestedResource?.aNumber ?? 0) > 1 &&
+                    (nestedResource?.aNumber ?? 0) < 3);
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - relation multiple or", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "relation-multiple-or",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "or",
+                operands: [
+                    {
+                        operator: "eq",
+                        operands: [
+                            { name: "request.resource.attr.createdBy" },
+                            { value: "user1" },
+                        ],
+                    },
+                    {
+                        operator: "in",
+                        operands: [
+                            { value: "user1" },
+                            { name: "request.resource.attr.ownedBy" },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.createdBy": {
+                        relation: {
+                            name: "createdBy",
+                            type: "one",
+                            field: "id",
+                        },
+                    },
+                    "request.resource.attr.ownedBy": {
+                        relation: {
+                            name: "ownedBy",
+                            type: "many",
+                            field: "id",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    OR: [
+                        {
+                            createdBy: {
+                                is: {
+                                    id: {
+                                        equals: "user1",
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            ownedBy: {
+                                some: {
+                                    id: "user1",
+                                },
+                            },
+                        },
+                    ],
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            // Should return resources where user1 is either creator or owner
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                const createdBy = r.createdBy?.connect?.id;
+                const ownedBy = Array.isArray(r.ownedBy?.connect)
+                    ? r.ownedBy?.connect.find((o) => o.id == "user1")
+                    : undefined;
+                return createdBy == "user1" || ownedBy;
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("conditional - relation multiple none", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "relation-multiple-none",
+            });
+            (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+            (0, globals_1.expect)(queryPlan.condition).toEqual({
+                operator: "and",
+                operands: [
+                    {
+                        operator: "not",
+                        operands: [
+                            {
+                                operator: "eq",
+                                operands: [
+                                    { name: "request.resource.attr.createdBy" },
+                                    { value: "user1" },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        operator: "not",
+                        operands: [
+                            {
+                                operator: "in",
+                                operands: [
+                                    { value: "public" },
+                                    { name: "request.resource.attr.tags" },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.createdBy": {
+                        relation: {
+                            name: "createdBy",
+                            type: "one",
+                            field: "id",
+                        },
+                    },
+                    "request.resource.attr.tags": {
+                        relation: {
+                            name: "tags",
+                            type: "many",
+                            field: "name",
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    AND: [
+                        {
+                            NOT: {
+                                createdBy: {
+                                    is: {
+                                        id: {
+                                            equals: "user1",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            NOT: {
+                                tags: {
+                                    some: {
+                                        name: "public",
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            // Should return resources where user1 is creator AND has public tag
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                const createdBy = r.createdBy?.connect?.id;
+                const hasPublicTag = Array.isArray(r.tags?.connect) &&
+                    r.tags?.connect.find((t) => t.id === "tag1"); // tag1 is public
+                return !(createdBy === "user1" && hasPublicTag);
+            })
+                .map((r) => r.id));
+        });
+    });
+    (0, globals_1.describe)("Collection Operations", () => {
+        (0, globals_1.test)("conditional - exists on nested collection", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "exists-nested-collection",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                name: { field: "name" },
+                                subCategories: {
+                                    relation: {
+                                        name: "subCategories",
+                                        type: "many",
+                                        fields: {
+                                            name: { field: "name" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            AND: [
+                                { name: { equals: "business" } },
+                                {
+                                    subCategories: {
+                                        some: {
+                                            name: { equals: "finance" },
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            });
+            if (result.kind !== _1.PlanKind.CONDITIONAL) {
+                throw new Error("Expected CONDITIONAL result");
+            }
+            const query = await prisma.resource.findMany({
+                where: { ...result.filters },
+            });
+            (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+                .filter((r) => {
+                const categoryConnections = r.categories
+                    ?.connect;
+                return categoryConnections?.some((categoryConnection) => {
+                    const category = fixtureCategories.find((fc) => fc.id === categoryConnection.id);
+                    return (category?.name === "business" &&
+                        category?.subCategories
+                            ?.connect?.some((sc) => fixtureSubCategories.find((fsc) => fsc.id === sc.id)
+                            ?.name === "finance"));
+                });
+            })
+                .map((r) => r.id));
+        });
+        (0, globals_1.test)("isSet with nested relation", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "is-set-nested",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.nested.aOptionalString": {
+                        relation: {
+                            name: "nested",
+                            type: "one",
+                            fields: {
+                                aOptionalString: { field: "aOptionalString" },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    nested: {
+                        is: {
+                            aOptionalString: { not: null },
+                        },
+                    },
+                },
+            });
+        });
+        (0, globals_1.test)("hasIntersection with nested collection", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "has-intersection-nested",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                subCategories: {
+                                    relation: {
+                                        name: "subCategories",
+                                        type: "many",
+                                        fields: {
+                                            name: { field: "name" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            subCategories: {
+                                some: {
+                                    name: { in: ["finance", "tech"] },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+    });
+    (0, globals_1.describe)("Deep Nesting", () => {
+        (0, globals_1.test)("filter on deeply nested relation", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "filter-deeply-nested",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                subCategories: {
+                                    relation: {
+                                        name: "subCategories",
+                                        type: "many",
+                                        fields: {
+                                            labels: {
+                                                relation: {
+                                                    name: "labels",
+                                                    type: "many",
+                                                    fields: {
+                                                        name: { field: "name" },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            subCategories: {
+                                some: {
+                                    labels: {
+                                        some: {
+                                            name: { equals: "important" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+        (0, globals_1.test)("map on deeply nested relation", async () => {
+            const queryPlan = await cerbos.planResources({
+                principal: { id: "user1", roles: ["USER"] },
+                resource: { kind: "resource" },
+                action: "map-deeply-nested",
+            });
+            const result = (0, _1.queryPlanToPrisma)({
+                queryPlan,
+                mapper: {
+                    "request.resource.attr.categories": {
+                        relation: {
+                            name: "categories",
+                            type: "many",
+                            fields: {
+                                subCategories: {
+                                    relation: {
+                                        name: "subCategories",
+                                        type: "many",
+                                        fields: {
+                                            name: { field: "name" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            (0, globals_1.expect)(result).toStrictEqual({
+                kind: _1.PlanKind.CONDITIONAL,
+                filters: {
+                    categories: {
+                        some: {
+                            subCategories: {
+                                some: {
+                                    name: { in: ["finance", "tech"] },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+        });
+    });
+});
+// Error Handling
+(0, globals_1.describe)("Error Cases", () => {
+    (0, globals_1.test)("throws error for invalid query plan", () => {
+        const invalidQueryPlan = {
+            kind: "INVALID_KIND",
+        };
+        (0, globals_1.expect)(() => (0, _1.queryPlanToPrisma)({
+            queryPlan: invalidQueryPlan,
+            mapper: {},
+        })).toThrow("Invalid query plan.");
+    });
+    (0, globals_1.test)("throws error for invalid expression structure", () => {
+        const invalidQueryPlan = {
+            kind: _1.PlanKind.CONDITIONAL,
+            condition: {
+            // Missing operator and operands
+            },
+        };
+        (0, globals_1.expect)(() => (0, _1.queryPlanToPrisma)({
+            queryPlan: invalidQueryPlan,
+            mapper: {},
+        })).toThrow("Invalid Cerbos expression structure");
+    });
+    (0, globals_1.test)("throws error for unsupported operator", () => {
+        const invalidQueryPlan = {
+            kind: _1.PlanKind.CONDITIONAL,
+            condition: {
+                operator: "unsupported",
+                operands: [],
+            },
+        };
+        (0, globals_1.expect)(() => (0, _1.queryPlanToPrisma)({
+            queryPlan: invalidQueryPlan,
+            mapper: {},
+        })).toThrow("Unsupported operator: unsupported");
+    });
+    (0, globals_1.test)("throws error for invalid operand structure", () => {
+        const invalidQueryPlan = {
+            kind: _1.PlanKind.CONDITIONAL,
+            condition: {
+                operator: "eq",
+                operands: [
+                    {}, // Invalid operand without name or value
+                    { value: "test" },
+                ],
+            },
+        };
+        (0, globals_1.expect)(() => (0, _1.queryPlanToPrisma)({
+            queryPlan: invalidQueryPlan,
+            mapper: {},
+        })).toThrow("No valid left operand found");
+    });
+});
+// Utility Tests
+(0, globals_1.describe)("Mapper Functions", () => {
+    (0, globals_1.test)("function mapper for field names", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "equal",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: (key) => ({
+                field: key.replace("request.resource.attr.", ""),
+            }),
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: { aBool: { equals: true } },
+        });
+    });
+    (0, globals_1.test)("function mapper for relations", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "relation-is",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: () => ({
+                relation: {
+                    name: "createdBy",
+                    type: "one",
+                    field: "id",
+                },
+            }),
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: {
+                createdBy: {
+                    is: {
+                        id: {
+                            equals: "user1",
+                        },
+                    },
+                },
+            },
+        });
+    });
+});
+// Integration
+(0, globals_1.describe)("Integration", () => {
+    (0, globals_1.test)("conditional - kitchen sink", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: {
+                id: "user1",
+                roles: ["USER"],
+                attr: { tags: ["public", "draft"] },
+            },
+            resource: { kind: "resource" },
+            action: "kitchensink",
+        });
+        (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+        // expect((queryPlan as PlanResourcesConditionalResponse).condition).toEqual({
+        //   operator: "filter",
+        //   operands: [
+        //     {
+        //       name: "request.resource.attr.tags",
+        //     },
+        //     {
+        //       operator: "lambda",
+        //       operands: [
+        //         {
+        //           operator: "eq",
+        //           operands: [
+        //             {
+        //               name: "tag.name",
+        //             },
+        //             {
+        //               value: "public",
+        //             },
+        //           ],
+        //         },
+        //         {
+        //           name: "tag",
+        //         },
+        //       ],
+        //     },
+        //   ],
+        // });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {
+                "request.resource.attr.aOptionalString": { field: "aOptionalString" },
+                "request.resource.attr.aBool": { field: "aBool" },
+                "request.resource.attr.aString": { field: "aString" },
+                "request.resource.attr.tags": {
+                    relation: {
+                        name: "tags",
+                        type: "many",
+                    },
+                },
+                "request.resource.attr.nested": {
+                    relation: {
+                        name: "nested",
+                        type: "one",
+                        fields: {
+                            nextlevel: {
+                                relation: {
+                                    name: "nextlevel",
+                                    type: "one",
+                                    fields: {
+                                        aBool: { field: "aBool" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        // expect(result).toStrictEqual({
+        //   kind: PlanKind.CONDITIONAL,
+        //   filters: {
+        //     tags: {
+        //       some: {
+        //         name: { equals: "public" },
+        //       },
+        //     },
+        //   },
+        // });
+        if (result.kind !== _1.PlanKind.CONDITIONAL) {
+            throw new Error("Expected CONDITIONAL result");
+        }
+        // console.log(JSON.stringify(result, null, 2));
+        await prisma.resource.findMany({
+            where: { ...result.filters },
+        });
+        // expect(query.map((r) => r.id)).toEqual(
+        //   fixtureResources
+        //     .filter(
+        //       (a) =>
+        //         Array.isArray(a.tags?.connect) &&
+        //         a.tags?.connect
+        //           .map((t) => {
+        //             return fixtureTags.find((f) => f.id === t.id);
+        //           })
+        //           .filter((t) => t?.name === "public").length > 0
+        //     )
+        //     .map((r) => r.id)
+        // );
+    });
+});
+(0, globals_1.describe)("Deep Nested Relations", () => {
+    (0, globals_1.test)("conditional - deeply nested many to many category label", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "deep-nested-category-label",
+        });
+        (0, globals_1.expect)(queryPlan.kind).toEqual(_1.PlanKind.CONDITIONAL);
+        (0, globals_1.expect)(queryPlan.condition).toEqual({
+            operator: "exists",
+            operands: [
+                {
+                    name: "request.resource.attr.categories",
+                },
+                {
+                    operator: "lambda",
+                    operands: [
+                        {
+                            operator: "exists",
+                            operands: [
+                                {
+                                    name: "cat.subCategories",
+                                },
+                                {
+                                    operator: "lambda",
+                                    operands: [
+                                        {
+                                            operator: "exists",
+                                            operands: [
+                                                {
+                                                    name: "sub.labels",
+                                                },
+                                                {
+                                                    operator: "lambda",
+                                                    operands: [
+                                                        {
+                                                            operator: "eq",
+                                                            operands: [
+                                                                {
+                                                                    name: "label.name",
+                                                                },
+                                                                {
+                                                                    value: "important",
+                                                                },
+                                                            ],
+                                                        },
+                                                        {
+                                                            name: "label",
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                        {
+                                            name: "sub",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            name: "cat",
+                        },
+                    ],
+                },
+            ],
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {
+                "request.resource.attr.categories": {
+                    relation: {
+                        name: "categories",
+                        type: "many",
+                        fields: {
+                            subCategories: {
+                                relation: {
+                                    name: "subCategories",
+                                    type: "many",
+                                    fields: {
+                                        labels: {
+                                            relation: {
+                                                name: "labels",
+                                                type: "many",
+                                                fields: {
+                                                    name: { field: "name" },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: {
+                categories: {
+                    some: {
+                        subCategories: {
+                            some: {
+                                labels: {
+                                    some: {
+                                        name: { equals: "important" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (result.kind !== _1.PlanKind.CONDITIONAL) {
+            throw new Error("Expected CONDITIONAL result");
+        }
+        const query = await prisma.resource.findMany({
+            where: { ...result.filters },
+            include: {
+                categories: {
+                    include: {
+                        subCategories: {
+                            include: {
+                                labels: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+            .filter((r) => {
+            return (r.categories?.connect)
+                .map((c) => {
+                return fixtureCategories.find((fc) => fc.id === c.id);
+            })
+                .some((c) => {
+                return (c?.subCategories
+                    ?.connect)
+                    .map((sc) => {
+                    return fixtureSubCategories.find((fsc) => fsc.id === sc.id);
+                })
+                    .some((sc) => {
+                    return (sc?.labels?.connect)
+                        .map((l) => {
+                        return fixtureLabels.find((fl) => fl.id === l.id);
+                    })
+                        .some((l) => l?.name === "important");
+                });
+            });
+        })
+            .map((r) => r.id));
+    });
+    (0, globals_1.test)("conditional - deep nested exists with multiple conditions", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "deep-nested-exists",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {
+                "request.resource.attr.categories": {
+                    relation: {
+                        name: "categories",
+                        type: "many",
+                        fields: {
+                            subCategories: {
+                                relation: {
+                                    name: "subCategories",
+                                    type: "many",
+                                    field: "name",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: {
+                categories: {
+                    some: {
+                        AND: [
+                            { name: { equals: "business" } },
+                            {
+                                subCategories: {
+                                    some: {
+                                        name: { equals: "finance" },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        });
+        if (result.kind !== _1.PlanKind.CONDITIONAL) {
+            throw new Error("Expected CONDITIONAL result");
+        }
+        const query = await prisma.resource.findMany({
+            where: { ...result.filters },
+        });
+        (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+            .filter((r) => {
+            const categoryConnections = r.categories
+                ?.connect;
+            return (categoryConnections?.some((categoryConnection) => {
+                const category = fixtureCategories.find((fc) => fc.id === categoryConnection.id);
+                return (category?.name === "business" &&
+                    category?.subCategories
+                        ?.connect?.some((sc) => fixtureSubCategories.find((fsc) => fsc.id === sc.id)
+                        ?.name === "finance"));
+            }) ?? false);
+        })
+            .map((r) => r.id));
+    });
+});
+(0, globals_1.describe)("Nested Relations String Operations", () => {
+    (0, globals_1.test)("conditional - nested contains", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "nested-contains",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {
+                "request.resource.attr.nested": {
+                    relation: {
+                        name: "nested",
+                        type: "one",
+                        fields: {
+                            aString: { field: "aString" },
+                        },
+                    },
+                },
+            },
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: {
+                nested: {
+                    is: {
+                        aString: { contains: "str" },
+                    },
+                },
+            },
+        });
+        if (result.kind !== _1.PlanKind.CONDITIONAL) {
+            throw new Error("Expected CONDITIONAL result");
+        }
+        const query = await prisma.resource.findMany({
+            where: { ...result.filters },
+        });
+        (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+            .filter((r) => {
+            const nested = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+            return nested?.aString.includes("str");
+        })
+            .map((r) => r.id));
+    });
+    (0, globals_1.test)("conditional - deeply nested startsWith", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "deeply-nested-starts-with",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {
+                "request.resource.attr.nested": {
+                    relation: {
+                        name: "nested",
+                        type: "one",
+                        fields: {
+                            nextlevel: {
+                                relation: {
+                                    name: "nextlevel",
+                                    type: "one",
+                                    fields: {
+                                        aString: { field: "aString" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: {
+                nested: {
+                    is: {
+                        nextlevel: {
+                            is: {
+                                aString: { startsWith: "str" },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (result.kind !== _1.PlanKind.CONDITIONAL) {
+            throw new Error("Expected CONDITIONAL result");
+        }
+        const query = await prisma.resource.findMany({
+            where: { ...result.filters },
+        });
+        (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+            .filter((r) => {
+            const nested = fixtureNestedResources.find((n) => n.id === r.nested.connect?.id);
+            const nextLevel = fixtureNextLevelResources.find((nl) => nl.id === nested?.nextlevel.connect?.id);
+            return nextLevel?.aString.startsWith("str");
+        })
+            .map((r) => r.id));
+    });
+});
+(0, globals_1.describe)("Collection Operations with Nested Relations", () => {
+    (0, globals_1.test)("conditional - exists on nested collection", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "exists-nested-collection",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {
+                "request.resource.attr.categories": {
+                    relation: {
+                        name: "categories",
+                        type: "many",
+                        fields: {
+                            name: { field: "name" },
+                            subCategories: {
+                                relation: {
+                                    name: "subCategories",
+                                    type: "many",
+                                    fields: {
+                                        name: { field: "name" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: {
+                categories: {
+                    some: {
+                        AND: [
+                            { name: { equals: "business" } },
+                            {
+                                subCategories: {
+                                    some: {
+                                        name: { equals: "finance" },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        });
+        if (result.kind !== _1.PlanKind.CONDITIONAL) {
+            throw new Error("Expected CONDITIONAL result");
+        }
+        const query = await prisma.resource.findMany({
+            where: { ...result.filters },
+        });
+        (0, globals_1.expect)(query.map((r) => r.id)).toEqual(fixtureResources
+            .filter((r) => {
+            const categoryConnections = r.categories
+                ?.connect;
+            return categoryConnections?.some((categoryConnection) => {
+                const category = fixtureCategories.find((fc) => fc.id === categoryConnection.id);
+                return (category?.name === "business" &&
+                    category?.subCategories
+                        ?.connect?.some((sc) => fixtureSubCategories.find((fsc) => fsc.id === sc.id)?.name ===
+                        "finance"));
+            });
+        })
+            .map((r) => r.id));
+    });
+});
+// Types
+(0, globals_1.describe)("Return Types", () => {
+    (0, globals_1.test)("returns ALWAYS_ALLOWED type", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "always-allow",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.ALWAYS_ALLOWED,
+        });
+        // Type assertion check
+        if (result.kind === _1.PlanKind.ALWAYS_ALLOWED) {
+            (0, globals_1.expect)(Object.keys(result)).toEqual(["kind"]);
+        }
+        else {
+            throw new Error("Expected ALWAYS_ALLOWED result");
+        }
+    });
+    (0, globals_1.test)("returns ALWAYS_DENIED type", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "always-deny",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.ALWAYS_DENIED,
+        });
+        // Type assertion check
+        if (result.kind === _1.PlanKind.ALWAYS_DENIED) {
+            (0, globals_1.expect)(Object.keys(result)).toEqual(["kind"]);
+        }
+        else {
+            throw new Error("Expected ALWAYS_DENIED result");
+        }
+    });
+    (0, globals_1.test)("returns CONDITIONAL type with filters", async () => {
+        const queryPlan = await cerbos.planResources({
+            principal: { id: "user1", roles: ["USER"] },
+            resource: { kind: "resource" },
+            action: "equal",
+        });
+        const result = (0, _1.queryPlanToPrisma)({
+            queryPlan,
+            mapper: {
+                "request.resource.attr.aBool": { field: "aBool" },
+            },
+        });
+        (0, globals_1.expect)(result).toStrictEqual({
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: { aBool: { equals: true } },
+        });
+        // Type assertion check
+        if (result.kind === _1.PlanKind.CONDITIONAL) {
+            (0, globals_1.expect)(Object.keys(result).sort()).toEqual(["filters", "kind"].sort());
+            (0, globals_1.expect)(typeof result.filters).toBe("object");
+        }
+        else {
+            throw new Error("Expected CONDITIONAL result");
+        }
+    });
+    (0, globals_1.test)("validates result type structure at compile time", () => {
+        // These should compile
+        const allowed = { kind: _1.PlanKind.ALWAYS_ALLOWED };
+        const denied = { kind: _1.PlanKind.ALWAYS_DENIED };
+        const conditional = {
+            kind: _1.PlanKind.CONDITIONAL,
+            filters: { someField: { equals: true } },
+        };
+        // Verify the objects exist to prevent unused variable warnings
+        (0, globals_1.expect)(allowed.kind).toBe(_1.PlanKind.ALWAYS_ALLOWED);
+        (0, globals_1.expect)(denied.kind).toBe(_1.PlanKind.ALWAYS_DENIED);
+        (0, globals_1.expect)(conditional.kind).toBe(_1.PlanKind.CONDITIONAL);
+    });
+});
+//# sourceMappingURL=index.test.js.map