@cosmicdrift/kumiko-renderer 0.174.0 → 0.176.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.174.0",
+  "version": "0.176.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,8 +15,8 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.174.0",
-    "@cosmicdrift/kumiko-headless": "0.174.0",
+    "@cosmicdrift/kumiko-framework": "0.176.0",
+    "@cosmicdrift/kumiko-headless": "0.176.0",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2"
   },

package/src/__tests__/merge-search-params-into-initial.test.ts

@@ -45,4 +45,24 @@ describe("mergeSearchParamsIntoInitial", () => {
     const result = mergeSearchParamsIntoInitial(fields, { price: "19.99" });
     expect(result["price"]).toBe(19.99);
   });
+
+  test("renderableFields set given: searchParam for a non-rendered field is ignored (#1708)", () => {
+    const fields: Record<string, FieldDef> = {
+      status: { type: "text", default: "draft" },
+      ownerId: { type: "text" },
+    };
+    const result = mergeSearchParamsIntoInitial(
+      fields,
+      { status: "approved", ownerId: "user-123" },
+      new Set(["status"]),
+    );
+    expect(result["status"]).toBe("approved");
+    expect(result["ownerId"]).toBe("");
+  });
+
+  test("no renderableFields set given (undefined): behaves as before, all fields eligible", () => {
+    const fields: Record<string, FieldDef> = { ownerId: { type: "text" } };
+    const result = mergeSearchParamsIntoInitial(fields, { ownerId: "user-123" });
+    expect(result["ownerId"]).toBe("user-123");
+  });
 });

package/src/app/kumiko-screen.tsx

@@ -1,6 +1,5 @@
 import type { ConfigCascade } from "@cosmicdrift/kumiko-framework/engine";
 import type {
-  AccessRule,
   ActionFormScreenDefinition,
   ConfigEditScreenDefinition,
   DashboardScreenDefinition,
@@ -16,7 +15,11 @@ import type {
   ScreenDefinition,
   ToolbarAction,
 } from "@cosmicdrift/kumiko-framework/ui-types";
-import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
+import {
+  evalFieldCondition,
+  isExtensionEditSection,
+  normalizeEditField,
+} from "@cosmicdrift/kumiko-framework/ui-types";
 import type {
   Command,
   FormSnapshot,
@@ -47,6 +50,7 @@ import {
 } from "./projection-detail-shim";
 import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projection-list-shim";
 import { lastSegment, toKebab } from "./qn";
+import { screenAccessAllows } from "./screen-access";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
 
 function evalRowExtractor(
@@ -114,21 +118,7 @@ export function qualifyNavId(featureName: string, navId: string): string {
   return `${featureName}:nav:${navId}`;
 }
 
-// Minimal role-gate for the screen-render path (#1203 — nav filtering via
-// filterByAccess in workspace-shell.tsx hid role-gated screens from the
-// menu, but a direct URL/screenQn hit reached KumikoScreen unchecked).
-// Duplicated instead of imported from framework/engine's hasAccess (pulls
-// server-side deps) — same bundle-purity reasoning as headless/nav's
-// resolve.ts:userCanSee, which this mirrors.
-export function screenAccessAllows(
-  access: AccessRule | undefined,
-  userRoles: readonly string[] | undefined,
-): boolean {
-  if (!access) return true;
-  if ("openToAll" in access) return access.openToAll;
-  if (userRoles === undefined) return false;
-  return access.roles.some((role) => userRoles.includes(role));
-}
+export { screenAccessAllows };
 
 export function KumikoScreen({
   schema,
@@ -336,13 +326,30 @@ export function buildInitialValues(
   return out;
 }
 
+// Field names actually rendered by the screen's layout — a search-param
+// merge must not set fields the form never shows the user (#1708:
+// unrendered fields get no client-side validation and no chance to
+// review/correct the injected value).
+function layoutFieldNames(screen: EntityEditScreenDefinition): ReadonlySet<string> {
+  const names = new Set<string>();
+  for (const section of screen.layout.sections) {
+    if (isExtensionEditSection(section)) continue;
+    for (const spec of section.fields) {
+      names.add(normalizeEditField(spec).field);
+    }
+  }
+  return names;
+}
+
 export function mergeSearchParamsIntoInitial(
   fields: Readonly<Record<string, unknown>>,
   searchParams: Readonly<Record<string, string>>,
+  renderableFields?: ReadonlySet<string>,
 ): Record<string, unknown> {
   const defaults = buildInitialValues(fields) as Record<string, unknown>;
   const merged: Record<string, unknown> = { ...defaults };
   for (const [name, fieldDef] of Object.entries(fields)) {
+    if (renderableFields !== undefined && !renderableFields.has(name)) continue;
     const shape = fieldDef as { type?: string; sensitive?: boolean };
     if (shape.sensitive === true) continue;
     const raw = searchParams[name];
@@ -431,8 +438,13 @@ function EntityEditCreateBody({
 }): ReactNode {
   const nav = useNav();
   const initial = useMemo(
-    () => mergeSearchParamsIntoInitial(entity.fields, nav.searchParams) as FormValues,
-    [entity.fields, nav.searchParams],
+    () =>
+      mergeSearchParamsIntoInitial(
+        entity.fields,
+        nav.searchParams,
+        layoutFieldNames(screen),
+      ) as FormValues,
+    [entity.fields, nav.searchParams, screen],
   );
   const writeCommand = entityWriteCommand(schema.featureName, screen.entity, "create");
   const navigateToList = useNavigateToListAfter(schema, screen.entity);
@@ -1430,8 +1442,13 @@ function ActionFormBody({
   const synthEntity = useMemo(() => synthesizeActionFormEntity(screen.fields), [screen.fields]);
   const synthScreen = useMemo(() => synthesizeActionFormScreen(screen), [screen]);
   const initial = useMemo(
-    () => mergeSearchParamsIntoInitial(screen.fields, nav.searchParams) as FormValues,
-    [screen.fields, nav.searchParams],
+    () =>
+      mergeSearchParamsIntoInitial(
+        screen.fields,
+        nav.searchParams,
+        layoutFieldNames(synthScreen),
+      ) as FormValues,
+    [screen.fields, nav.searchParams, synthScreen],
   );
   const handleSubmitted = useCallback(
     (result: SubmitResult<unknown>) => {

package/src/app/screen-access.ts

@@ -0,0 +1,19 @@
+import type { AccessRule } from "@cosmicdrift/kumiko-framework/ui-types";
+
+// Minimal role-gate for the screen-render path (#1203 — nav filtering via
+// filterByAccess in workspace-shell.tsx hid role-gated screens from the
+// menu, but a direct URL/screenQn hit reached KumikoScreen unchecked).
+// Reimplemented instead of imported from framework/engine's hasAccess
+// (pulls server-side deps) — same bundle-purity reasoning as headless/nav's
+// resolve.ts:userCanSee, which this mirrors. Own leaf module (not exported
+// from kumiko-screen.tsx directly) so render-field.tsx can import it too
+// without the kumiko-screen → RenderEdit → RenderField cycle.
+export function screenAccessAllows(
+  access: AccessRule | undefined,
+  userRoles: readonly string[] | undefined,
+): boolean {
+  if (!access) return true;
+  if ("openToAll" in access) return access.openToAll;
+  if (userRoles === undefined) return false;
+  return access.roles.some((role) => userRoles.includes(role));
+}

package/src/components/reference-create-dialog.tsx

@@ -32,7 +32,11 @@ function extractCreatedId(data: unknown): string | undefined {
 export type ReferenceCreateDialogProps = {
   readonly open: boolean;
   readonly onClose: () => void;
-  readonly onCreated: (id: string) => void;
+  // id is undefined when the record was created but the write-handler's
+  // success payload carried no `id` (custom create-handler variant) — the
+  // record already exists server-side, so this is still a success signal
+  // to the caller, just one it can't auto-select from (#1694).
+  readonly onCreated: (id: string | undefined) => void;
   readonly featureName: string;
   readonly screen: EntityEditScreenDefinition;
   readonly entity: EntityDefinition;
@@ -52,8 +56,7 @@ export function ReferenceCreateDialog({
   const writeCommand = entityWriteCommand(featureName, screen.entity);
   const handleSubmitted = (result: SubmitResult<unknown>): void => {
     if (result.validationBlocked || !result.isSuccess) return;
-    const id = extractCreatedId(result.data);
-    if (id !== undefined) onCreated(id);
+    onCreated(extractCreatedId(result.data));
   };
   if (!open) return null;
   return (

package/src/components/render-field.tsx

@@ -1,11 +1,9 @@
-import type {
-  AccessRule,
-  EntityEditScreenDefinition,
-} from "@cosmicdrift/kumiko-framework/ui-types";
+import type { EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { EditFieldViewModel, FieldIssue } from "@cosmicdrift/kumiko-headless";
 import { type ReactNode, useCallback, useMemo, useState } from "react";
 import { useAppFeatures } from "../app/app-features-context";
 import { toKebab } from "../app/qn";
+import { screenAccessAllows } from "../app/screen-access";
 import { useUserRoles } from "../context/user-roles-context";
 import { REFERENCE_COMBOBOX_LIMIT } from "../hooks/reference-limits";
 import { useQuery } from "../hooks/use-query";
@@ -89,19 +87,6 @@ export function RenderField({
   );
 }
 
-// Duplicated from kumiko-screen.tsx's screenAccessAllows (not imported —
-// that module imports RenderEdit → RenderField, importing back from here
-// would cycle). Same minimal role-gate logic.
-function createScreenAccessAllows(
-  access: AccessRule | undefined,
-  userRoles: readonly string[] | undefined,
-): boolean {
-  if (!access) return true;
-  if ("openToAll" in access) return access.openToAll;
-  if (userRoles === undefined) return false;
-  return access.roles.some((role) => userRoles.includes(role));
-}
-
 // Tier 2.7e-3 + 2.1c: Reference-Input rendert eine Searchable Combobox
 // gefüllt aus einer Live-Query auf die referenced Entity. Default-
 // Limit: 200 — bei größeren Datasets fehlt der Tail im Dropdown
@@ -132,6 +117,7 @@ function ReferenceInput({
   readonly Input: ReturnType<typeof usePrimitives>["Input"];
   readonly featureName: string;
 }): ReactNode {
+  const { Banner } = usePrimitives();
   const refEntity = field.refEntity ?? "";
   const refFeature = field.refFeature ?? featureName;
   const labelField = field.refLabelField ?? "id";
@@ -157,7 +143,7 @@ function ReferenceInput({
       s.type === "entityEdit" &&
       s.entity === refEntity &&
       s.allowCreate !== false &&
-      createScreenAccessAllows(s.access, userRoles),
+      screenAccessAllows(s.access, userRoles),
   );
   const refEntityDef = refTargetSchema?.entities[refEntity];
   // Tier 2.7e Remote-Search: User tippt im Combobox → Server filtert
@@ -178,10 +164,18 @@ function ReferenceInput({
   );
   const handleSearchChange = useCallback((q: string) => setSearchTerm(q), []);
   const canCreate = !field.readOnly && refCreateScreen !== undefined && refEntityDef !== undefined;
+  const [createdWithoutIdWarning, setCreatedWithoutIdWarning] = useState(false);
   const handleCreated = useCallback(
-    (newId: string) => {
+    (newId: string | undefined) => {
       setCreateOpen(false);
       void queryResult.refetch();
+      if (newId === undefined) {
+        // Record was created server-side but the payload carried no id —
+        // can't auto-select it, surface that instead of failing silently.
+        setCreatedWithoutIdWarning(true);
+        return;
+      }
+      setCreatedWithoutIdWarning(false);
       if (isMultiple) {
         const current = Array.isArray(field.value) ? (field.value as readonly string[]) : [];
         onChange([...current, newId]);
@@ -217,15 +211,22 @@ function ReferenceInput({
       createLabel: t("kumiko.actions.create"),
     }),
   } as const;
-  const createDialog = canCreate && refCreateScreen && refEntityDef && (
-    <ReferenceCreateDialog
-      open={createOpen}
-      onClose={() => setCreateOpen(false)}
-      onCreated={handleCreated}
-      featureName={refFeature}
-      screen={refCreateScreen}
-      entity={refEntityDef}
-    />
+  const createDialog = (
+    <>
+      {canCreate && refCreateScreen && refEntityDef && (
+        <ReferenceCreateDialog
+          open={createOpen}
+          onClose={() => setCreateOpen(false)}
+          onCreated={handleCreated}
+          featureName={refFeature}
+          screen={refCreateScreen}
+          entity={refEntityDef}
+        />
+      )}
+      {createdWithoutIdWarning && (
+        <Banner variant="error">{t("kumiko.field.reference-created-no-id")}</Banner>
+      )}
+    </>
   );
   if (isMultiple) {
     const arrayValue: readonly string[] = Array.isArray(field.value)

package/src/i18n-defaults.ts

@@ -34,6 +34,8 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "kumiko.field.time": "Uhrzeit",
     "kumiko.field.timezone": "Zeitzone",
     "kumiko.field.locatedTzHint": "Zeit lokal am angegebenen Ort",
+    "kumiko.field.reference-created-no-id":
+      "Datensatz wurde angelegt, konnte aber nicht automatisch ausgewählt werden. Bitte manuell auswählen.",
 
     // List — DataTable Toolbar, Empty-State, Search.
     "kumiko.list.search-placeholder": "Suchen…",
@@ -172,6 +174,8 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "kumiko.field.time": "Time",
     "kumiko.field.timezone": "Time zone",
     "kumiko.field.locatedTzHint": "Time local to the given location",
+    "kumiko.field.reference-created-no-id":
+      "Record was created but could not be selected automatically. Please select it manually.",
 
     "kumiko.list.search-placeholder": "Search…",
     "kumiko.list.empty.title": "No entries yet.",