@cosmicdrift/kumiko-bundled-features 0.121.1 → 0.122.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-bundled-features",
-  "version": "0.121.1",
+  "version": "0.122.1",
   "description": "Built-in features — tenant, user, auth, delivery. The stuff you'd rewrite anyway, already typed.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -96,11 +96,11 @@
     "./step-dispatcher": "./src/step-dispatcher/index.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.121.1",
-    "@cosmicdrift/kumiko-framework": "0.121.1",
-    "@cosmicdrift/kumiko-headless": "0.121.1",
-    "@cosmicdrift/kumiko-renderer": "0.121.1",
-    "@cosmicdrift/kumiko-renderer-web": "0.121.1",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.122.1",
+    "@cosmicdrift/kumiko-framework": "0.122.1",
+    "@cosmicdrift/kumiko-headless": "0.122.1",
+    "@cosmicdrift/kumiko-renderer": "0.122.1",
+    "@cosmicdrift/kumiko-renderer-web": "0.122.1",
     "@mollie/api-client": "^4.5.0",
     "@node-rs/argon2": "^2.0.2",
     "@types/nodemailer": "^8.0.0",

package/src/user-data-rights/__tests__/read-users-rebuild-survives-lifecycle.integration.test.ts

@@ -283,8 +283,11 @@ describe("#494 :: read_users-Rebuild bewahrt Lifecycle-State", () => {
     expect(backfilled).toBeGreaterThanOrEqual(1);
 
     // Proof the loop didn't abort at the corrupt row: rebuild the projection —
-    // goodRow got its user.updated event (survives), badRow never did (wiped
-    // back to Active, exactly the data-loss this backfill exists to prevent).
+    // goodRow got its user.updated event (survives). badRow's Stream ist
+    // archiviert und replayt seit fw#832 gar nicht mehr: die Row ist nach dem
+    // Rebuild WEG (nicht bloss auf Active zurueckgewischt). Genau deshalb ist
+    // der failed-Report oben der Operator-Alarm — Heilung: restoreStream +
+    // Backfill-Re-Run, DANN rebuild.
     await rebuildProjection(USER_PROJECTION, { db: stack.db, registry });
     const rows = (await selectMany(stack.db, userTable, {})) as Array<{
       id: string;
@@ -293,6 +296,6 @@ describe("#494 :: read_users-Rebuild bewahrt Lifecycle-State", () => {
     const good = rows.find((r) => r.id === goodRow.id);
     const bad = rows.find((r) => r.id === badRow.id);
     expect(good?.status).toBe(USER_STATUS.Restricted);
-    expect(bad?.status).toBe(USER_STATUS.Active);
+    expect(bad).toBeUndefined();
   });
 });

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

@@ -574,6 +574,67 @@ describe("runExportJobs :: Atom 4a download-tokens", () => {
     expect(tokenRows).toHaveLength(1);
   });
 
+  test("Re-Run (fw#832): Job zurueck auf pending → Token in place rotiert, kein 2. created-Event", async () => {
+    const jobId = await seedPendingJob();
+    const first = await runExportJobs({
+      db: stack.db,
+      registry: stack.registry,
+      buildStorageProvider: buildProvider,
+      now: NOW(),
+    });
+    const firstPlain = first.tokenByJobId.get(jobId);
+    expect(firstPlain).toBeDefined();
+
+    const [tokenBefore] = (await selectMany(stack.db, exportDownloadTokensTable, {
+      jobId,
+    })) as Array<{ id: string }>;
+
+    // Operator-Recovery (Email-Fail, plain verloren): NUR den Job auf
+    // pending flippen — die Token-Row bleibt liegen. Vor fw#832 created
+    // der Worker dann ein ZWEITES Aggregat fuers gleiche jobId und der
+    // Projection-Rebuild kollidierte dauerhaft am one_per_job-Index.
+    await updateRows(
+      stack.db,
+      exportJobsTable,
+      { status: EXPORT_JOB_STATUS.Pending },
+      { id: jobId },
+    );
+
+    const second = await runExportJobs({
+      db: stack.db,
+      registry: stack.registry,
+      buildStorageProvider: buildProvider,
+      now: NOW(),
+    });
+    expect(second.completedJobIds).toContain(jobId);
+    const secondPlain = second.tokenByJobId.get(jobId);
+    expect(secondPlain).toBeDefined();
+    expect(secondPlain).not.toBe(firstPlain);
+
+    // Genau EINE Row, GLEICHES Aggregat, frischer Hash, Audit-Reset.
+    const tokenRows = (await selectMany(stack.db, exportDownloadTokensTable, {
+      jobId,
+    })) as Array<{
+      id: string;
+      tokenHash: string;
+      useCount: number | null;
+      lastUsedAt: unknown;
+    }>;
+    expect(tokenRows).toHaveLength(1);
+    expect(tokenRows[0]?.id).toBe(tokenBefore?.id as string);
+    expect(tokenRows[0]?.tokenHash).toBe(await hashDownloadToken(secondPlain as string));
+    expect(tokenRows[0]?.useCount).toBe(0);
+    expect(tokenRows[0]?.lastUsedAt).toBeNull();
+
+    // Rebuild-Invariante: genau EIN created-Event — der one_per_job-
+    // Index kann beim Replay nie kollidieren.
+    const events = (await asRawClient(stack.db).unsafe(
+      `SELECT type FROM kumiko_events WHERE aggregate_type = 'export-download-token'`,
+    )) as unknown as Array<{ type: string }>;
+    expect(events.filter((e) => e.type === "export-download-token.created")).toHaveLength(1);
+    expect(events.some((e) => e.type === "export-download-token.updated")).toBe(true);
+  });
+
   test("failed-Job: kein Token wird generiert", async () => {
     // Bewusst keinen Job — leerer Pending-Pass. Aber wir koennen den
     // failure-Pfad pinnen via runUserExport-Fehler. Einfacher: nur

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

@@ -105,9 +105,10 @@ export const tokenCrud = createEventStoreExecutor(
  *
  * **Plain-Token-Recovery bei Email-Fail:** plain ist ephemeral. Wenn
  * der Callback throwt, ist der plain verloren. Operator-Eingriff
- * noetig (Token in DB nullen + Job auf pending → next Worker-Run
- * generiert neuen Token). Atom 5b (Re-issue-handler) wird das
- * automatisieren.
+ * noetig: Job auf pending flippen — NUR das. Die Token-Row NICHT
+ * loeschen (eventloser Read-Side-Delete → Rebuild-Kollision, fw#832);
+ * der naechste Worker-Run rotiert das Token in place auf demselben
+ * Aggregat. Atom 5b (Re-issue-handler) wird das automatisieren.
  */
 export type SendExportReadyEmailFn = (args: {
   readonly userId: string;
@@ -427,22 +428,53 @@ async function processJob(args: {
     // Plain-Token bleibt im Worker-Memory + wird via RunExportJobsResult
     // an Atom 5 (Notification) weitergegeben. NUR der hash landet in DB.
     // ES via tokenCrud.create — kein direct-INSERT.
+    //
+    // **Re-Run (fw#832):** Flippt ein Operator einen done/failed-Job
+    // zurueck auf pending (Plain-Token verloren, Email-Fail), existiert
+    // fuers jobId schon eine Token-Row. Ein zweites create wuerde ein
+    // zweites `created`-Event auf frischem Aggregat emittieren — der
+    // Projection-Rebuild kollidiert dann dauerhaft am one_per_job-Index.
+    // Stattdessen: Token-Rotation in place auf demselben Aggregat
+    // (update mit frischem Hash + Reset der Audit-Felder).
     const expiresAt = addDurationSpec(now, ttl);
     const { plain: tokenPlain, hash: tokenHash } = await generateDownloadToken();
-    const tokenCreateResult = await tokenCrud.create(
-      {
-        jobId: job.id,
-        tokenHash,
-        issuedAt: now,
-        expiresAt,
-        // Atom 4a.fix: useCount explizit 0 statt default null. 4b's
-        // Verify-Pfad incrementiert via `useCount + 1` ohne COALESCE-
-        // Defensiv-Code.
-        useCount: 0,
-      },
-      executor,
-      tdb,
+    const existingToken = await fetchOne<{ id: string; version: number }>(
+      db,
+      exportDownloadTokensTable,
+      { jobId: job.id },
     );
+    const tokenCreateResult = existingToken
+      ? await tokenCrud.update(
+          {
+            id: existingToken.id,
+            version: existingToken.version,
+            changes: {
+              tokenHash,
+              issuedAt: now,
+              expiresAt,
+              useCount: 0,
+              lastUsedAt: null,
+              lastUsedFromIp: null,
+              lastUsedUserAgent: null,
+            },
+          },
+          executor,
+          tdb,
+        )
+      : await tokenCrud.create(
+          {
+            jobId: job.id,
+            tokenHash,
+            issuedAt: now,
+            expiresAt,
+            // Atom 4a.fix: useCount explizit 0 statt default null. 4b's
+            // Verify-Pfad incrementiert via `useCount + 1` ohne COALESCE-
+            // Defensiv-Code.
+            useCount: 0,
+          },
+          executor,
+          tdb,
+        );
     if (!tokenCreateResult.isSuccess) {
       // Token-Creation failed VOR done-flip → Job bleibt running.
       // Catch-Pfad flippt auf failed mit klarer Diagnose. Storage-

package/src/user-data-rights/schema/download-token.ts

@@ -93,9 +93,11 @@ export const exportDownloadTokenEntity = createEntity({
     }),
   },
 
-  // 1 Token pro Job. UNIQUE auf jobId — garantiert dass Worker-
-  // Idempotency (Atom 3b's "2× run done-Job → no-op") auch fuer
-  // Token-Generierung gilt: zweiter Versuch faellt auf Constraint.
+  // 1 Token pro Job. UNIQUE auf jobId — Backstop fuer Worker-Idempotency
+  // (Atom 3b's "2× run done-Job → no-op"). Der Worker created NIE ein
+  // zweites Aggregat fuers gleiche jobId: Re-Runs rotieren das Token
+  // in place via update (fw#832) — sonst kollidiert der Projection-
+  // Rebuild an genau diesem Index.
   indexes: [
     {
       unique: true,