@webiny/app-admin 6.3.0 → 6.4.0-beta.0

package/features/formModel/Rules.test.js

@@ -1,289 +1,324 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { Container } from "@webiny/di";
 import { FormModelFeature } from "./feature.js";
 import { ConditionRuleEvaluator } from "./ConditionRuleEvaluator.js";
 import { FormModelFactory } from "./abstractions.js";
 function createForm(config) {
-  const container = new Container();
-  FormModelFeature.register(container);
-  return container.resolve(FormModelFactory).create({
-    fields: config.fields,
-    layout: config.layout,
-    ruleEvaluators: config.extraEvaluators
-  });
-}
-describe("Rules system", () => {
-  describe("condition rule on a field", () => {
-    it("hides a field when its rule matches", () => {
-      const form = createForm({
-        fields: fields => ({
-          title: fields.text().label("Title"),
-          subtitle: fields.text().label("Subtitle").rules([{
-            type: "condition",
-            target: "title",
-            operator: "isEmpty",
-            value: null,
-            action: "hide"
-          }])
-        })
-      });
-      expect(form.field("subtitle").visible).toBe(false);
-      expect(form.field("subtitle").vm.visible).toBe(false);
-      form.field("title").setValue("Hello");
-      expect(form.field("subtitle").visible).toBe(true);
-      expect(form.field("subtitle").vm.visible).toBe(true);
-    });
-    it("disables a field when its rule matches", () => {
-      const form = createForm({
-        fields: fields => ({
-          country: fields.text().label("Country"),
-          city: fields.text().label("City").rules([{
-            type: "condition",
-            target: "country",
-            operator: "isEmpty",
-            value: null,
-            action: "disable"
-          }])
-        })
-      });
-      expect(form.field("city").vm.disabled).toBe(true);
-      form.field("country").setValue("US");
-      expect(form.field("city").vm.disabled).toBe(false);
-    });
-    it("supports eq operator", () => {
-      const form = createForm({
-        fields: fields => ({
-          plan: fields.text().label("Plan"),
-          enterpriseOnly: fields.text().label("Enterprise").rules([{
-            type: "condition",
-            target: "plan",
-            operator: "eq",
-            value: "enterprise",
-            action: "hide"
-          }])
-        })
-      });
-      form.field("plan").setValue("starter");
-      expect(form.field("enterpriseOnly").visible).toBe(true);
-      form.field("plan").setValue("enterprise");
-      expect(form.field("enterpriseOnly").visible).toBe(false);
-    });
-    it("excludes hidden fields from validation", async () => {
-      const form = createForm({
-        fields: fields => ({
-          toggle: fields.text().label("Toggle"),
-          required: fields.text().label("Required").required("Must fill").rules([{
-            type: "condition",
-            target: "toggle",
-            operator: "isEmpty",
-            value: null,
-            action: "hide"
-          }])
-        })
-      });
-
-      // toggle is empty → "required" is hidden → should not count as invalid
-      const valid = await form.validate();
-      expect(valid).toBe(true);
-
-      // Fill toggle → "required" becomes visible → fails without a value
-      form.field("toggle").setValue("anything");
-      const valid2 = await form.validate();
-      expect(valid2).toBe(false);
-      expect(form.errors.some(e => e.path === "required")).toBe(true);
-    });
-  });
-  describe("rules on layout elements", () => {
-    it("cascades disable from tabs container to contained fields", () => {
-      const form = createForm({
-        fields: fields => ({
-          trigger: fields.text().label("Trigger"),
-          general: fields.text().label("General"),
-          seo: fields.text().label("SEO")
-        }),
-        layout: layout => [layout.row("trigger"), layout.tabs("settings").rules([{
-          type: "condition",
-          target: "trigger",
-          operator: "isEmpty",
-          value: null,
-          action: "disable"
-        }]).tab("general", tab => {
-          tab.label("General").layout(layout => [layout.row("general")]);
-        }).tab("seo", tab => {
-          tab.label("SEO").layout(layout => [layout.row("seo")]);
-        })]
-      });
-      expect(form.field("general").vm.disabled).toBe(true);
-      expect(form.field("seo").vm.disabled).toBe(true);
-      const tabs = form.vm.layout[1];
-      expect(tabs.disabled).toBe(true);
-      expect(tabs.tabs[0].disabled).toBe(true);
-      form.field("trigger").setValue("go");
-      expect(form.field("general").vm.disabled).toBe(false);
-      expect(form.field("seo").vm.disabled).toBe(false);
+    const container = new Container();
+    FormModelFeature.register(container);
+    return container.resolve(FormModelFactory).create({
+        fields: config.fields,
+        layout: config.layout,
+        ruleEvaluators: config.extraEvaluators
     });
-    it("cascades disable from a single tab to its fields only", () => {
-      const form = createForm({
-        fields: fields => ({
-          title: fields.text().label("Title"),
-          general: fields.text().label("General"),
-          seo: fields.text().label("SEO")
-        }),
-        layout: layout => [layout.tabs("settings").tab("general", tab => {
-          tab.label("General").layout(layout => [layout.row("general")]);
-        }).tab("seo", tab => {
-          tab.label("SEO").rules([{
-            type: "condition",
-            target: "title",
-            operator: "isEmpty",
-            value: null,
-            action: "disable"
-          }]).layout(layout => [layout.row("seo")]);
-        })]
-      });
-      expect(form.field("general").vm.disabled).toBe(false);
-      expect(form.field("seo").vm.disabled).toBe(true);
-      const tabs = form.vm.layout[0];
-      expect(tabs.tabs[0].disabled).toBe(false);
-      expect(tabs.tabs[1].disabled).toBe(true);
-    });
-    it("hides a tab and its fields when the tab has a hide rule", async () => {
-      const form = createForm({
-        fields: fields => ({
-          trigger: fields.text().label("Trigger"),
-          hiddenField: fields.text().label("Hidden").required("needed")
-        }),
-        layout: layout => [layout.row("trigger"), layout.tabs("settings").tab("secret", tab => {
-          tab.label("Secret").rules([{
-            type: "condition",
-            target: "trigger",
-            operator: "isEmpty",
-            value: null,
-            action: "hide"
-          }]).layout(layout => [layout.row("hiddenField")]);
-        })]
-      });
-
-      // Tab is hidden → field inside is hidden → not validated
-      const valid = await form.validate();
-      expect(valid).toBe(true);
-
-      // Form VM should not expose this tabs node (all tabs hidden = no tabs node)
-      const tabsVm = form.vm.layout.find(n => n.type === "tabs");
-      expect(tabsVm).toBeUndefined();
-    });
-    it("hides the entire tabs container when its rule matches", () => {
-      const form = createForm({
-        fields: fields => ({
-          trigger: fields.text().label("Trigger"),
-          inner: fields.text().label("Inner")
-        }),
-        layout: layout => [layout.row("trigger"), layout.tabs("settings").rules([{
-          type: "condition",
-          target: "trigger",
-          operator: "isEmpty",
-          value: null,
-          action: "hide"
-        }]).tab("tab1", tab => {
-          tab.label("Tab 1").layout(layout => [layout.row("inner")]);
-        })]
-      });
-      expect(form.vm.layout.find(n => n.type === "tabs")).toBeUndefined();
-      expect(form.field("inner").visible).toBe(false);
-      form.field("trigger").setValue("yes");
-      expect(form.field("inner").visible).toBe(true);
-      expect(form.vm.layout.find(n => n.type === "tabs")).toBeDefined();
-    });
-  });
-  describe("custom rule evaluators", () => {
-    it("uses externally registered evaluators for custom rule types", () => {
-      class AccessControlEvaluator {
-        constructor(userTeams) {
-          this.userTeams = userTeams;
-        }
-        canEvaluate(rule) {
-          return rule.type === "accessControl";
-        }
-        evaluate(rule) {
-          if (!rule.value) {
-            return false;
-          }
-          const [scope, id] = rule.value.split(":");
-          return scope === "team" && this.userTeams.includes(id);
-        }
-      }
-      const form = createForm({
-        extraEvaluators: [new AccessControlEvaluator(["admins"])],
-        fields: fields => ({
-          adminField: fields.text().label("Admin Only").rules([{
-            type: "accessControl",
-            target: "identity",
-            operator: "matches",
-            value: "team:admins",
-            action: "disable"
-          }])
-        })
-      });
-      expect(form.field("adminField").vm.disabled).toBe(true);
+}
+describe("Rules system", ()=>{
+    describe("condition rule on a field", ()=>{
+        it("hides a field when its rule matches", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text().label("Title"),
+                        subtitle: fields.text().label("Subtitle").rules([
+                            {
+                                type: "condition",
+                                target: "title",
+                                operator: "isEmpty",
+                                value: null,
+                                action: "hide"
+                            }
+                        ])
+                    })
+            });
+            expect(form.field("subtitle").visible).toBe(false);
+            expect(form.field("subtitle").vm.visible).toBe(false);
+            form.field("title").setValue("Hello");
+            expect(form.field("subtitle").visible).toBe(true);
+            expect(form.field("subtitle").vm.visible).toBe(true);
+        });
+        it("disables a field when its rule matches", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        country: fields.text().label("Country"),
+                        city: fields.text().label("City").rules([
+                            {
+                                type: "condition",
+                                target: "country",
+                                operator: "isEmpty",
+                                value: null,
+                                action: "disable"
+                            }
+                        ])
+                    })
+            });
+            expect(form.field("city").vm.disabled).toBe(true);
+            form.field("country").setValue("US");
+            expect(form.field("city").vm.disabled).toBe(false);
+        });
+        it("supports eq operator", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        plan: fields.text().label("Plan"),
+                        enterpriseOnly: fields.text().label("Enterprise").rules([
+                            {
+                                type: "condition",
+                                target: "plan",
+                                operator: "eq",
+                                value: "enterprise",
+                                action: "hide"
+                            }
+                        ])
+                    })
+            });
+            form.field("plan").setValue("starter");
+            expect(form.field("enterpriseOnly").visible).toBe(true);
+            form.field("plan").setValue("enterprise");
+            expect(form.field("enterpriseOnly").visible).toBe(false);
+        });
+        it("excludes hidden fields from validation", async ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        toggle: fields.text().label("Toggle"),
+                        required: fields.text().label("Required").required("Must fill").rules([
+                            {
+                                type: "condition",
+                                target: "toggle",
+                                operator: "isEmpty",
+                                value: null,
+                                action: "hide"
+                            }
+                        ])
+                    })
+            });
+            const valid = await form.validate();
+            expect(valid).toBe(true);
+            form.field("toggle").setValue("anything");
+            const valid2 = await form.validate();
+            expect(valid2).toBe(false);
+            expect(form.errors.some((e)=>"required" === e.path)).toBe(true);
+        });
     });
-    it("ignores rules with unknown types (no evaluator)", () => {
-      const form = createForm({
-        fields: fields => ({
-          weird: fields.text().label("Weird").rules([{
-            type: "bogusType",
-            target: "x",
-            operator: "noop",
-            value: null,
-            action: "hide"
-          }])
-        })
-      });
-
-      // Unknown rule types are ignored — field remains visible
-      expect(form.field("weird").visible).toBe(true);
-      expect(form.field("weird").vm.disabled).toBe(false);
+    describe("rules on layout elements", ()=>{
+        it("cascades disable from tabs container to contained fields", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        trigger: fields.text().label("Trigger"),
+                        general: fields.text().label("General"),
+                        seo: fields.text().label("SEO")
+                    }),
+                layout: (layout)=>[
+                        layout.row("trigger"),
+                        layout.tabs("settings").rules([
+                            {
+                                type: "condition",
+                                target: "trigger",
+                                operator: "isEmpty",
+                                value: null,
+                                action: "disable"
+                            }
+                        ]).tab("general", (tab)=>{
+                            tab.label("General").layout((layout)=>[
+                                    layout.row("general")
+                                ]);
+                        }).tab("seo", (tab)=>{
+                            tab.label("SEO").layout((layout)=>[
+                                    layout.row("seo")
+                                ]);
+                        })
+                    ]
+            });
+            expect(form.field("general").vm.disabled).toBe(true);
+            expect(form.field("seo").vm.disabled).toBe(true);
+            const tabs = form.vm.layout[1];
+            expect(tabs.disabled).toBe(true);
+            expect(tabs.tabs[0].disabled).toBe(true);
+            form.field("trigger").setValue("go");
+            expect(form.field("general").vm.disabled).toBe(false);
+            expect(form.field("seo").vm.disabled).toBe(false);
+        });
+        it("cascades disable from a single tab to its fields only", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text().label("Title"),
+                        general: fields.text().label("General"),
+                        seo: fields.text().label("SEO")
+                    }),
+                layout: (layout)=>[
+                        layout.tabs("settings").tab("general", (tab)=>{
+                            tab.label("General").layout((layout)=>[
+                                    layout.row("general")
+                                ]);
+                        }).tab("seo", (tab)=>{
+                            tab.label("SEO").rules([
+                                {
+                                    type: "condition",
+                                    target: "title",
+                                    operator: "isEmpty",
+                                    value: null,
+                                    action: "disable"
+                                }
+                            ]).layout((layout)=>[
+                                    layout.row("seo")
+                                ]);
+                        })
+                    ]
+            });
+            expect(form.field("general").vm.disabled).toBe(false);
+            expect(form.field("seo").vm.disabled).toBe(true);
+            const tabs = form.vm.layout[0];
+            expect(tabs.tabs[0].disabled).toBe(false);
+            expect(tabs.tabs[1].disabled).toBe(true);
+        });
+        it("hides a tab and its fields when the tab has a hide rule", async ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        trigger: fields.text().label("Trigger"),
+                        hiddenField: fields.text().label("Hidden").required("needed")
+                    }),
+                layout: (layout)=>[
+                        layout.row("trigger"),
+                        layout.tabs("settings").tab("secret", (tab)=>{
+                            tab.label("Secret").rules([
+                                {
+                                    type: "condition",
+                                    target: "trigger",
+                                    operator: "isEmpty",
+                                    value: null,
+                                    action: "hide"
+                                }
+                            ]).layout((layout)=>[
+                                    layout.row("hiddenField")
+                                ]);
+                        })
+                    ]
+            });
+            const valid = await form.validate();
+            expect(valid).toBe(true);
+            const tabsVm = form.vm.layout.find((n)=>"tabs" === n.type);
+            expect(tabsVm).toBeUndefined();
+        });
+        it("hides the entire tabs container when its rule matches", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        trigger: fields.text().label("Trigger"),
+                        inner: fields.text().label("Inner")
+                    }),
+                layout: (layout)=>[
+                        layout.row("trigger"),
+                        layout.tabs("settings").rules([
+                            {
+                                type: "condition",
+                                target: "trigger",
+                                operator: "isEmpty",
+                                value: null,
+                                action: "hide"
+                            }
+                        ]).tab("tab1", (tab)=>{
+                            tab.label("Tab 1").layout((layout)=>[
+                                    layout.row("inner")
+                                ]);
+                        })
+                    ]
+            });
+            expect(form.vm.layout.find((n)=>"tabs" === n.type)).toBeUndefined();
+            expect(form.field("inner").visible).toBe(false);
+            form.field("trigger").setValue("yes");
+            expect(form.field("inner").visible).toBe(true);
+            expect(form.vm.layout.find((n)=>"tabs" === n.type)).toBeDefined();
+        });
     });
-  });
-  describe("ConditionRuleEvaluator", () => {
-    it("canEvaluate returns true only for condition rules", () => {
-      const e = new ConditionRuleEvaluator();
-      expect(e.canEvaluate({
-        type: "condition",
-        target: "x",
-        operator: "eq",
-        value: "y",
-        action: "hide"
-      })).toBe(true);
-      expect(e.canEvaluate({
-        type: "accessControl",
-        target: "identity",
-        operator: "matches",
-        value: "team:x",
-        action: "hide"
-      })).toBe(false);
+    describe("custom rule evaluators", ()=>{
+        it("uses externally registered evaluators for custom rule types", ()=>{
+            class AccessControlEvaluator {
+                constructor(userTeams){
+                    this.userTeams = userTeams;
+                }
+                canEvaluate(rule) {
+                    return "accessControl" === rule.type;
+                }
+                evaluate(rule) {
+                    if (!rule.value) return false;
+                    const [scope, id] = rule.value.split(":");
+                    return "team" === scope && this.userTeams.includes(id);
+                }
+            }
+            const form = createForm({
+                extraEvaluators: [
+                    new AccessControlEvaluator([
+                        "admins"
+                    ])
+                ],
+                fields: (fields)=>({
+                        adminField: fields.text().label("Admin Only").rules([
+                            {
+                                type: "accessControl",
+                                target: "identity",
+                                operator: "matches",
+                                value: "team:admins",
+                                action: "disable"
+                            }
+                        ])
+                    })
+            });
+            expect(form.field("adminField").vm.disabled).toBe(true);
+        });
+        it("ignores rules with unknown types (no evaluator)", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        weird: fields.text().label("Weird").rules([
+                            {
+                                type: "bogusType",
+                                target: "x",
+                                operator: "noop",
+                                value: null,
+                                action: "hide"
+                            }
+                        ])
+                    })
+            });
+            expect(form.field("weird").visible).toBe(true);
+            expect(form.field("weird").vm.disabled).toBe(false);
+        });
     });
-    it("isEmpty matches null, undefined, empty string, empty array", () => {
-      const e = new ConditionRuleEvaluator();
-      const mkForm = value => ({
-        field: () => ({
-          getValue: () => value
-        })
-      });
-      const rule = {
-        type: "condition",
-        target: "x",
-        operator: "isEmpty",
-        value: null,
-        action: "hide"
-      };
-      expect(e.evaluate(rule, mkForm(null))).toBe(true);
-      expect(e.evaluate(rule, mkForm(undefined))).toBe(true);
-      expect(e.evaluate(rule, mkForm(""))).toBe(true);
-      expect(e.evaluate(rule, mkForm([]))).toBe(true);
-      expect(e.evaluate(rule, mkForm("hello"))).toBe(false);
-      expect(e.evaluate(rule, mkForm(0))).toBe(false);
+    describe("ConditionRuleEvaluator", ()=>{
+        it("canEvaluate returns true only for condition rules", ()=>{
+            const e = new ConditionRuleEvaluator();
+            expect(e.canEvaluate({
+                type: "condition",
+                target: "x",
+                operator: "eq",
+                value: "y",
+                action: "hide"
+            })).toBe(true);
+            expect(e.canEvaluate({
+                type: "accessControl",
+                target: "identity",
+                operator: "matches",
+                value: "team:x",
+                action: "hide"
+            })).toBe(false);
+        });
+        it("isEmpty matches null, undefined, empty string, empty array", ()=>{
+            const e = new ConditionRuleEvaluator();
+            const mkForm = (value)=>({
+                    field: ()=>({
+                            getValue: ()=>value
+                        })
+                });
+            const rule = {
+                type: "condition",
+                target: "x",
+                operator: "isEmpty",
+                value: null,
+                action: "hide"
+            };
+            expect(e.evaluate(rule, mkForm(null))).toBe(true);
+            expect(e.evaluate(rule, mkForm(void 0))).toBe(true);
+            expect(e.evaluate(rule, mkForm(""))).toBe(true);
+            expect(e.evaluate(rule, mkForm([]))).toBe(true);
+            expect(e.evaluate(rule, mkForm("hello"))).toBe(false);
+            expect(e.evaluate(rule, mkForm(0))).toBe(false);
+        });
     });
-  });
 });
 
 //# sourceMappingURL=Rules.test.js.map