@cosmicdrift/kumiko-framework 1.0.0 → 2.0.0

package/src/pipeline/__tests__/lifecycle-pipeline.test.ts

@@ -4,6 +4,7 @@ import {
   createEntity,
   createRegistry,
   createTextField,
+  type DeleteContext,
   defineFeature,
   type PostSaveHookFn,
   type PreSaveHookFn,
@@ -201,74 +202,78 @@ describe("runPostSave", () => {
   test("postSave errors don't throw — logged and continued", async () => {
     const calls: string[] = [];
     const consoleSpy = spyOn(console, "error").mockImplementation(() => {});
-
-    const registry = makeRegistry({
-      postSave: [
-        async () => {
-          throw new Error("feature-fail");
-        },
-      ],
-    });
-
-    const systemHooks: SystemHooks = {
-      postSave: [
-        {
-          name: "search",
-          priority: 1000,
-          fn: async () => {
-            calls.push("search-ran");
+    try {
+      const registry = makeRegistry({
+        postSave: [
+          async () => {
+            throw new Error("feature-fail");
           },
-        },
-      ],
-    };
-
-    const pipeline = createLifecycleHooks(registry, systemHooks);
-    // Should not throw
-    await pipeline.runPostSave("test:write:user", savectx, {});
+        ],
+      });
 
-    // System hook still ran despite feature hook failure
-    expect(calls).toContain("search-ran");
-    expect(consoleSpy).toHaveBeenCalled();
-    consoleSpy.mockRestore();
+      const systemHooks: SystemHooks = {
+        postSave: [
+          {
+            name: "search",
+            priority: 1000,
+            fn: async () => {
+              calls.push("search-ran");
+            },
+          },
+        ],
+      };
+
+      const pipeline = createLifecycleHooks(registry, systemHooks);
+      // Should not throw
+      await pipeline.runPostSave("test:write:user", savectx, {});
+
+      // System hook still ran despite feature hook failure
+      expect(calls).toContain("search-ran");
+      expect(consoleSpy).toHaveBeenCalled();
+    } finally {
+      consoleSpy.mockRestore();
+    }
   });
 
   test("system hook failure doesn't block other system hooks", async () => {
     const calls: string[] = [];
     const consoleSpy = spyOn(console, "error").mockImplementation(() => {});
-
-    const registry = makeRegistry();
-
-    const systemHooks: SystemHooks = {
-      postSave: [
-        {
-          name: "search",
-          priority: 1000,
-          fn: async () => {
-            throw new Error("meili-down");
+    try {
+      const registry = makeRegistry();
+
+      const systemHooks: SystemHooks = {
+        postSave: [
+          {
+            name: "search",
+            priority: 1000,
+            fn: async () => {
+              throw new Error("meili-down");
+            },
           },
-        },
-        {
-          name: "sse",
-          priority: 1001,
-          fn: async () => {
-            calls.push("sse-ran");
+          {
+            name: "sse",
+            priority: 1001,
+            fn: async () => {
+              calls.push("sse-ran");
+            },
           },
-        },
-        {
-          name: "audit",
-          priority: 1002,
-          fn: async () => {
-            calls.push("audit-ran");
+          {
+            name: "audit",
+            priority: 1002,
+            fn: async () => {
+              calls.push("audit-ran");
+            },
           },
-        },
-      ],
-    };
+        ],
+      };
 
-    const pipeline = createLifecycleHooks(registry, systemHooks);
-    await pipeline.runPostSave("test:write:user", savectx, {});
+      const pipeline = createLifecycleHooks(registry, systemHooks);
+      await pipeline.runPostSave("test:write:user", savectx, {});
 
-    expect(calls).toEqual(["sse-ran", "audit-ran"]);
-    consoleSpy.mockRestore();
+      expect(calls).toEqual(["sse-ran", "audit-ran"]);
+    } finally {
+      consoleSpy.mockRestore();
+    }
   });
 });
 
@@ -335,29 +340,32 @@ describe("runPostSave phase routing", () => {
 
   test("afterCommit phase: hook errors are logged, never thrown", async () => {
     const consoleSpy = spyOn(console, "error").mockImplementation(() => {});
-    const afterRan: string[] = [];
-    const feature = defineFeature("phases", (r) => {
-      r.entity("user", createEntity({ table: "Users", fields: {} }));
-      r.writeHandler("user", z.object({}), async () => ({ isSuccess: true, data: null }), {
-        access: { openToAll: true },
+    try {
+      const afterRan: string[] = [];
+      const feature = defineFeature("phases", (r) => {
+        r.entity("user", createEntity({ table: "Users", fields: {} }));
+        r.writeHandler("user", z.object({}), async () => ({ isSuccess: true, data: null }), {
+          access: { openToAll: true },
+        });
+        r.hook("postSave", "user", async () => {
+          throw new Error("afterCommit-boom");
+        });
+        r.hook("postSave", "user", async () => {
+          afterRan.push("second");
+        });
       });
-      r.hook("postSave", "user", async () => {
-        throw new Error("afterCommit-boom");
-      });
-      r.hook("postSave", "user", async () => {
-        afterRan.push("second");
-      });
-    });
-    const registry = createRegistry([feature]);
-    const pipeline = createLifecycleHooks(registry);
+      const registry = createRegistry([feature]);
+      const pipeline = createLifecycleHooks(registry);
 
-    // Must not throw — errors are swallowed + logged
-    await pipeline.runPostSave("phases:write:user", savectx, {}, "afterCommit");
+      // Must not throw — errors are swallowed + logged
+      await pipeline.runPostSave("phases:write:user", savectx, {}, "afterCommit");
 
-    // Subsequent hooks still fire (failure in one hook doesn't block the rest)
-    expect(afterRan).toEqual(["second"]);
-    expect(consoleSpy).toHaveBeenCalled();
-    consoleSpy.mockRestore();
+      // Subsequent hooks still fire (failure in one hook doesn't block the rest)
+      expect(afterRan).toEqual(["second"]);
+      expect(consoleSpy).toHaveBeenCalled();
+    } finally {
+      consoleSpy.mockRestore();
+    }
   });
 
   test("system hooks respect their phase setting", async () => {
@@ -424,7 +432,7 @@ describe("Sprint 8a: per-tenant entity-hook filter", () => {
     });
 
     const featureB = defineFeature("feat-b", (r) => {
-      r.entityHook("postSave", "widget", async (_result, ctx) => {
+      r.hook("postSave", { allOf: "widget" }, async (_result, ctx) => {
         calls.push({ tenant: ctx._tenantId ?? "no-tenant" });
       });
     });
@@ -528,3 +536,226 @@ describe("buildEventId — dedup key construction", () => {
     expect(buildEventId("handler", { id: 0 }, "phase")).toBeNull();
   });
 });
+
+// --- PreDelete / PostDelete pipeline ---
+
+const deletectx: DeleteContext = {
+  kind: "delete",
+  id: 1,
+  data: { email: "test@test.de" },
+  entityName: "user",
+};
+
+describe("runPreDelete", () => {
+  test("runs feature + entity + system hooks, all inTransaction (throw on error)", async () => {
+    const calls: string[] = [];
+    const feature = defineFeature("test", (r) => {
+      r.entity("user", createEntity({ table: "Users", fields: { email: createTextField() } }));
+      r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
+        access: { openToAll: true },
+      });
+      r.hook("preDelete", "user", async () => {
+        calls.push("handler");
+      });
+      r.hook("preDelete", { allOf: "user" }, async () => {
+        calls.push("entity");
+      });
+    });
+    const registry = createRegistry([feature]);
+    const systemHooks: SystemHooks = {
+      preDelete: [
+        {
+          name: "sys",
+          priority: 1000,
+          fn: async () => {
+            calls.push("system");
+          },
+        },
+      ],
+    };
+    const pipeline = createLifecycleHooks(registry, systemHooks);
+    await pipeline.runPreDelete("test:write:user", deletectx, {});
+    expect(calls).toEqual(["handler", "entity", "system"]);
+  });
+
+  test("a hook throwing aborts the delete (rejects, not swallowed)", async () => {
+    const feature = defineFeature("test", (r) => {
+      r.entity("user", createEntity({ table: "Users", fields: { email: createTextField() } }));
+      r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
+        access: { openToAll: true },
+      });
+      r.hook("preDelete", "user", async () => {
+        throw new Error("blocked-delete");
+      });
+    });
+    const registry = createRegistry([feature]);
+    const pipeline = createLifecycleHooks(registry);
+    await expect(pipeline.runPreDelete("test:write:user", deletectx, {})).rejects.toThrow(
+      "blocked-delete",
+    );
+  });
+
+  test("system hook with a non-inTransaction phase is skipped", async () => {
+    const registry = makeRegistry();
+    const calls: string[] = [];
+    const systemHooks: SystemHooks = {
+      preDelete: [
+        {
+          name: "sys",
+          priority: 1000,
+          phase: "afterCommit",
+          fn: async () => {
+            calls.push("system");
+          },
+        },
+      ],
+    };
+    const pipeline = createLifecycleHooks(registry, systemHooks);
+    await pipeline.runPreDelete("test:write:user", deletectx, {});
+    expect(calls).toEqual([]);
+  });
+});
+
+describe("runPostDelete", () => {
+  test("runs feature then system hooks (best-effort by default phase)", async () => {
+    const calls: string[] = [];
+    const feature = defineFeature("test", (r) => {
+      r.entity("user", createEntity({ table: "Users", fields: { email: createTextField() } }));
+      r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
+        access: { openToAll: true },
+      });
+      r.hook("postDelete", "user", async () => {
+        calls.push("feature");
+      });
+    });
+    const registry = createRegistry([feature]);
+    const systemHooks: SystemHooks = {
+      postDelete: [
+        {
+          name: "sys",
+          priority: 1000,
+          fn: async () => {
+            calls.push("system");
+          },
+        },
+      ],
+    };
+    const pipeline = createLifecycleHooks(registry, systemHooks);
+    await pipeline.runPostDelete("test:write:user", deletectx, {});
+    expect(calls).toEqual(["feature", "system"]);
+  });
+
+  test("inTransaction phase: hook errors throw", async () => {
+    const feature = defineFeature("test", (r) => {
+      r.entity("user", createEntity({ table: "Users", fields: { email: createTextField() } }));
+      r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
+        access: { openToAll: true },
+      });
+      r.hook(
+        "postDelete",
+        "user",
+        async () => {
+          throw new Error("postDelete-inTx-boom");
+        },
+        { phase: "inTransaction" },
+      );
+    });
+    const registry = createRegistry([feature]);
+    const pipeline = createLifecycleHooks(registry);
+    await expect(
+      pipeline.runPostDelete("test:write:user", deletectx, {}, "inTransaction"),
+    ).rejects.toThrow("postDelete-inTx-boom");
+  });
+});
+
+// --- Batch hooks ---
+
+describe("runPostSaveBatch / runPostDeleteBatch", () => {
+  test("no batch hooks registered → resolves without throwing", async () => {
+    const pipeline = createLifecycleHooks(makeRegistry());
+    await expect(pipeline.runPostSaveBatch([savectx], {})).resolves.toBeUndefined();
+    await expect(pipeline.runPostDeleteBatch([deletectx], {})).resolves.toBeUndefined();
+    // Should not throw — nothing registered.
+  });
+
+  test("runPostSaveBatch runs all system hooks concurrently with the batch payload", async () => {
+    const seen: (readonly SaveContext[])[] = [];
+    const systemHooks: SystemHooks = {
+      postSaveBatch: [
+        {
+          name: "a",
+          priority: 1000,
+          fn: async (results) => {
+            seen.push(results);
+          },
+        },
+      ],
+    };
+    const pipeline = createLifecycleHooks(makeRegistry(), systemHooks);
+    await pipeline.runPostSaveBatch([savectx], {});
+    expect(seen).toEqual([[savectx]]);
+  });
+
+  test("runPostDeleteBatch runs all system hooks with the batch payload", async () => {
+    const seen: (readonly DeleteContext[])[] = [];
+    const systemHooks: SystemHooks = {
+      postDeleteBatch: [
+        {
+          name: "a",
+          priority: 1000,
+          fn: async (payloads) => {
+            seen.push(payloads);
+          },
+        },
+      ],
+    };
+    const pipeline = createLifecycleHooks(makeRegistry(), systemHooks);
+    await pipeline.runPostDeleteBatch([deletectx], {});
+    expect(seen).toEqual([[deletectx]]);
+  });
+
+  test.each([
+    [
+      "postSaveBatch",
+      (hooks: { name: string; priority: number; fn: () => Promise<void> }[]) =>
+        ({ postSaveBatch: hooks }) satisfies SystemHooks,
+      (pipeline: ReturnType<typeof createLifecycleHooks>) =>
+        pipeline.runPostSaveBatch([savectx], {}),
+    ],
+    [
+      "postDeleteBatch",
+      (hooks: { name: string; priority: number; fn: () => Promise<void> }[]) =>
+        ({ postDeleteBatch: hooks }) satisfies SystemHooks,
+      (pipeline: ReturnType<typeof createLifecycleHooks>) =>
+        pipeline.runPostDeleteBatch([deletectx], {}),
+    ],
+  ])("one %s hook throwing doesn't stop the others (Promise.allSettled) — logged, never thrown", async (_name, buildHooks, run) => {
+    const consoleSpy = spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const calls: string[] = [];
+      const systemHooks = buildHooks([
+        {
+          name: "failing",
+          priority: 1000,
+          fn: async () => {
+            throw new Error("batch-hook-boom");
+          },
+        },
+        {
+          name: "ok",
+          priority: 1001,
+          fn: async () => {
+            calls.push("ok-ran");
+          },
+        },
+      ]);
+      const pipeline = createLifecycleHooks(makeRegistry(), systemHooks);
+      // Must not throw.
+      await run(pipeline);
+      expect(calls).toEqual(["ok-ran"]);
+      expect(consoleSpy).toHaveBeenCalled();
+    } finally {
+      consoleSpy.mockRestore();
+    }
+  });
+});

package/src/pipeline/__tests__/load-aggregate-query.integration.test.ts

@@ -45,15 +45,23 @@ const asOfFeature = defineFeature("asoftest", (r) => {
   const approved = r.defineEvent(
     "approved",
     z.object({ amount: z.number().int(), approvedBy: z.string() }),
-    { version: 2 },
+    {
+      version: 2,
+      migrations: [
+        {
+          fromVersion: 1,
+          toVersion: 2,
+          transform: (payload) => {
+            const p = payload as { amount: string; approvedBy: string };
+            return {
+              amount: Math.round(Number.parseFloat(p.amount) * 100),
+              approvedBy: p.approvedBy,
+            };
+          },
+        },
+      ],
+    },
   );
-  r.eventMigration("approved", 1, 2, (payload) => {
-    const p = payload as { amount: string; approvedBy: string };
-    return {
-      amount: Math.round(Number.parseFloat(p.amount) * 100),
-      approvedBy: p.approvedBy,
-    };
-  });
 
   const executor = createEventStoreExecutor(invoiceTable, invoiceEntity, {
     entityName: "asof-invoice",

package/src/pipeline/__tests__/post-query-hook.integration.test.ts

@@ -65,7 +65,7 @@ const postQueryFeature = defineFeature("postquerytest", (r) => {
   r.hook("postQuery", "widget:list", handlerKeyedHook);
 
   // Entity-keyed: fires for ALL query-handlers of widget-entity
-  r.entityHook("postQuery", widget, entityKeyedHook);
+  r.hook("postQuery", { allOf: widget }, entityKeyedHook);
 });
 
 // --- Single-object-result invariant fixtures ---
@@ -93,13 +93,13 @@ const singleObjectFeature = defineFeature("singleobjtest", (r) => {
   r.queryHandler("gadget:get", z.object({}), async () => ({ id: "g1", name: "Gadget" }), {
     access: { openToAll: true },
   });
-  r.entityHook("postQuery", gadget, dropRowHook);
+  r.hook("postQuery", { allOf: gadget }, dropRowHook);
 
   const gizmo = r.entity("gizmo", gizmoEntity);
   r.queryHandler("gizmo:get", z.object({}), async () => ({ id: "z1", name: "Gizmo" }), {
     access: { openToAll: true },
   });
-  r.entityHook("postQuery", gizmo, duplicateRowHook);
+  r.hook("postQuery", { allOf: gizmo }, duplicateRowHook);
 });
 
 // --- Test stack ---

package/src/pipeline/__tests__/projection-rebuild.integration.test.ts

@@ -26,7 +26,7 @@ import {
   defineFeature,
 } from "../../engine";
 import type { ProjectionDefinition } from "../../engine/types";
-import { createEventsTable } from "../../event-store";
+import { archiveStream, createEventsTable } from "../../event-store";
 import {
   createProjectionStateTable,
   getAllProjectionProgress,
@@ -116,7 +116,7 @@ afterAll(async () => {
 
 beforeEach(async () => {
   await asRawClient(testDb.db).unsafe(
-    `TRUNCATE kumiko_events, read_rebuild_items, read_rebuild_items_per_group, kumiko_projections RESTART IDENTITY CASCADE`,
+    `TRUNCATE kumiko_events, read_rebuild_items, read_rebuild_items_per_group, kumiko_projections, kumiko_archived_streams RESTART IDENTITY CASCADE`,
   );
 });
 
@@ -210,6 +210,36 @@ describe("rebuildProjection — happy path", () => {
     expect(result.eventsProcessed).toBe(0);
     expect(result.lastProcessedEventId).toBe(0n);
   });
+
+  test("archived streams don't replay (fw#832) — stranded aggregate heals via archiveStream", async () => {
+    // Heilungs-Muster fuer eventlose Read-Side-Deletes im Bestand: ein
+    // Aggregat, dessen Live-Row (vor dem fw#832-Fix) read-side entfernt
+    // wurde, hinterlaesst ein created-Event ohne deleted — jeder Rebuild
+    // wuerde die Row resurrecten (bzw. an unique-Indexen kollidieren).
+    // archiveStream friert den Stream ein UND nimmt ihn aus dem Replay.
+    const group = "00000000-0000-4000-8000-000000000020";
+    const stranded = await executor.create({ groupId: group, name: "stranded" }, admin, tdb);
+    if (!stranded.isSuccess) throw new Error("create failed");
+    await appendCreatedEvent(group, "survivor");
+
+    await archiveStream(testDb.db, {
+      tenantId: admin.tenantId,
+      aggregateId: String(stranded.data.id),
+      aggregateType: "rebuild-item",
+      archivedBy: "fw832-heal-test",
+    });
+
+    const result = await rebuildProjection(qualifiedProjectionName, {
+      db: testDb.db,
+      registry,
+    });
+
+    // Nur das survivor-Event replayed; das archivierte Aggregat traegt
+    // nicht mehr bei — auch nicht im #443-ground-truth-count (sonst
+    // wuerde der Recompute-Pfad endlos nachziehen).
+    expect(result.eventsProcessed).toBe(1);
+    expect(await getCount(group)).toBe(1);
+  });
 });
 
 describe("rebuildProjection — state table lifecycle", () => {
@@ -860,3 +890,51 @@ describe("rebuildProjection — live-tail catch-up (#363 Phase 2)", () => {
     await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS "cutover_probe"`);
   });
 });
+
+describe("rebuildProjection — stale-registry column fence (#835)", () => {
+  // Simulates the rolling-deploy race: a migration added a column to the live
+  // table, but the pod running the rebuild still carries the old registry
+  // (EntityTableMeta without that column). The rebuild must abort instead of
+  // swapping in a shadow that silently drops the migrated column (#494 class).
+  test("aborts when the live table has a column the registry meta lacks — data survives", async () => {
+    const group = "00000000-0000-4000-8000-000000000041";
+    await appendCreatedEvent(group, "item1");
+    await rebuildProjection(qualifiedProjectionName, { db: testDb.db, registry });
+    expect(await getCount(group)).toBe(1);
+
+    const raw = asRawClient(testDb.db);
+    await raw.unsafe(`ALTER TABLE "read_rebuild_items_per_group" ADD COLUMN migrated_col text`);
+    try {
+      await raw.unsafe(
+        `UPDATE "read_rebuild_items_per_group" SET migrated_col = 'must-survive' WHERE group_id = $1::uuid`,
+        [group],
+      );
+
+      await expect(
+        rebuildProjection(qualifiedProjectionName, { db: testDb.db, registry }),
+      ).rejects.toThrow(/live-only: migrated_col/);
+
+      // Live table untouched: column AND its data still there.
+      const [row] = await raw.unsafe<{ migrated_col: string | null }>(
+        `SELECT migrated_col FROM "read_rebuild_items_per_group" WHERE group_id = $1::uuid`,
+        [group],
+      );
+      expect(row?.migrated_col).toBe("must-survive");
+      expect(await getCount(group)).toBe(1);
+
+      // Failure is visible to ops.
+      const state = await getProjectionState(testDb.db, qualifiedProjectionName);
+      expect(state?.status).toBe("failed");
+      expect(state?.lastError).toContain("migrated_col");
+    } finally {
+      await raw.unsafe(
+        `ALTER TABLE "read_rebuild_items_per_group" DROP COLUMN IF EXISTS migrated_col`,
+      );
+    }
+
+    // Column sets aligned again → rebuild works.
+    const result = await rebuildProjection(qualifiedProjectionName, { db: testDb.db, registry });
+    expect(result.eventsProcessed).toBe(1);
+    expect(await getCount(group)).toBe(1);
+  });
+});