@cosmicdrift/kumiko-framework 0.187.0 → 0.189.0

package/src/engine/__tests__/boot-validator.test.ts

@@ -7,8 +7,11 @@ import { validateBoot as validateBootRaw } from "../boot-validator";
 import { createSystemConfig, createTenantConfig } from "../config-helpers";
 import {
   createDerivedField,
+  createEmbeddedField,
   createEmbeddedListField,
   createEntity,
+  createFilesField,
+  createJsonbField,
   createMultiSelectField,
   createTextField,
   defineFeature,
@@ -1742,6 +1745,8 @@ describe("boot-validator", () => {
       readonly redirect?: string;
       readonly cancelTarget?: string | false;
       readonly extraScreens?: readonly string[];
+      readonly mode?: "single" | "wizard";
+      readonly draft?: boolean;
     };
 
     // Hilfs-Schema-Setup: stamps eine Test-Entity + write-handler
@@ -1770,7 +1775,11 @@ describe("boot-validator", () => {
           type: "actionForm",
           handler,
           fields: fields as never,
-          layout: { sections: sections as never },
+          layout: {
+            sections: sections as never,
+            ...(override.mode !== undefined && { mode: override.mode }),
+            ...(override.draft !== undefined && { draft: override.draft }),
+          },
           ...(override.redirect !== undefined && { redirect: override.redirect }),
           ...(override.cancelTarget !== undefined && { cancelTarget: override.cancelTarget }),
         });
@@ -1858,6 +1867,39 @@ describe("boot-validator", () => {
       expect(() => validateBoot([makeFeature({ cancelTarget: false })])).not.toThrow();
     });
 
+    // --- redirect/cancelTarget: cross-feature QN (#1946) ---
+    test("redirect → voll-qualifizierte Cross-Feature-QN → kein Throw", () => {
+      const consumer = defineFeature("statements", (r) => {
+        r.screen({ id: "statement-upload-list", type: "custom", renderer: { react: "stub" } });
+      });
+      expect(() =>
+        validateBoot([
+          makeFeature({ redirect: "statements:screen:statement-upload-list" }),
+          consumer,
+        ]),
+      ).not.toThrow();
+    });
+
+    test("redirect → unbekannte Cross-Feature-QN → Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature({ redirect: "statements:screen:ghost-screen" })]),
+      ).toThrow(
+        /redirect "statements:screen:ghost-screen" does not resolve to a registered screen/,
+      );
+    });
+
+    test("cancelTarget → voll-qualifizierte Cross-Feature-QN → kein Throw", () => {
+      const consumer = defineFeature("statements", (r) => {
+        r.screen({ id: "statement-upload-list", type: "custom", renderer: { react: "stub" } });
+      });
+      expect(() =>
+        validateBoot([
+          makeFeature({ cancelTarget: "statements:screen:statement-upload-list" }),
+          consumer,
+        ]),
+      ).not.toThrow();
+    });
+
     test("extension section ohne component → Throw (Parität zu entityEdit)", () => {
       // synthesizeActionFormScreen reicht die layout 1:1 an RenderEdit weiter —
       // eine Extension-Section ohne react/native-Marker rendert sonst stumm leer.
@@ -1871,6 +1913,66 @@ describe("boot-validator", () => {
       const section = { kind: "extension", title: "Custom", component: { react: "Panel" } };
       expect(() => validateBoot([makeFeature({ sections: [section] as never })])).not.toThrow();
     });
+
+    test("mode: wizard mit nur 1 Section → Throw", () => {
+      expect(() =>
+        validateBoot([
+          makeFeature({
+            mode: "wizard",
+            sections: [{ title: "Step 1", fields: ["note"] }],
+          }),
+        ]),
+      ).toThrow(/mode: "wizard" but only 1 section\(s\)/);
+    });
+
+    test("mode: wizard mit Section ohne Titel → Throw", () => {
+      const sections = [
+        { title: "Step 1", fields: ["note"] },
+        { title: "", fields: ["priority"] },
+      ];
+      expect(() => validateBoot([makeFeature({ mode: "wizard", sections })])).toThrow(
+        /sections\[1\] has no title/,
+      );
+    });
+
+    test("mode: wizard mit >= 2 betitelten Sections → kein Throw", () => {
+      const sections = [
+        { title: "Step 1", fields: ["note"] },
+        { title: "Step 2", fields: ["priority"] },
+      ];
+      expect(() => validateBoot([makeFeature({ mode: "wizard", sections })])).not.toThrow();
+    });
+
+    test("draft: true ohne gemountetes form-draft-Feature → Throw", () => {
+      const sections = [
+        { title: "Step 1", fields: ["note"] },
+        { title: "Step 2", fields: ["priority"] },
+      ];
+      expect(() => validateBoot([makeFeature({ mode: "wizard", sections, draft: true })])).toThrow(
+        /"form-draft" is not mounted/,
+      );
+    });
+
+    test("draft: true mit gemountetem form-draft-Feature → kein Throw", () => {
+      const sections = [
+        { title: "Step 1", fields: ["note"] },
+        { title: "Step 2", fields: ["priority"] },
+      ];
+      expect(() =>
+        validateBoot([
+          makeFeature({ mode: "wizard", sections, draft: true }),
+          defineFeature("form-draft", () => {}),
+        ]),
+      ).not.toThrow();
+    });
+
+    test("draft: true ohne mode: 'wizard' → Throw", () => {
+      expect(() => validateBoot([makeFeature({ draft: true })])).toThrow(/mode is not "wizard"/);
+    });
+
+    test("mode weggelassen (Default 'single') bleibt bestehendes Layout gültig → kein Throw", () => {
+      expect(() => validateBoot([makeFeature()])).not.toThrow();
+    });
   });
 
   // --- configEdit-Screen ---
@@ -2046,6 +2148,308 @@ describe("boot-validator", () => {
     });
   });
 
+  // --- entityEdit wizard mode (framework#1884) ---
+  // layout.mode: "wizard" renders one section per step instead of all
+  // sections at once — needs >= 2 sections, each with a title (the step
+  // title), or it's a boot-fail instead of a broken step UI.
+  describe("entityEdit wizard mode", () => {
+    function makeFeature(
+      sections: readonly { readonly title?: string; readonly fields: readonly string[] }[],
+      mode?: "single" | "wizard",
+    ) {
+      return defineFeature("shop", (r) => {
+        r.entity(
+          "product",
+          createEntity({ fields: { name: createTextField(), sku: createTextField() } }),
+        );
+        r.screen({
+          id: "product-edit",
+          type: "entityEdit",
+          entity: "product",
+          layout: {
+            sections: sections as never,
+            ...(mode !== undefined && { mode }),
+          },
+        });
+      });
+    }
+
+    test("mode: wizard mit nur 1 Section → Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature([{ title: "Step 1", fields: ["name"] }], "wizard")]),
+      ).toThrow(/mode: "wizard" but only 1 section\(s\)/);
+    });
+
+    test("mode: wizard mit Section ohne Titel → Throw", () => {
+      expect(() =>
+        validateBoot([
+          makeFeature([{ title: "Step 1", fields: ["name"] }, { fields: ["sku"] }], "wizard"),
+        ]),
+      ).toThrow(/sections\[1\] has no title/);
+    });
+
+    test("mode: wizard mit >= 2 betitelten Sections → kein Throw", () => {
+      expect(() =>
+        validateBoot([
+          makeFeature(
+            [
+              { title: "Step 1", fields: ["name"] },
+              { title: "Step 2", fields: ["sku"] },
+            ],
+            "wizard",
+          ),
+        ]),
+      ).not.toThrow();
+    });
+
+    test("mode weggelassen (Default 'single') bleibt bestehendes Layout gültig → kein Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature([{ title: "Details", fields: ["name", "sku"] }])]),
+      ).not.toThrow();
+    });
+  });
+
+  // --- entityEdit redirect (framework#1942) ---
+  // Post-save navigation target, same validation as actionForm's redirect:
+  // short screen-ID, same feature, must resolve to a registered screen.
+  describe("entityEdit redirect", () => {
+    function makeFeature(redirect?: string, extraScreens: readonly string[] = []) {
+      return defineFeature("shop", (r) => {
+        r.entity(
+          "product",
+          createEntity({ fields: { name: createTextField(), sku: createTextField() } }),
+        );
+        r.screen({
+          id: "product-edit",
+          type: "entityEdit",
+          entity: "product",
+          layout: { sections: [{ fields: ["name", "sku"] }] },
+          ...(redirect !== undefined && { redirect }),
+        });
+        for (const extra of extraScreens) {
+          r.screen({
+            id: extra,
+            type: "custom",
+            renderer: { react: "stub" },
+          });
+        }
+      });
+    }
+
+    test("redirect → existing screen-id im selben feature → kein Throw", () => {
+      expect(() => validateBoot([makeFeature("product-list", ["product-list"])])).not.toThrow();
+    });
+
+    test("redirect → unknown screen-id → Throw", () => {
+      expect(() => validateBoot([makeFeature("ghost-screen")])).toThrow(
+        /redirect "ghost-screen" does not resolve to a registered screen/,
+      );
+    });
+
+    test("kein redirect gesetzt → kein Throw (Default: Liste)", () => {
+      expect(() => validateBoot([makeFeature()])).not.toThrow();
+    });
+
+    // --- redirect: cross-feature QN (#1946) ---
+    test("redirect → voll-qualifizierte Cross-Feature-QN → kein Throw", () => {
+      const consumer = defineFeature("statements", (r) => {
+        r.screen({ id: "statement-upload-list", type: "custom", renderer: { react: "stub" } });
+      });
+      expect(() =>
+        validateBoot([makeFeature("statements:screen:statement-upload-list"), consumer]),
+      ).not.toThrow();
+    });
+
+    test("redirect → unbekannte Cross-Feature-QN → Throw", () => {
+      expect(() => validateBoot([makeFeature("statements:screen:ghost-screen")])).toThrow(
+        /redirect "statements:screen:ghost-screen" does not resolve to a registered screen/,
+      );
+    });
+  });
+
+  // --- no-widget field types + required (#1925) ---
+  // jsonb/embedded/files/images render read-only on the auto-wired
+  // entityEdit path (render-field.tsx) — a statically-`required: true`
+  // field of one of these types would be unresolvable by the user, so it's
+  // caught loudly at boot instead of silently accepting an unfillable form.
+  // Only the static case (literal `true`, entity-level or screen-spec) is
+  // checked; a dynamic FieldCondition can't be evaluated without runtime
+  // form values and is a documented, accepted gap.
+  describe("no-widget field types + required (#1925)", () => {
+    test("embedded field, entity-level required: true → Throw", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity(
+            "order",
+            createEntity({
+              fields: {
+                lines: createEmbeddedField({ note: { type: "text" } }, { required: true }),
+              },
+            }),
+          );
+          r.screen({
+            id: "order-edit",
+            type: "entityEdit",
+            entity: "order",
+            layout: { sections: [{ fields: ["lines"] }] },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).toThrow(
+        /field "lines" is type "embedded", which renders read-only/,
+      );
+    });
+
+    test("embedded field, entity-level required: true, screen-spec required: false override → kein Throw", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity(
+            "order",
+            createEntity({
+              fields: {
+                lines: createEmbeddedField({ note: { type: "text" } }, { required: true }),
+              },
+            }),
+          );
+          r.screen({
+            id: "order-edit",
+            type: "entityEdit",
+            entity: "order",
+            layout: { sections: [{ fields: [{ field: "lines", required: false }] }] },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).not.toThrow();
+    });
+
+    test("embedded field, entity-level required: true, screen-spec readOnly: true → kein Throw", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity(
+            "order",
+            createEntity({
+              fields: {
+                lines: createEmbeddedField({ note: { type: "text" } }, { required: true }),
+              },
+            }),
+          );
+          r.screen({
+            id: "order-edit",
+            type: "entityEdit",
+            entity: "order",
+            layout: { sections: [{ fields: [{ field: "lines", readOnly: true }] }] },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).not.toThrow();
+    });
+
+    test("embedded field, entity-level required: true, dynamic screen-spec required condition → kein Throw (not statically resolvable)", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity(
+            "order",
+            createEntity({
+              fields: {
+                kind: createTextField(),
+                lines: createEmbeddedField({ note: { type: "text" } }, { required: true }),
+              },
+            }),
+          );
+          r.screen({
+            id: "order-edit",
+            type: "entityEdit",
+            entity: "order",
+            layout: {
+              sections: [
+                { fields: ["kind", { field: "lines", required: { field: "kind", eq: "b2b" } }] },
+              ],
+            },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).not.toThrow();
+    });
+
+    test("jsonb field, screen-spec required: true override → Throw (JsonbFieldDef has no entity-level required)", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity("order", createEntity({ fields: { data: createJsonbField() } }));
+          r.screen({
+            id: "order-edit",
+            type: "entityEdit",
+            entity: "order",
+            layout: { sections: [{ fields: [{ field: "data", required: true }] }] },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).toThrow(
+        /field "data" is type "jsonb", which renders read-only/,
+      );
+    });
+
+    test("files field, screen-spec required: true override → Throw (deliberately deferred, no multi-upload widget)", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity("order", createEntity({ fields: { attachments: createFilesField() } }));
+          r.screen({
+            id: "order-edit",
+            type: "entityEdit",
+            entity: "order",
+            layout: { sections: [{ fields: [{ field: "attachments", required: true }] }] },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).toThrow(
+        /field "attachments" is type "files", which renders read-only/,
+      );
+    });
+
+    test("multiSelect field, entity-level required: true → kein Throw (has a combobox widget since #1925)", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity(
+            "product",
+            createEntity({
+              fields: {
+                tags: createMultiSelectField({ options: ["a", "b"] as const, required: true }),
+              },
+            }),
+          );
+          r.screen({
+            id: "product-edit",
+            type: "entityEdit",
+            entity: "product",
+            layout: { sections: [{ fields: ["tags"] }] },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).not.toThrow();
+    });
+
+    test("embedded LIST field (multiple: true), entity-level required: true → kein Throw (has an EmbeddedListField grid widget since #1838)", () => {
+      const features = [
+        defineFeature("shop", (r) => {
+          r.entity(
+            "invoice",
+            createEntity({
+              fields: {
+                lines: createEmbeddedListField({ note: { type: "text" } }, { required: true }),
+              },
+            }),
+          );
+          r.screen({
+            id: "invoice-edit",
+            type: "entityEdit",
+            entity: "invoice",
+            layout: { sections: [{ fields: ["lines"] }] },
+          });
+        }),
+      ];
+      expect(() => validateBoot(features)).not.toThrow();
+    });
+  });
+
   // --- Tier 2.7e-3: ReferenceFieldDef ---
   describe("reference field (Tier 2.7e-3)", () => {
     test("reference auf bestehende Entity → kein Throw", () => {

package/src/engine/__tests__/build-app-schema.test.ts

@@ -160,7 +160,7 @@ describe("buildAppSchema", () => {
     });
     const app = buildAppSchema(createRegistry([f]));
     const fields = (
-      app.features[0]?.entities["thing"] as unknown as {
+      app.features[0]!.entities["thing"] as unknown as {
         fields: Record<string, Record<string, unknown>>;
       }
     ).fields;
@@ -186,7 +186,7 @@ describe("buildAppSchema", () => {
     });
     const app = buildAppSchema(createRegistry([f]));
     const fields = (
-      app.features[0]?.entities["thing"] as unknown as {
+      app.features[0]!.entities["thing"] as unknown as {
         fields: Record<string, Record<string, unknown>>;
       }
     ).fields;
@@ -207,7 +207,7 @@ describe("buildAppSchema", () => {
     });
     const app = buildAppSchema(createRegistry([f]));
     const fields = (
-      app.features[0]?.entities["thing"] as unknown as {
+      app.features[0]!.entities["thing"] as unknown as {
         fields: Record<string, Record<string, unknown>>;
       }
     ).fields;
@@ -228,7 +228,7 @@ describe("buildAppSchema", () => {
     });
     const app = buildAppSchema(createRegistry([f]));
     const fields = (
-      app.features[0]?.entities["thing"] as unknown as {
+      app.features[0]!.entities["thing"] as unknown as {
         fields: Record<string, Record<string, unknown>>;
       }
     ).fields;

package/src/engine/__tests__/engine.test.ts

@@ -634,14 +634,13 @@ describe("hasAccess", () => {
     { userRoles: [], requiredRoles: ["Admin"], expected: false },
     // Empty required-roles list denies everyone under default-deny.
     { userRoles: ["Admin"], requiredRoles: [], expected: false },
-  ])("user $userRoles vs required $requiredRoles → $expected", ({
-    userRoles,
-    requiredRoles,
-    expected,
-  }) => {
-    const user = createTestUser({ roles: userRoles });
-    expect(hasAccess(user, { roles: requiredRoles })).toBe(expected);
-  });
+  ])(
+    "user $userRoles vs required $requiredRoles → $expected",
+    ({ userRoles, requiredRoles, expected }) => {
+      const user = createTestUser({ roles: userRoles });
+      expect(hasAccess(user, { roles: requiredRoles })).toBe(expected);
+    },
+  );
 
   test("missing access rule denies access (default-deny)", () => {
     const user = createTestUser({ roles: ["Employee"] });

package/src/engine/__tests__/soft-delete-cleanup.test.ts

@@ -120,7 +120,7 @@ describe("softDeleteCleanupJob handler", () => {
   test("cutoff defaults to DEFAULT_GRACE_DAYS when no config resolver", async () => {
     const calls: DeleteCall[] = [];
     await softDeleteCleanupJob({}, makeCtx({ calls }));
-    const cutoff = (calls[0]?.where["deletedAt"] as { lt: Temporal.Instant }).lt;
+    const cutoff = (calls[0]!.where["deletedAt"] as { lt: Temporal.Instant }).lt;
     const expected = Temporal.Now.instant().subtract({ hours: DEFAULT_GRACE_DAYS * 24 });
     expect(Math.abs(cutoff.epochMilliseconds - expected.epochMilliseconds)).toBeLessThan(10_000);
   });
@@ -128,7 +128,7 @@ describe("softDeleteCleanupJob handler", () => {
   test("honours a per-tenant grace-days value from the config resolver", async () => {
     const calls: DeleteCall[] = [];
     await softDeleteCleanupJob({}, makeCtx({ calls, graceDays: 7 }));
-    const cutoff = (calls[0]?.where["deletedAt"] as { lt: Temporal.Instant }).lt;
+    const cutoff = (calls[0]!.where["deletedAt"] as { lt: Temporal.Instant }).lt;
     const expected = Temporal.Now.instant().subtract({ hours: 7 * 24 });
     expect(Math.abs(cutoff.epochMilliseconds - expected.epochMilliseconds)).toBeLessThan(10_000);
   });
@@ -155,7 +155,7 @@ describe("softDeleteCleanupSystemJob handler", () => {
   test("cutoff is DEFAULT_GRACE_DAYS — no per-tenant config to read", async () => {
     const calls: DeleteCall[] = [];
     await softDeleteCleanupSystemJob({}, makeCtx({ calls }));
-    const cutoff = (calls[0]?.where["deletedAt"] as { lt: Temporal.Instant }).lt;
+    const cutoff = (calls[0]!.where["deletedAt"] as { lt: Temporal.Instant }).lt;
     const expected = Temporal.Now.instant().subtract({ hours: DEFAULT_GRACE_DAYS * 24 });
     expect(Math.abs(cutoff.epochMilliseconds - expected.epochMilliseconds)).toBeLessThan(10_000);
   });