@cosmicdrift/kumiko-headless 0.235.0 → 0.235.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-headless",
-  "version": "0.235.0",
+  "version": "0.235.2",
   "description": "Headless UI logic for Kumiko — Dispatcher contract, Form-Controller, View-Model, Nav-Resolver. Plattform- und React-frei; jeder Renderer (renderer, renderer-web, renderer-native, …) komponiert darauf.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.235.0",
+    "@cosmicdrift/kumiko-framework": "0.235.2",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
   },

package/src/view-model/__tests__/list.test.ts

@@ -3,6 +3,10 @@ import type {
   EntityDefinition,
   EntityListScreenDefinition,
 } from "@cosmicdrift/kumiko-framework/ui-types";
+import {
+  LIST_ROW_META_COLUMNS,
+  LIST_ROW_META_REFERENCES,
+} from "@cosmicdrift/kumiko-framework/ui-types";
 import { computeListViewModel } from "../list";
 
 // Minimal EntityDefinition-shape. ui-core's view-model only reads
@@ -264,6 +268,96 @@ describe("computeListViewModel", () => {
     });
   });
 
+  // Table-driven over LIST_ROW_META_COLUMNS itself (not one-off cases) — a
+  // row-meta column (id/tenantId/version/insertedAt/...) is a base-table
+  // column, never a declared entity field (a SystemAdmin cross-tenant list
+  // picks tenantId as a column this way). Together with boot-validator.test.ts
+  // (both boot validators accept the same set) and list-row-meta-drift.test.ts
+  // (LIST_ROW_META_COLUMNS key-set drift guard), this pins "whatever boot
+  // accepts as a row-meta column, the renderer can actually draw" — a #2601
+  // review found the two sides had drifted apart.
+  test("every row-meta column resolves to its declared type, sortable, no throw", () => {
+    for (const [field, expectedType] of Object.entries(LIST_ROW_META_COLUMNS)) {
+      const vm = computeListViewModel({
+        screen: listScreen(["title", field]),
+        entity: taskEntity,
+        rows: [],
+        translate,
+        featureName: "tasks",
+      });
+
+      const ref = LIST_ROW_META_REFERENCES[field];
+      expect(vm.columns[1]).toEqual({
+        field,
+        label: `tasks:entity:task:field:${field}`,
+        ...(ref !== undefined
+          ? {
+              type: "reference",
+              sortable: false,
+              refFeature: ref.refFeature,
+              refEntity: ref.refEntity,
+              refLabelField: ref.refLabelField,
+            }
+          : { type: expectedType, sortable: true }),
+      });
+    }
+  });
+
+  // tenantId carries a GUID in the DB but should render the referenced
+  // tenant's display name, like a declared reference field does — not the
+  // raw GUID. insertedById stays unchanged: this also pins that the map
+  // switches exactly one column, not every row-meta ID column.
+  test("tenantId row-meta column resolves as a reference column, insertedById unchanged", () => {
+    const vm = computeListViewModel({
+      screen: listScreen(["tenantId", "insertedById", "id"]),
+      entity: taskEntity,
+      rows: [],
+      translate,
+      featureName: "tasks",
+    });
+
+    expect(vm.columns[0]).toEqual({
+      field: "tenantId",
+      label: "tasks:entity:task:field:tenantId",
+      type: "reference",
+      sortable: false,
+      refFeature: "tenant",
+      refEntity: "tenant",
+      refLabelField: "name",
+    });
+    expect(vm.columns[1]).toEqual({
+      field: "insertedById",
+      label: "tasks:entity:task:field:insertedById",
+      type: "text",
+      sortable: true,
+    });
+    expect(vm.columns[2]).toEqual({
+      field: "id",
+      label: "tasks:entity:task:field:id",
+      type: "text",
+      sortable: true,
+    });
+  });
+
+  test("row-meta column: explicit label + renderer are passed through unchanged", () => {
+    const fmt = { format: "currency" as const, symbol: "€" };
+    const vm = computeListViewModel({
+      screen: listScreen([{ field: "insertedAt", label: "custom.created", renderer: fmt }]),
+      entity: taskEntity,
+      rows: [],
+      translate,
+      featureName: "tasks",
+    });
+
+    expect(vm.columns[0]).toEqual({
+      field: "insertedAt",
+      label: "custom.created",
+      type: "timestamp",
+      sortable: true,
+      renderer: fmt,
+    });
+  });
+
   test("slots pass through unchanged for the renderer to mount", () => {
     const slots = { header: { react: { component: "HeaderRef" } } };
     const vm = computeListViewModel({

package/src/view-model/list.ts

@@ -3,7 +3,12 @@ import type {
   EntityListScreenDefinition,
   FieldDefinition,
 } from "@cosmicdrift/kumiko-framework/ui-types";
-import { normalizeListColumn, parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+import {
+  LIST_ROW_META_COLUMNS,
+  LIST_ROW_META_REFERENCES,
+  normalizeListColumn,
+  parseRefTarget,
+} from "@cosmicdrift/kumiko-framework/ui-types";
 import type { ListColumnViewModel, ListRowViewModel, ListViewModel, Translate } from "./types";
 
 export type ComputeListViewModelInput = {
@@ -42,6 +47,33 @@ export function computeListViewModel(input: ComputeListViewModelInput): ListView
       // columns carry no reference/select metadata and never server-sort.
       const derivedDef = entity.derivedFields?.[normalized.field];
       if (!derivedDef) {
+        // Row-meta column (id/tenantId/version/insertedAt/modifiedAt/...) —
+        // a real base-table column that's never a declared entity field, e.g.
+        // a SystemAdmin cross-tenant list exposing tenantId. Unlike the
+        // derivedFields branch above, these are actual DB columns, so
+        // server-side ORDER BY works — sortable stays true, except for the
+        // ID columns in LIST_ROW_META_REFERENCES (see their reference branch).
+        const rowMetaType = LIST_ROW_META_COLUMNS[normalized.field];
+        if (rowMetaType !== undefined) {
+          const rowMetaRef = LIST_ROW_META_REFERENCES[normalized.field];
+          columns.push({
+            field: normalized.field,
+            label: translate(
+              normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field),
+            ),
+            type: rowMetaRef !== undefined ? "reference" : rowMetaType,
+            // The DB column holds the GUID, not the resolved label — server-side
+            // ORDER BY would sort by GUID while the cell shows the name.
+            sortable: rowMetaRef === undefined,
+            ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
+            ...(rowMetaRef !== undefined && {
+              refEntity: rowMetaRef.refEntity,
+              refFeature: rowMetaRef.refFeature,
+              refLabelField: rowMetaRef.refLabelField,
+            }),
+          });
+          continue;
+        }
         // A virtual presentational column — drawn entirely by a columnRenderer
         // component from the row (e.g. tag chips); value is undefined and it
         // never server-sorts. `field` is just the column key. It needs BOTH a