@cosmicdrift/kumiko-headless 0.289.0 → 0.291.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-headless",
-  "version": "0.289.0",
+  "version": "0.291.0",
   "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.289.0",
+    "@cosmicdrift/kumiko-framework": "0.291.0",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
   },

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

@@ -424,6 +424,31 @@ describe("computeEditViewModel — embedded-list cells (#1835)", () => {
       refFeature: "orders",
       refLabelField: "name",
     });
+    expect(byField["product"]?.refOptionsQuery).toBeUndefined();
+  });
+
+  test("a reference sub-field's optionsQuery reaches the cell view-model (fw#2780)", () => {
+    const vm = computeEditViewModel({
+      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
+      entity: embeddedListEntity({
+        schema: {
+          ...lineFieldSchema,
+          product: {
+            type: "reference",
+            entity: "product",
+            labelField: "name",
+            optionsQuery: "orders:query:product:options",
+          },
+        },
+      }),
+      values: { lines: [] },
+      translate,
+      featureName: "orders",
+    });
+
+    const cells = asFields(vm.sections[0]).fields[0]?.embeddedListCells;
+    const product = (cells ?? []).find((cell) => cell.field === "product");
+    expect(product?.refOptionsQuery).toBe("orders:query:product:options");
   });
 
   test("minItems/maxItems/derived/totals pass through onto the field view-model when set", () => {
@@ -720,6 +745,34 @@ describe("computeEditViewModel — declared reference metadata (fw#2662)", () =>
     expect(field?.refMultiple).toBeUndefined();
   });
 
+  test("a reference field's optionsQuery reaches the field view-model, labelField untouched (fw#2780)", () => {
+    const entity = {
+      fields: {
+        leaseId: {
+          type: "reference",
+          entity: "lease",
+          labelField: "startDate",
+          optionsQuery: "deposits:query:lease:options",
+        },
+      },
+    } as unknown as EntityDefinition;
+    const vm = computeEditViewModel({
+      screen: editScreen({ sections: [{ fields: ["leaseId"] }] }),
+      entity,
+      values: {},
+      translate,
+      featureName: "deposits",
+    });
+
+    const field = asFields(vm.sections[0]).fields[0];
+    expect(field).toMatchObject({
+      type: "reference",
+      refEntity: "lease",
+      refLabelField: "startDate",
+      refOptionsQuery: "deposits:query:lease:options",
+    });
+  });
+
   test("non-regression: a projectionDetail field without refEntity metadata stays 'text', unchanged (fw#2662)", () => {
     const vm = computeEditViewModel({
       screen: editScreen({ sections: [{ fields: ["ip"] }] }),

package/src/view-model/edit.ts

@@ -12,6 +12,7 @@ import {
   isWriteFormEditSection,
   normalizeEditField,
   parseRefTarget,
+  sectionFieldSpecs,
   WRITE_FORM_SECTION_ENTITY,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import {
@@ -51,6 +52,7 @@ type EmbeddedSubFieldShape = {
   readonly options?: readonly string[];
   readonly entity?: string;
   readonly labelField?: string;
+  readonly optionsQuery?: string;
   readonly scale?: number;
 };
 
@@ -167,11 +169,7 @@ export function computeEditViewModel<
     }
     // `groups` flattens into the same per-field pipeline as plain `fields`;
     // the group structure below just re-groups the computed views by name.
-    const flatFieldSpecs =
-      sectionSpec.groups !== undefined
-        ? sectionSpec.groups.flatMap((group) => group.fields)
-        : sectionSpec.fields;
-    const fields: EditFieldViewModel[] = flatFieldSpecs.map((fieldSpec) => {
+    const fields: EditFieldViewModel[] = sectionFieldSpecs(sectionSpec).map((fieldSpec) => {
       const normalized = normalizeEditField(fieldSpec);
       const fieldDef = entity.fields[normalized.field];
       if (!fieldDef) {
@@ -286,13 +284,17 @@ export function computeEditViewModel<
           : fieldDef.type === "reference"
             ? ((fieldDef as unknown as { labelField?: string }).labelField ?? "id")
             : undefined;
-      // Declared reference metadata has no `multiple` concept (it targets
-      // row-meta/derived fields, always single-valued) — only a real
-      // ReferenceFieldDef carries it.
-      const refMultiple =
+      // Declared reference metadata has no `multiple` or `optionsQuery`
+      // concept (it targets row-meta/derived fields, always single-valued and
+      // resolved through the target entity) — only a real ReferenceFieldDef
+      // carries them.
+      const ownReferenceDef =
         declaredRefTarget === undefined && fieldDef.type === "reference"
-          ? ((fieldDef as unknown as { multiple?: boolean }).multiple ?? false)
+          ? (fieldDef as unknown as { multiple?: boolean; optionsQuery?: string })
           : undefined;
+      const refOptionsQuery = ownReferenceDef?.optionsQuery;
+      const refMultiple =
+        ownReferenceDef === undefined ? undefined : (ownReferenceDef.multiple ?? false);
       // file/image: accept/maxSize ins ViewModel + entityType/fieldName für
       // den Upload-POST (Endpoint validiert gegen die richtige Field-Def).
       const isFileType =
@@ -359,9 +361,10 @@ export function computeEditViewModel<
                       cellOptions,
                     )
                   : undefined;
+              const cellRef = subField.type === "reference" ? subField : undefined;
               const cellRefTarget =
-                subField.type === "reference" && subField.entity !== undefined
-                  ? parseRefTarget(subField.entity, featureName)
+                cellRef?.entity !== undefined
+                  ? parseRefTarget(cellRef.entity, featureName)
                   : undefined;
               const cell: EmbeddedListCellViewModel = {
                 field: subFieldName,
@@ -372,8 +375,10 @@ export function computeEditViewModel<
                 ...(cellOptionLabels !== undefined && { optionLabels: cellOptionLabels }),
                 ...(cellRefTarget !== undefined && { refEntity: cellRefTarget.entityName }),
                 ...(cellRefTarget !== undefined && { refFeature: cellRefTarget.featureName }),
-                ...(subField.type === "reference" &&
-                  subField.labelField !== undefined && { refLabelField: subField.labelField }),
+                ...(cellRef?.labelField !== undefined && { refLabelField: cellRef.labelField }),
+                ...(cellRef?.optionsQuery !== undefined && {
+                  refOptionsQuery: cellRef.optionsQuery,
+                }),
                 ...(subField.type === "decimal" &&
                   subField.scale !== undefined && { scale: subField.scale }),
               };
@@ -404,6 +409,7 @@ export function computeEditViewModel<
         ...(refEntity !== undefined && { refEntity }),
         ...(refFeature !== undefined && { refFeature }),
         ...(refLabelField !== undefined && { refLabelField }),
+        ...(refOptionsQuery !== undefined && { refOptionsQuery }),
         ...(refMultiple !== undefined && { refMultiple }),
         ...(fileDef?.accept !== undefined && { accept: fileDef.accept }),
         ...(fileDef?.maxSize !== undefined && { maxSize: fileDef.maxSize }),

package/src/view-model/types.ts

@@ -112,6 +112,7 @@ export type EmbeddedListCellViewModel = {
   readonly refEntity?: string;
   readonly refFeature?: string;
   readonly refLabelField?: string;
+  readonly refOptionsQuery?: string;
   /** Only for `type: "decimal"`. */
   readonly scale?: number;
 };
@@ -190,6 +191,11 @@ export type EditFieldViewModel = {
   /** Nur bei `type: "reference"` gesetzt — Welches Feld der referenced
    *  Entity als Display-Label im Dropdown erscheint. Default: "id". */
   readonly refLabelField?: string;
+  /** Only for `type: "reference"` — query handler QN the picker sources its
+   *  options from (fw#2780), replacing the referenced entity's list handler.
+   *  Rows carry `{ id, label }`; `refLabelField` is then unused for the
+   *  picker but still drives list cells. */
+  readonly refOptionsQuery?: string;
   /** Nur bei `type: "reference"` — Multi-Mode (Tier 2.7e-Multi):
    *  Wert ist UUID-Array, Renderer mountet Multi-Combobox mit Tags. */
   readonly refMultiple?: boolean;