@cosmicdrift/kumiko-bundled-features 0.14.0 → 0.16.0

package/src/user-data-rights/__tests__/run-export-jobs.integration.ts

@@ -12,10 +12,17 @@
 //      downloadStorageKey wird genullt + storage-key geloescht
 //   6. Idempotency: 2× run → kein Re-Processing von done/failed-Jobs
 
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { spawn } from "node:child_process";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import {
+  asRawClient,
+  insertOne,
+  selectMany,
+  updateMany,
+} from "@cosmicdrift/kumiko-framework/bun-db";
 import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
 import {
   createInMemoryFileProvider,
@@ -29,8 +36,6 @@ import {
   unsafeCreateEntityTable,
 } from "@cosmicdrift/kumiko-framework/stack";
 import { getTemporal } from "@cosmicdrift/kumiko-framework/time";
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
 import {
   createComplianceProfilesFeature,
   tenantComplianceProfileEntity,
@@ -65,7 +70,7 @@ beforeAll(async () => {
   await createEventsTable(stack.db);
   // tenant-membership-table fuer runUserExport's Cross-Tenant-Iteration.
   // Pattern matched user-data-rights-defaults integration-test.
-  await stack.db.execute(sql`
+  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,
@@ -89,30 +94,27 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await stack.db.delete(exportDownloadTokensTable);
-  await stack.db.delete(exportJobsTable);
-  await stack.db.delete(userTable);
-  await stack.db.execute(sql`DELETE FROM kumiko_events`);
-  await stack.db.execute(sql`DELETE FROM read_tenant_compliance_profiles`);
-  await stack.db.execute(sql`DELETE FROM read_tenant_memberships`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${exportDownloadTokensTable.tableName}"`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${exportJobsTable.tableName}"`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${userTable.tableName}"`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM kumiko_events`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM read_tenant_compliance_profiles`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM read_tenant_memberships`);
   providerPerTenant = new Map();
 
   // Atom 5: aliceUser-Row mit email seeden — Worker-Notification-Callback
   // schaut email via lookupUserEmail an.
-  await stack.db
-    .insert(userTable)
-    .values({
-      id: String(aliceUser.id),
-      tenantId: tenantA,
-      email: "alice@example.com",
-      passwordHash: "hashed",
-      displayName: "Alice",
-      locale: "de",
-      emailVerified: true,
-      roles: '["Member"]',
-      status: USER_STATUS.Active,
-    })
-    .onConflictDoNothing();
+  await insertOne(stack.db, userTable, {
+    id: String(aliceUser.id),
+    tenantId: tenantA,
+    email: "alice@example.com",
+    passwordHash: "hashed",
+    displayName: "Alice",
+    locale: "de",
+    emailVerified: true,
+    roles: '["Member"]',
+    status: USER_STATUS.Active,
+  });
 });
 
 const NOW = () => getTemporal().Now.instant();
@@ -154,10 +156,7 @@ describe("runExportJobs :: happy path", () => {
     expect(result.errors).toEqual([]);
 
     // Job-Row ist done
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
       status: string;
       downloadStorageKey: string | null;
       expiresAt: { toString(): string } | null;
@@ -215,10 +214,12 @@ describe("runExportJobs :: stale-detection", () => {
     const jobId = await seedPendingJob();
     const T = getTemporal();
     const twoHoursAgo = T.Instant.fromEpochMilliseconds(Date.now() - 2 * 60 * 60 * 1000);
-    await stack.db
-      .update(exportJobsTable)
-      .set({ status: EXPORT_JOB_STATUS.Running, startedAt: twoHoursAgo })
-      .where(sql`id = ${jobId}`);
+    await updateMany(
+      stack.db,
+      exportJobsTable,
+      { status: EXPORT_JOB_STATUS.Running, startedAt: twoHoursAgo },
+      { id: jobId },
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -229,10 +230,7 @@ describe("runExportJobs :: stale-detection", () => {
 
     expect(result.staleFailedJobIds).toContain(jobId);
 
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
       status: string;
       errorMessage: string | null;
     }>;
@@ -244,10 +242,12 @@ describe("runExportJobs :: stale-detection", () => {
     const jobId = await seedPendingJob();
     const T = getTemporal();
     const justNow = T.Instant.fromEpochMilliseconds(Date.now() - 60 * 1000); // 1min ago
-    await stack.db
-      .update(exportJobsTable)
-      .set({ status: EXPORT_JOB_STATUS.Running, startedAt: justNow })
-      .where(sql`id = ${jobId}`);
+    await updateMany(
+      stack.db,
+      exportJobsTable,
+      { status: EXPORT_JOB_STATUS.Running, startedAt: justNow },
+      { id: jobId },
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -257,10 +257,9 @@ describe("runExportJobs :: stale-detection", () => {
     });
 
     expect(result.staleFailedJobIds).not.toContain(jobId);
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ status: string }>;
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      status: string;
+    }>;
     expect(row?.status).toBe(EXPORT_JOB_STATUS.Running);
   });
 
@@ -278,14 +277,16 @@ describe("runExportJobs :: stale-detection", () => {
     // gesetzt + ZIP geschrieben. Worker dann gecrashed (kein done-flip).
     const provider = await buildProvider(tenantA);
     await provider.write(storageKey, new Uint8Array([1, 2, 3]));
-    await stack.db
-      .update(exportJobsTable)
-      .set({
+    await updateMany(
+      stack.db,
+      exportJobsTable,
+      {
         status: EXPORT_JOB_STATUS.Running,
         startedAt: twoHoursAgo,
         downloadStorageKey: storageKey,
-      })
-      .where(sql`id = ${jobId}`);
+      },
+      { id: jobId },
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -298,10 +299,10 @@ describe("runExportJobs :: stale-detection", () => {
     expect(result.cleanedJobIds).toContain(jobId);
     expect(await provider.exists(storageKey)).toBe(false);
 
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ status: string; downloadStorageKey: string | null }>;
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      status: string;
+      downloadStorageKey: string | null;
+    }>;
     expect(row?.status).toBe(EXPORT_JOB_STATUS.Failed);
     expect(row?.downloadStorageKey).toBeNull();
   });
@@ -318,16 +319,18 @@ describe("runExportJobs :: storage-cleanup", () => {
     const provider = await buildProvider(tenantA);
     await provider.write(storageKey, new Uint8Array([1, 2, 3]));
 
-    await stack.db
-      .update(exportJobsTable)
-      .set({
+    await updateMany(
+      stack.db,
+      exportJobsTable,
+      {
         status: EXPORT_JOB_STATUS.Done,
         startedAt: longAgo,
         completedAt: longAgo,
         downloadStorageKey: storageKey,
         expiresAt: longAgo,
-      })
-      .where(sql`id = ${jobId}`);
+      },
+      { id: jobId },
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -339,10 +342,7 @@ describe("runExportJobs :: storage-cleanup", () => {
     expect(result.cleanedJobIds).toContain(jobId);
     expect(await provider.exists(storageKey)).toBe(false);
 
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
       status: string;
       downloadStorageKey: string | null;
     }>;
@@ -358,16 +358,18 @@ describe("runExportJobs :: storage-cleanup", () => {
     const provider = await buildProvider(tenantA);
     await provider.write(storageKey, new Uint8Array([4, 5, 6]));
 
-    await stack.db
-      .update(exportJobsTable)
-      .set({
+    await updateMany(
+      stack.db,
+      exportJobsTable,
+      {
         status: EXPORT_JOB_STATUS.Done,
         startedAt: oneHourAgo,
         completedAt: oneHourAgo,
         downloadStorageKey: storageKey,
         expiresAt: oneHourAgo,
-      })
-      .where(sql`id = ${jobId}`);
+      },
+      { id: jobId },
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -436,10 +438,10 @@ describe("runExportJobs :: concurrency", () => {
     expect([...resultA.failedJobIds, ...resultB.failedJobIds]).toEqual([]);
 
     // DB hat genau eine done-Row
-    const rows = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ status: string; downloadStorageKey: string | null }>;
+    const rows = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      status: string;
+      downloadStorageKey: string | null;
+    }>;
     expect(rows).toHaveLength(1);
     expect(rows[0]?.status).toBe(EXPORT_JOB_STATUS.Done);
     expect(rows[0]?.downloadStorageKey).toBe(`${tenantA}/exports/${jobId}.zip`);
@@ -460,10 +462,12 @@ describe("runExportJobs :: stale-detection profile-driven cutoff", () => {
     const jobId = await seedPendingJob();
     const T = getTemporal();
     const fortyFiveMinAgo = T.Instant.fromEpochMilliseconds(Date.now() - 45 * 60 * 1000);
-    await stack.db
-      .update(exportJobsTable)
-      .set({ status: EXPORT_JOB_STATUS.Running, startedAt: fortyFiveMinAgo })
-      .where(sql`id = ${jobId}`);
+    await updateMany(
+      stack.db,
+      exportJobsTable,
+      { status: EXPORT_JOB_STATUS.Running, startedAt: fortyFiveMinAgo },
+      { id: jobId },
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -473,10 +477,9 @@ describe("runExportJobs :: stale-detection profile-driven cutoff", () => {
     });
 
     expect(result.staleFailedJobIds).toContain(jobId);
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ status: string }>;
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      status: string;
+    }>;
     expect(row?.status).toBe(EXPORT_JOB_STATUS.Failed);
   });
 });
@@ -500,10 +503,7 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     expect(plainToken).toMatch(/^[A-Za-z0-9_-]{43}$/);
 
     // Hash in DB matched plain via hashDownloadToken roundtrip
-    const tokenRows = (await stack.db
-      .select()
-      .from(exportDownloadTokensTable)
-      .where(sql`job_id = ${jobId}`)) as Array<{
+    const tokenRows = (await selectMany(stack.db, exportDownloadTokensTable, { jobId })) as Array<{
       jobId: string;
       tokenHash: string;
       issuedAt: { toString(): string };
@@ -519,10 +519,9 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     expect(tokenRows[0]?.useCount).toBe(0);
 
     // expiresAt im Token = job.expiresAt (denormalized)
-    const [jobRow] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ expiresAt: { toString(): string } | null }>;
+    const [jobRow] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      expiresAt: { toString(): string } | null;
+    }>;
     expect(tokenRows[0]?.expiresAt.toString()).toBe(jobRow?.expiresAt?.toString());
   });
 
@@ -539,8 +538,8 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
       now: NOW(),
     });
 
-    const events = (await stack.db.execute(
-      sql`SELECT type FROM kumiko_events WHERE type LIKE 'export-download-token.%'`,
+    const events = (await asRawClient(stack.db).unsafe(
+      `SELECT type FROM kumiko_events WHERE type LIKE 'export-download-token.%'`,
     )) as unknown as Array<{ type: string }>;
     // Mindestens 1 created-Event fuer den Token
     expect(events.some((e) => e.type === "export-download-token.created")).toBe(true);
@@ -565,10 +564,9 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     expect(second.completedJobIds).toEqual([]);
     expect(second.tokenByJobId.size).toBe(0);
 
-    const tokenRows = (await stack.db
-      .select()
-      .from(exportDownloadTokensTable)
-      .where(sql`job_id = ${jobId}`)) as Array<unknown>;
+    const tokenRows = (await selectMany(stack.db, exportDownloadTokensTable, {
+      jobId,
+    })) as Array<unknown>;
     expect(tokenRows).toHaveLength(1);
   });
 
@@ -585,7 +583,7 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     expect(result.completedJobIds).toEqual([]);
     expect(result.tokenByJobId.size).toBe(0);
 
-    const allTokens = (await stack.db.select().from(exportDownloadTokensTable)) as Array<unknown>;
+    const allTokens = (await selectMany(stack.db, exportDownloadTokensTable)) as Array<unknown>;
     expect(allTokens).toHaveLength(0);
   });
 
@@ -605,21 +603,24 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     // direct-INSERT (Test-Exemption). Worker's tokenCrud.create wird
     // dann mit constraintName "read_export_download_tokens_one_per_job"
     // failen.
-    await stack.db.execute(sql`
+    await asRawClient(stack.db).unsafe(
+      `
       INSERT INTO read_export_download_tokens
         (id, tenant_id, job_id, token_hash, issued_at, expires_at, version, inserted_at, modified_at)
       VALUES (
         gen_random_uuid(),
-        ${tenantA},
-        ${jobId},
-        ${"existing-hash"},
+        $1,
+        $2,
+        $3,
         now(),
         now() + interval '7 days',
         1,
         now(),
         now()
       )
-    `);
+    `,
+      [tenantA, jobId, "existing-hash"],
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -632,10 +633,10 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     expect(result.completedJobIds).not.toContain(jobId);
     expect(result.failedJobIds).toContain(jobId);
 
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ status: string; errorMessage: string | null }>;
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      status: string;
+      errorMessage: string | null;
+    }>;
     expect(row?.status).toBe(EXPORT_JOB_STATUS.Failed);
     expect(row?.errorMessage).toMatch(/Token-Creation failed/);
   });
@@ -652,14 +653,16 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     // (simuliert orphan-state nach Worker-crash).
     const provider = await buildProvider(tenantA);
     await provider.write(storageKey, new Uint8Array([99, 99, 99]));
-    await stack.db
-      .update(exportJobsTable)
-      .set({
+    await updateMany(
+      stack.db,
+      exportJobsTable,
+      {
         status: EXPORT_JOB_STATUS.Failed,
         downloadStorageKey: storageKey,
         errorMessage: "synthetic crash mid-run",
-      })
-      .where(sql`id = ${jobId}`);
+      },
+      { id: jobId },
+    );
 
     const result = await runExportJobs({
       db: stack.db,
@@ -671,10 +674,9 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     expect(result.cleanedJobIds).toContain(jobId);
     expect(await provider.exists(storageKey)).toBe(false);
 
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ downloadStorageKey: string | null }>;
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      downloadStorageKey: string | null;
+    }>;
     expect(row?.downloadStorageKey).toBeNull();
   });
 });
@@ -740,7 +742,7 @@ describe("runExportJobs :: Atom 3c file-binaries", () => {
     await unsafeCreateEntityTable(localStack.db, exportDownloadTokenEntity);
     await unsafeCreateEntityTable(localStack.db, tenantComplianceProfileEntity);
     await createEventsTable(localStack.db);
-    await localStack.db.execute(sql`
+    await asRawClient(localStack.db).unsafe(`
       CREATE TABLE IF NOT EXISTS read_tenant_memberships (
         id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
         tenant_id UUID NOT NULL,
@@ -765,21 +767,24 @@ describe("runExportJobs :: Atom 3c file-binaries", () => {
 
   beforeEach(async () => {
     if (!localStack) return;
-    await localStack.db.delete(exportDownloadTokensTable);
-    await localStack.db.delete(exportJobsTable);
-    await localStack.db.execute(sql`DELETE FROM kumiko_events`);
-    await localStack.db.execute(sql`DELETE FROM read_tenant_compliance_profiles`);
-    await localStack.db.execute(sql`DELETE FROM read_tenant_memberships`);
+    await asRawClient(localStack.db).unsafe(`DELETE FROM "${exportDownloadTokensTable.tableName}"`);
+    await asRawClient(localStack.db).unsafe(`DELETE FROM "${exportJobsTable.tableName}"`);
+    await asRawClient(localStack.db).unsafe(`DELETE FROM kumiko_events`);
+    await asRawClient(localStack.db).unsafe(`DELETE FROM read_tenant_compliance_profiles`);
+    await asRawClient(localStack.db).unsafe(`DELETE FROM read_tenant_memberships`);
     // Reset zu safe Default damit kein Test den State an den naechsten leakt.
     currentTestFileName = "report.pdf";
   });
 
   async function seedMembership(tenantId: string, userId: string | number) {
-    await localStack.db.execute(sql`
+    await asRawClient(localStack.db).unsafe(
+      `
       INSERT INTO read_tenant_memberships (tenant_id, user_id)
-      VALUES (${tenantId}, ${String(userId)})
+      VALUES ($1, $2)
       ON CONFLICT (user_id, tenant_id) DO NOTHING
-    `);
+    `,
+      [tenantId, String(userId)],
+    );
   }
 
   async function seedPendingJobLocal(user: typeof aliceUser): Promise<string> {
@@ -879,10 +884,10 @@ describe("runExportJobs :: Atom 3c file-binaries", () => {
     expect(result.failedJobIds).toContain(jobId);
     expect(result.errors[0]?.message).toMatch(/in-memory file not found/);
 
-    const [row] = (await localStack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ status: string; errorMessage: string | null }>;
+    const [row] = (await selectMany(localStack.db, exportJobsTable, { id: jobId })) as Array<{
+      status: string;
+      errorMessage: string | null;
+    }>;
     expect(row?.status).toBe(EXPORT_JOB_STATUS.Failed);
     expect(row?.errorMessage).toMatch(/in-memory file not found/);
   });
@@ -1028,8 +1033,8 @@ describe("runExportJobs :: Atom 5 notification-callbacks", () => {
   test("user ohne email → Callback skipped + console.warn (kein Throw)", async () => {
     // User-Row mit email=null seeden (override). Worker logged warn,
     // Callback wird NICHT gerufen, Worker-Run bleibt successful.
-    await stack.db.delete(userTable);
-    await stack.db.insert(userTable).values({
+    await asRawClient(stack.db).unsafe(`DELETE FROM "${userTable.tableName}"`);
+    await insertOne(stack.db, userTable, {
       id: String(aliceUser.id),
       tenantId: tenantA,
       email: "" as string, // empty string — lookupUserEmail returnt null
@@ -1056,10 +1061,9 @@ describe("runExportJobs :: Atom 5 notification-callbacks", () => {
     expect(callbackInvoked).toBe(false);
     // Job ist trotzdem done (Notification ist best-effort, Audit-Trail
     // existiert via Token-DB-row)
-    const [row] = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id = ${jobId}`)) as Array<{ status: string }>;
+    const [row] = (await selectMany(stack.db, exportJobsTable, { id: jobId })) as Array<{
+      status: string;
+    }>;
     expect(row?.status).toBe("done");
   });
 
@@ -1076,7 +1080,7 @@ describe("runExportJobs :: Atom 5 notification-callbacks", () => {
       tenantId: tenantA,
       roles: ["Member"],
     });
-    await stack.db.insert(userTable).values({
+    await insertOne(stack.db, userTable, {
       id: String(bobUser.id),
       tenantId: tenantA,
       email: "bob@example.com",
@@ -1114,11 +1118,12 @@ describe("runExportJobs :: Atom 5 notification-callbacks", () => {
 
     // Beide DB-Rows tatsaechlich done (Job A's Status wurde VOR dem
     // Email-Versand committed — der Throw aenderte daran nichts).
-    const rows = (await stack.db
-      .select()
-      .from(exportJobsTable)
-      .where(sql`id IN (${jobAId}, ${jobBId})`)) as Array<{ id: string; status: string }>;
-    expect(rows).toHaveLength(2);
-    expect(rows.every((r) => r.status === "done")).toBe(true);
+    const rows = (await selectMany(stack.db, exportJobsTable, {})) as Array<{
+      id: string;
+      status: string;
+    }>;
+    const filteredRows = rows.filter((r) => r.id === jobAId || r.id === jobBId);
+    expect(filteredRows).toHaveLength(2);
+    expect(filteredRows.every((r) => r.status === "done")).toBe(true);
   });
 });