@cosmicdrift/kumiko-renderer-web 0.155.1 → 0.156.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer-web",
-  "version": "0.155.1",
+  "version": "0.156.1",
   "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.155.1",
-    "@cosmicdrift/kumiko-headless": "0.155.1",
-    "@cosmicdrift/kumiko-renderer": "0.155.1",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.156.1",
+    "@cosmicdrift/kumiko-headless": "0.156.1",
+    "@cosmicdrift/kumiko-renderer": "0.156.1",
     "@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__/create-app.test.tsx

@@ -6,7 +6,12 @@ import type {
   EntityListScreenDefinition,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
-import type { ColumnRendererProps, FeatureSchema, NavApi } from "@cosmicdrift/kumiko-renderer";
+import type {
+  AppSchema,
+  ColumnRendererProps,
+  FeatureSchema,
+  NavApi,
+} from "@cosmicdrift/kumiko-renderer";
 import { createStaticLocaleResolver } from "@cosmicdrift/kumiko-renderer";
 import { act, screen, waitFor } from "@testing-library/react";
 import type { ReactNode } from "react";
@@ -150,6 +155,54 @@ describe("createKumikoApp", () => {
     );
   });
 
+  test("fallback screen skips access-restricted screens across features (#1176)", async () => {
+    mountRoot();
+    const restrictedFeature: FeatureSchema = {
+      featureName: "user",
+      entities: { task: taskEntity },
+      screens: [{ ...listScreen, id: "user-list", access: { roles: ["SystemAdmin"] } }],
+    };
+    const openFeature: FeatureSchema = { ...baseSchema, featureName: "tasks" };
+    const schema: AppSchema = { features: [restrictedFeature, openFeature] };
+    await mountApp({ schema, dispatcher: makeDispatcher() });
+    // Landing on user-list (SystemAdmin-only) would show an access-denied
+    // banner instead — the tasks:task-edit form must win instead.
+    await waitFor(() => expect(screen.getByTestId("render-edit-form")).toBeTruthy());
+  });
+
+  test("fallback screen: an openToAll screen counts as accessible", async () => {
+    mountRoot();
+    const restrictedFeature: FeatureSchema = {
+      featureName: "user",
+      entities: { task: taskEntity },
+      screens: [{ ...editScreen, id: "user-edit", access: { roles: ["SystemAdmin"] } }],
+    };
+    const openFeature: FeatureSchema = {
+      featureName: "tasks",
+      entities: { task: taskEntity },
+      screens: [{ ...listScreen, access: { openToAll: true } }],
+    };
+    const schema: AppSchema = { features: [restrictedFeature, openFeature] };
+    await mountApp({ schema, dispatcher: makeDispatcher() });
+    expect(await screen.findByTestId("render-list-table-empty")).toBeTruthy();
+  });
+
+  test("all screens access-restricted → throws (no accessible fallback)", () => {
+    mountRoot();
+    const restrictedOnly: AppSchema = {
+      features: [
+        {
+          featureName: "user",
+          entities: { task: taskEntity },
+          screens: [{ ...editScreen, access: { roles: ["SystemAdmin"] } }],
+        },
+      ],
+    };
+    expect(() => createKumikoApp({ schema: restrictedOnly, dispatcher: makeDispatcher() })).toThrow(
+      /no screens/,
+    );
+  });
+
   test("clientFeatures.columnRenderers → bei Key-Kollision warnt + last-wins gewinnt", async () => {
     // Zwei Features liefern denselben Renderer-Key — der Merge in
     // create-app warnt und behält den späteren Eintrag (Last-Wins).

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

@@ -314,6 +314,68 @@ describe("KumikoScreen", () => {
     expect(screen.queryByTestId("render-edit-delete")).toBeNull();
   });
 
+  // Issue #912 — Copy-Link-Action. KumikoScreen threads an already-bound
+  // onCopyLink callback down to RenderEdit (the actual URL-build/clipboard
+  // impl lives in renderer-web's RoutedScreen, outside this test — here we
+  // only verify the wiring: button renders in update-mode, fires the
+  // callback, and shows the "copied" label afterwards).
+  test("entityEdit update-mode: Copy-Link-Button feuert onCopyLink + zeigt 'copied'-Label", async () => {
+    const user = userEvent.setup();
+    const onCopyLink = mock(() => Promise.resolve());
+    const dispatcher = makeDispatcher({
+      query: (async () => ({
+        isSuccess: true,
+        data: { id: "task-1", version: 1, title: "loaded", count: 3, done: false },
+      })) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen
+          schema={schema}
+          qn="tasks:screen:task-edit"
+          entityId="task-1"
+          onCopyLink={onCopyLink}
+        />
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull());
+
+    const button = screen.getByTestId("render-edit-copy-link");
+    expect(button.textContent).toBe("Copy link");
+    await user.click(button);
+    expect(onCopyLink).toHaveBeenCalledTimes(1);
+    await waitFor(() => expect(button.textContent).toBe("Copied!"));
+  });
+
+  test("entityEdit create-mode: kein Copy-Link-Button (keine entity-id → kein Permalink)", () => {
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <KumikoScreen
+          schema={schema}
+          qn="tasks:screen:task-edit"
+          onCopyLink={() => Promise.resolve()}
+        />
+      </DispatcherProvider>,
+    );
+    expect(screen.queryByTestId("render-edit-copy-link")).toBeNull();
+  });
+
+  test("entityEdit update-mode ohne onCopyLink-Prop: kein Copy-Link-Button", async () => {
+    const dispatcher = makeDispatcher({
+      query: (async () => ({
+        isSuccess: true,
+        data: { id: "task-1", version: 1, title: "loaded", count: 3, done: false },
+      })) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={schema} qn="tasks:screen:task-edit" entityId="task-1" />
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull());
+    expect(screen.queryByTestId("render-edit-copy-link")).toBeNull();
+  });
+
   test("entityEdit update-mode: version_conflict → Banner + 'Neu laden' triggert detail-refetch", async () => {
     let detailCalls = 0;
     const dispatcher = makeDispatcher({

package/src/app/create-app.tsx

@@ -129,6 +129,22 @@ function readInjectedSchema(): AppSchema | FeatureSchema | undefined {
   return w.__KUMIKO_SCHEMA__;
 }
 
+// Erstes Screen über alle Features in deklarierter Reihenfolge, dessen
+// `access` niemanden ausschließt (undefined oder openToAll). Die Landing-
+// Route wird VOR Auth-Resolution gewählt, kennt also keine User-Rollen —
+// ein role-restricted Screen (z.B. bundled user/tenant, SystemAdmin-only)
+// darf hier nie gewinnen, sonst landet jeder Nicht-Admin auf einem
+// Access-Denied-Screen (#1176).
+function firstOpenScreenQn(features: readonly FeatureSchema[]): string | undefined {
+  for (const feature of features) {
+    const openScreen = feature.screens.find(
+      (s) => s.access === undefined || "openToAll" in s.access,
+    );
+    if (openScreen !== undefined) return qualifyScreenId(feature.featureName, openScreen.id);
+  }
+  return undefined;
+}
+
 export function createKumikoApp(options: CreateKumikoAppOptions = {}): { readonly root: Root } {
   const rootId = options.rootId ?? "root";
   const container = document.getElementById(rootId);
@@ -154,19 +170,11 @@ export function createKumikoApp(options: CreateKumikoAppOptions = {}): { readonl
   }
   const app = toAppSchema(rawSchema);
 
-  // Fallback-Screen: erstes Screen über alle Features in deklarierter
-  // Reihenfolge. War vorher schema.screens[0], jetzt search the first
-  // feature with screens.
-  const firstFeatureWithScreens = app.features.find((f) => f.screens.length > 0);
-  const firstScreen = firstFeatureWithScreens?.screens[0];
-  const fallbackQn =
-    options.screenQn ??
-    (firstScreen !== undefined && firstFeatureWithScreens !== undefined
-      ? qualifyScreenId(firstFeatureWithScreens.featureName, firstScreen.id)
-      : undefined);
+  // Fallback-Screen falls kein explizites screenQn übergeben wurde.
+  const fallbackQn = options.screenQn ?? firstOpenScreenQn(app.features);
   if (!fallbackQn) {
     throw new Error(
-      "createKumikoApp: schema contains no screens. Add at least one entry to `schema.screens` or pass `screenQn` explicitly.",
+      "createKumikoApp: schema contains no screens accessible without a role restriction. Add at least one entry to `schema.screens` without `access.roles`, or pass `screenQn` explicitly.",
     );
   }
 
@@ -455,6 +463,25 @@ function RoutedScreen({
     };
   }, [onRowClick, app.features, nav]);
 
+  // Copy-Link-Action (Issue #912) für entityEdit-Update-Screens. Baut die
+  // absolute Permalink-URL aus der aktuellen Route + kopiert sie —
+  // `navigator`/`window` sind hier erlaubt (renderer-web, kein
+  // platform-neutrales Package). Kein Button ohne entityId (create-mode).
+  // Silent-catch bei Clipboard-Fehler (non-secure context) mirrort das
+  // bestehende Muster in pat-tokens-screen.tsx.
+  const effectiveOnCopyLink = useMemo<(() => Promise<void> | void) | undefined>(() => {
+    const route = nav.route;
+    if (route?.entityId === undefined) return undefined;
+    return async () => {
+      const url = `${window.location.origin}${nav.hrefFor(route)}`;
+      try {
+        await navigator.clipboard.writeText(url);
+      } catch {
+        // clipboard blocked (non-secure context) — no fallback UI needed here
+      }
+    };
+  }, [nav]);
+
   // KumikoScreen will nach wie vor ein single-feature schema. Wir
   // füttern es mit dem owning Feature — es enthält Entity-Defs +
   // Screen-Defs für den aktiven Render-Pfad. Kein Owner gefunden → wir
@@ -474,6 +501,7 @@ function RoutedScreen({
       {...(translate !== undefined && { translate })}
       {...(entityId !== undefined && { entityId })}
       onRowClick={effectiveOnRowClick}
+      {...(effectiveOnCopyLink !== undefined && { onCopyLink: effectiveOnCopyLink })}
     />
   );
 }

package/src/layout/__tests__/nav-registry.test.ts

@@ -128,6 +128,25 @@ describe("buildNavRegistrySliceForApp", () => {
     expect(slice.topLevel[0]?.access).toEqual({ roles: ["Admin", "Editor"] });
   });
 
+  test("nav ohne eigene access bleibt ohne access, wenn der Ziel-Screen offen ist (kein Verstecken eines openToAll-Screens)", () => {
+    const app: AppSchema = {
+      features: [
+        featureWithScreens(
+          [{ id: "pub", label: "Pub", screen: "pub" }],
+          [
+            {
+              id: "pub",
+              type: "custom",
+              renderer: { react: { __component: "Pub" } },
+            },
+          ],
+        ),
+      ],
+    };
+    const slice = buildNavRegistrySliceForApp(app);
+    expect(slice.topLevel[0]?.access).toBeUndefined();
+  });
+
   test("nav ohne screen bleibt ohne access (nichts zum Erben da)", () => {
     const app: AppSchema = {
       features: [feature([{ id: "group", label: "Group" }])],