@cosmicdrift/kumiko-renderer 0.281.0 → 0.283.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.281.0",
+  "version": "0.283.0",
   "description": "Platform-agnostic React renderer for Kumiko screens. Contains the shared logic — primitives-contract, hooks, KumikoScreen, navigation & SSE abstractions — that any platform-specific renderer (web, native) composes. No DOM, no EventSource, no react-dom.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -15,9 +15,9 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.281.0",
-    "@cosmicdrift/kumiko-headless": "0.281.0",
-    "@cosmicdrift/kumiko-types": "0.281.0",
+    "@cosmicdrift/kumiko-framework": "0.283.0",
+    "@cosmicdrift/kumiko-headless": "0.283.0",
+    "@cosmicdrift/kumiko-types": "0.283.0",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
@@ -28,7 +28,7 @@
     "@types/react-dom": "^19.2.3",
     "jsdom": "^29.1.1",
     "react-dom": "^19.2.6",
-    "@cosmicdrift/kumiko-locale-de": "0.281.0"
+    "@cosmicdrift/kumiko-locale-de": "0.283.0"
   },
   "repository": {
     "type": "git",

package/src/app/__tests__/projection-detail-shim.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 import type { ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import { synthesizeProjectionDetailScreen } from "../projection-detail-shim";
+import {
+  synthesizeProjectionDetailEntity,
+  synthesizeProjectionDetailScreen,
+} from "../projection-detail-shim";
 
 // Regression for the writeForm extension (fw editable-detail-screens): the
 // hard readOnly:true enforcement in synthesizeProjectionDetailScreen must
@@ -60,3 +63,126 @@ describe("synthesizeProjectionDetailScreen", () => {
     expect("description" in withoutDescription).toBe(false);
   });
 });
+
+// Regression for fw#2982: a section that puts its fields in `groups`
+// instead of `fields` used to vanish entirely — synthesizeProjectionDetailEntity
+// never registered the field names, so computeEditViewModel threw "references
+// unknown field" for every one of them, and synthesizeProjectionDetailScreen
+// let a group field's own readOnly value pass through unforced.
+describe("groups-sections (fw#2982)", () => {
+  const groupsOnlyScreen: ProjectionDetailScreenDefinition = {
+    id: "contact-detail",
+    type: "projectionDetail",
+    query: "contacts:query:contact:detail",
+    layout: {
+      sections: [
+        {
+          title: "Stammdaten",
+          fields: [],
+          groups: [
+            {
+              title: "Kontakt",
+              fields: [{ field: "contactKind", readOnly: false }, "email"],
+            },
+          ],
+        },
+      ],
+    },
+  };
+
+  test("synthesizeProjectionDetailEntity registers every field declared only through groups", () => {
+    const entity = synthesizeProjectionDetailEntity(groupsOnlyScreen.layout);
+    expect(entity.fields["contactKind"]).toEqual({ type: "text" });
+    expect(entity.fields["email"]).toEqual({ type: "text" });
+  });
+
+  test("synthesizeProjectionDetailScreen forces readOnly:true on a group field even when the author set readOnly:false", () => {
+    const result = synthesizeProjectionDetailScreen(groupsOnlyScreen);
+    const [section] = result.layout.sections;
+    if (section === undefined || !("fields" in section) || "kind" in section) {
+      throw new Error("expected the section to stay a plain fields section");
+    }
+    if (!("groups" in section) || section.groups === undefined) {
+      throw new Error("expected the section to keep its groups");
+    }
+    expect(section.groups[0]?.fields).toEqual([
+      { field: "contactKind", readOnly: true },
+      { field: "email", readOnly: true },
+    ]);
+  });
+
+  test("a screen mixing a plain fields section and a groups section resolves both, for both functions", () => {
+    const mixedScreen: ProjectionDetailScreenDefinition = {
+      id: "deposit-detail",
+      type: "projectionDetail",
+      query: "deposits:query:deposit:detail",
+      layout: {
+        sections: [
+          { title: "Basics", fields: [{ field: "amount", readOnly: false }] },
+          {
+            title: "Parties",
+            fields: [],
+            groups: [{ title: "Tenant", fields: ["tenantName"] }],
+          },
+        ],
+      },
+    };
+
+    const entity = synthesizeProjectionDetailEntity(mixedScreen.layout);
+    expect(entity.fields["amount"]).toEqual({ type: "text" });
+    expect(entity.fields["tenantName"]).toEqual({ type: "text" });
+
+    const result = synthesizeProjectionDetailScreen(mixedScreen);
+    const [fieldsSection, groupsSection] = result.layout.sections;
+    if (fieldsSection === undefined || !("fields" in fieldsSection) || "kind" in fieldsSection) {
+      throw new Error("expected the first section to stay a plain fields section");
+    }
+    expect(fieldsSection.fields[0]).toMatchObject({ field: "amount", readOnly: true });
+
+    if (
+      groupsSection === undefined ||
+      !("groups" in groupsSection) ||
+      groupsSection.groups === undefined
+    ) {
+      throw new Error("expected the second section to keep its groups");
+    }
+    expect(groupsSection.groups[0]?.fields).toEqual([{ field: "tenantName", readOnly: true }]);
+  });
+
+  // The boot-validator rejects fields+groups both non-empty on one section at
+  // boot time, so an author can never actually ship this shape — but the shim
+  // is not itself a validation pass, and this pins the union, not the
+  // either/or a naive `groups !== undefined ? grouped : fields` would take.
+  test("a single section carrying both fields and groups resolves both, for both functions", () => {
+    const bothScreen: ProjectionDetailScreenDefinition = {
+      id: "invoice-detail",
+      type: "projectionDetail",
+      query: "invoices:query:invoice:detail",
+      layout: {
+        sections: [
+          {
+            title: "Mixed",
+            fields: [{ field: "amount", readOnly: false }],
+            groups: [{ title: "Tenant", fields: ["tenantName"] }],
+          },
+        ],
+      },
+    };
+
+    const entity = synthesizeProjectionDetailEntity(bothScreen.layout);
+    expect(entity.fields["amount"]).toEqual({ type: "text" });
+    expect(entity.fields["tenantName"]).toEqual({ type: "text" });
+
+    const result = synthesizeProjectionDetailScreen(bothScreen);
+    const [section] = result.layout.sections;
+    if (section === undefined || !("fields" in section) || "kind" in section) {
+      throw new Error("expected the section to stay a plain fields section");
+    }
+    expect(section.fields[0]).toMatchObject({ field: "amount", readOnly: true });
+
+    if (!("groups" in section) || section.groups === undefined) {
+      throw new Error("expected the section to keep its groups");
+    }
+    expect(section.groups[0]?.fields).toEqual([{ field: "tenantName", readOnly: true }]);
+  });
+});

package/src/app/projection-detail-shim.ts

@@ -21,6 +21,8 @@
 // Komponente.
 
 import type {
+  EditFieldSpec,
+  EditFieldsSection,
   EditLayout,
   EntityDefinition,
   EntityEditScreenDefinition,
@@ -32,6 +34,16 @@ import {
   PROJECTION_DETAIL_ENTITY as PROJECTION_DETAIL_PSEUDO_ENTITY,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 
+// The boot-validator treats `fields`/`groups` as mutually exclusive per
+// section, but this reads both anyway: an extra name the current section
+// shape can never carry is harmless, while a name computeEditViewModel does
+// reference and this shim omitted throws downstream ("references unknown
+// field ... on entity"). Union is strictly safer than picking one branch.
+function allFieldSpecs(section: EditFieldsSection): readonly EditFieldSpec[] {
+  const grouped = section.groups?.flatMap((group) => group.fields) ?? [];
+  return [...section.fields, ...grouped];
+}
+
 /** Minimale EntityDefinition aus den Layout-Feldern: jedes Feld ein Text-
  *  Feld — computeEditViewModel liest nur `fields[<f>].type`, Text reicht für
  *  eine reine Anzeige (kein Select/Number-spezifisches Rendering nötig). */
@@ -40,7 +52,7 @@ export function synthesizeProjectionDetailEntity(layout: EditLayout): EntityDefi
   for (const section of layout.sections) {
     // relatedList and extension sections carry no `fields` to synthesize.
     if (!isFieldsEditSection(section)) continue;
-    for (const spec of section.fields) {
+    for (const spec of allFieldSpecs(section)) {
       fields[normalizeEditField(spec).field] = { type: "text" };
     }
   }
@@ -52,12 +64,19 @@ export function synthesizeProjectionDetailEntity(layout: EditLayout): EntityDefi
 export function synthesizeProjectionDetailScreen(
   screen: ProjectionDetailScreenDefinition,
 ): EntityEditScreenDefinition {
+  const forceReadOnly = (spec: EditFieldSpec) => ({ ...normalizeEditField(spec), readOnly: true });
   const sections = screen.layout.sections.map((section) => {
     // relatedList and extension sections pass through unchanged.
     if (!isFieldsEditSection(section)) return section;
     return {
       ...section,
-      fields: section.fields.map((spec) => ({ ...normalizeEditField(spec), readOnly: true })),
+      fields: section.fields.map(forceReadOnly),
+      ...(section.groups !== undefined && {
+        groups: section.groups.map((group) => ({
+          ...group,
+          fields: group.fields.map(forceReadOnly),
+        })),
+      }),
     };
   });
   return {

package/src/changes.json

@@ -0,0 +1,8 @@
+[
+  {
+    "version": "0.283.0",
+    "type": "fix",
+    "title": "Fix projectionDetail detail screens dropping fields declared through groups",
+    "detail": "synthesizeProjectionDetailEntity/synthesizeProjectionDetailScreen only read section.fields, so a section that put its fields in groups instead lost them entirely, and any group field's own readOnly:false passed through unforced. Both helpers now read fields and groups together, and force readOnly:true on both."
+  }
+]