@cosmicdrift/kumiko-renderer-web 0.187.0 → 0.189.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer-web",
-  "version": "0.187.0",
+  "version": "0.189.0",
   "description": "Web-platform bindings for @cosmicdrift/kumiko-renderer. HTML default-primitives, browser history-based navigation, EventSource-backed live events, and a one-call createKumikoApp that mounts the whole stack via react-dom.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -16,9 +16,9 @@
     "./styles.css": "./src/styles.css"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.187.0",
-    "@cosmicdrift/kumiko-headless": "0.187.0",
-    "@cosmicdrift/kumiko-renderer": "0.187.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.189.0",
+    "@cosmicdrift/kumiko-headless": "0.189.0",
+    "@cosmicdrift/kumiko-renderer": "0.189.0",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@radix-ui/react-label": "^2.1.8",

package/src/__tests__/config-edit.test.tsx

@@ -38,6 +38,28 @@ const settingsScreen: ConfigEditScreenDefinition = {
   },
 };
 
+// A money-typed field is a legitimate FieldDefinition (screen.fields reuses
+// the entity field-shape, kumiko-framework#1923 render-field.tsx money case)
+// even though ConfigKeyType (write-helpers.ts) never carries "money" — the
+// server side of a config key is always a bare scalar.
+const moneySettingsScreen: ConfigEditScreenDefinition = {
+  id: "money-settings",
+  type: "configEdit",
+  scope: "tenant",
+  configKeys: { priceLimit: "demo:config:price-limit" },
+  fields: {
+    priceLimit: { type: "money" },
+    // @cast-boundary inline schema-author shape — FieldDefinition union too narrow
+  } as ConfigEditScreenDefinition["fields"],
+  layout: { sections: [{ title: "Basics", fields: ["priceLimit"] }] },
+};
+
+const moneySchema: FeatureSchema = {
+  featureName: "demo",
+  entities: {},
+  screens: [moneySettingsScreen],
+};
+
 const schema: FeatureSchema = {
   featureName: "demo",
   entities: {},
@@ -138,6 +160,50 @@ describe("KumikoScreen / configEdit", () => {
     });
   });
 
+  // kumiko-framework#1923: RenderField's money case now always emits the
+  // entityEdit `{amount, currency}` payload shape. A config key's server
+  // value is always a bare scalar (ConfigKeyType has no "money" variant) —
+  // customSubmit must unwrap back to `.amount` before dispatching, or the
+  // batch's config:write:set value fails its `string | number | boolean`
+  // schema entirely (regression guard for that unwrap).
+  test("money field submit unwraps {amount, currency} back to a bare number", async () => {
+    const batchSpy = mock(async (_commands: ReadonlyArray<{ type: string; payload: unknown }>) => ({
+      isSuccess: true as const,
+      results: [],
+    }));
+    const dispatcher: Dispatcher = createMockDispatcher({
+      query: (async () => ({
+        isSuccess: true,
+        data: { "demo:config:price-limit": { value: 12.99, scope: "tenant" } },
+      })) as unknown as Dispatcher["query"],
+      batch: batchSpy as unknown as Dispatcher["batch"],
+    });
+
+    const user = userEvent.setup();
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={moneySchema} qn="demo:screen:money-settings" />
+      </DispatcherProvider>,
+    );
+
+    await waitFor(() => screen.getByTestId("render-edit-form"));
+    const priceInput = screen.getByTestId("field-priceLimit").querySelector("input");
+    if (!priceInput) throw new Error("expected priceLimit input");
+
+    await user.clear(priceInput);
+    await user.type(priceInput, "15.00");
+    await user.click(screen.getByTestId("render-edit-submit"));
+
+    await waitFor(() => expect(batchSpy).toHaveBeenCalled());
+    const commands = batchSpy.mock.calls[0]?.[0];
+    if (!commands) throw new Error("batchSpy not called");
+    expect(commands).toHaveLength(1);
+    expect(commands[0]).toEqual({
+      type: "config:write:set",
+      payload: { key: "demo:config:price-limit", value: 15, scope: "tenant" },
+    });
+  });
+
   test("save-button disabled after successful submit (rebase fired)", async () => {
     const dispatcher: Dispatcher = createMockDispatcher({
       query: (async () => ({

package/src/__tests__/entity-edit-redirect.test.tsx

@@ -0,0 +1,166 @@
+// Issue #1942: entityEdit had no post-save redirect (only actionForm did) —
+// RenderEdit only exposed onSubmit/onCancel, unreachable from a declarative
+// screen. This exercises the real create/update submit path through
+// KumikoScreen → EntityEditCreateBody/EntityEditUpdateForm, not just the
+// type/boot-validator layer, proving a successful save actually calls
+// nav.navigate(redirect) instead of the default "back to list", and that
+// omitting redirect keeps the existing list-navigation behavior.
+import { describe, expect, test } from "bun:test";
+import type {
+  EntityDefinition,
+  FeatureSchema,
+  ScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
+import type { NavTarget } from "@cosmicdrift/kumiko-renderer";
+import { DispatcherProvider, KumikoScreen, NavProvider } from "@cosmicdrift/kumiko-renderer";
+import { createMockDispatcher, fireEvent, render, screen, waitFor } from "./test-utils";
+
+const productEntity: EntityDefinition = {
+  fields: { name: { type: "text", required: false, searchable: false, sortable: false } },
+};
+
+function buildSchema(redirect?: string): FeatureSchema {
+  const editScreen: ScreenDefinition = {
+    id: "product-edit",
+    type: "entityEdit",
+    entity: "product",
+    layout: { sections: [{ fields: ["name"] }] },
+    ...(redirect !== undefined && { redirect }),
+  };
+  const listScreen: ScreenDefinition = {
+    id: "product-list",
+    type: "entityList",
+    entity: "product",
+    columns: ["name"],
+  };
+  return {
+    featureName: "shop",
+    entities: { product: productEntity },
+    screens: [editScreen, listScreen],
+  } as FeatureSchema;
+}
+
+function fillNameAndSubmit(): void {
+  const nameInput = screen.getByTestId("field-name").querySelector("input") as HTMLInputElement;
+  fireEvent.change(nameInput, { target: { value: "Widget" } });
+  const form = screen.getByTestId("render-edit-form");
+  fireEvent.submit(form);
+}
+
+describe("entityEdit redirect (#1942)", () => {
+  test("create: successful save with redirect set navigates there, not to the list", async () => {
+    const navigated: NavTarget[] = [];
+    render(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <NavProvider
+          value={{
+            route: { screenId: "shop:screen:product-edit" },
+            navigate: (target) => navigated.push(target),
+            replace: () => {},
+            hrefFor: () => "",
+            searchParams: {},
+            setSearchParams: () => {},
+          }}
+        >
+          <KumikoScreen schema={buildSchema("product-detail")} qn="shop:screen:product-edit" />
+        </NavProvider>
+      </DispatcherProvider>,
+    );
+
+    fillNameAndSubmit();
+
+    await waitFor(() => expect(navigated).toEqual([{ screenId: "product-detail" }]));
+  });
+
+  test("create: no redirect set falls back to the entity's list screen", async () => {
+    const navigated: NavTarget[] = [];
+    render(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <NavProvider
+          value={{
+            route: { screenId: "shop:screen:product-edit" },
+            navigate: (target) => navigated.push(target),
+            replace: () => {},
+            hrefFor: () => "",
+            searchParams: {},
+            setSearchParams: () => {},
+          }}
+        >
+          <KumikoScreen schema={buildSchema()} qn="shop:screen:product-edit" />
+        </NavProvider>
+      </DispatcherProvider>,
+    );
+
+    fillNameAndSubmit();
+
+    await waitFor(() => expect(navigated).toEqual([{ screenId: "product-list" }]));
+  });
+
+  test("create: redirect as fully-qualified cross-feature QN navigates via its short id (#1946)", async () => {
+    // redirect may name a screen in ANOTHER feature via `<feature>:screen:<id>`
+    // (boot-validator accepts the QN directly) — the renderer must strip it
+    // down to the short id before calling nav.navigate, since the runtime
+    // router resolves bare short ids app-wide, not raw QNs (see nav.tsx).
+    const navigated: NavTarget[] = [];
+    render(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <NavProvider
+          value={{
+            route: { screenId: "shop:screen:product-edit" },
+            navigate: (target) => navigated.push(target),
+            replace: () => {},
+            hrefFor: () => "",
+            searchParams: {},
+            setSearchParams: () => {},
+          }}
+        >
+          <KumikoScreen
+            schema={buildSchema("statements:screen:statement-upload-list")}
+            qn="shop:screen:product-edit"
+          />
+        </NavProvider>
+      </DispatcherProvider>,
+    );
+
+    fillNameAndSubmit();
+
+    await waitFor(() => expect(navigated).toEqual([{ screenId: "statement-upload-list" }]));
+  });
+
+  test("update: successful save with redirect set navigates there, not to the list", async () => {
+    const navigated: NavTarget[] = [];
+    const dispatcher = createMockDispatcher({
+      query: (async () => ({
+        isSuccess: true,
+        data: { id: "42", version: 1, name: "Existing" },
+      })) as unknown as Dispatcher["query"],
+    });
+
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <NavProvider
+          value={{
+            route: { screenId: "shop:screen:product-edit", entityId: "42" },
+            navigate: (target) => navigated.push(target),
+            replace: () => {},
+            hrefFor: () => "",
+            searchParams: {},
+            setSearchParams: () => {},
+          }}
+        >
+          <KumikoScreen
+            schema={buildSchema("product-detail")}
+            qn="shop:screen:product-edit"
+            entityId="42"
+          />
+        </NavProvider>
+      </DispatcherProvider>,
+    );
+
+    await waitFor(() => expect(screen.getByTestId("field-name")).toBeTruthy());
+    fillNameAndSubmit();
+
+    await waitFor(() => expect(navigated).toEqual([{ screenId: "product-detail" }]));
+  });
+});

package/src/__tests__/kumiko-screen.test.tsx

@@ -1404,6 +1404,50 @@ describe("KumikoScreen", () => {
     expect(navigateCalls[0]).toEqual({ screenId: "task-list" });
   });
 
+  test("actionForm mit Cross-Feature-QN als redirect: navigiert per Short-Id (#1946)", async () => {
+    const navigateCalls: { screenId: string }[] = [];
+    const dispatcher = makeDispatcher({
+      write: (async () => ({
+        isSuccess: true,
+        data: { id: "x" },
+      })) as unknown as Dispatcher["write"],
+    });
+    const memoryNav = {
+      route: { screenId: "quick-add" },
+      navigate: (target: { screenId: string }) => navigateCalls.push(target),
+      replace: () => undefined,
+      hrefFor: (t: { screenId: string }) => `/${t.screenId}`,
+      searchParams: {},
+      setSearchParams: () => undefined,
+    };
+    const actionScreen: ActionFormScreenDefinition = {
+      id: "quick-add",
+      type: "actionForm",
+      handler: "tasks:write:task:quick-add",
+      fields: { title: { type: "text", required: true } },
+      layout: { sections: [{ title: "x", fields: ["title"] }] },
+      redirect: "statements:screen:statement-upload-list",
+    };
+
+    const { NavProvider } = await import("@cosmicdrift/kumiko-renderer");
+    render(
+      <NavProvider value={memoryNav}>
+        <DispatcherProvider dispatcher={dispatcher}>
+          <KumikoScreen
+            schema={{ ...schema, screens: [actionScreen, listScreen] }}
+            qn="tasks:screen:quick-add"
+          />
+        </DispatcherProvider>
+      </NavProvider>,
+    );
+
+    const titleInput = screen.getByTestId("field-title").querySelector("input") as HTMLInputElement;
+    fireEvent.change(titleInput, { target: { value: "go" } });
+    fireEvent.click(screen.getByTestId("render-edit-submit"));
+    await waitFor(() => expect(navigateCalls.length).toBe(1));
+    expect(navigateCalls[0]).toEqual({ screenId: "statement-upload-list" });
+  });
+
   // cancelTarget (Bug-Bash 2026-06-07, Bug 9): redirect erzeugte
   // automatisch einen Abbrechen-Button mit demselben Ziel wie der
   // Submit-Redirect — auf Single-Action-Screens ("Test-Mail senden")
@@ -1814,6 +1858,106 @@ describe("KumikoScreen: update-only entityEdit (allowCreate/allowDelete)", () =>
   });
 });
 
+// --- singleton entityEdit (fw#1941) ---
+// Singleton entities (exactly one record per tenant) have no nav path
+// that supplies an entityId. `singleton: true` resolves the existing
+// record via list(limit:1) before deciding create vs update.
+describe("KumikoScreen: singleton entityEdit", () => {
+  const singletonEdit: EntityEditScreenDefinition = {
+    id: "task-edit",
+    type: "entityEdit",
+    entity: "task",
+    singleton: true,
+    layout: { sections: [{ title: "Basics", fields: ["title"] }] },
+  };
+  const singletonSchema: FeatureSchema = {
+    featureName: "tasks",
+    entities: { task: taskEntity },
+    screens: [singletonEdit],
+  };
+
+  test("kein vorhandener Record → rendert leeres Create-Form", async () => {
+    const queryCalls: { type: string; payload: unknown }[] = [];
+    const dispatcher = makeDispatcher({
+      query: (async (type: string, payload: unknown) => {
+        queryCalls.push({ type, payload });
+        return { isSuccess: true, data: { rows: [], nextCursor: null } };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={singletonSchema} qn="tasks:screen:task-edit" />
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull());
+    expect(screen.getByTestId("render-edit-form")).toBeTruthy();
+    const titleInput = screen.getByTestId("field-title").querySelector("input") as HTMLInputElement;
+    expect(titleInput.value).toBe("");
+    expect(queryCalls).toEqual([{ type: "tasks:query:task:list", payload: { limit: 1 } }]);
+  });
+
+  test("vorhandener Record → lädt ihn (Update-Form, prefilled) statt Create", async () => {
+    const queryCalls: { type: string; payload: unknown }[] = [];
+    const dispatcher = makeDispatcher({
+      query: (async (type: string, payload: unknown) => {
+        queryCalls.push({ type, payload });
+        if (type.endsWith(":list")) {
+          return {
+            isSuccess: true,
+            data: { rows: [{ id: "task-1", title: "loaded-title" }], nextCursor: null },
+          };
+        }
+        return {
+          isSuccess: true,
+          data: { id: "task-1", version: 1, title: "loaded-title", count: 0, done: false },
+        };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={singletonSchema} qn="tasks:screen:task-edit" />
+      </DispatcherProvider>,
+    );
+    // Two sequential loading cycles (list, then detail once the singleton
+    // wrapper hands off to EntityEditUpdateBody) — default waitFor timeout
+    // can be too tight under CI's shared-process test load.
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull(), {
+      timeout: 5000,
+    });
+    expect(screen.getByTestId("render-edit-form")).toBeTruthy();
+    const titleInput = screen.getByTestId("field-title").querySelector("input") as HTMLInputElement;
+    expect(titleInput.value).toBe("loaded-title");
+    // Anchor: the id resolved from list(limit:1) reaches the detail query —
+    // otherwise the form would render empty/create-mode instead of loading it.
+    expect(queryCalls).toContainEqual({
+      type: "tasks:query:task:detail",
+      payload: { id: "task-1" },
+    });
+  });
+
+  test("allowCreate:false + leere Tabelle → Fehler-Banner statt Create-Form", async () => {
+    const disabledSchema: FeatureSchema = {
+      featureName: "tasks",
+      entities: { task: taskEntity },
+      screens: [{ ...singletonEdit, allowCreate: false }],
+    };
+    const dispatcher = makeDispatcher({
+      query: (async () => ({
+        isSuccess: true,
+        data: { rows: [], nextCursor: null },
+      })) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={disabledSchema} qn="tasks:screen:task-edit" />
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull());
+    expect(screen.getByTestId("kumiko-screen-create-disabled")).toBeTruthy();
+    expect(screen.queryByTestId("render-edit-form")).toBeNull();
+  });
+});
+
 // --- actionForm extension-section (Wave J: Incident-Update-Timeline) ---
 // actionForm hat keinen record — Extension-Sections bekommen stattdessen
 // die initialen Form-Values (inkl. searchParams-Prefill) als initialValues.

package/src/__tests__/primitives.test.tsx

@@ -1040,6 +1040,29 @@ describe("Form", () => {
     );
     expect(screen.queryByTestId("form-actions")).toBeNull();
   });
+
+  test("stickyActions: Footer bekommt mobile-fixed-Klassen (fw#1918)", () => {
+    render(
+      <Form
+        onSubmit={() => undefined}
+        actions={<button type="submit">Next</button>}
+        testId="form"
+        stickyActions
+      >
+        <div>content</div>
+      </Form>,
+    );
+    expect(screen.getByTestId("form-actions").className).toContain("max-sm:fixed");
+  });
+
+  test("ohne stickyActions: Footer bleibt im normalen Dokumentfluss", () => {
+    render(
+      <Form onSubmit={() => undefined} actions={<button type="submit">Save</button>} testId="form">
+        <div>content</div>
+      </Form>,
+    );
+    expect(screen.getByTestId("form-actions").className).not.toContain("max-sm:fixed");
+  });
 });
 
 describe("Banner padded", () => {