@webiny/app-admin 6.4.12-beta.4 → 6.5.0-beta.0

package/features/formModel/FormModel.test.js

@@ -2,9 +2,11 @@ import { describe, expect, it, vi } from "vitest";
 import { z } from "zod";
 import { Container } from "@webiny/di";
 import { FormModelFeature } from "./feature.js";
+import { IdentityContextFeature } from "../security/IdentityContext/feature.js";
 import { FormModelFactory } from "./abstractions.js";
 function createForm(config) {
     const container = new Container();
+    IdentityContextFeature.register(container);
     FormModelFeature.register(container);
     return container.resolve(FormModelFactory).create(config);
 }
@@ -177,6 +179,63 @@ describe("FormModel", ()=>{
             expect(valid).toBe(false);
             expect(form.errors[0].message).toBe("Email is required");
         });
+        it("should skip zod validation for non-required field with null value", async ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        description: fields.text().label("Description").schema(z.string())
+                    })
+            });
+            const valid = await form.validate();
+            expect(valid).toBe(true);
+            expect(form.errors).toHaveLength(0);
+            expect(form.field("description").vm.validation.isValid).toBeNull();
+        });
+        it("should skip zod validation for non-required field with undefined value", async ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        description: fields.text().label("Description").schema(z.string())
+                    })
+            });
+            form.field("description").setValue(void 0);
+            const valid = await form.validate();
+            expect(valid).toBe(true);
+            expect(form.errors).toHaveLength(0);
+            expect(form.field("description").vm.validation.isValid).toBeNull();
+        });
+        it("should run zod validation for non-required field with empty string value", async ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        description: fields.text().label("Description").schema(z.string().min(3, "Too short"))
+                    })
+            });
+            form.field("description").setValue("");
+            const valid = await form.validate();
+            expect(valid).toBe(false);
+            expect(form.field("description").vm.validation.isValid).toBe(false);
+            expect(form.field("description").vm.validation.message).toBe("Too short");
+        });
+        it("should fail required validation for required field with null value even when schema is set", async ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        description: fields.text().label("Description").required("Description is required").schema(z.string().min(3, "Too short"))
+                    })
+            });
+            const valid = await form.validate();
+            expect(valid).toBe(false);
+            expect(form.field("description").vm.validation.isValid).toBe(false);
+            expect(form.field("description").vm.validation.message).toBe("Description is required");
+        });
+        it("should run and pass zod validation for non-required field with valid value", async ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        description: fields.text().label("Description").schema(z.string().min(3, "Too short"))
+                    })
+            });
+            form.field("description").setValue("Hello world");
+            const valid = await form.validate();
+            expect(valid).toBe(true);
+            expect(form.field("description").vm.validation.isValid).toBe(true);
+        });
         it("should expose field-level validation in field.vm", async ()=>{
             const form = createBasicForm();
             await form.validate();
@@ -184,6 +243,23 @@ describe("FormModel", ()=>{
             expect(titleVm.validation.isValid).toBe(false);
             expect(titleVm.validation.message).toBe("Title is required");
         });
+        it("setValidationWithCache should populate the validation cache", async ()=>{
+            const schema = z.string().min(3, "Too short");
+            const spy = vi.spyOn(schema, "safeParseAsync");
+            const form = createForm({
+                fields: (fields)=>({
+                        description: fields.text().label("Description").schema(schema)
+                    })
+            });
+            const valid1 = await form.validate();
+            expect(valid1).toBe(true);
+            expect(spy).not.toHaveBeenCalled();
+            const valid2 = await form.validate();
+            expect(valid2).toBe(true);
+            expect(spy).not.toHaveBeenCalled();
+            expect(form.field("description").vm.validation.isValid).toBeNull();
+            spy.mockRestore();
+        });
         it("isValid should be null before first validation", ()=>{
             const form = createBasicForm();
             expect(form.isValid).toBeNull();
@@ -364,9 +440,9 @@ describe("FormModel", ()=>{
         it("should support cross-field afterChange triggering target field pipeline", ()=>{
             const form = createForm({
                 fields: (fields)=>({
-                        title: fields.text().label("Title").afterChange((value, f)=>{
+                        title: fields.text().label("Title").afterChange((value, { form })=>{
                             const path = "/" + String(value).toLowerCase().replace(/\s+/g, "-");
-                            f.field("path").setValue(path);
+                            form.field("path").setValue(path);
                         }),
                         path: fields.text().label("Path").beforeChange((value)=>{
                             const str = String(value);
@@ -401,10 +477,10 @@ describe("FormModel", ()=>{
         it("should demonstrate title→path with path-dirty tracking", ()=>{
             const form = createForm({
                 fields: (fields)=>({
-                        title: fields.text().label("Title").required("Title is required").afterChange((value, f)=>{
-                            if (f.field("path").getValue()) return;
+                        title: fields.text().label("Title").required("Title is required").afterChange((value, { form })=>{
+                            if (form.field("path").getValue()) return;
                             const slug = String(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-                            f.field("path").setValue("/" + slug);
+                            form.field("path").setValue("/" + slug);
                         }),
                         path: fields.text().label("Path").required("Path is required").beforeChange((value)=>{
                             const str = String(value);
@@ -606,9 +682,9 @@ describe("FormModel", ()=>{
                             path: fields.text().label("Path")
                         })
                 });
-                form.field("title").addAfterChange((value, f)=>{
+                form.field("title").addAfterChange((value, { form })=>{
                     received.push(value);
-                    f.field("path").setValue("/" + String(value).toLowerCase());
+                    form.field("path").setValue("/" + String(value).toLowerCase());
                 });
                 form.field("title").setValue("Hello");
                 expect(received).toEqual([
@@ -751,11 +827,11 @@ describe("FormModel", ()=>{
                                         label: "German",
                                         value: "de"
                                     }
-                                ]).afterChange((value, f)=>{
-                                    const current = String(f.field("path").getValue() || "");
+                                ]).afterChange((value, { form })=>{
+                                    const current = String(form.field("path").getValue() || "");
                                     const stripped = current.replace(/^\/[a-z]{2}\//, "/");
-                                    if (value && "en" !== value) f.field("path").setValue("/" + value + stripped);
-                                    else f.field("path").setValue(stripped);
+                                    if (value && "en" !== value) form.field("path").setValue("/" + value + stripped);
+                                    else form.field("path").setValue(stripped);
                                 })
                             }));
                         form.layout((layout)=>[
@@ -1316,6 +1392,108 @@ describe("FormModel", ()=>{
                     }
                 });
             });
+            it("should skip schema validation for non-required object field with null underlying data", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            address: fields.object().label("Address").fields((f)=>({
+                                    street: f.text().label("Street")
+                                })).schema(z.object({
+                                street: z.string().min(1)
+                            }))
+                        })
+                });
+                form.setData({
+                    address: null
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(true);
+                expect(form.errors).toHaveLength(0);
+            });
+            it("should skip schema validation for non-required object field with undefined underlying data", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            address: fields.object().label("Address").fields((f)=>({
+                                    street: f.text().label("Street")
+                                })).schema(z.object({
+                                street: z.string().min(1)
+                            }))
+                        })
+                });
+                form.setData({
+                    address: void 0
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(true);
+                expect(form.errors).toHaveLength(0);
+            });
+            it("should run schema validation for non-required object field with populated values", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            address: fields.object().label("Address").fields((f)=>({
+                                    street: f.text().label("Street")
+                                })).schema(z.object({
+                                street: z.string().min(5, "Street too short")
+                            }))
+                        })
+                });
+                form.field("address.street").setValue("Hi");
+                const valid = await form.validate();
+                expect(valid).toBe(false);
+                expect(form.errors).toHaveLength(1);
+                expect(form.errors[0].message).toBe("Street too short");
+            });
+            it("should run schema validation for required object field with populated but invalid values", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            address: fields.object().label("Address").fields((f)=>({
+                                    street: f.text().label("Street")
+                                })).required("Address is required").schema(z.object({
+                                street: z.string().min(5, "Street too short")
+                            }))
+                        })
+                });
+                form.field("address.street").setValue("Hi");
+                const valid = await form.validate();
+                expect(valid).toBe(false);
+                expect(form.errors).toHaveLength(1);
+                expect(form.errors[0].message).toBe("Street too short");
+            });
+            it("should fail required validation for required object field with null data even when schema is set", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            address: fields.object().label("Address").fields((f)=>({
+                                    street: f.text().label("Street")
+                                })).required("Address is required").schema(z.object({
+                                street: z.string().min(1)
+                            }))
+                        })
+                });
+                form.setData({
+                    address: null
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(false);
+                expect(form.errors).toHaveLength(1);
+                expect(form.errors[0].message).toBe("Address is required");
+            });
+            it("should skip schema validation for non-required object field when all child values are empty", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            address: fields.object().label("Address").fields((f)=>({
+                                    street: f.text().label("Street"),
+                                    city: f.text().label("City")
+                                })).schema(z.object({
+                                street: z.string().min(1),
+                                city: z.string().min(1)
+                            }))
+                        })
+                });
+                form.field("address.street").setValue("");
+                form.field("address.city").setValue("");
+                const valid = await form.validate();
+                expect(valid).toBe(true);
+                expect(form.errors).toHaveLength(0);
+            });
         });
         describe("list object field", ()=>{
             function createFormWithList() {
@@ -1503,6 +1681,74 @@ describe("FormModel", ()=>{
                 expect(valid).toBe(false);
                 expect(form.errors[0].message).toBe("At least 2 presets are required");
             });
+            it("should skip listSchema validation for non-required list field with empty list", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            presets: fields.object().label("Presets").fields((f)=>({
+                                    name: f.text().label("Name")
+                                })).list().listSchema(z.array(z.any()).min(2, "At least 2 presets are required"))
+                        })
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(true);
+                expect(form.errors).toHaveLength(0);
+            });
+            it("should skip listSchema validation for non-required list field with undefined value", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            presets: fields.object().label("Presets").fields((f)=>({
+                                    name: f.text().label("Name")
+                                })).list().listSchema(z.array(z.any()).min(2, "At least 2 presets are required"))
+                        })
+                });
+                form.setData({
+                    presets: void 0
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(true);
+                expect(form.errors).toHaveLength(0);
+            });
+            it("should skip listSchema validation for non-required list field with null value", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            presets: fields.object().label("Presets").fields((f)=>({
+                                    name: f.text().label("Name")
+                                })).list().listSchema(z.array(z.any()).min(2, "At least 2 presets are required"))
+                        })
+                });
+                form.setData({
+                    presets: null
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(true);
+                expect(form.errors).toHaveLength(0);
+            });
+            it("should enforce listSchema validation for required list field with null value", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            presets: fields.object().label("Presets").fields((f)=>({
+                                    name: f.text().label("Name")
+                                })).list().required("Presets are required").listSchema(z.array(z.any()).min(2, "At least 2 presets are required"))
+                        })
+                });
+                form.setData({
+                    presets: null
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(false);
+                expect(form.errors[0].message).toBe("Presets are required");
+            });
+            it("should enforce listSchema validation for required list field with empty list", async ()=>{
+                const form = createForm({
+                    fields: (fields)=>({
+                            presets: fields.object().label("Presets").fields((f)=>({
+                                    name: f.text().label("Name")
+                                })).list().required("Presets are required").listSchema(z.array(z.any()).min(2, "At least 2 presets are required"))
+                        })
+                });
+                const valid = await form.validate();
+                expect(valid).toBe(false);
+            });
             it("should be dirty after adding an item", ()=>{
                 const form = createFormWithList();
                 form.setData({
@@ -2957,7 +3203,7 @@ describe("FormModel", ()=>{
             const form = createForm({
                 fields: (fields)=>({
                         plan: fields.text().defaultValue("free"),
-                        seats: fields.text().requiredWhen((f)=>"pro" === f.field("plan").getValue(), "Seats required")
+                        seats: fields.text().requiredWhen(({ form })=>"pro" === form.field("plan").getValue(), "Seats required")
                     })
             });
             expect(form.field("seats").vm.required).toBe(false);
@@ -2972,7 +3218,7 @@ describe("FormModel", ()=>{
                 fields: (fields)=>({
                         plan: fields.text().defaultValue("free"),
                         flag: fields.text().defaultValue("off"),
-                        seats: fields.text().requiredWhen((f)=>"pro" === f.field("plan").getValue(), "Pro requires it").requiredWhen((f)=>"on" === f.field("flag").getValue(), "Flag requires it")
+                        seats: fields.text().requiredWhen(({ form })=>"pro" === form.field("plan").getValue(), "Pro requires it").requiredWhen(({ form })=>"on" === form.field("flag").getValue(), "Flag requires it")
                     })
             });
             form.field("flag").setValue("on");
@@ -2997,10 +3243,10 @@ describe("FormModel", ()=>{
                 fields: (fields)=>({
                         plan: fields.text().defaultValue("free"),
                         other: fields.text().defaultValue("off"),
-                        seats: fields.text().requiredWhen((f)=>"pro" === f.field("plan").getValue(), "Pro required")
+                        seats: fields.text().requiredWhen(({ form })=>"pro" === form.field("plan").getValue(), "Pro required")
                     })
             });
-            form.field("seats").addRequiredWhen((f)=>"on" === f.field("other").getValue(), "Other required");
+            form.field("seats").addRequiredWhen(({ form })=>"on" === form.field("other").getValue(), "Other required");
             expect(form.field("seats").vm.required).toBe(false);
             form.field("other").setValue("on");
             await form.validate();
@@ -3013,7 +3259,7 @@ describe("FormModel", ()=>{
                 fields: (fields)=>({
                         first: fields.text().defaultValue("Ada"),
                         last: fields.text().defaultValue("Lovelace"),
-                        full: fields.text().computed((f)=>`${f.field("first").getValue()} ${f.field("last").getValue()}`)
+                        full: fields.text().computed(({ form })=>`${form.field("first").getValue()} ${form.field("last").getValue()}`)
                     })
             });
             expect(form.field("full").getValue()).toBe("Ada Lovelace");
@@ -3024,7 +3270,7 @@ describe("FormModel", ()=>{
             const form = createForm({
                 fields: (fields)=>({
                         src: fields.text().defaultValue("A"),
-                        derived: fields.text().computed((f)=>f.field("src").getValue())
+                        derived: fields.text().computed(({ form })=>form.field("src").getValue())
                     })
             });
             expect(form.field("derived").vm.disabled).toBe(false);
@@ -3035,7 +3281,7 @@ describe("FormModel", ()=>{
             const form = createForm({
                 fields: (fields)=>({
                         src: fields.text().defaultValue("A"),
-                        derived: fields.text().computedUntilDirty((f)=>`derived-${f.field("src").getValue()}`)
+                        derived: fields.text().computedUntilDirty(({ form })=>`derived-${form.field("src").getValue()}`)
                     })
             });
             expect(form.field("derived").getValue()).toBe("derived-A");
@@ -3048,7 +3294,7 @@ describe("FormModel", ()=>{
             const form = createForm({
                 fields: (fields)=>({
                         src: fields.text().defaultValue(""),
-                        derived: fields.text().required("Derived must not be empty").computed((f)=>f.field("src").getValue())
+                        derived: fields.text().required("Derived must not be empty").computed(({ form })=>form.field("src").getValue())
                     })
             });
             const valid = await form.validate();
@@ -3057,6 +3303,77 @@ describe("FormModel", ()=>{
             form.field("src").setValue("hello");
             expect(await form.validate()).toBe(true);
         });
+        it("computedUntilDirty can access nested fields inside object via dot notation", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        group: fields.object().renderer("passthrough").fields((f)=>({
+                                label: f.text().defaultValue("Hello World"),
+                                fieldId: f.text().computedUntilDirty(({ form })=>String(form.field("group.label").getValue() || "").toLowerCase().replace(/\s+/g, "-"))
+                            }))
+                    })
+            });
+            expect(form.field("group.fieldId").getValue()).toBe("hello-world");
+            form.field("group.label").setValue("New Title");
+            expect(form.field("group.fieldId").getValue()).toBe("new-title");
+            form.field("group.fieldId").vm.onChange("custom-id");
+            expect(form.field("group.fieldId").getValue()).toBe("custom-id");
+            form.field("group.label").setValue("Another");
+            expect(form.field("group.fieldId").getValue()).toBe("custom-id");
+        });
+        it("computedUntilDirty works after setData for nested object fields", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        general: fields.object().renderer("passthrough").fields((f)=>({
+                                label: f.text(),
+                                fieldId: f.text().computedUntilDirty(({ form })=>String(form.field("general.label").getValue() || "").toLowerCase().replace(/\s+/g, "-"))
+                            }))
+                    })
+            });
+            expect(form.field("general.fieldId").getValue()).toBe("");
+            form.setData({
+                general: {
+                    label: "My Field"
+                }
+            });
+            expect(form.field("general.fieldId").getValue()).toBe("my-field");
+            form.field("general.label").setValue("Updated Label");
+            expect(form.field("general.fieldId").getValue()).toBe("updated-label");
+            form.field("general.fieldId").vm.onChange("custom");
+            expect(form.field("general.fieldId").getValue()).toBe("custom");
+            form.field("general.label").setValue("Ignored");
+            expect(form.field("general.fieldId").getValue()).toBe("custom");
+        });
+        it("field.parent().field() resolves sibling fields relative to the parent object", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        group: fields.object().renderer("passthrough").fields((f)=>({
+                                label: f.text().defaultValue("Hello"),
+                                slug: f.text().computedUntilDirty(({ field })=>String(field.parent().field("label").getValue() || "").toLowerCase().replace(/\s+/g, "-"))
+                            }))
+                    })
+            });
+            expect(form.field("group.slug").getValue()).toBe("hello");
+            form.field("group.label").setValue("New Title");
+            expect(form.field("group.slug").getValue()).toBe("new-title");
+        });
+        it("field.parent().field() can traverse into sibling objects", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        wrapper: fields.object().renderer("passthrough").fields((f)=>({
+                                message: f.text().defaultValue("default").computedUntilDirty(({ field })=>{
+                                    const preset = field.parent().field("settings.preset").getValue();
+                                    return "custom" === preset ? "Custom message" : `Preset: ${preset}`;
+                                }),
+                                settings: f.object().renderer("passthrough").fields((inner)=>({
+                                        preset: inner.text().defaultValue("custom")
+                                    }))
+                            }))
+                    })
+            });
+            expect(form.field("wrapper.message").getValue()).toBe("Custom message");
+            form.field("wrapper.settings.preset").setValue("email");
+            expect(form.field("wrapper.message").getValue()).toBe("Preset: email");
+        });
         it("modifier setComputed converts a regular field into a computed one", ()=>{
             const form = createForm({
                 fields: (fields)=>({
@@ -3064,7 +3381,7 @@ describe("FormModel", ()=>{
                         derived: fields.text().defaultValue("initial")
                     })
             });
-            form.field("derived").setComputed((f)=>`from-${f.field("src").getValue()}`);
+            form.field("derived").setComputed(({ form })=>`from-${form.field("src").getValue()}`);
             expect(form.field("derived").getValue()).toBe("from-X");
             form.field("src").setValue("Y");
             expect(form.field("derived").getValue()).toBe("from-Y");
@@ -3786,7 +4103,7 @@ describe("FormModel", ()=>{
                 fields: (f)=>({
                         tags: f.text().list().defaultValue([
                             "a"
-                        ]).beforeChange((value, _form)=>{
+                        ]).beforeChange((value, _params)=>{
                             log.push(value);
                             return value;
                         })
@@ -3808,6 +4125,180 @@ describe("FormModel", ()=>{
             ]);
         });
     });
+    describe("field context", ()=>{
+        it("should expose context derived from sibling fields via form param", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text().defaultValue("My Article"),
+                        description: fields.text().defaultValue("A great article"),
+                        media: fields.file().context(({ form })=>({
+                                title: form.field("title").getValue(),
+                                description: form.field("description").getValue()
+                            }))
+                    })
+            });
+            expect(form.field("media").vm.context).toEqual({
+                title: "My Article",
+                description: "A great article"
+            });
+        });
+        it("should access root-level siblings via field.parent().field()", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text().defaultValue("Root Sibling"),
+                        media: fields.file().context(({ field })=>({
+                                title: field.parent().field("title").getValue()
+                            }))
+                    })
+            });
+            expect(form.field("media").vm.context).toEqual({
+                title: "Root Sibling"
+            });
+        });
+        it("should reactively update context when source fields change", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text().defaultValue("Original"),
+                        media: fields.file().context(({ form })=>({
+                                title: form.field("title").getValue()
+                            }))
+                    })
+            });
+            expect(form.field("media").vm.context).toEqual({
+                title: "Original"
+            });
+            form.field("title").setValue("Updated");
+            expect(form.field("media").vm.context).toEqual({
+                title: "Updated"
+            });
+        });
+        it("should default to empty object when no context callback is set", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text()
+                    })
+            });
+            expect(form.field("title").vm.context).toEqual({});
+        });
+        it("should access root fields via form param from nested object", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text().defaultValue("Page Title"),
+                        settings: fields.object().fields((f)=>({
+                                media: f.file().context(({ form })=>({
+                                        title: form.field("title").getValue()
+                                    }))
+                            }))
+                    }),
+                layout: (l)=>[
+                        l.row("title"),
+                        l.row("settings")
+                    ]
+            });
+            expect(form.field("settings.media").vm.context).toEqual({
+                title: "Page Title"
+            });
+            form.field("title").setValue("New Title");
+            expect(form.field("settings.media").vm.context).toEqual({
+                title: "New Title"
+            });
+        });
+        it("should navigate to siblings via field.parent().field()", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        wrapper: fields.object().fields((f)=>({
+                                title: f.text().defaultValue("Nested Title"),
+                                media: f.file().context(({ field })=>({
+                                        title: field.parent().field("title").getValue()
+                                    }))
+                            }))
+                    }),
+                layout: (l)=>[
+                        l.row("wrapper")
+                    ]
+            });
+            expect(form.field("wrapper.media").vm.context).toEqual({
+                title: "Nested Title"
+            });
+        });
+        it("should navigate multiple levels up via chained parent()", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        title: fields.text().defaultValue("Root Title"),
+                        settings: fields.object().fields((f)=>({
+                                nested: f.object().fields((inner)=>({
+                                        media: inner.file().context(({ field })=>({
+                                                title: field.parent().parent().parent().field("title").getValue()
+                                            }))
+                                    }))
+                            }))
+                    }),
+                layout: (l)=>[
+                        l.row("title"),
+                        l.row("settings")
+                    ]
+            });
+            expect(form.field("settings.nested.media").vm.context).toEqual({
+                title: "Root Title"
+            });
+            form.field("title").setValue("Updated Root");
+            expect(form.field("settings.nested.media").vm.context).toEqual({
+                title: "Updated Root"
+            });
+        });
+        it("should navigate past parent to grandparent scope", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        settings: fields.object().fields((f)=>({
+                                label: f.text().defaultValue("Settings Label"),
+                                nested: f.object().fields((inner)=>({
+                                        media: inner.file().context(({ field })=>({
+                                                label: field.parent().parent().field("label").getValue()
+                                            }))
+                                    }))
+                            }))
+                    }),
+                layout: (l)=>[
+                        l.row("settings")
+                    ]
+            });
+            expect(form.field("settings.nested.media").vm.context).toEqual({
+                label: "Settings Label"
+            });
+        });
+        it("should throw when navigating above root level", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        media: fields.file().context(({ field })=>({
+                                bad: field.parent().parent().field("x").getValue()
+                            }))
+                    })
+            });
+            expect(()=>form.field("media").vm.context).toThrow("Cannot navigate above root level.");
+        });
+        it("should use both field navigator and form in the same callback", ()=>{
+            const form = createForm({
+                fields: (fields)=>({
+                        slug: fields.text().defaultValue("my-slug"),
+                        settings: fields.object().fields((f)=>({
+                                label: f.text().defaultValue("Settings Label"),
+                                media: f.file().context(({ field, form })=>({
+                                        label: field.parent().field("label").getValue(),
+                                        slug: form.field("slug").getValue()
+                                    }))
+                            }))
+                    }),
+                layout: (l)=>[
+                        l.row("slug"),
+                        l.row("settings")
+                    ]
+            });
+            expect(form.field("settings.media").vm.context).toEqual({
+                label: "Settings Label",
+                slug: "my-slug"
+            });
+        });
+    });
     describe("$. static references in rules", ()=>{
         it("$. resolves rule targets relative to the parent object", ()=>{
             const form = createForm({
@@ -3818,7 +4309,7 @@ describe("FormModel", ()=>{
                                     {
                                         type: "condition",
                                         target: "$.status",
-                                        operator: "eq",
+                                        operator: "==",
                                         value: "draft",
                                         action: "hide"
                                     }
@@ -3842,7 +4333,7 @@ describe("FormModel", ()=>{
                                     {
                                         type: "condition",
                                         target: "$.locked",
-                                        operator: "eq",
+                                        operator: "==",
                                         value: "yes",
                                         action: "disable"
                                     }