@cosmicdrift/kumiko-bundled-features 0.98.0 → 0.102.0

package/src/tags/web/tag-filter.tsx

@@ -1,10 +1,13 @@
 // @runtime client
 // TagFilter — a drop-in tag filter for ANY entityList toolbar. Register it as
-// the list's header slot (`screen.slots.header`) and mark `id` filterable is NOT
-// needed — the renderer passes this control the list's screenId, and picking
-// tags resolves the matching row ids and narrows the list via an id-set URL
-// filter (`<screenId>.f.id=…`, applied as `{ field: "id", op: "in" }`). No host
-// schema change: any list gets tag-filtering by mounting this in its header.
+// the list's header slot (`screen.slots.header`); the renderer passes it the
+// list's screenId, and picking tags resolves the matching row ids and narrows
+// the list via an id-set URL filter (`<screenId>.f.id=…`, applied as
+// `{ field: "id", op: "in" }`). No host schema change: any list gets
+// tag-filtering by mounting this in its header.
+//
+// The active selection is shown inline as colored chips next to the button, with
+// a clear affordance — so the filter is visible, not hidden behind a count.
 //
 // ponytail: resolves ids from the assignment list (first 500 rows) + an id-IN
 // URL filter — fine for typical tag volumes. For huge assignment sets add a
@@ -18,6 +21,7 @@ import {
 } from "@cosmicdrift/kumiko-renderer";
 import { type ReactNode, useState } from "react";
 import { TagsQueries } from "../constants";
+import { TagChip } from "./tag-chip";
 import { TagPicker } from "./tag-picker";
 
 // Tags chosen but zero matching entities → filter to a value that matches no row
@@ -29,6 +33,7 @@ type AssignmentRow = {
   readonly entityType: string;
   readonly entityId: string;
 };
+type TagRow = { readonly id: string; readonly name: string; readonly color?: string | null };
 
 export function TagFilter({
   entityName,
@@ -42,6 +47,7 @@ export function TagFilter({
   const t = useTranslation();
   const [open, setOpen] = useState(false);
   const [selected, setSelected] = useState<readonly string[]>([]);
+  const catalog = useQuery<{ rows: readonly TagRow[] }>(TagsQueries.tagList, {});
   const assignments = useQuery<{ rows: readonly AssignmentRow[] }>(TagsQueries.assignmentList, {
     limit: 500,
   });
@@ -66,16 +72,22 @@ export function TagFilter({
     urlState.setFilter("id", ids.length > 0 ? ids : [NO_MATCH]);
   };
 
-  const label =
-    selected.length > 0
-      ? t("tags.filter.active", { count: selected.length })
-      : t("tags.filter.label");
+  const byId = new Map((catalog.data?.rows ?? []).map((tg) => [tg.id, tg]));
 
   return (
-    <>
+    <div className="flex flex-wrap items-center gap-1">
       <Button variant="secondary" onClick={() => setOpen(true)} testId="tag-filter-open">
-        {label}
+        {t("tags.filter.label")}
       </Button>
+      {selected.map((id) => {
+        const tag = byId.get(id);
+        return <TagChip key={id} name={tag?.name ?? id} color={tag?.color} />;
+      })}
+      {selected.length > 0 && (
+        <Button variant="secondary" onClick={() => applyFilter([])} testId="tag-filter-clear">
+          {t("tags.filter.clear")}
+        </Button>
+      )}
       <TagPicker
         entityType={entityName}
         value={selected}
@@ -83,6 +95,6 @@ export function TagFilter({
         open={open}
         onOpenChange={setOpen}
       />
-    </>
+    </div>
   );
 }

package/src/tags/web/tags-cell.tsx

@@ -0,0 +1,46 @@
+// @runtime client
+// TagsCell — a reusable columnRenderer that shows an entity's tags as colored
+// chips inline in a list row. Drop it into ANY entityList by declaring a labeled
+// virtual column (no host-schema change), after mounting tagsClient():
+//   columns: [
+//     "title",
+//     { field: "tags", label: "Tags",
+//       renderer: { react: { __component: TAGS_COLUMN_RENDERER_NAME } } },
+//   ]
+// It reads the row's id (entity ids are unique, so entityType is unnecessary)
+// and renders a TagChip per assigned tag; renders nothing when the row has none.
+//
+// ponytail: bulk-loads the assignment list (first 500) + the catalog once and
+// filters per row — kumiko's useQuery dedupes the identical (type, payload)
+// calls, so the whole column shares two queries, not two-per-row. For huge
+// assignment sets add a server-side entitiesByTag query + join filter.
+
+import { type ColumnRendererProps, useQuery } from "@cosmicdrift/kumiko-renderer";
+import type { ReactNode } from "react";
+import { TagsQueries } from "../constants";
+import { TagChip } from "./tag-chip";
+
+type TagRow = { readonly id: string; readonly name: string; readonly color?: string | null };
+type AssignmentRow = { readonly tagId: string; readonly entityId: string };
+
+export function TagsCell({ row }: ColumnRendererProps): ReactNode {
+  const entityId = String(row["id"] ?? "");
+  const catalog = useQuery<{ rows: readonly TagRow[] }>(TagsQueries.tagList, {});
+  const assignments = useQuery<{ rows: readonly AssignmentRow[] }>(TagsQueries.assignmentList, {
+    limit: 500,
+  });
+  if (entityId === "") return null;
+  const byId = new Map((catalog.data?.rows ?? []).map((t) => [t.id, t]));
+  const tagIds = (assignments.data?.rows ?? [])
+    .filter((a) => a.entityId === entityId)
+    .map((a) => a.tagId);
+  if (tagIds.length === 0) return null;
+  return (
+    <div className="flex flex-wrap gap-1" data-testid="tags-cell">
+      {tagIds.map((id) => {
+        const tag = byId.get(id);
+        return <TagChip key={id} name={tag?.name ?? id} color={tag?.color} />;
+      })}
+    </div>
+  );
+}

package/src/text-content/__tests__/seed-legal-content.integration.test.ts

@@ -0,0 +1,61 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { type DbConnection, fetchOne } from "@cosmicdrift/kumiko-framework/db";
+import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { createTextContentFeature } from "../feature";
+import { type LegalContentBlock, seedLegalContentFromJson } from "../seeding";
+import { type TextBlockRow, textBlockEntity, textBlocksTable } from "../table";
+
+// Pins seedLegalContentFromJson: seeds into SYSTEM_TENANT_ID by default and
+// re-seeds with ifExists:"update" so a changed template body lands on an
+// already-seeded block (legal-drift guard — the load-bearing behaviour).
+
+let stack: TestStack;
+let db: DbConnection;
+
+beforeAll(async () => {
+  stack = await setupTestStack({ features: [createTextContentFeature()] });
+  db = stack.db;
+  await unsafeCreateEntityTable(db, textBlockEntity);
+  await createEventsTable(db);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+function read(slug: string, lang: string) {
+  return fetchOne<TextBlockRow>(db, textBlocksTable, { tenantId: SYSTEM_TENANT_ID, slug, lang });
+}
+
+describe("seedLegalContentFromJson", () => {
+  test("seeds all blocks into SYSTEM_TENANT_ID by default", async () => {
+    const blocks: LegalContentBlock[] = [
+      { slug: "imprint", lang: "de", title: "Impressum", body: "Marc Frost" },
+      { slug: "imprint", lang: "en", title: "Imprint", body: "Marc Frost" },
+    ];
+    await seedLegalContentFromJson(db, blocks);
+
+    expect(await read("imprint", "de")).toMatchObject({ title: "Impressum", body: "Marc Frost" });
+    expect(await read("imprint", "en")).toMatchObject({ title: "Imprint", body: "Marc Frost" });
+  });
+
+  test("re-seed lifts an existing block to the new template state (ifExists:update)", async () => {
+    const v1: LegalContentBlock[] = [
+      { slug: "privacy", lang: "de", title: "Datenschutz", body: "v1" },
+    ];
+    await seedLegalContentFromJson(db, v1);
+    expect(await read("privacy", "de")).toMatchObject({ body: "v1" });
+
+    const v2: LegalContentBlock[] = [
+      { slug: "privacy", lang: "de", title: "Datenschutz", body: "v2 + Sub-Processor-Tabelle" },
+    ];
+    await seedLegalContentFromJson(db, v2);
+    expect(await read("privacy", "de")).toMatchObject({ body: "v2 + Sub-Processor-Tabelle" });
+  });
+});

package/src/text-content/seeding.ts

@@ -9,7 +9,11 @@ import {
   createTenantDb,
   type DbConnection,
 } from "@cosmicdrift/kumiko-framework/db";
-import type { SessionUser, TenantId } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  type SessionUser,
+  SYSTEM_TENANT_ID,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
 import { runEventStoreSeed, type SeedIfExists } from "@cosmicdrift/kumiko-framework/seeding";
 import { TestUsers } from "@cosmicdrift/kumiko-framework/stack";
 import { type TextBlockRow, textBlockEntity, textBlocksTable } from "./table";
@@ -101,3 +105,33 @@ export async function seedTextBlock(
     },
   });
 }
+
+export type LegalContentBlock = {
+  readonly slug: string;
+  readonly lang: string;
+  readonly title: string;
+  readonly body: string;
+};
+
+// Boot-Seed für Legal-/Marketing-Texte aus einer JSON-Vorlage. `ifExists:
+// "update"` ist load-bearing: die Vorlage ist autoritativ, jeder Boot hebt
+// bestehende Blöcke auf den kompilierten Stand — sonst erreichen gesetzlich
+// vorgeschriebene Zusätze (z.B. Sub-Processor-Tabelle) bereits geseedete
+// Prod-Records nie. Genau diese Entscheidung soll keine App selbst treffen.
+export async function seedLegalContentFromJson(
+  db: DbConnection,
+  blocks: readonly LegalContentBlock[],
+  opts: { readonly tenantId?: TenantId } = {},
+): Promise<void> {
+  const tenantId = opts.tenantId ?? SYSTEM_TENANT_ID;
+  for (const block of blocks) {
+    await seedTextBlock(db, {
+      tenantId,
+      slug: block.slug,
+      lang: block.lang,
+      title: block.title,
+      body: block.body,
+      ifExists: "update",
+    });
+  }
+}

package/src/user-data-rights/__tests__/file-binary-forget-cleanup.integration.test.ts

@@ -80,7 +80,6 @@ beforeAll(async () => {
       createUserDataRightsFeature(),
       createUserDataRightsDefaultsFeature(),
     ],
-    files: { storageProvider: provider },
     extraContext: ({ registry }) => ({
       configResolver: resolver,
       _configAccessorFactory: createConfigAccessorFactory(registry, resolver),

package/src/user-data-rights/__tests__/file-binary-forget-failure.integration.test.ts

@@ -90,7 +90,6 @@ beforeAll(async () => {
       createUserDataRightsFeature(),
       createUserDataRightsDefaultsFeature(),
     ],
-    files: { storageProvider: flakyProvider },
     extraContext: ({ registry }) => ({
       configResolver: resolver,
       _configAccessorFactory: createConfigAccessorFactory(registry, resolver),

package/src/user-data-rights/__tests__/file-storage-unification.integration.test.ts

@@ -0,0 +1,162 @@
+// #608 trap-closed regression: uploads and erasure resolve the file provider
+// through ONE source (file-foundation), end-to-end through the real server.
+//
+// The stack mounts file-foundation + a provider plugin but does NOT inject a
+// resolver (no `files:` option) — so buildServer must build the upload-route
+// resolver itself from the mounted features, exactly as production does. A file
+// uploaded through POST /api/files must land in the SAME store the GDPR forget
+// pipeline deletes from. Before the unification the upload route wrote through a
+// separately-wired provider while erasure deleted through file-foundation — so a
+// regression to a static `storageProvider` makes the `provider.exists(...)`
+// assertion below go red.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { type SessionUser, SYSTEM_USER_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createInMemoryFileProvider,
+  type FileStorageProvider,
+  fileRefsTable,
+  type InMemoryFileProvider,
+} from "@cosmicdrift/kumiko-framework/files";
+import {
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
+import {
+  buildMultipartBody,
+  patchFileInstanceofForBunTest,
+  resetTestTables,
+} from "@cosmicdrift/kumiko-framework/testing";
+import { createComplianceProfilesFeature } from "../../compliance-profiles";
+import { createConfigFeature } from "../../config";
+import { createConfigAccessorFactory } from "../../config/feature";
+import { createConfigResolver } from "../../config/resolver";
+import { configValuesTable } from "../../config/table";
+import { createDataRetentionFeature, tenantRetentionOverrideEntity } from "../../data-retention";
+import { fileFoundationFeature } from "../../file-foundation";
+import { createFilesFeature } from "../../files";
+import { createSessionsFeature } from "../../sessions";
+import { createUserFeature, userEntity, userTable } from "../../user";
+import { createUserDataRightsDefaultsFeature } from "../../user-data-rights-defaults";
+import { createUserDataRightsFeature } from "../feature";
+import { makeTenantStorageProviderResolver } from "../lib/storage-provider-resolver";
+import { runForgetCleanup } from "../run-forget-cleanup";
+import {
+  createForgetSeeders,
+  createTestFileProviderFeature,
+  type ForgetSeeders,
+  nowInstant,
+  READ_TENANT_MEMBERSHIPS_DDL,
+  TENANT_SYSTEM,
+} from "./forget-test-helpers";
+
+const FILE_PROVIDER_CONFIG_KEY = "file-foundation:config:provider";
+
+let stack: TestStack;
+let db: DbConnection;
+let provider: InMemoryFileProvider;
+let seed: ForgetSeeders;
+let buildStorageProvider: (tenantId: string) => Promise<FileStorageProvider>;
+
+function uuid(suffix: number): string {
+  return `cccccccc-cccc-4ccc-8ccc-${suffix.toString(16).padStart(12, "0")}`;
+}
+
+async function uploadAs(user: SessionUser, fileName: string, bytes: Uint8Array): Promise<Response> {
+  const token = await stack.jwt.sign(user);
+  const fd = new FormData();
+  fd.append("file", new File([Buffer.from(bytes)], fileName, { type: "application/pdf" }));
+  const { body, contentType } = await buildMultipartBody(fd);
+  return stack.app.request("/api/files", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+    body,
+  });
+}
+
+beforeAll(async () => {
+  patchFileInstanceofForBunTest();
+  provider = createInMemoryFileProvider();
+  // Select the test plugin app-wide via a config app-override (no admin write).
+  const appOverrides = new Map<string, string>([[FILE_PROVIDER_CONFIG_KEY, "test"]]);
+  const resolver = createConfigResolver({ appOverrides });
+  stack = await setupTestStack({
+    features: [
+      createConfigFeature(),
+      createUserFeature(),
+      createFilesFeature(),
+      fileFoundationFeature,
+      createTestFileProviderFeature(provider, "test"),
+      createDataRetentionFeature(),
+      createComplianceProfilesFeature(),
+      createSessionsFeature(),
+      createUserDataRightsFeature(),
+      createUserDataRightsDefaultsFeature(),
+    ],
+    // No `files:` option on purpose — buildServer must resolve the upload
+    // provider through the mounted file-foundation, like production.
+    extraContext: ({ registry }) => ({
+      configResolver: resolver,
+      _configAccessorFactory: createConfigAccessorFactory(registry, resolver),
+    }),
+  });
+  db = stack.db;
+  seed = createForgetSeeders(db, provider);
+  buildStorageProvider = makeTenantStorageProviderResolver({
+    registry: stack.registry,
+    configResolver: resolver,
+    secrets: undefined,
+    db,
+    userId: SYSTEM_USER_ID,
+    handlerName: "test-608-e2e",
+  });
+
+  await unsafeCreateEntityTable(db, userEntity);
+  await unsafeCreateEntityTable(db, tenantRetentionOverrideEntity);
+  await unsafePushTables(db, { fileRefsTable, configValuesTable });
+  await createEventsTable(db);
+  await asRawClient(db).unsafe(READ_TENANT_MEMBERSHIPS_DDL);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  provider.clear();
+  await resetTestTables(db, [userTable, "read_tenant_memberships", fileRefsTable]);
+});
+
+describe("#608 unified file-storage :: route upload + GDPR erasure hit one store", () => {
+  test("a file uploaded via /api/files lands in the file-foundation store and forget erases it", async () => {
+    const userId = uuid(1);
+    // The uploader is also the forget subject (DeletionRequested + grace passed).
+    await seed.seedForgetUser(userId);
+    await seed.seedMembership(userId, TENANT_SYSTEM);
+    const uploader: SessionUser = { id: userId, tenantId: TENANT_SYSTEM, roles: ["Member"] };
+
+    const res = await uploadAs(uploader, "secret.pdf", new Uint8Array([10, 20, 30, 40]));
+    expect(res.status).toBe(201);
+    const { storageKey } = (await res.json()) as { storageKey: string };
+
+    // The upload route resolved its provider through file-foundation — the bytes
+    // are in `provider`. A static/separate upload provider would miss here.
+    expect(await provider.exists(storageKey)).toBe(true);
+
+    // Erasure resolves through the SAME source and deletes the very same bytes —
+    // no false "done", no orphaned binary.
+    const result = await runForgetCleanup({
+      db,
+      registry: stack.registry,
+      now: nowInstant(),
+      buildStorageProvider,
+    });
+    expect(result.processedUserIds).toContain(userId);
+    expect(await provider.exists(storageKey)).toBe(false);
+  });
+});

package/src/user-data-rights/web/__tests__/deletion-screens.test.tsx

@@ -51,12 +51,12 @@ function renderWith(ui: ReactElement, dispatcher: Dispatcher): ReturnType<typeof
   return within(container);
 }
 
-// SKIPPED — CI-only flake (#457): on the shared single-process happy-dom runner
-// the click never reaches React's submit handler after ~30 prior DOM test files
-// have mounted/unmounted (write is never invoked, calls stays empty). Green
-// locally and on main; not a timing issue. Un-skip once the global afterEach
-// teardown / per-file DOM isolation fix lands.
-describe.skip("RequestAccountDeletionScreen", () => {
+// CI runs this file in its own `bun test` process (own ci.yml step), NOT in the
+// shared `kumiko check` run — see bunfig.ci.toml pathIgnorePatterns. The shared
+// single-process happy-dom corrupts React event delegation after ~30 prior DOM
+// test files mount/unmount, so the click never reached the submit handler here
+// (#457). A fresh process has no such accumulation.
+describe("RequestAccountDeletionScreen", () => {
   test("Submit → write(request-deletion-by-email) + enumeration-safe Success", async () => {
     const calls: WriteCall[] = [];
     const ui = renderWith(<RequestAccountDeletionScreen />, makeDispatcher(true, calls));
@@ -78,7 +78,7 @@ describe.skip("RequestAccountDeletionScreen", () => {
   });
 });
 
-describe.skip("ConfirmAccountDeletionScreen", () => {
+describe("ConfirmAccountDeletionScreen", () => {
   test("ohne ?token → missingToken, kein Confirm-Button", () => {
     window.history.replaceState({}, "", "/delete-account/confirm");
     const ui = renderWith(<ConfirmAccountDeletionScreen />, makeDispatcher(true, []));

package/src/user-data-rights/web/__tests__/privacy-center-screen.test.tsx

@@ -114,19 +114,13 @@ async function waitForMount(view: ReturnType<typeof render>): Promise<void> {
   });
 }
 
-// QUARANTINED (#457-Klasse): diese Render-Tests laufen lokal grün (13/13 isoliert,
-// 82/88 mit allen bundled-features-web-Tests parallel), failen aber auf CI-Linux
-// unter bun-`concurrency=8`. Diagnose aus dem CI-Log: parallele Test-FILES teilen
-// sich das eine globale happy-dom `document`; der globale `afterEach` aus
-// `test-setup/dom.preload.ts` (`cleanup()` + `document.body.replaceChildren()`)
-// eines parallel laufenden Tests wischt die in-flight gerenderte DOM eines anderen
-// weg → die `await`-Assertions hier finden den Screen-Stand eines Nachbar-Tests
-// (sichtbar: alle Fails zeigen denselben active-state Screen statt der eigenen
-// Test-Daten). Nicht aus diesem File fixbar — gleiche Architektur-Flake, wegen der
-// `deletion-screens.test.tsx` im selben Verzeichnis quarantäniert ist. Un-skip,
-// sobald das framework-weite Test-Isolation-Problem (#457) gelöst ist. Die
-// QN-Drift-Pins + formatDate unten decken die CI-stabile Verdrahtungs-Korrektheit ab.
-describe.skip("PrivacyCenterScreen", () => {
+// CI runs this file in its own `bun test` process (own ci.yml step), NOT in the
+// shared `kumiko check` run — see bunfig.ci.toml pathIgnorePatterns. In the shared
+// single-process happy-dom, the global `afterEach` from `test-setup/dom.preload.ts`
+// plus accumulated global DOM/event state across ~30 prior DOM test files corrupts
+// these in-flight renders (#457-class). A fresh process has no such accumulation.
+// The QN-Drift-Pins + formatDate describes below are pure-logic and CI-stable.
+describe("PrivacyCenterScreen", () => {
   test("aktiver User: Export/Einschränken/Löschen-Sektionen, Texte übersetzt (keine rohen Keys)", async () => {
     const { view } = renderCenter({ me: activeMe });
     await waitForMount(view);