@cosmicdrift/kumiko-bundled-features 1.0.0 → 2.0.0

package/src/user-data-rights/__tests__/download-by-token-resolver-trust.integration.test.ts

@@ -0,0 +1,169 @@
+// #1057 regression: anonymous GDPR magic-link download under
+// `resolverTrust: "authoritative"` WITHOUT `defaultTenantId` (publicstatus's
+// real prod config — Host-Resolver-only, no single-tenant fallback).
+//
+// The tenantResolver derives the ambient tenant from the request Host — here
+// it always resolves to `hostTenant`, DIFFERENT from the tenant the export
+// job actually belongs to (`jobTenant`). Before the fix, `download-by-token`
+// resolved the file-storage-provider *selection* via `ctx.config`, which is
+// bound to the ambient (resolved) tenant — `hostTenant` has no provider
+// configured at all here, so the download 500s even though the token/job
+// themselves are perfectly valid. The fix resolves the provider explicitly
+// for `jobRow.requestedFromTenantId` instead.
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { randomBytes } from "node:crypto";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createInMemoryFileProvider,
+  type FileStorageProvider,
+} from "@cosmicdrift/kumiko-framework/files";
+import {
+  createTestUser,
+  setupTestStack,
+  type TestStack,
+  testTenantId,
+  unsafeCreateEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { createTestEnvelopeCipher } from "@cosmicdrift/kumiko-framework/testing";
+import { getTemporal } from "@cosmicdrift/kumiko-framework/time";
+import {
+  createComplianceProfilesFeature,
+  tenantComplianceProfileEntity,
+} from "../../compliance-profiles";
+import { createConfigFeature } from "../../config";
+import { ConfigHandlers } from "../../config/constants";
+import { createConfigAccessorFactory } from "../../config/feature";
+import { createConfigResolver } from "../../config/resolver";
+import { configValuesTable } from "../../config/table";
+import { createDataRetentionFeature } from "../../data-retention";
+import { fileFoundationFeature } from "../../file-foundation";
+import { fileProviderInMemoryFeature } from "../../file-provider-inmemory";
+import { createSessionsFeature } from "../../sessions";
+import { createUserFeature } from "../../user";
+import { createUserDataRightsFeature } from "../feature";
+import { runExportJobs } from "../run-export-jobs";
+import { exportDownloadTokenEntity } from "../schema/download-token";
+import { exportJobEntity } from "../schema/export-job";
+
+const jobTenant = testTenantId(1);
+const hostTenant = testTenantId(2);
+const jobTenantAdmin = createTestUser({ id: 99, tenantId: jobTenant, roles: ["TenantAdmin"] });
+const aliceUser = createTestUser({ id: 42, tenantId: jobTenant, roles: ["Member"] });
+
+const providerPerTenant = new Map<string, ReturnType<typeof createInMemoryFileProvider>>();
+function buildProvider(tenantId: string): Promise<FileStorageProvider> {
+  let p = providerPerTenant.get(tenantId);
+  if (!p) {
+    p = createInMemoryFileProvider();
+    providerPerTenant.set(tenantId, p);
+  }
+  return Promise.resolve(p);
+}
+
+let stack: TestStack;
+
+beforeAll(async () => {
+  const encryption = createTestEnvelopeCipher(randomBytes(32).toString("base64"));
+  const resolver = createConfigResolver({ cipher: encryption });
+
+  stack = await setupTestStack({
+    features: [
+      createConfigFeature(),
+      createUserFeature(),
+      createDataRetentionFeature(),
+      createComplianceProfilesFeature(),
+      fileFoundationFeature,
+      fileProviderInMemoryFeature,
+      authFoundationFeature,
+      createSessionsFeature(),
+      createUserDataRightsFeature(),
+    ],
+    extraContext: ({ registry }) => ({
+      configResolver: resolver,
+      configEncryption: encryption,
+      _configAccessorFactory: createConfigAccessorFactory(registry, resolver),
+    }),
+    // publicstatus prod: Host-Resolver-only, NO defaultTenantId. Resolver
+    // always answers `hostTenant` here — jobTenant never appears as the
+    // ambient/resolved tenant, only ever as jobRow.requestedFromTenantId.
+    anonymousAccess: {
+      tenantResolver: () => hostTenant,
+      resolverTrust: "authoritative",
+      tenantExists: async (id) => id === jobTenant || id === hostTenant,
+    },
+  });
+  await unsafeCreateEntityTable(stack.db, exportJobEntity);
+  await unsafeCreateEntityTable(stack.db, exportDownloadTokenEntity);
+  await unsafeCreateEntityTable(stack.db, tenantComplianceProfileEntity);
+  await unsafePushTables(stack.db, { configValuesTable });
+  await createEventsTable(stack.db);
+  await asRawClient(stack.db).unsafe(`
+    CREATE TABLE IF NOT EXISTS read_tenant_memberships (
+      id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      tenant_id UUID NOT NULL,
+      user_id TEXT NOT NULL,
+      version INTEGER NOT NULL DEFAULT 0,
+      inserted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      modified_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      inserted_by_id TEXT,
+      modified_by_id TEXT,
+      is_deleted BOOLEAN NOT NULL DEFAULT false,
+      deleted_at TIMESTAMPTZ,
+      deleted_by_id TEXT,
+      roles TEXT NOT NULL DEFAULT '[]',
+      UNIQUE(user_id, tenant_id)
+    )
+  `);
+
+  // Only jobTenant gets a provider configured — hostTenant deliberately has
+  // NONE, so a pre-fix ambient-tenant read would hard-fail with "no provider
+  // selected", not just pick the wrong one.
+  await stack.http.writeOk(
+    ConfigHandlers.set,
+    { key: "file-foundation:config:provider", value: "inmemory" },
+    jobTenantAdmin,
+  );
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+describe("download-by-token under resolverTrust: authoritative, no defaultTenantId", () => {
+  test("magic-link download succeeds via the job's own tenant, not the Host-resolved ambient tenant", async () => {
+    const requestRes = await stack.http.writeOk<{ jobId: string }>(
+      "user-data-rights:write:request-export",
+      {},
+      aliceUser,
+    );
+    const jobId = requestRes.jobId;
+    const provider = await buildProvider(jobTenant);
+    await provider.write(`${jobTenant}/exports/${jobId}.zip`, new Uint8Array([1, 2, 3]));
+
+    const result = await runExportJobs({
+      db: stack.db,
+      registry: stack.registry,
+      buildStorageProvider: buildProvider,
+      now: getTemporal().Now.instant(),
+    });
+    const plainToken = result.tokenByJobId.get(jobId);
+    if (!plainToken) {
+      throw new Error("token-create failed in worker run");
+    }
+
+    const res = await stack.app.fetch(
+      new Request("http://test/user-export/by-token", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ token: plainToken }),
+      }),
+    );
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { data?: { url?: string } };
+    expect(body.data?.url).toMatch(/^memory:\/\//);
+    expect(body.data?.url).toContain(`${jobTenant}/exports/${jobId}.zip`);
+  });
+});

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

@@ -9,8 +9,8 @@
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
 import { asRawClient, selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
-import { createEncryptionProvider } from "@cosmicdrift/kumiko-framework/db";
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
 import { createEventsTable, eventsTable } from "@cosmicdrift/kumiko-framework/event-store";
 import {
@@ -25,7 +25,11 @@ import {
   unsafeCreateEntityTable,
   unsafePushTables,
 } from "@cosmicdrift/kumiko-framework/stack";
-import { resetTestTables, updateRows } from "@cosmicdrift/kumiko-framework/testing";
+import {
+  createTestEnvelopeCipher,
+  resetTestTables,
+  updateRows,
+} from "@cosmicdrift/kumiko-framework/testing";
 import { getTemporal } from "@cosmicdrift/kumiko-framework/time";
 import {
   createComplianceProfilesFeature,
@@ -100,8 +104,8 @@ const noSignedUrlProviderFeature = defineFeature("test-no-signed-url-provider",
 });
 
 beforeAll(async () => {
-  const encryption = createEncryptionProvider(testEncryptionKey);
-  const resolver = createConfigResolver({ encryption });
+  const encryption = createTestEnvelopeCipher(testEncryptionKey);
+  const resolver = createConfigResolver({ cipher: encryption });
 
   stack = await setupTestStack({
     features: [
@@ -112,6 +116,7 @@ beforeAll(async () => {
       fileFoundationFeature,
       fileProviderInMemoryFeature,
       noSignedUrlProviderFeature,
+      authFoundationFeature,
       createSessionsFeature(),
 
       createUserDataRightsFeature(),
@@ -432,8 +437,8 @@ describe("download-by-job :: happy path", () => {
 });
 
 describe("r.httpRoute :: /user-export/by-token (Magic-Link e2e)", () => {
-  test("happy: 302-Redirect mit Location-Header zur signed-URL", async () => {
-    const { plainToken } = await seedDoneJobWithToken();
+  test("`?token=` in query is ignored — serves interstitial HTML instead of resolving it (no access-log leak)", async () => {
+    const { jobId, plainToken } = await seedDoneJobWithToken();
 
     const res = await stack.app.fetch(
       new Request(`http://test/user-export/by-token?token=${plainToken}`, {
@@ -444,43 +449,55 @@ describe("r.httpRoute :: /user-export/by-token (Magic-Link e2e)", () => {
         },
       }),
     );
-    expect(res.status).toBe(302);
-    const location = res.headers.get("location");
-    expect(location).toBeTruthy();
-    expect(location).toMatch(/^memory:\/\//);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("text/html");
+    const body = await res.text();
+    expect(body).toContain("/user-export/by-token.js");
+
+    const [row] = (await selectMany(stack.db, exportDownloadTokensTable, { jobId })) as Array<{
+      useCount: number;
+    }>;
+    expect(row?.useCount).toBe(0);
   });
 
-  test("invalid token → 404 passthrough mit i18nKey", async () => {
+  test("no query token (fragment-Pfad) → serviert Interstitial-HTML statt 400", async () => {
     const res = await stack.app.fetch(
-      new Request("http://test/user-export/by-token?token=fake-xxxxx", {
-        method: "GET",
-      }),
+      new Request("http://test/user-export/by-token", { method: "GET" }),
     );
-    expect(res.status).toBe(404);
-    const body = (await res.json()) as { error?: { i18nKey?: string } };
-    expect(body.error?.i18nKey).toBe("userDataRights.errors.download.notFound");
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("text/html");
+    const body = await res.text();
+    expect(body).toContain("/user-export/by-token.js");
   });
 
-  test("missing token query-param → 400", async () => {
+  test("by-token.js → same-origin exchange-script, application/javascript", async () => {
     const res = await stack.app.fetch(
-      new Request("http://test/user-export/by-token", { method: "GET" }),
+      new Request("http://test/user-export/by-token.js", { method: "GET" }),
     );
-    expect(res.status).toBe(400);
-    const body = (await res.json()) as { error?: string };
-    expect(body.error).toBe("missing_token");
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("application/javascript");
+    const body = await res.text();
+    expect(body).toContain("location.hash");
+    expect(body).toContain("/user-export/by-token");
   });
 
-  test("Audit-Update: useCount + IP/UA aus httpRoute-Headers (nicht aus payload)", async () => {
+  test("POST-Exchange (Fragment-Pfad): happy-path + IP/UA-Audit aus httpRoute-Headers", async () => {
     const { jobId, plainToken } = await seedDoneJobWithToken();
-    await stack.app.fetch(
-      new Request(`http://test/user-export/by-token?token=${plainToken}`, {
-        method: "GET",
+
+    const res = await stack.app.fetch(
+      new Request("http://test/user-export/by-token", {
+        method: "POST",
         headers: {
-          "user-agent": "e2e-test/2.0",
-          "x-forwarded-for": "198.51.100.7, 10.0.0.1",
+          "content-type": "application/json",
+          "user-agent": "e2e-test/3.0",
+          "x-forwarded-for": "203.0.113.9, 10.0.0.1",
         },
+        body: JSON.stringify({ token: plainToken }),
       }),
     );
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { data?: { url?: string } };
+    expect(body.data?.url).toBeTruthy();
 
     const [row] = (await selectMany(stack.db, exportDownloadTokensTable, { jobId })) as Array<{
       useCount: number;
@@ -488,9 +505,21 @@ describe("r.httpRoute :: /user-export/by-token (Magic-Link e2e)", () => {
       lastUsedUserAgent: string | null;
     }>;
     expect(row?.useCount).toBe(1);
-    // X-Forwarded-For: erster Wert, comma-trimmed
-    expect(row?.lastUsedFromIp).toBe("198.51.100.7");
-    expect(row?.lastUsedUserAgent).toBe("e2e-test/2.0");
+    expect(row?.lastUsedFromIp).toBe("203.0.113.9");
+    expect(row?.lastUsedUserAgent).toBe("e2e-test/3.0");
+  });
+
+  test("POST-Exchange: missing token → 400", async () => {
+    const res = await stack.app.fetch(
+      new Request("http://test/user-export/by-token", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({}),
+      }),
+    );
+    expect(res.status).toBe(400);
+    const body = (await res.json()) as { error?: string };
+    expect(body.error).toBe("missing_token");
   });
 });
 
@@ -511,8 +540,8 @@ describe("download-by-job :: cross-user + cross-tenant", () => {
   });
 
   test("provider ohne getSignedUrl → 422 unprocessable signedUrlNotSupported (job-Pfad)", async () => {
-    // Symmetrisch zum token-Pfad: derselbe Operator-Konfig-Bug muss auch
-    // beim UI-Klick-Pfad als 422 raus, nicht 404.
+    // Same as the token path: the operator misconfig must also surface as
+    // 422 on the UI click path, not 404.
     const { jobId } = await seedDoneJobWithToken();
     await stack.http.writeOk(
       ConfigHandlers.set,
@@ -556,4 +585,43 @@ describe("download-by-job :: cross-user + cross-tenant", () => {
     );
     expect(result.url).toMatch(/^memory:\/\//);
   });
+
+  test("cross-tenant same-user: provider is resolved for the job's tenant, not the ambient session tenant", async () => {
+    // #1057 regression: createFileProviderForTenant used to read the
+    // provider *selection* from the ambient session's ctx.config — here
+    // Tenant B (Alice's session tenant) — instead of the job's own
+    // Tenant A. Give Tenant A a provider WITHOUT getSignedUrl while
+    // Tenant B keeps "inmemory" (default from beforeEach): if the bug
+    // resurfaces, the wrong (Tenant B) provider is picked and the
+    // request succeeds with 200 instead of 422.
+    const { jobId } = await seedDoneJobWithToken();
+    await stack.http.writeOk(
+      ConfigHandlers.set,
+      { key: "file-foundation:config:provider", value: "no-signed-url" },
+      tenantAdmin, // Tenant A admin
+    );
+    const aliceFromTenantB = createTestUser({
+      id: 42,
+      tenantId: tenantB,
+      roles: ["Member"],
+    });
+    await asRawClient(stack.db).unsafe(
+      `
+      INSERT INTO read_tenant_memberships (tenant_id, user_id)
+      VALUES ($1, $2)
+      ON CONFLICT (user_id, tenant_id) DO NOTHING
+    `,
+      [tenantB, String(aliceUser.id)],
+    );
+
+    const res = await stack.http.query(
+      "user-data-rights:query:download-by-job",
+      { jobId },
+      aliceFromTenantB,
+    );
+    expect(res.status).toBe(422);
+    const body = (await res.json()) as { error: { code: string; i18nKey: string } };
+    expect(body.error.code).toBe("unprocessable");
+    expect(body.error.i18nKey).toBe("userDataRights.errors.download.signedUrlNotSupported");
+  });
 });

package/src/user-data-rights/__tests__/email-templates.test.ts

@@ -31,6 +31,21 @@ describe("gdpr email-templates", () => {
     expect(de.subject).not.toBe(en.subject);
   });
 
+  test("export-ready: html lang attribute matches the requested locale (654/1)", () => {
+    const de = renderExportReadyEmail({
+      downloadUrl: "https://app.test/x?token=abc",
+      expiresAt: "2026-07-01T13:45:00Z",
+      locale: "de",
+    });
+    expect(de.html).toContain('<html lang="de">');
+    const en = renderExportReadyEmail({
+      downloadUrl: "https://app.test/x?token=abc",
+      expiresAt: "2026-07-01T13:45:00Z",
+      locale: "en",
+    });
+    expect(en.html).toContain('<html lang="en">');
+  });
+
   test("export-ready: ampersand in download url is escaped in the href attr", () => {
     const r = renderExportReadyEmail({
       downloadUrl: "https://app.test/x?token=a&next=b",

package/src/user-data-rights/__tests__/export-encrypted-fields.integration.test.ts

@@ -0,0 +1,154 @@
+// Art. 20 + encrypted entity fields: export hooks read raw rows past the
+// executor's decrypt layer, so runUserExport must decrypt encrypted fields
+// centrally — plaintext with a configured cipher, an explicit marker
+// (never the raw ciphertext) without one.
+
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
+import { asRawClient, selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import {
+  buildEntityTable,
+  configureEntityFieldEncryption,
+  resetEntityFieldEncryptionCacheForTests,
+} from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEntity,
+  createRegistry,
+  createTextField,
+  defineFeature,
+  EXT_USER_DATA,
+  type UserDataExportHook,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { setupTestStack, type TestStack } from "@cosmicdrift/kumiko-framework/stack";
+import { createTestEnvelopeCipher } from "@cosmicdrift/kumiko-framework/testing";
+import { getTemporal } from "@cosmicdrift/kumiko-framework/time";
+import { createComplianceProfilesFeature } from "../../compliance-profiles";
+import { createDataRetentionFeature } from "../../data-retention";
+import { createSessionsFeature } from "../../sessions";
+import { createUserFeature } from "../../user";
+import { createUserDataRightsFeature } from "../feature";
+import { runUserExport } from "../run-user-export";
+
+const TENANT = "00000000-0000-4000-8000-00000000000a";
+const USER_ID = "cccccccc-cccc-4ccc-8ccc-000000000001";
+const PLAINTEXT_NOTE = "my private vault note";
+
+const cipher = createTestEnvelopeCipher();
+
+const vaultNoteEntity = createEntity({
+  table: "read_vault_notes",
+  fields: {
+    ownerId: createTextField({ required: true }),
+    note: createTextField({ encrypted: true }),
+  },
+});
+
+const vaultNotesTableRef = buildEntityTable("vault-note", vaultNoteEntity);
+
+// Export hook mirrors real hooks (folders-user-data pattern): raw select,
+// no decrypt of its own.
+const vaultExportHook: UserDataExportHook = async (ctx) => {
+  const rows = await selectMany<Record<string, unknown>>(ctx.db, vaultNotesTableRef, {
+    ownerId: ctx.userId,
+  });
+  if (rows.length === 0) return null;
+  return { entity: "vault-note", rows };
+};
+
+const vaultFeature = defineFeature("vault", (r) => {
+  const entity = r.entity("vault-note", vaultNoteEntity);
+  r.useExtension(EXT_USER_DATA, entity, {
+    export: vaultExportHook,
+    delete: async () => undefined,
+  });
+});
+
+let stack: TestStack;
+let registry: ReturnType<typeof createRegistry>;
+
+beforeAll(async () => {
+  stack = await setupTestStack({ features: [] });
+  // user-data-rights hosts EXT_USER_DATA — without it the vault feature's
+  // useExtension reference fails registry creation. Its hard requires
+  // (user/data-retention/compliance-profiles/sessions) come along.
+  registry = createRegistry([
+    createUserFeature(),
+    createDataRetentionFeature(),
+    createComplianceProfilesFeature(),
+    authFoundationFeature,
+    createSessionsFeature(),
+    createUserDataRightsFeature(),
+    vaultFeature,
+  ]);
+
+  await asRawClient(stack.db).unsafe(`
+    CREATE TABLE IF NOT EXISTS read_tenant_memberships (
+      id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      tenant_id UUID NOT NULL,
+      user_id TEXT NOT NULL,
+      version INTEGER NOT NULL DEFAULT 0,
+      inserted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      modified_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      inserted_by_id TEXT,
+      modified_by_id TEXT,
+      is_deleted BOOLEAN NOT NULL DEFAULT false,
+      deleted_at TIMESTAMPTZ,
+      deleted_by_id TEXT,
+      roles TEXT NOT NULL DEFAULT '[]',
+      UNIQUE(user_id, tenant_id)
+    )
+  `);
+  await asRawClient(stack.db).unsafe(
+    `INSERT INTO read_tenant_memberships (tenant_id, user_id) VALUES ('${TENANT}', '${USER_ID}')
+     ON CONFLICT DO NOTHING`,
+  );
+
+  await asRawClient(stack.db).unsafe(`
+    CREATE TABLE IF NOT EXISTS read_vault_notes (
+      id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      tenant_id UUID NOT NULL,
+      version INTEGER NOT NULL DEFAULT 0,
+      inserted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      modified_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      inserted_by_id TEXT,
+      modified_by_id TEXT,
+      owner_id TEXT NOT NULL,
+      note TEXT
+    )
+  `);
+  const storedNote = await cipher.encrypt(PLAINTEXT_NOTE);
+  await asRawClient(stack.db).unsafe(
+    `INSERT INTO read_vault_notes (tenant_id, owner_id, note) VALUES ('${TENANT}', '${USER_ID}', '${storedNote.replaceAll("'", "''")}')`,
+  );
+});
+
+afterEach(() => {
+  resetEntityFieldEncryptionCacheForTests();
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+async function exportedNote(): Promise<unknown> {
+  const bundle = await runUserExport({
+    db: stack.db,
+    registry,
+    userId: USER_ID,
+    now: getTemporal().Now.instant(),
+  });
+  const snippet = bundle.tenants.flatMap((t) => t.entities).find((e) => e.entity === "vault-note");
+  return snippet?.rows[0]?.["note"];
+}
+
+describe("user export with encrypted entity fields", () => {
+  test("decrypts encrypted fields when the cipher is configured", async () => {
+    configureEntityFieldEncryption(cipher);
+    expect(await exportedNote()).toBe(PLAINTEXT_NOTE);
+  });
+
+  test("exports an explicit marker — never ciphertext — without a cipher", async () => {
+    const value = await exportedNote();
+    expect(value).toBe("[encrypted:unavailable]");
+  });
+});

package/src/user-data-rights/__tests__/export-job-idempotency.integration.test.ts

@@ -10,6 +10,7 @@
 // reale Postgres + Drizzle-customType-Codec-Path braucht.
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
 import { asRawClient, selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { extractPgError } from "@cosmicdrift/kumiko-framework/db";
 import {
@@ -43,6 +44,7 @@ beforeAll(async () => {
       createUserFeature(),
       createDataRetentionFeature(),
       createComplianceProfilesFeature(),
+      authFoundationFeature,
       createSessionsFeature(),
 
       createUserDataRightsFeature(),

package/src/user-data-rights/__tests__/export-job-list-cross-tenant.integration.test.ts

@@ -6,6 +6,7 @@
 // tenant A saw only tenant A's export jobs, never tenant B's.
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
 import { createEventsTable, eventsTable } from "@cosmicdrift/kumiko-framework/event-store";
 import {
   createTestUser,
@@ -40,6 +41,7 @@ beforeAll(async () => {
       createUserFeature(),
       createDataRetentionFeature(),
       createComplianceProfilesFeature(),
+      authFoundationFeature,
       createSessionsFeature(),
       createUserDataRightsFeature(),
     ],

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

@@ -6,6 +6,7 @@
 // Datei ihre Bytes dauerhaft auf Disk (Issue gefunden im Review zu #177).
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
 import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
 import { type JobContext, SYSTEM_USER_ID } from "@cosmicdrift/kumiko-framework/engine";
@@ -30,7 +31,7 @@ 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 { createSessionsFeature, userSessionEntity } from "../../sessions";
 import { createUserFeature, userEntity, userTable } from "../../user";
 import { createUserDataRightsDefaultsFeature } from "../../user-data-rights-defaults";
 import { createUserDataRightsFeature } from "../feature";
@@ -78,6 +79,7 @@ beforeAll(async () => {
       createTestFileProviderFeature(provider, "test"),
       createDataRetentionFeature(),
       createComplianceProfilesFeature(),
+      authFoundationFeature,
       createSessionsFeature(),
       createUserDataRightsFeature(),
       createUserDataRightsDefaultsFeature(),
@@ -99,6 +101,7 @@ beforeAll(async () => {
   });
 
   await unsafeCreateEntityTable(db, userEntity);
+  await unsafeCreateEntityTable(db, userSessionEntity);
   await unsafeCreateEntityTable(db, tenantRetentionOverrideEntity);
   await unsafePushTables(db, { fileRefsTable, configValuesTable });
   await asRawClient(db).unsafe(READ_TENANT_MEMBERSHIPS_DDL);

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

@@ -10,6 +10,7 @@
 // still unvollständig).
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
 import { asRawClient, fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
 import { SYSTEM_USER_ID } from "@cosmicdrift/kumiko-framework/engine";
@@ -34,7 +35,7 @@ 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 { createSessionsFeature, userSessionEntity } from "../../sessions";
 import { createUserFeature, USER_STATUS, userEntity, userTable } from "../../user";
 import { createUserDataRightsDefaultsFeature } from "../../user-data-rights-defaults";
 import { createUserDataRightsFeature } from "../feature";
@@ -86,6 +87,7 @@ beforeAll(async () => {
       createTestFileProviderFeature(flakyProvider, "test"),
       createDataRetentionFeature(),
       createComplianceProfilesFeature(),
+      authFoundationFeature,
       createSessionsFeature(),
       createUserDataRightsFeature(),
       createUserDataRightsDefaultsFeature(),
@@ -109,6 +111,7 @@ beforeAll(async () => {
   });
 
   await unsafeCreateEntityTable(db, userEntity);
+  await unsafeCreateEntityTable(db, userSessionEntity);
   await unsafeCreateEntityTable(db, tenantRetentionOverrideEntity);
   await unsafePushTables(db, { fileRefsTable, configValuesTable });
   await asRawClient(db).unsafe(READ_TENANT_MEMBERSHIPS_DDL);