@cosmicdrift/kumiko-bundled-features 1.0.0 → 2.0.0

package/src/user-data-rights-defaults/__tests__/bundled-entities.userdata-hooks.integration.test.ts

@@ -0,0 +1,455 @@
+// userData-Hook Integration-Tests für die Bundled-Entity-Hooks (GDPR-Audit
+// 2026-07): user-session, api-token, in-app-message, tenant-invitation,
+// notification-preference, config-value.
+//
+// Zwei Stacks:
+//   FULL    — alle Source-Features gemountet; testet Export-Inhalt, Forget-
+//             Semantik (hard-delete vs. executor-forget vs. anonymize) und
+//             Tenant-Isolation.
+//   MINIMAL — nur user/files/udr/defaults; testet das Presence-Gating: jeder
+//             Hook muss null/no-op liefern statt gegen fehlende Tabellen zu
+//             crashen (der Export-Runner hat kein per-Hook try/catch).
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import {
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { seedRow } from "@cosmicdrift/kumiko-framework/testing";
+import { authFoundationFeature } from "../../auth-foundation";
+import { createChannelInAppFeature, inAppMessagesTable } from "../../channel-in-app";
+import { createComplianceProfilesFeature } from "../../compliance-profiles";
+import { configValueEntity, createConfigFeature } from "../../config";
+import { createDataRetentionFeature } from "../../data-retention";
+import { createDeliveryFeature, notificationPreferenceEntity } from "../../delivery";
+import { createFilesFeature } from "../../files";
+import { createJobsFeature, jobRunLogsTable, jobRunsTable } from "../../jobs";
+import {
+  apiTokenEntity,
+  createPersonalAccessTokensFeature,
+  PatQueries,
+  type PatScopeConfig,
+} from "../../personal-access-tokens";
+import { createSessionsFeature, userSessionEntity } from "../../sessions";
+import { createTenantFeature, tenantInvitationEntity } from "../../tenant";
+import { createUserFeature, USER_STATUS, userEntity, userTable } from "../../user";
+import { createUserDataRightsFeature } from "../../user-data-rights";
+import { createUserDataRightsDefaultsFeature } from "../feature";
+import {
+  apiTokenDeleteHook,
+  apiTokenExportHook,
+  configValueDeleteHook,
+  configValueExportHook,
+  deliveryAttemptExportHook,
+  inAppMessageDeleteHook,
+  inAppMessageExportHook,
+  jobRunExportHook,
+  notificationPreferenceDeleteHook,
+  notificationPreferenceExportHook,
+  tenantInvitationDeleteHook,
+  tenantInvitationExportHook,
+  userSessionDeleteHook,
+  userSessionExportHook,
+} from "../index";
+
+const PAT_SCOPES: PatScopeConfig = {
+  tokens: { label: "Tokens", read: [PatQueries.mine] },
+};
+
+let full: TestStack;
+let minimal: TestStack;
+
+beforeAll(async () => {
+  full = await setupTestStack({
+    features: [
+      createUserFeature(),
+      createFilesFeature(),
+      createDataRetentionFeature(),
+      createComplianceProfilesFeature(),
+      createSessionsFeature(),
+      createConfigFeature(),
+      createTenantFeature(),
+      createPersonalAccessTokensFeature({ scopes: PAT_SCOPES }),
+      authFoundationFeature,
+      createDeliveryFeature(),
+      createChannelInAppFeature(),
+      createJobsFeature(),
+      createUserDataRightsFeature(),
+      createUserDataRightsDefaultsFeature(),
+    ],
+  });
+  await unsafeCreateEntityTable(full.db, userEntity);
+  await unsafeCreateEntityTable(full.db, userSessionEntity);
+  await unsafeCreateEntityTable(full.db, apiTokenEntity);
+  await unsafeCreateEntityTable(full.db, tenantInvitationEntity);
+  await unsafeCreateEntityTable(full.db, notificationPreferenceEntity);
+  await unsafeCreateEntityTable(full.db, configValueEntity);
+  await unsafePushTables(full.db, { inAppMessagesTable, jobRunsTable, jobRunLogsTable });
+
+  minimal = await setupTestStack({
+    features: [
+      createUserFeature(),
+      createFilesFeature(),
+      createDataRetentionFeature(),
+      createComplianceProfilesFeature(),
+      authFoundationFeature,
+      createSessionsFeature(),
+      createUserDataRightsFeature(),
+      createUserDataRightsDefaultsFeature(),
+    ],
+  });
+});
+
+afterAll(async () => {
+  await full.cleanup();
+  await minimal.cleanup();
+});
+
+const TENANT_A = "00000000-0000-4000-8000-00000000000a";
+const TENANT_B = "00000000-0000-4000-8000-00000000000b";
+
+function uuid(suffix: number): string {
+  return `bbbbbbbb-bbbb-4bbb-8bbb-${suffix.toString(16).padStart(12, "0")}`;
+}
+
+function ctx(userId: string, overrides: Record<string, unknown> = {}) {
+  return {
+    db: full.db,
+    registry: full.registry,
+    tenantId: TENANT_A,
+    userId,
+    ...overrides,
+  };
+}
+
+async function rawSelect(sql: string, params: unknown[]) {
+  const result = await asRawClient(full.db).unsafe(sql, params);
+  // biome-ignore lint/suspicious/noExplicitAny: drizzle execute typing
+  return ((result as any).rows ?? result) as Array<Record<string, unknown>>;
+}
+
+async function seedUser(id: string): Promise<void> {
+  const SYSTEM_TENANT = "00000000-0000-4000-8000-000000000001";
+  await seedRow(full.db, userTable, {
+    id,
+    tenantId: SYSTEM_TENANT,
+    email: `user-${id}@example.com`,
+    passwordHash: "hashed-password",
+    displayName: `User ${id}`,
+    locale: "de",
+    emailVerified: true,
+    roles: '["Member"]',
+    status: USER_STATUS.Active,
+  });
+}
+
+describe("user-session userData-hooks", () => {
+  async function seedSession(id: string, userId: string, tenantId: string): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO store_user_sessions (id, user_id, tenant_id, created_at, expires_at, ip, user_agent)
+       VALUES ($1, $2, $3, now(), now() + interval '1 day', '203.0.113.7', 'TestAgent/1.0')`,
+      [id, userId, tenantId],
+    );
+  }
+
+  test("export liefert ip/userAgent, aber keine Session-Id (jti)", async () => {
+    await seedSession(uuid(1), "sess-user-1", TENANT_A);
+
+    const result = await userSessionExportHook(ctx("sess-user-1"));
+    expect(result?.entity).toBe("user-session");
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows[0]?.["ip"]).toBe("203.0.113.7");
+    expect(result?.rows[0]?.["userAgent"]).toBe("TestAgent/1.0");
+    expect(result?.rows[0]?.["id"]).toBeUndefined();
+  });
+
+  test("delete entfernt Sessions des Users, Cross-Tenant bleibt", async () => {
+    await seedSession(uuid(2), "sess-user-2", TENANT_A);
+    await seedSession(uuid(3), "sess-user-2", TENANT_B);
+
+    await userSessionDeleteHook(ctx("sess-user-2"), "delete");
+
+    const a = await rawSelect(
+      "SELECT * FROM store_user_sessions WHERE user_id = $1 AND tenant_id = $2",
+      ["sess-user-2", TENANT_A],
+    );
+    const b = await rawSelect(
+      "SELECT * FROM store_user_sessions WHERE user_id = $1 AND tenant_id = $2",
+      ["sess-user-2", TENANT_B],
+    );
+    expect(a).toHaveLength(0);
+    expect(b).toHaveLength(1);
+  });
+});
+
+describe("api-token userData-hooks", () => {
+  async function seedToken(id: string, userId: string): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO store_api_tokens (id, user_id, tenant_id, name, token_hash, prefix, scopes, created_at)
+       VALUES ($1, $2, $3, 'My MacBook', $4, 'kum_ab12', '["read"]', now())`,
+      [id, userId, TENANT_A, `hash-${id}`],
+    );
+  }
+
+  test("export liefert Token-Metadata ohne tokenHash", async () => {
+    await seedToken(uuid(10), "pat-user-1");
+
+    const result = await apiTokenExportHook(ctx("pat-user-1"));
+    expect(result?.entity).toBe("api-token");
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows[0]?.["name"]).toBe("My MacBook");
+    expect(result?.rows[0]?.["prefix"]).toBe("kum_ab12");
+    expect(result?.rows[0]?.["tokenHash"]).toBeUndefined();
+  });
+
+  test("delete entfernt Tokens (= Revoke)", async () => {
+    await seedToken(uuid(11), "pat-user-2");
+
+    await apiTokenDeleteHook(ctx("pat-user-2"), "delete");
+
+    const rows = await rawSelect("SELECT * FROM store_api_tokens WHERE user_id = $1", [
+      "pat-user-2",
+    ]);
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe("in-app-message userData-hooks", () => {
+  async function seedMessage(userId: string, title: string): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO in_app_messages (tenant_id, user_id, notification_type, title, body)
+       VALUES ($1, $2, 'test:notify', $3, 'Hallo Marc, dein Export ist da')`,
+      [TENANT_A, userId, title],
+    );
+  }
+
+  test("export liefert Messages, delete entfernt sie", async () => {
+    await seedMessage("inapp-user-1", "Export fertig");
+
+    const result = await inAppMessageExportHook(ctx("inapp-user-1"));
+    expect(result?.entity).toBe("in-app-message");
+    expect(result?.rows[0]?.["title"]).toBe("Export fertig");
+
+    await inAppMessageDeleteHook(ctx("inapp-user-1"), "delete");
+    const rows = await rawSelect("SELECT * FROM in_app_messages WHERE user_id = $1", [
+      "inapp-user-1",
+    ]);
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe("tenant-invitation userData-hooks", () => {
+  async function seedInvitation(
+    id: string,
+    email: string,
+    invitedBy: string,
+    tenantId = TENANT_A,
+  ): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO read_tenant_invitations (id, tenant_id, email, role, status, invited_by, expires_at)
+       VALUES ($1, $2, $3, 'Member', 'pending', $4, now() + interval '7 days')`,
+      [id, tenantId, email, invitedBy],
+    );
+  }
+
+  test("export matcht Invitations über die User-Email", async () => {
+    await seedUser(uuid(20));
+    await seedInvitation(uuid(21), `user-${uuid(20)}@example.com`, "admin-1");
+
+    const result = await tenantInvitationExportHook(ctx(uuid(20)));
+    expect(result?.entity).toBe("tenant-invitation");
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows[0]?.["role"]).toBe("Member");
+  });
+
+  test("forget delete purged die Invitee-Row (rebuild-sicher via Executor)", async () => {
+    await seedUser(uuid(22));
+    await seedInvitation(uuid(23), `user-${uuid(22)}@example.com`, "admin-1");
+
+    await tenantInvitationDeleteHook(ctx(uuid(22)), "delete");
+
+    const rows = await rawSelect("SELECT * FROM read_tenant_invitations WHERE id = $1", [uuid(23)]);
+    expect(rows).toHaveLength(0);
+  });
+
+  test("anonymize pseudonymisiert die Invitee-Email (unique-index-sicher)", async () => {
+    await seedUser(uuid(24));
+    await seedInvitation(uuid(25), `user-${uuid(24)}@example.com`, "admin-1");
+
+    await tenantInvitationDeleteHook(ctx(uuid(24)), "anonymize");
+
+    const rows = await rawSelect("SELECT email FROM read_tenant_invitations WHERE id = $1", [
+      uuid(25),
+    ]);
+    expect(rows).toHaveLength(1);
+    expect(String(rows[0]?.["email"])).toBe(`forgotten-${uuid(25)}@anonymized.invalid`);
+  });
+
+  test("userEmailBeforeDelete hat Vorrang (User-Row schon anonymisiert)", async () => {
+    await seedInvitation(uuid(26), "vanished@example.com", "admin-1");
+
+    await tenantInvitationDeleteHook(
+      ctx("ghost-user-forgotten", { userEmailBeforeDelete: "Vanished@Example.com" }),
+      "delete",
+    );
+
+    const rows = await rawSelect("SELECT * FROM read_tenant_invitations WHERE id = $1", [uuid(26)]);
+    expect(rows).toHaveLength(0);
+  });
+
+  test("Inviter-Forget severs invitedBy, Row bleibt (gehört dem Invitee)", async () => {
+    // userId als echte UUID — der Email-Lookup geht gegen read_users.id (uuid).
+    const inviter = uuid(28);
+    await seedInvitation(uuid(27), "someone-else@example.com", inviter);
+
+    await tenantInvitationDeleteHook(ctx(inviter), "delete");
+
+    const rows = await rawSelect(
+      "SELECT email, invited_by FROM read_tenant_invitations WHERE id = $1",
+      [uuid(27)],
+    );
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.["email"]).toBe("someone-else@example.com");
+    expect(rows[0]?.["invited_by"]).toBe("anonymized");
+  });
+});
+
+describe("notification-preference userData-hooks", () => {
+  async function seedPreference(id: string, userId: string): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO read_notification_preferences (id, tenant_id, user_id, notification_type, channel, enabled)
+       VALUES ($1, $2, $3, 'test:notify', 'email', false)`,
+      [id, TENANT_A, userId],
+    );
+  }
+
+  test("export liefert Prefs, forget purged sie via Executor", async () => {
+    await seedPreference(uuid(30), "pref-user-1");
+
+    const result = await notificationPreferenceExportHook(ctx("pref-user-1"));
+    expect(result?.entity).toBe("notification-preference");
+    expect(result?.rows[0]?.["channel"]).toBe("email");
+    expect(result?.rows[0]?.["enabled"]).toBe(false);
+
+    await notificationPreferenceDeleteHook(ctx("pref-user-1"), "delete");
+    const rows = await rawSelect("SELECT * FROM read_notification_preferences WHERE user_id = $1", [
+      "pref-user-1",
+    ]);
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe("config-value userData-hooks", () => {
+  async function seedConfig(id: string, key: string, userId: string | null): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO read_config_values (id, tenant_id, key, value, user_id)
+       VALUES ($1, $2, $3, '"dark"', $4)`,
+      [id, TENANT_A, key, userId],
+    );
+  }
+
+  test("export + forget treffen NUR user-scoped Rows, tenant-scope bleibt", async () => {
+    await seedConfig(uuid(40), "ui.theme", "cfg-user-1");
+    await seedConfig(uuid(41), "tenant.brand", null);
+
+    const result = await configValueExportHook(ctx("cfg-user-1"));
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows[0]?.["key"]).toBe("ui.theme");
+
+    await configValueDeleteHook(ctx("cfg-user-1"), "delete");
+    const userRows = await rawSelect("SELECT * FROM read_config_values WHERE user_id = $1", [
+      "cfg-user-1",
+    ]);
+    const tenantRows = await rawSelect("SELECT * FROM read_config_values WHERE id = $1", [
+      uuid(41),
+    ]);
+    expect(userRows).toHaveLength(0);
+    expect(tenantRows).toHaveLength(1);
+  });
+});
+
+describe("delivery-attempt userData-hooks (#799)", () => {
+  async function seedAttempt(id: string, recipientId: string, tenantId: string): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO store_delivery_attempts
+         (id, tenant_id, notification_type, channel, recipient_id, recipient_address, status, priority)
+       VALUES ($1, $2, 'app:notify:ping', 'email', $3, $4, 'sent', 'normal')`,
+      [id, tenantId, recipientId, `user-${recipientId}@example.com`],
+    );
+  }
+
+  test("export returns only the user's attempts in the export tenant", async () => {
+    await seedAttempt(uuid(60), "da-user-1", TENANT_A);
+    await seedAttempt(uuid(61), "da-user-1", TENANT_B);
+    await seedAttempt(uuid(62), "da-user-2", TENANT_A);
+
+    const result = await deliveryAttemptExportHook(ctx("da-user-1"));
+    expect(result?.entity).toBe("delivery-attempt");
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows[0]?.["recipientAddress"]).toBe("user-da-user-1@example.com");
+    expect(result?.rows[0]?.["channel"]).toBe("email");
+  });
+
+  test("export returns null for a user without attempts", async () => {
+    expect(await deliveryAttemptExportHook(ctx("da-nobody"))).toBeNull();
+  });
+});
+
+describe("job-run userData-hooks (#799)", () => {
+  async function seedRun(id: string, triggeredById: string | null): Promise<void> {
+    await asRawClient(full.db).unsafe(
+      `INSERT INTO read_job_runs
+         (id, tenant_id, job_name, bull_job_id, status, payload, attempt, started_at, triggered_by_id)
+       VALUES ($1::uuid, $2, 'app:job:export', $3, 'completed', '{"scope":"mine"}', 1, now(), $4)`,
+      [id, TENANT_A, `bull-${id}`, triggeredById],
+    );
+  }
+
+  test("export filters by triggeredById only (system-tenant rows)", async () => {
+    await seedRun(uuid(70), "jr-user-1");
+    await seedRun(uuid(71), "jr-user-2");
+    await seedRun(uuid(72), null);
+
+    const result = await jobRunExportHook(ctx("jr-user-1"));
+    expect(result?.entity).toBe("job-run");
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows[0]?.["jobName"]).toBe("app:job:export");
+    expect(result?.rows[0]?.["payload"]).toBe('{"scope":"mine"}');
+  });
+
+  test("export returns null for a user without runs", async () => {
+    expect(await jobRunExportHook(ctx("jr-nobody"))).toBeNull();
+  });
+});
+
+describe("Presence-Gating: Source-Feature nicht gemountet → null/no-op statt Crash", () => {
+  test("alle gegateten Hooks no-open auf dem Minimal-Stack", async () => {
+    const minCtx = {
+      db: minimal.db,
+      registry: minimal.registry,
+      tenantId: TENANT_A,
+      userId: "any-user",
+    };
+
+    // sessions ist im Minimal-Stack GEMOUNTET aber die Tabelle existiert
+    // nicht — der Gate-Check greift auf Feature-Ebene, deshalb hier nur die
+    // fünf wirklich ungemounteten Features. (user-session wird im FULL-Stack
+    // getestet.)
+    expect(await apiTokenExportHook(minCtx)).toBeNull();
+    expect(await inAppMessageExportHook(minCtx)).toBeNull();
+    expect(await tenantInvitationExportHook(minCtx)).toBeNull();
+    expect(await notificationPreferenceExportHook(minCtx)).toBeNull();
+    expect(await configValueExportHook(minCtx)).toBeNull();
+    expect(await deliveryAttemptExportHook(minCtx)).toBeNull();
+    expect(await jobRunExportHook(minCtx)).toBeNull();
+
+    await expect(apiTokenDeleteHook(minCtx, "delete")).resolves.toBeUndefined();
+    await expect(inAppMessageDeleteHook(minCtx, "delete")).resolves.toBeUndefined();
+    await expect(tenantInvitationDeleteHook(minCtx, "delete")).resolves.toBeUndefined();
+    await expect(notificationPreferenceDeleteHook(minCtx, "delete")).resolves.toBeUndefined();
+    await expect(configValueDeleteHook(minCtx, "delete")).resolves.toBeUndefined();
+  });
+});

package/src/user-data-rights-defaults/__tests__/feature-mounted.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import type { UserDataHookCtx } from "@cosmicdrift/kumiko-framework/engine";
+import { featureMounted } from "../hooks/feature-mounted";
+
+function ctxWithFeatures(mounted: readonly string[]): UserDataHookCtx {
+  return {
+    registry: {
+      getFeature: (name: string) => (mounted.includes(name) ? { name } : undefined),
+      // @cast-boundary test fixture — featureMounted only reads ctx.registry.getFeature
+    } as unknown as UserDataHookCtx["registry"],
+  } as unknown as UserDataHookCtx;
+}
+
+describe("featureMounted", () => {
+  test("returns true when the feature is registered", () => {
+    const ctx = ctxWithFeatures(["sessions"]);
+    expect(featureMounted(ctx, "sessions")).toBe(true);
+  });
+
+  test("returns false when the feature is not registered", () => {
+    const ctx = ctxWithFeatures(["sessions"]);
+    expect(featureMounted(ctx, "channel-email")).toBe(false);
+  });
+});

package/src/user-data-rights-defaults/__tests__/user-data-rights-defaults.integration.test.ts

@@ -11,6 +11,7 @@
 //     fileRef-Forget beruehrt Tenant B's Files nicht)
 
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
 import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
 import { fileRefsTable } from "@cosmicdrift/kumiko-framework/files";
 import {
@@ -43,6 +44,7 @@ const features = [
   createFilesFeature(),
   createDataRetentionFeature(),
   createComplianceProfilesFeature(),
+  authFoundationFeature,
   createSessionsFeature(),
   createUserDataRightsFeature(),
   createUserDataRightsDefaultsFeature(),
@@ -162,6 +164,7 @@ describe("S2.H1 :: userExportHook", () => {
 
     const result = await userExportHook({
       db: stack.db,
+      registry: stack.registry,
       tenantId: TENANT_A,
       userId: uuid(1001),
     });
@@ -182,6 +185,7 @@ describe("S2.H1 :: userExportHook", () => {
   test("returns null wenn User nicht existiert", async () => {
     const result = await userExportHook({
       db: stack.db,
+      registry: stack.registry,
       tenantId: TENANT_A,
       userId: uuid(1002),
     });
@@ -193,7 +197,10 @@ describe("S2.H1 :: userDeleteHook", () => {
   test('strategy="delete" → softDelete + email/displayName anonymisiert + status=deleted', async () => {
     await seedUser(uuid(1003));
 
-    await userDeleteHook({ db: stack.db, tenantId: TENANT_A, userId: uuid(1003) }, "delete");
+    await userDeleteHook(
+      { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: uuid(1003) },
+      "delete",
+    );
 
     const row = await fetchUser(uuid(1003));
     expect(row).not.toBeNull();
@@ -209,7 +216,10 @@ describe("S2.H1 :: userDeleteHook", () => {
   test('strategy="anonymize" → email/displayName anonymisiert aber status bleibt active', async () => {
     await seedUser(uuid(1004));
 
-    await userDeleteHook({ db: stack.db, tenantId: TENANT_A, userId: uuid(1004) }, "anonymize");
+    await userDeleteHook(
+      { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: uuid(1004) },
+      "anonymize",
+    );
 
     const row = await fetchUser(uuid(1004));
     if (!row) throw new Error("row should exist");
@@ -222,13 +232,19 @@ describe("S2.H1 :: userDeleteHook", () => {
   test("idempotent: zweiter delete-Call crasht nicht UND State bleibt korrekt deleted", async () => {
     await seedUser(uuid(1005));
 
-    await userDeleteHook({ db: stack.db, tenantId: TENANT_A, userId: uuid(1005) }, "delete");
+    await userDeleteHook(
+      { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: uuid(1005) },
+      "delete",
+    );
     const afterFirst = await fetchUser(uuid(1005));
     if (!afterFirst) throw new Error("user should exist after first delete");
 
     // Zweiter Call: kein Crash + State unverändert
     await expect(
-      userDeleteHook({ db: stack.db, tenantId: TENANT_A, userId: uuid(1005) }, "delete"),
+      userDeleteHook(
+        { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: uuid(1005) },
+        "delete",
+      ),
     ).resolves.toBeUndefined();
 
     // State-Verifikation (S2.H1+H2-Audit N3): Row weiterhin deleted,
@@ -249,6 +265,7 @@ describe("S2.H2 :: fileRefExportHook", () => {
 
     const result = await fileRefExportHook({
       db: stack.db,
+      registry: stack.registry,
       tenantId: TENANT_A,
       userId: "user-files-1",
     });
@@ -263,6 +280,7 @@ describe("S2.H2 :: fileRefExportHook", () => {
   test("returns null wenn User keine Files hat", async () => {
     const result = await fileRefExportHook({
       db: stack.db,
+      registry: stack.registry,
       tenantId: TENANT_A,
       userId: "ghost-user-no-files",
     });
@@ -276,7 +294,7 @@ describe("S2.H2 :: fileRefDeleteHook", () => {
     await seedFileRef(uuid(202), TENANT_A, "user-delete-files", "f2.pdf");
 
     await fileRefDeleteHook(
-      { db: stack.db, tenantId: TENANT_A, userId: "user-delete-files" },
+      { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: "user-delete-files" },
       "delete",
     );
 
@@ -288,7 +306,7 @@ describe("S2.H2 :: fileRefDeleteHook", () => {
     await seedFileRef(uuid(203), TENANT_A, "user-anon-files", "shared.pdf");
 
     await fileRefDeleteHook(
-      { db: stack.db, tenantId: TENANT_A, userId: "user-anon-files" },
+      { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: "user-anon-files" },
       "anonymize",
     );
 
@@ -305,7 +323,10 @@ describe("S2.H2 :: fileRefDeleteHook", () => {
     await seedFileRef(uuid(302), TENANT_B, "shared-user", "tenantB.pdf");
 
     // Tenant A loescht alle Files von "shared-user"
-    await fileRefDeleteHook({ db: stack.db, tenantId: TENANT_A, userId: "shared-user" }, "delete");
+    await fileRefDeleteHook(
+      { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: "shared-user" },
+      "delete",
+    );
 
     const aRemaining = await fetchFileRefs(TENANT_A, "shared-user");
     const bRemaining = await fetchFileRefs(TENANT_B, "shared-user");
@@ -319,7 +340,7 @@ describe("S2.H2 :: fileRefDeleteHook", () => {
     await seedFileRef(uuid(401), TENANT_A, "user-idem-files", "f.pdf");
 
     await fileRefDeleteHook(
-      { db: stack.db, tenantId: TENANT_A, userId: "user-idem-files" },
+      { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: "user-idem-files" },
       "delete",
     );
     const afterFirst = await fetchFileRefs(TENANT_A, "user-idem-files");
@@ -327,7 +348,10 @@ describe("S2.H2 :: fileRefDeleteHook", () => {
 
     // Zweiter Call: kein Crash + State weiter 0 Files
     await expect(
-      fileRefDeleteHook({ db: stack.db, tenantId: TENANT_A, userId: "user-idem-files" }, "delete"),
+      fileRefDeleteHook(
+        { db: stack.db, registry: stack.registry, tenantId: TENANT_A, userId: "user-idem-files" },
+        "delete",
+      ),
     ).resolves.toBeUndefined();
     const afterSecond = await fetchFileRefs(TENANT_A, "user-idem-files");
     expect(afterSecond).toHaveLength(0);