@cosmicdrift/kumiko-renderer 0.327.0 → 0.328.1

package/src/app/__tests__/projection-detail-reference-field.test.tsx

@@ -1,165 +0,0 @@
-// fw#2662: projectionDetail fields have no EntityDefinition to carry a real
-// "reference" field type (the shim hardcodes every field as "text"), so a
-// declared reference field used to render the raw id. This renders the real
-// path (KumikoScreen -> ProjectionDetailScreen -> RenderEdit -> RenderField
-// -> ReadOnlyReferenceValue) under a stub dispatcher.
-
-import { describe, expect, test } from "bun:test";
-import type { ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
-import { render, waitFor } from "@testing-library/react";
-import type { ComponentType, ReactNode } from "react";
-import { DispatcherProvider } from "../../context/dispatcher-context";
-import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
-import { kumikoDefaultTranslations } from "../../i18n-defaults";
-import { type CorePrimitives, PrimitivesProvider, type TextProps } from "../../primitives";
-import type { FeatureSchema } from "../feature-schema";
-import { KumikoScreen } from "../kumiko-screen";
-import type { NavApi } from "../nav";
-import { NavProvider } from "../nav";
-
-const SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
-
-const noop = (): ReactNode => null;
-const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
-// passChildren would drop testId — ReadOnlyReferenceValue/readOnlyDisplayText
-// render their resolved text into `<Text testId="field-value-<field>">`, and
-// the assertions below read it back by that testid.
-const TestText: ComponentType<TextProps> = ({ children, testId }) => (
-  <span data-testid={testId}>{children}</span>
-);
-
-const testPrimitives: CorePrimitives = {
-  Button: noop,
-  Banner: passChildren,
-  Field: passChildren,
-  Input: noop,
-  DataTable: noop,
-  Form: passChildren,
-  Section: passChildren,
-  Card: passChildren,
-  Grid: passChildren,
-  GridCell: passChildren,
-  Text: TestText,
-  Heading: noop,
-  Dialog: noop,
-  Modal: noop,
-  Lightbox: noop,
-  ConfigSourceBadge: noop,
-  ConfigCascadeView: noop,
-  Link: noop,
-};
-
-function stubDispatcher(): Dispatcher {
-  return {
-    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
-    query: (async (type: string) => {
-      if (type === "sessions:query:session:detail") {
-        return {
-          isSuccess: true,
-          data: { id: "sess-1", userId: "u-1", actedBy: SYSTEM_USER_ID, ip: "10.0.0.1" },
-        };
-      }
-      // user:user resolves through the tenant-scoped member directory, not the
-      // SystemAdmin-only user:query:user:list a TenantAdmin can't call (fw#3107).
-      if (type === "tenant:query:member-directory") {
-        return {
-          isSuccess: true,
-          data: { rows: [{ id: "u-1", label: "Jane Doe" }], nextCursor: null },
-        };
-      }
-      return { isSuccess: true, data: { rows: [], nextCursor: null } };
-    }) as unknown as Dispatcher["query"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    async *stream() {},
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-}
-
-const detailScreen: ProjectionDetailScreenDefinition = {
-  id: "session-detail",
-  type: "projectionDetail",
-  query: "sessions:query:session:detail",
-  layout: {
-    sections: [
-      {
-        fields: [
-          { field: "userId", refEntity: "user:user", refLabelField: "displayName" },
-          // Mirrors the audit-log detail actor field (fw#3103) — a system
-          // write has no read_users row for the bulk lookup to find.
-          { field: "actedBy", refEntity: "user:user", refLabelField: "displayName" },
-          "ip",
-        ],
-      },
-    ],
-  },
-};
-
-function buildSchema(): FeatureSchema {
-  return {
-    featureName: "sessions",
-    entities: {},
-    screens: [detailScreen],
-  } as FeatureSchema;
-}
-
-const staticNav: NavApi = {
-  route: { screenId: "sessions:screen:session-detail" },
-  navigate: () => {},
-  replace: () => {},
-  hrefFor: () => "",
-  searchParams: {},
-  setSearchParams: () => {},
-};
-
-function renderDetailScreen(): ReturnType<typeof render> {
-  return render(
-    <LocaleProvider
-      resolver={createStaticLocaleResolver({ locale: "en" })}
-      fallbackBundles={[kumikoDefaultTranslations]}
-    >
-      <DispatcherProvider dispatcher={stubDispatcher()}>
-        <NavProvider value={staticNav}>
-          <PrimitivesProvider value={testPrimitives}>
-            <KumikoScreen
-              schema={buildSchema()}
-              qn="sessions:screen:session-detail"
-              entityId="sess-1"
-            />
-          </PrimitivesProvider>
-        </NavProvider>
-      </DispatcherProvider>
-    </LocaleProvider>,
-  );
-}
-
-describe("projectionDetail reference field resolves labels (fw#2662)", () => {
-  test("a field with refEntity metadata shows the resolved display name instead of the raw id", async () => {
-    const { getByTestId } = renderDetailScreen();
-
-    await waitFor(() => {
-      expect(getByTestId("field-value-userId").textContent).toBe("Jane Doe");
-    });
-  });
-
-  test("SYSTEM_USER_ID resolves to the system label instead of the raw id (fw#3103)", async () => {
-    const { getByTestId } = renderDetailScreen();
-
-    await waitFor(() => {
-      expect(getByTestId("field-value-actedBy").textContent).toBe("System");
-    });
-  });
-
-  test("non-regression: a field without refEntity metadata renders its raw value unchanged", async () => {
-    const { getByTestId } = renderDetailScreen();
-
-    await waitFor(() => {
-      expect(getByTestId("field-value-ip").textContent).toBe("10.0.0.1");
-    });
-  });
-});

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

@@ -1,188 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import {
-  synthesizeProjectionDetailEntity,
-  synthesizeProjectionDetailScreen,
-} from "../projection-detail-shim";
-
-// Regression for the writeForm extension (fw editable-detail-screens): the
-// hard readOnly:true enforcement in synthesizeProjectionDetailScreen must
-// still apply to every ordinary fields-section, unchanged — a writeForm
-// section is the one deliberate exception (isFieldsEditSection excludes it,
-// same as relatedList/extension), it must pass through editable.
-describe("synthesizeProjectionDetailScreen", () => {
-  test("forces readOnly:true on a fields section, but leaves a writeForm section's own readOnly untouched", () => {
-    const screen: ProjectionDetailScreenDefinition = {
-      id: "order-detail",
-      type: "projectionDetail",
-      query: "orders:query:order:detail",
-      layout: {
-        sections: [
-          { title: "Basics", fields: [{ field: "name", readOnly: false }] },
-          {
-            kind: "writeForm",
-            title: "Add note",
-            fieldDefs: { note: { type: "text" } },
-            fields: [{ field: "note", readOnly: false }],
-            handler: "orders:write:add-note",
-          },
-        ],
-      },
-    };
-
-    const result = synthesizeProjectionDetailScreen(screen);
-
-    const [fieldsSection, writeFormSection] = 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: "name", readOnly: true });
-
-    if (writeFormSection === undefined || writeFormSection.kind !== "writeForm") {
-      throw new Error("expected the second section to stay kind: writeForm, untouched");
-    }
-    expect(writeFormSection.fields[0]).toEqual({ field: "note", readOnly: false });
-  });
-
-  test("carries description through so RenderEdit can render it as the form subtitle (fw#2723)", () => {
-    const withDescription = synthesizeProjectionDetailScreen({
-      id: "order-detail",
-      type: "projectionDetail",
-      description: "Read-only view of a placed order.",
-      query: "orders:query:order:detail",
-      layout: { sections: [{ title: "Basics", fields: ["name"] }] },
-    });
-    expect(withDescription.description).toBe("Read-only view of a placed order.");
-
-    const withoutDescription = synthesizeProjectionDetailScreen({
-      id: "order-detail",
-      type: "projectionDetail",
-      query: "orders:query:order:detail",
-      layout: { sections: [{ title: "Basics", fields: ["name"] }] },
-    });
-    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/__tests__/projection-detail-singleton.test.tsx

@@ -1,191 +0,0 @@
-// fw#2312: `singleton: true` marks a projectionDetail screen whose query
-// determines the shown row from the caller's session/context instead of a
-// row id in the path (a self-service "my profile"/"my data" screen has no
-// row to link to). Before this flag, ProjectionDetailBody always rendered
-// the "needs a row id in the path" error banner when `entityId` was
-// undefined (kumiko-screen.tsx) — both user-profile and user-data-rights'
-// privacy-center screen hit exactly that, unrenderable, until the flag
-// existed (fw#2312 bug report). This proves the fix, the no-flag regression
-// case stays covered, and that a stray/spoofed path id never reaches the
-// query under singleton (renderer-side half of the security requirement —
-// the boot-validator half lives in framework's projection-detail-
-// singleton.test.ts).
-
-import { describe, expect, test } from "bun:test";
-import type { ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
-import { render, waitFor } from "@testing-library/react";
-import type { ComponentType, ReactNode } from "react";
-import { DispatcherProvider } from "../../context/dispatcher-context";
-import { UserRolesProvider } from "../../context/user-roles-context";
-import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
-import { kumikoDefaultTranslations } from "../../i18n-defaults";
-import {
-  type BannerProps,
-  type CorePrimitives,
-  type FormProps,
-  PrimitivesProvider,
-} from "../../primitives";
-import { AppFeaturesProvider } from "../app-features-context";
-import type { FeatureSchema } from "../feature-schema";
-import { KumikoScreen } from "../kumiko-screen";
-import type { NavApi } from "../nav";
-import { NavProvider } from "../nav";
-
-const noop = (): ReactNode => null;
-const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
-
-const FormWithActions: ComponentType<FormProps> = ({ children }) => (
-  <div data-testid="form-body">{children}</div>
-);
-
-const TestBanner: ComponentType<BannerProps> = ({ children, testId }) => (
-  <div data-testid={testId}>{children}</div>
-);
-
-const testPrimitives: CorePrimitives = {
-  Button: noop,
-  Banner: TestBanner,
-  Field: passChildren,
-  Input: noop,
-  DataTable: noop,
-  Form: FormWithActions,
-  Section: passChildren,
-  Card: passChildren,
-  Grid: passChildren,
-  GridCell: passChildren,
-  Text: passChildren,
-  Heading: noop,
-  Dialog: noop,
-  Modal: noop,
-  Lightbox: noop,
-  ConfigSourceBadge: noop,
-  ConfigCascadeView: noop,
-  Link: noop,
-};
-
-function stubDispatcher(
-  record: Readonly<Record<string, unknown>> | null,
-  queries: Array<{ type: string; payload: unknown }>,
-): Dispatcher {
-  return {
-    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
-    query: (async (type: string, payload: unknown) => {
-      queries.push({ type, payload });
-      return { isSuccess: true, data: record };
-    }) as unknown as Dispatcher["query"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    async *stream() {},
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-}
-
-function meScreen(
-  overrides?: Partial<ProjectionDetailScreenDefinition>,
-): FeatureSchema["screens"][number] {
-  return {
-    id: "profile",
-    type: "projectionDetail",
-    query: "app:query:me",
-    layout: { sections: [{ title: "s", fields: ["name"] }] },
-    ...overrides,
-  } as FeatureSchema["screens"][number];
-}
-
-function renderScreen(opts: {
-  readonly screen: FeatureSchema["screens"][number];
-  readonly entityId?: string;
-  readonly queries: Array<{ type: string; payload: unknown }>;
-  readonly record?: Readonly<Record<string, unknown>> | null;
-}): ReturnType<typeof render> {
-  const schema: FeatureSchema = { featureName: "app", entities: {}, screens: [opts.screen] };
-  const navApi: NavApi = {
-    route: { screenId: "app:screen:profile" },
-    navigate: () => {},
-    replace: () => {},
-    hrefFor: () => "",
-    searchParams: {},
-    setSearchParams: () => {},
-  };
-  return render(
-    <LocaleProvider
-      resolver={createStaticLocaleResolver({ locale: "de-DE" })}
-      fallbackBundles={[kumikoDefaultTranslations]}
-    >
-      <DispatcherProvider
-        dispatcher={stubDispatcher(
-          opts.record !== undefined ? opts.record : { id: "u1", name: "Ada" },
-          opts.queries,
-        )}
-      >
-        <AppFeaturesProvider features={[schema]}>
-          <UserRolesProvider roles={[]}>
-            <NavProvider value={navApi}>
-              <PrimitivesProvider value={testPrimitives}>
-                <KumikoScreen
-                  schema={schema}
-                  qn="app:screen:profile"
-                  {...(opts.entityId !== undefined && { entityId: opts.entityId })}
-                />
-              </PrimitivesProvider>
-            </NavProvider>
-          </UserRolesProvider>
-        </AppFeaturesProvider>
-      </DispatcherProvider>
-    </LocaleProvider>,
-  );
-}
-
-describe("projectionDetail singleton (fw#2312)", () => {
-  test("singleton + no path id renders the record instead of the missing-id banner", async () => {
-    const queries: Array<{ type: string; payload: unknown }> = [];
-    const { queryByTestId, getByTestId } = renderScreen({
-      screen: meScreen({ singleton: true }),
-      queries,
-    });
-
-    await waitFor(() => expect(getByTestId("form-body")).toBeTruthy());
-    expect(queryByTestId("kumiko-screen-projection-detail-missing-id")).toBeNull();
-    expect(queries).toEqual([{ type: "app:query:me", payload: {} }]);
-  });
-
-  test("no singleton flag + no path id still shows the missing-id banner (no regression)", async () => {
-    const queries: Array<{ type: string; payload: unknown }> = [];
-    const { getByTestId } = renderScreen({ screen: meScreen(), queries });
-
-    await waitFor(() =>
-      expect(getByTestId("kumiko-screen-projection-detail-missing-id")).toBeTruthy(),
-    );
-  });
-
-  test("singleton ignores a stray path id — the query never receives it", async () => {
-    const queries: Array<{ type: string; payload: unknown }> = [];
-    const { getByTestId } = renderScreen({
-      screen: meScreen({ singleton: true }),
-      entityId: "attacker-controlled-id",
-      queries,
-    });
-
-    await waitFor(() => expect(getByTestId("form-body")).toBeTruthy());
-    expect(queries).toEqual([{ type: "app:query:me", payload: {} }]);
-  });
-
-  test("singleton + record-not-found banner never shows the (ignored) path id", async () => {
-    const queries: Array<{ type: string; payload: unknown }> = [];
-    const { getByTestId } = renderScreen({
-      screen: meScreen({ singleton: true }),
-      entityId: "99",
-      record: null,
-      queries,
-    });
-
-    const banner = await waitFor(() => getByTestId("kumiko-screen-record-missing"));
-    expect(banner.textContent).toBe("Record not found.");
-    expect(banner.textContent).not.toContain("99");
-  });
-});