@firecms/core 3.0.1 → 3.1.0-canary.9e89e98

package/src/util/__tests__/conditions.test.ts

@@ -0,0 +1,506 @@
+import {
+    applyPropertyConditions,
+    buildConditionContext,
+    evaluateCondition,
+    registerConditionOperations
+} from "../conditions";
+import { ConditionContext, ResolvedProperty } from "../../types";
+
+describe("Property Conditions", () => {
+
+    beforeAll(() => {
+        registerConditionOperations();
+    });
+
+    describe("evaluateCondition", () => {
+
+        it("should evaluate simple equality", () => {
+            const context: ConditionContext = {
+                values: { status: "archived" },
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                entityId: "123",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            const rule = { "==": [{ "var": "values.status" }, "archived"] };
+            expect(evaluateCondition(rule, context)).toBe(true);
+        });
+
+        it("should evaluate var access to nested values", () => {
+            const context: ConditionContext = {
+                values: { shipping: { method: "pickup" } },
+                previousValues: {},
+                propertyValue: undefined,
+                path: "orders",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            const rule = { "==": [{ "var": "values.shipping.method" }, "pickup"] };
+            expect(evaluateCondition(rule, context)).toBe(true);
+        });
+
+        it("should check isNew status", () => {
+            const contextNew: ConditionContext = {
+                values: {},
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: true,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            const rule = { "var": "isNew" };
+            expect(evaluateCondition(rule, contextNew)).toBe(true);
+
+            const contextExisting: ConditionContext = {
+                ...contextNew,
+                entityId: "123",
+                isNew: false
+            };
+            expect(evaluateCondition(rule, contextExisting)).toBe(false);
+        });
+
+        it("should handle if/then/else with object values (Firestore workaround)", () => {
+            const context: ConditionContext = {
+                values: { status: "active" },
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            // Firestore stores arrays as objects like {"0": "a", "1": "b"}
+            const rule = {
+                "if": [
+                    { "==": [{ "var": "values.status" }, "active"] },
+                    { "0": "electronics", "1": "clothing" },
+                    { "0": "electronics", "1": "clothing", "2": "food" }
+                ]
+            };
+
+            const result = evaluateCondition(rule, context);
+            expect(result).toEqual({ "0": "electronics", "1": "clothing" });
+        });
+
+        it("should evaluate truthy operator (!!)", () => {
+            const context: ConditionContext = {
+                values: { name: "Product", emptyField: "" },
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            expect(evaluateCondition({ "!!": { "var": "values.name" } }, context)).toBe(true);
+            expect(evaluateCondition({ "!!": { "var": "values.emptyField" } }, context)).toBe(false);
+        });
+
+        it("should evaluate falsy operator (!)", () => {
+            const context: ConditionContext = {
+                values: { name: "Product", emptyField: "" },
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            expect(evaluateCondition({ "!": { "var": "values.name" } }, context)).toBe(false);
+            expect(evaluateCondition({ "!": { "var": "values.emptyField" } }, context)).toBe(true);
+        });
+
+        it("should evaluate greater than operator", () => {
+            const context: ConditionContext = {
+                values: { price: 100 },
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            expect(evaluateCondition({ ">": [{ "var": "values.price" }, 50] }, context)).toBe(true);
+            expect(evaluateCondition({ ">": [{ "var": "values.price" }, 100] }, context)).toBe(false);
+        });
+
+        it("should evaluate in operator with array", () => {
+            const context: ConditionContext = {
+                values: { category: "electronics" },
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            expect(evaluateCondition({ "in": [{ "var": "values.category" }, ["electronics", "clothing"]] }, context)).toBe(true);
+            expect(evaluateCondition({ "in": [{ "var": "values.category" }, ["food", "toys"]] }, context)).toBe(false);
+        });
+    });
+
+    describe("Custom operations", () => {
+
+        it("isPast should check if timestamp is in the past", () => {
+            const context: ConditionContext = {
+                values: {},
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            const pastTimestamp = Date.now() - 86400000;
+            const futureTimestamp = Date.now() + 86400000;
+
+            expect(evaluateCondition({ "isPast": pastTimestamp }, context)).toBe(true);
+            expect(evaluateCondition({ "isPast": futureTimestamp }, context)).toBe(false);
+        });
+
+        it("isFuture should check if timestamp is in the future", () => {
+            const context: ConditionContext = {
+                values: {},
+                previousValues: {},
+                propertyValue: undefined,
+                path: "products",
+                isNew: false,
+                user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: [] },
+                now: Date.now()
+            };
+
+            const pastTimestamp = Date.now() - 86400000;
+            const futureTimestamp = Date.now() + 86400000;
+
+            expect(evaluateCondition({ "isFuture": futureTimestamp }, context)).toBe(true);
+            expect(evaluateCondition({ "isFuture": pastTimestamp }, context)).toBe(false);
+        });
+    });
+
+    describe("applyPropertyConditions", () => {
+
+        const baseContext: ConditionContext = {
+            values: { status: "archived" },
+            previousValues: {},
+            propertyValue: undefined,
+            path: "products",
+            entityId: "123",
+            isNew: false,
+            user: { uid: "user1", email: null, displayName: null, photoURL: null, roles: ["admin"] },
+            now: Date.now()
+        };
+
+        it("should apply disabled condition", () => {
+            const property = {
+                dataType: "string",
+                name: "Title",
+                resolved: true,
+                fromBuilder: false,
+                conditions: {
+                    disabled: { "==": [{ "var": "values.status" }, "archived"] },
+                    disabledMessage: "Cannot edit archived items"
+                }
+            } as ResolvedProperty<string>;
+
+            const result = applyPropertyConditions(property, baseContext);
+
+            expect(result.disabled).toEqual({
+                clearOnDisabled: false,
+                disabledMessage: "Cannot edit archived items",
+                hidden: false
+            });
+        });
+
+        it("should apply hidden condition", () => {
+            const property = {
+                dataType: "string",
+                name: "Internal Notes",
+                resolved: true,
+                fromBuilder: false,
+                conditions: {
+                    hidden: { "==": [{ "var": "values.status" }, "archived"] }
+                }
+            } as ResolvedProperty<string>;
+
+            const result = applyPropertyConditions(property, baseContext);
+
+            expect(result.disabled).toEqual(expect.objectContaining({
+                hidden: true
+            }));
+        });
+
+        it("should apply required condition", () => {
+            const property = {
+                dataType: "string",
+                name: "Email",
+                resolved: true,
+                fromBuilder: false,
+                conditions: {
+                    required: { "!!": { "var": "values.status" } }
+                }
+            } as ResolvedProperty<string>;
+
+            const result = applyPropertyConditions(property, baseContext);
+
+            expect(result.validation?.required).toBe(true);
+        });
+
+        it("should not apply disabled when condition is false", () => {
+            const property = {
+                dataType: "string",
+                name: "Title",
+                resolved: true,
+                fromBuilder: false,
+                conditions: {
+                    disabled: { "==": [{ "var": "values.status" }, "draft"] }
+                }
+            } as ResolvedProperty<string>;
+
+            const result = applyPropertyConditions(property, baseContext);
+
+            expect(result.disabled).toBeUndefined();
+        });
+
+        it("should apply enum conditions to filter values", () => {
+            const property = {
+                dataType: "string",
+                name: "Category",
+                resolved: true,
+                fromBuilder: false,
+                enumValues: [
+                    { id: "electronics", label: "Electronics" },
+                    { id: "clothing", label: "Clothing" },
+                    { id: "food", label: "Food" }
+                ],
+                conditions: {
+                    allowedEnumValues: ["electronics", "clothing"]
+                }
+            } as any;
+
+            const result = applyPropertyConditions(property, baseContext) as any;
+
+            expect(result.enumValues).toHaveLength(2);
+            expect(result.enumValues.map((e: any) => e.id)).toEqual(["electronics", "clothing"]);
+        });
+
+        it("should apply enum conditions with object format (Firestore workaround)", () => {
+            const property = {
+                dataType: "string",
+                name: "Category",
+                resolved: true,
+                fromBuilder: false,
+                enumValues: [
+                    { id: "electronics", label: "Electronics" },
+                    { id: "clothing", label: "Clothing" },
+                    { id: "food", label: "Food" }
+                ],
+                conditions: {
+                    allowedEnumValues: {
+                        "if": [
+                            { "!!": { "var": "values.status" } },
+                            { "0": "electronics", "1": "clothing" },
+                            { "0": "electronics", "1": "clothing", "2": "food" }
+                        ]
+                    }
+                }
+            } as any;
+
+            const result = applyPropertyConditions(property, baseContext) as any;
+
+            expect(result.enumValues).toHaveLength(2);
+            expect(result.enumValues.map((e: any) => e.id)).toEqual(["electronics", "clothing"]);
+        });
+
+        it("should apply excludedEnumValues to remove specific values", () => {
+            const property = {
+                dataType: "string",
+                name: "Status",
+                resolved: true,
+                fromBuilder: false,
+                enumValues: [
+                    { id: "draft", label: "Draft" },
+                    { id: "published", label: "Published" },
+                    { id: "archived", label: "Archived" }
+                ],
+                conditions: {
+                    // Simple array of excluded values
+                    excludedEnumValues: ["published"]
+                }
+            } as any;
+
+            const result = applyPropertyConditions(property, baseContext) as any;
+
+            expect(result.enumValues).toHaveLength(2);
+            expect(result.enumValues.map((e: any) => e.id)).toEqual(["draft", "archived"]);
+        });
+
+        it("should apply enum conditions to disable specific values", () => {
+            const property = {
+                dataType: "string",
+                name: "Status",
+                resolved: true,
+                fromBuilder: false,
+                enumValues: [
+                    { id: "draft", label: "Draft" },
+                    { id: "published", label: "Published" },
+                    { id: "archived", label: "Archived" }
+                ],
+                conditions: {
+                    enumConditions: {
+                        archived: {
+                            disabled: { "!=": [{ "var": "values.status" }, "archived"] }
+                        }
+                    }
+                }
+            } as any;
+
+            const result = applyPropertyConditions(property, baseContext) as any;
+            const archivedOption = result.enumValues.find((e: any) => e.id === "archived");
+            expect(archivedOption.disabled).toBeFalsy();
+
+            const contextDraft = { ...baseContext, values: { status: "draft" } };
+            const resultDraft = applyPropertyConditions(property, contextDraft) as any;
+            const archivedOptionDraft = resultDraft.enumValues.find((e: any) => e.id === "archived");
+            expect(archivedOptionDraft.disabled).toBe(true);
+        });
+
+        it("should handle multiple conditions together", () => {
+            const property = {
+                dataType: "string",
+                name: "Notes",
+                resolved: true,
+                fromBuilder: false,
+                conditions: {
+                    disabled: { "==": [{ "var": "values.status" }, "archived"] },
+                    required: { "==": [{ "var": "values.status" }, "published"] },
+                    disabledMessage: "Cannot edit notes on archived items"
+                }
+            } as ResolvedProperty<string>;
+
+            const resultArchived = applyPropertyConditions(property, baseContext);
+            expect(resultArchived.disabled).toBeDefined();
+            expect(resultArchived.validation?.required).toBeFalsy();
+
+            const contextPublished = { ...baseContext, values: { status: "published" } };
+            const resultPublished = applyPropertyConditions(property, contextPublished);
+            expect(resultPublished.disabled).toBeUndefined();
+            expect(resultPublished.validation?.required).toBe(true);
+        });
+
+        it("should handle clearOnDisabled option", () => {
+            const property = {
+                dataType: "string",
+                name: "Title",
+                resolved: true,
+                fromBuilder: false,
+                conditions: {
+                    disabled: { "==": [{ "var": "values.status" }, "archived"] },
+                    clearOnDisabled: true
+                }
+            } as ResolvedProperty<string>;
+
+            const result = applyPropertyConditions(property, baseContext);
+
+            expect(result.disabled).toEqual(expect.objectContaining({
+                clearOnDisabled: true
+            }));
+        });
+    });
+
+    describe("buildConditionContext", () => {
+
+        it("should build context with serialized dates", () => {
+            const mockAuthController = {
+                user: {
+                    uid: "user123",
+                    email: "test@example.com",
+                    displayName: "Test User",
+                    photoURL: null,
+                    providerId: "google.com",
+                    isAnonymous: false,
+                    roles: [{ id: "admin", name: "Admin" }, { id: "editor", name: "Editor" }]
+                }
+            };
+
+            const now = new Date();
+            const context = buildConditionContext({
+                propertyKey: "title",
+                values: { title: "Hello", createdAt: now },
+                path: "products",
+                entityId: "123",
+                authController: mockAuthController as any
+            });
+
+            expect(context.values.createdAt).toBe(now.getTime());
+            expect(context.user.uid).toBe("user123");
+            expect(context.user.roles).toEqual(["admin", "editor"]);
+            expect(context.isNew).toBe(false);
+            expect(context.entityId).toBe("123");
+        });
+
+        it("should mark isNew as true when no entityId", () => {
+            const mockAuthController = {
+                user: null
+            };
+
+            const context = buildConditionContext({
+                path: "products",
+                authController: mockAuthController as any
+            });
+
+            expect(context.isNew).toBe(true);
+            expect(context.entityId).toBeUndefined();
+        });
+
+        it("should handle user with Role object roles", () => {
+            const mockAuthController = {
+                user: {
+                    uid: "user123",
+                    email: "test@example.com",
+                    displayName: "Test User",
+                    photoURL: null,
+                    roles: [{ id: "admin", name: "Admin" }, { id: "editor", name: "Editor" }]
+                }
+            };
+
+            const context = buildConditionContext({
+                path: "products",
+                entityId: "123",
+                authController: mockAuthController as any
+            });
+
+            // Roles are mapped from Role.id
+            expect(context.user.roles).toEqual(["admin", "editor"]);
+        });
+
+        it("should handle null user", () => {
+            const mockAuthController = {
+                user: null
+            };
+
+            const context = buildConditionContext({
+                path: "products",
+                authController: mockAuthController as any
+            });
+
+            expect(context.user).toBeDefined();
+            // uid defaults to empty string when user is null
+            expect(context.user.uid).toBe("");
+            expect(context.user.roles).toEqual([]);
+        });
+    });
+});

package/src/util/__tests__/objects.test.ts

@@ -0,0 +1,196 @@
+import { removeFunctions, removeUndefined, isPlainObject } from "../objects";
+
+describe("objects utilities", () => {
+
+    describe("removeFunctions", () => {
+
+        it("should remove functions from objects", () => {
+            const obj = {
+                name: "test",
+                value: 42,
+                callback: () => console.log("hi")
+            };
+
+            const result = removeFunctions(obj);
+
+            expect(result.name).toBe("test");
+            expect(result.value).toBe(42);
+            expect(result.callback).toBeUndefined();
+        });
+
+        it("should preserve arrays at top level", () => {
+            const arr = ["a", "b", "c"];
+            const result = removeFunctions(arr);
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toEqual(["a", "b", "c"]);
+        });
+
+        it("should preserve nested arrays", () => {
+            const obj = {
+                items: ["a", "b", "c"],
+                numbers: [1, 2, 3]
+            };
+
+            const result = removeFunctions(obj);
+
+            expect(Array.isArray(result.items)).toBe(true);
+            expect(result.items).toEqual(["a", "b", "c"]);
+            expect(Array.isArray(result.numbers)).toBe(true);
+            expect(result.numbers).toEqual([1, 2, 3]);
+        });
+
+        it("should NOT convert arrays to objects with numeric keys", () => {
+            const arr = ["first", "second", "third"];
+            const result = removeFunctions(arr);
+
+            // Key check: the result should be an Array, not a plain object
+            // If it were converted to an object, Array.isArray would return false
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.length).toBe(3);
+            expect(result[0]).toBe("first");
+            expect(result[1]).toBe("second");
+            expect(result[2]).toBe("third");
+        });
+
+        it("should handle undefined", () => {
+            expect(removeFunctions(undefined)).toBeUndefined();
+        });
+
+        it("should handle null", () => {
+            expect(removeFunctions(null as any)).toBeNull();
+        });
+
+        it("should preserve class instances (not recurse into them)", () => {
+            class CustomClass {
+                value = 42;
+                getDouble() { return this.value * 2; }
+            }
+
+            const instance = new CustomClass();
+            const obj = { custom: instance };
+
+            const result = removeFunctions(obj);
+
+            // Class instances should be preserved as-is (not have functions stripped)
+            expect(result.custom).toBe(instance);
+            expect(result.custom.getDouble()).toBe(84);
+        });
+
+        it("should recursively remove functions from nested objects", () => {
+            const obj = {
+                level1: {
+                    name: "nested",
+                    fn: () => "should be removed",
+                    level2: {
+                        value: 100,
+                        anotherFn: () => "also removed"
+                    }
+                }
+            };
+
+            const result = removeFunctions(obj);
+
+            expect(result.level1.name).toBe("nested");
+            expect(result.level1.fn).toBeUndefined();
+            expect(result.level1.level2.value).toBe(100);
+            expect(result.level1.level2.anotherFn).toBeUndefined();
+        });
+
+        it("should handle arrays containing objects with functions", () => {
+            const arr = [
+                { name: "item1", fn: () => { } },
+                { name: "item2", fn: () => { } }
+            ];
+
+            const result = removeFunctions(arr);
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result[0].name).toBe("item1");
+            expect(result[0].fn).toBeUndefined();
+            expect(result[1].name).toBe("item2");
+            expect(result[1].fn).toBeUndefined();
+        });
+
+        it("should handle deeply nested arrays", () => {
+            const obj = {
+                conditions: {
+                    allowedEnumValues: {
+                        if: [
+                            { "==": [{ var: "values.status" }, "active"] },
+                            ["a", "b"],
+                            ["a", "b", "c"]
+                        ]
+                    }
+                }
+            };
+
+            const result = removeFunctions(obj);
+
+            // Ensure arrays inside the if array are preserved as arrays
+            expect(Array.isArray(result.conditions.allowedEnumValues.if)).toBe(true);
+            expect(Array.isArray(result.conditions.allowedEnumValues.if[1])).toBe(true);
+            expect(result.conditions.allowedEnumValues.if[1]).toEqual(["a", "b"]);
+        });
+    });
+
+    describe("removeUndefined", () => {
+
+        it("should remove undefined values from objects", () => {
+            const obj = {
+                name: "test",
+                value: undefined,
+                count: 0
+            };
+
+            const result = removeUndefined(obj);
+
+            expect(result.name).toBe("test");
+            expect(result.count).toBe(0);
+            expect("value" in result).toBe(false);
+        });
+
+        it("should preserve arrays", () => {
+            const arr = ["a", "b", "c"];
+            const result = removeUndefined(arr);
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toEqual(["a", "b", "c"]);
+        });
+
+        it("should handle null values", () => {
+            const obj = { value: null };
+            const result = removeUndefined(obj);
+
+            expect(result.value).toBeNull();
+        });
+    });
+
+    describe("isPlainObject", () => {
+
+        it("should return true for plain objects", () => {
+            expect(isPlainObject({})).toBe(true);
+            expect(isPlainObject({ a: 1 })).toBe(true);
+        });
+
+        it("should return false for arrays", () => {
+            expect(isPlainObject([])).toBe(false);
+            expect(isPlainObject([1, 2, 3])).toBe(false);
+        });
+
+        it("should return false for null", () => {
+            expect(isPlainObject(null)).toBe(false);
+        });
+
+        it("should return false for primitives", () => {
+            expect(isPlainObject("string")).toBe(false);
+            expect(isPlainObject(42)).toBe(false);
+            expect(isPlainObject(true)).toBe(false);
+        });
+
+        it("should return false for class instances", () => {
+            class MyClass { }
+            expect(isPlainObject(new MyClass())).toBe(false);
+        });
+    });
+});