@cosmicdrift/kumiko-bundled-features 0.124.0 → 0.125.0

package/src/audit/web/audit-log-screen.tsx

@@ -0,0 +1,136 @@
+// @runtime client
+// Paginated tenant-scoped audit log (event store).
+
+import { useDispatcher, usePrimitives, useTranslation } from "@cosmicdrift/kumiko-renderer";
+import { FormScreenShell } from "@cosmicdrift/kumiko-renderer-web";
+import { type ReactNode, useCallback, useEffect, useState } from "react";
+import { AuditQueries } from "../constants";
+
+type AuditRow = {
+  readonly id: string;
+  readonly aggregateId: string;
+  readonly aggregateType: string;
+  readonly type: string;
+  readonly createdBy: string;
+  readonly createdAt: string;
+  readonly payload: Record<string, unknown>;
+};
+
+type AuditResponse = { readonly rows: readonly AuditRow[]; readonly nextBefore: string | null };
+
+type State =
+  | { readonly kind: "loading" }
+  | { readonly kind: "error"; readonly message: string }
+  | {
+      readonly kind: "ready";
+      readonly rows: readonly AuditRow[];
+      readonly nextBefore: string | null;
+    };
+
+export function AuditLogScreen(): ReactNode {
+  const t = useTranslation();
+  const { Banner, Button, Card, DataTable, Heading, Text } = usePrimitives();
+  const dispatcher = useDispatcher();
+  const [state, setState] = useState<State>({ kind: "loading" });
+  const [before, setBefore] = useState<string | undefined>(undefined);
+
+  const load = useCallback(
+    async (cursor?: string): Promise<void> => {
+      setState({ kind: "loading" });
+      const res = await dispatcher.query<AuditResponse>(AuditQueries.list, {
+        limit: 50,
+        ...(cursor !== undefined && { before: cursor }),
+      });
+      if (!res.isSuccess) {
+        setState({ kind: "error", message: res.error.message });
+        return;
+      }
+      setState({ kind: "ready", rows: res.data.rows, nextBefore: res.data.nextBefore });
+    },
+    [dispatcher],
+  );
+
+  useEffect(() => {
+    void load(before);
+  }, [load, before]);
+
+  if (state.kind === "loading") {
+    return (
+      <FormScreenShell testId="audit-log-screen">
+        <Text variant="small">{t("audit.log.loading")}</Text>
+      </FormScreenShell>
+    );
+  }
+
+  if (state.kind === "error") {
+    return (
+      <FormScreenShell testId="audit-log-screen">
+        <Banner variant="error">{state.message}</Banner>
+      </FormScreenShell>
+    );
+  }
+
+  return (
+    <FormScreenShell testId="audit-log-screen" className="flex max-w-5xl flex-col gap-6">
+      <Heading variant="page">{t("audit.log.title")}</Heading>
+
+      <Card options={{ padded: false }}>
+        <DataTable
+          testId="audit-log-table"
+          columns={[
+            { field: "when", label: t("audit.log.col.when"), type: "string", sortable: false },
+            { field: "type", label: t("audit.log.col.type"), type: "string", sortable: false },
+            {
+              field: "aggregate",
+              label: t("audit.log.col.aggregate"),
+              type: "string",
+              sortable: false,
+            },
+            { field: "actor", label: t("audit.log.col.actor"), type: "string", sortable: false },
+          ]}
+          rows={state.rows.map((row) => ({
+            id: row.id,
+            values: {
+              when: formatWhen(row.createdAt),
+              type: row.type,
+              aggregate: `${row.aggregateType} / ${row.aggregateId}`,
+              actor: row.createdBy,
+            },
+          }))}
+          emptyState={<Text variant="small">{t("audit.log.empty")}</Text>}
+        />
+      </Card>
+
+      <div className="flex gap-2">
+        {before !== undefined && (
+          <Button
+            type="button"
+            variant="secondary"
+            onClick={() => setBefore(undefined)}
+            testId="audit-log-newest"
+          >
+            {t("audit.log.newest")}
+          </Button>
+        )}
+        {state.nextBefore !== null && (
+          <Button
+            type="button"
+            variant="secondary"
+            onClick={() => setBefore(state.nextBefore ?? undefined)}
+            testId="audit-log-older"
+          >
+            {t("audit.log.older")}
+          </Button>
+        )}
+      </div>
+    </FormScreenShell>
+  );
+}
+
+function formatWhen(value: string): string {
+  try {
+    return new Date(value).toLocaleString();
+  } catch {
+    return value;
+  }
+}

package/src/audit/web/client-plugin.tsx

@@ -0,0 +1,20 @@
+// @runtime client
+import { mergeTranslations, type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
+import { AUDIT_FEATURE, AUDIT_LOG_SCREEN_ID } from "../constants";
+import { AuditLogScreen } from "./audit-log-screen";
+import { defaultTranslations } from "./i18n";
+
+export type AuditClientOptions = {
+  readonly translations?: TranslationsByLocale;
+};
+
+export function auditClient(options?: AuditClientOptions): ClientFeatureDefinition {
+  return {
+    name: AUDIT_FEATURE,
+    translations: mergeTranslations(defaultTranslations, options?.translations ?? {}),
+    components: {
+      [AUDIT_LOG_SCREEN_ID]: AuditLogScreen,
+    },
+  };
+}

package/src/audit/web/i18n.ts

@@ -0,0 +1,12 @@
+// @runtime client
+import type { TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import { AUDIT_I18N } from "../i18n";
+
+const LOCALES = ["de", "en"] as const;
+
+export const defaultTranslations: TranslationsByLocale = Object.fromEntries(
+  LOCALES.map((locale) => [
+    locale,
+    Object.fromEntries(Object.entries(AUDIT_I18N).map(([key, value]) => [key, value[locale]])),
+  ]),
+);

package/src/audit/web/index.ts

@@ -0,0 +1,4 @@
+// @runtime client
+
+export { AuditLogScreen } from "./audit-log-screen";
+export { type AuditClientOptions, auditClient } from "./client-plugin";

package/src/auth-email-password/handlers/invite-create.write.ts

@@ -19,7 +19,7 @@
 import { generateToken } from "@cosmicdrift/kumiko-framework/api";
 import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import { createEventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
-import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { access, defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
 import { InternalError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import { Temporal } from "temporal-polyfill";
 import { z } from "zod";
@@ -77,7 +77,7 @@ export function createInviteCreateHandler(opts: InviteCreateOptions) {
   return defineWriteHandler<"invite-create", typeof InviteCreateSchema, InviteCreateData>({
     name: "invite-create",
     schema: InviteCreateSchema,
-    access: { roles: ["Admin"] },
+    access: { roles: access.admin },
     handler: async (event, ctx) => {
       if (!ctx.redis) {
         return writeFailure(

package/src/auth-email-password/web/use-shell-user.ts

@@ -29,6 +29,9 @@ export function useShellUser(): ShellUser | undefined {
     if (session.status !== "authenticated" || session.user === null) return undefined;
     const activeTenant = session.tenants.find((t) => t.tenantId === session.activeTenantId);
     if (activeTenant === undefined) return undefined;
-    return { id: session.user.id, roles: activeTenant.roles };
-  }, [session.status, session.user, session.activeTenantId, session.tenants]);
+    // session.roles merges globalRoles (e.g. SystemAdmin) + membership — same
+    // merge the server uses for handler access; membership-only broke platform
+    // workspace gating for global operators.
+    return { id: session.user.id, roles: session.roles };
+  }, [session.status, session.user, session.activeTenantId, session.tenants, session.roles]);
 }

package/src/cap-counter/__tests__/cap-list.boot.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import { validateBoot } from "@cosmicdrift/kumiko-framework/engine";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { CAP_COUNTER_LIST_SCREEN_ID } from "../constants";
+import { capCounterFeature } from "../feature";
+
+describe("cap-counter list screen + handler access alignment", () => {
+  const features = [capCounterFeature];
+
+  test("boot-validates with cap-list screen registered", () => {
+    expect(() => validateBoot(features)).not.toThrow();
+  });
+
+  test("cap-list screen is entityList, SystemAdmin-gated", () => {
+    const screen = capCounterFeature.screens[CAP_COUNTER_LIST_SCREEN_ID];
+    expect(screen?.type).toBe("entityList");
+    if (screen && "access" in screen && screen.access && "roles" in screen.access) {
+      expect(screen.access.roles).toEqual(["SystemAdmin"]);
+    }
+  });
+
+  test("cap-counter list query shares SystemAdmin access", () => {
+    expect(rolesOf(capCounterFeature.queryHandlers["cap-counter:list"]?.access)).toEqual([
+      "SystemAdmin",
+    ]);
+  });
+});

package/src/cap-counter/__tests__/cap-list.security.integration.test.ts

@@ -0,0 +1,53 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+  createTestUser,
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { CAP_COUNTER_LIST_SCREEN_ID, CapCounterQueries } from "../constants";
+import { capCounterEntity } from "../entity";
+import { capCounterFeature } from "../feature";
+
+let stack: TestStack;
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [capCounterFeature],
+  });
+  await unsafeCreateEntityTable(stack.db, capCounterEntity);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+describe("cap-counter access matrix", () => {
+  test("cap-list screen and list query are SystemAdmin-only", () => {
+    expect(rolesOf(stack.registry.getQueryHandler(CapCounterQueries.list)?.access)).toEqual([
+      "SystemAdmin",
+    ]);
+    const screen = capCounterFeature.screens[CAP_COUNTER_LIST_SCREEN_ID];
+    if (screen && "access" in screen && screen.access && "roles" in screen.access) {
+      expect(screen.access.roles).toEqual(["SystemAdmin"]);
+    }
+  });
+});
+
+describe("cap-counter list HTTP access", () => {
+  test("SystemAdmin can list counters", async () => {
+    const admin = createTestUser({ id: 41, roles: ["SystemAdmin"] });
+    const res = await stack.http.queryOk<{ rows: readonly unknown[] }>(
+      CapCounterQueries.list,
+      {},
+      admin,
+    );
+    expect(Array.isArray(res.rows)).toBe(true);
+  });
+
+  test("TenantAdmin gets 403 on list", async () => {
+    const user = createTestUser({ id: 42, roles: ["TenantAdmin"] });
+    expect((await stack.http.query(CapCounterQueries.list, {}, user)).status).toBe(403);
+  });
+});

package/src/cap-counter/constants.ts

@@ -1,6 +1,8 @@
 // Feature name
 export const CAP_COUNTER_FEATURE = "cap-counter" as const;
 
+export const CAP_COUNTER_LIST_SCREEN_ID = "cap-list" as const;
+
 // Aggregate types — calendar-period-Counter benutzt CRUD-Events der
 // projection-row. Rolling-Window-Counter benutzt einen eigenen
 // aggregate-type mit custom increment-events (no projection — der

package/src/cap-counter/feature.ts

@@ -47,7 +47,11 @@
 // vom Framework-Default (Base-Column tenantId).
 
 import { defineEntityListHandler, defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { CAP_COUNTER_FEATURE, ROLLING_INCREMENTED_EVENT_SHORT } from "./constants";
+import {
+  CAP_COUNTER_FEATURE,
+  CAP_COUNTER_LIST_SCREEN_ID,
+  ROLLING_INCREMENTED_EVENT_SHORT,
+} from "./constants";
 import { capCounterEntity } from "./entity";
 import { getCounterQuery } from "./handlers/get-counter.query";
 import { incrementCapHandler } from "./handlers/increment.write";
@@ -91,4 +95,19 @@ export const capCounterFeature = defineFeature(CAP_COUNTER_FEATURE, (r) => {
   // über aggregate-id).
   r.queryHandler(defineEntityListHandler("cap-counter", capCounterEntity, sysadminAccess));
   r.queryHandler(getCounterQuery);
+
+  r.screen({
+    id: CAP_COUNTER_LIST_SCREEN_ID,
+    type: "entityList",
+    entity: "cap-counter",
+    columns: ["capName", "value", "periodStart", "lastSoftWarnedAt"],
+    searchable: false,
+    access: { roles: ["SystemAdmin"] },
+  });
+  r.nav({
+    id: "cap-list",
+    label: "Caps",
+    screen: "cap-counter:screen:cap-list",
+    order: 60,
+  });
 });

package/src/compliance-profiles/__tests__/profile-picker.boot.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { access, validateBoot } from "@cosmicdrift/kumiko-framework/engine";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { COMPLIANCE_PROFILE_SCREEN_ID, ComplianceProfileHandlers } from "../constants";
+import { createComplianceProfilesFeature } from "../feature";
+
+describe("compliance profile screen + handler access alignment", () => {
+  const features = [createComplianceProfilesFeature()];
+
+  test("boot-validates with profile-picker screen registered", () => {
+    expect(() => validateBoot(features)).not.toThrow();
+  });
+
+  test("profile-picker screen is custom, access.admin-gated", () => {
+    const feature = createComplianceProfilesFeature();
+    const screen = feature.screens[COMPLIANCE_PROFILE_SCREEN_ID];
+    expect(screen?.type).toBe("custom");
+    if (screen && "access" in screen && screen.access && "roles" in screen.access) {
+      expect(screen.access.roles).toEqual(access.admin);
+    }
+  });
+
+  test("set-profile handler shares access.admin", () => {
+    const feature = createComplianceProfilesFeature();
+    expect(rolesOf(feature.writeHandlers["set-profile"]?.access)).toEqual([...access.admin]);
+    void ComplianceProfileHandlers;
+  });
+});

package/src/compliance-profiles/__tests__/profile-picker.security.integration.test.ts

@@ -0,0 +1,91 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import { access } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  createTestUser,
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import {
+  COMPLIANCE_PROFILE_SCREEN_ID,
+  ComplianceProfileHandlers,
+  ComplianceProfileQueries,
+} from "../constants";
+import { createComplianceProfilesFeature } from "../feature";
+import {
+  tenantComplianceProfileEntity,
+  tenantComplianceProfileTable,
+} from "../schema/profile-selection";
+
+let stack: TestStack;
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [createComplianceProfilesFeature()],
+  });
+  await unsafeCreateEntityTable(stack.db, tenantComplianceProfileEntity);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${tenantComplianceProfileTable.tableName}"`);
+});
+
+describe("compliance-profiles access matrix", () => {
+  test("set-profile handler and screen share access.admin", () => {
+    expect(
+      rolesOf(stack.registry.getWriteHandler(ComplianceProfileHandlers.setProfile)?.access),
+    ).toEqual([...access.admin]);
+    const feature = createComplianceProfilesFeature();
+    const screen = feature.screens[COMPLIANCE_PROFILE_SCREEN_ID];
+    if (screen && "access" in screen && screen.access && "roles" in screen.access) {
+      expect(screen.access.roles).toEqual(access.admin);
+    }
+  });
+});
+
+describe("compliance profile HTTP access", () => {
+  test("historic Admin can set a profile for own tenant", async () => {
+    const admin = createTestUser({ id: 31, roles: ["Admin"] });
+    const res = await stack.http.writeOk<{ profileKey: string; isNew: boolean }>(
+      ComplianceProfileHandlers.setProfile,
+      { profileKey: "eu-dsgvo" },
+      admin,
+    );
+    expect(res.profileKey).toBe("eu-dsgvo");
+    const current = await stack.http.queryOk<{ profile: { key: string } }>(
+      ComplianceProfileQueries.forTenant,
+      {},
+      admin,
+    );
+    expect(current.profile.key).toBe("eu-dsgvo");
+  });
+
+  test("TenantAdmin can set a profile for own tenant", async () => {
+    const admin = createTestUser({ id: 32, roles: ["TenantAdmin"] });
+    const res = await stack.http.writeOk<{ profileKey: string }>(
+      ComplianceProfileHandlers.setProfile,
+      { profileKey: "swiss-dsg" },
+      admin,
+    );
+    expect(res.profileKey).toBe("swiss-dsg");
+  });
+
+  test("regular User gets 403 on set-profile", async () => {
+    const user = createTestUser({ id: 33, roles: ["User"] });
+    expect(
+      (
+        await stack.http.write(
+          ComplianceProfileHandlers.setProfile,
+          { profileKey: "eu-dsgvo" },
+          user,
+        )
+      ).status,
+    ).toBe(403);
+  });
+});

package/src/compliance-profiles/constants.ts

@@ -0,0 +1,15 @@
+// @runtime client
+export const COMPLIANCE_PROFILES_FEATURE = "compliance-profiles" as const;
+
+export const ComplianceProfileHandlers = {
+  setProfile: "compliance-profiles:write:set-profile",
+} as const;
+
+export const ComplianceProfileQueries = {
+  forTenant: "compliance-profiles:query:for-tenant",
+  listProfiles: "compliance-profiles:query:list-profiles",
+  needsProfile: "compliance-profiles:query:needs-profile",
+  subProcessors: "compliance-profiles:query:sub-processors",
+} as const;
+
+export const COMPLIANCE_PROFILE_SCREEN_ID = "profile-picker" as const;

package/src/compliance-profiles/feature.ts

@@ -1,4 +1,9 @@
-import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  access,
+  defineFeature,
+  type FeatureDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { COMPLIANCE_PROFILE_SCREEN_ID } from "./constants";
 import { forTenantQuery } from "./handlers/for-tenant.query";
 import { listProfilesQuery } from "./handlers/list-profiles.query";
 import { needsProfileQuery } from "./handlers/needs-profile.query";
@@ -54,6 +59,19 @@ export function createComplianceProfilesFeature(): FeatureDefinition {
       needsProfile: r.queryHandler(needsProfileQuery),
     };
 
+    r.screen({
+      id: COMPLIANCE_PROFILE_SCREEN_ID,
+      type: "custom",
+      renderer: { react: { __component: "ComplianceProfileScreen" } },
+      access: { roles: access.admin },
+    });
+    r.nav({
+      id: "profile-picker",
+      label: "compliance-profiles:nav.profilePicker",
+      screen: "compliance-profiles:screen:profile-picker",
+      order: 50,
+    });
+
     return { handlers, queries };
   });
 }

package/src/compliance-profiles/handlers/set-profile.write.ts

@@ -1,4 +1,3 @@
-import { ROLES } from "@cosmicdrift/kumiko-framework/auth";
 import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import {
   complianceProfileOverrideSchema,
@@ -6,6 +5,7 @@ import {
 } from "@cosmicdrift/kumiko-framework/compliance";
 import { createEventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
 import {
+  access,
   crossTenantOverrideDenied,
   defineWriteHandler,
   type TenantId,
@@ -58,7 +58,7 @@ export const setProfileWrite = defineWriteHandler({
   }),
   // SystemAdmin kann Profile fuer Customer-Setup setzen (Plattform-
   // Operator-Pfad). TenantAdmin nur fuer eigenen Tenant.
-  access: { roles: [ROLES.TenantAdmin, ROLES.SystemAdmin] },
+  access: { roles: access.admin },
   handler: async (event, ctx) => {
     const tenantOverride = event.payload.tenantIdOverride;
     const overrideDenied = crossTenantOverrideDenied(

package/src/compliance-profiles/index.ts

@@ -1,3 +1,9 @@
+export {
+  COMPLIANCE_PROFILE_SCREEN_ID,
+  COMPLIANCE_PROFILES_FEATURE,
+  ComplianceProfileHandlers,
+  ComplianceProfileQueries,
+} from "./constants";
 export {
   createComplianceProfilesFeature,
   tenantComplianceProfileEntity,

package/src/compliance-profiles/web/client-plugin.tsx

@@ -0,0 +1,22 @@
+// @runtime client
+import { mergeTranslations, type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
+import { COMPLIANCE_PROFILE_SCREEN_ID, COMPLIANCE_PROFILES_FEATURE } from "../constants";
+import { ComplianceProfileScreen } from "./compliance-profile-screen";
+import { defaultTranslations } from "./i18n";
+
+export type ComplianceProfilesClientOptions = {
+  readonly translations?: TranslationsByLocale;
+};
+
+export function complianceProfilesClient(
+  options?: ComplianceProfilesClientOptions,
+): ClientFeatureDefinition {
+  return {
+    name: COMPLIANCE_PROFILES_FEATURE,
+    translations: mergeTranslations(defaultTranslations, options?.translations ?? {}),
+    components: {
+      [COMPLIANCE_PROFILE_SCREEN_ID]: ComplianceProfileScreen,
+    },
+  };
+}