@cosmicdrift/kumiko-framework 0.121.0 → 0.122.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.121.0",
+  "version": "0.122.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -135,6 +135,10 @@
       "types": "./src/crypto/index.ts",
       "default": "./src/crypto/index.ts"
     },
+    "./logging": {
+      "types": "./src/logging/index.ts",
+      "default": "./src/logging/index.ts"
+    },
     "./schema-cli": {
       "types": "./src/schema-cli.ts",
       "default": "./src/schema-cli.ts"
@@ -185,7 +189,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.121.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.122.0",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/db/queries/projection-rebuild.ts

@@ -23,12 +23,19 @@ export async function selectEventsForProjectionRebuildBatch(
   afterId: bigint,
   limit: number,
 ): Promise<ReadonlyArray<Record<string, unknown>>> {
+  // Archived streams don't replay (Marten-aligned): their aggregates are
+  // frozen ops-tombstones — replaying them would resurrect rows (or, for
+  // stranded duplicate-aggregates like fw#832, collide on unique indexes).
   return (await asRawClient(db).unsafe(
-    `SELECT * FROM "kumiko_events"
-     WHERE "aggregate_type" = ANY($1::text[])
-       AND "type" = ANY($2::text[])
-       AND "id" > $3
-     ORDER BY "id" ASC
+    `SELECT * FROM "kumiko_events" e
+     WHERE e."aggregate_type" = ANY($1::text[])
+       AND e."type" = ANY($2::text[])
+       AND e."id" > $3
+       AND NOT EXISTS (
+         SELECT 1 FROM "kumiko_archived_streams" a
+          WHERE a."tenant_id" = e."tenant_id" AND a."aggregate_id" = e."aggregate_id"
+       )
+     ORDER BY e."id" ASC
      LIMIT $4`,
     [aggregateTypes, eventTypes, afterId, limit],
   )) as ReadonlyArray<Record<string, unknown>>;
@@ -43,10 +50,17 @@ export async function countSubscribedEvents(
   aggregateTypes: readonly string[],
   eventTypes: readonly string[],
 ): Promise<bigint> {
+  // Same archived-streams exclusion as the batch query — the #443 recompute
+  // compares this count against applied events; a filter mismatch would make
+  // every rebuild with an archived stream loop the full-re-replay forever.
   const rows = (await asRawClient(db).unsafe(
-    `SELECT count(*)::bigint AS n FROM "kumiko_events"
-     WHERE "aggregate_type" = ANY($1::text[])
-       AND "type" = ANY($2::text[])`,
+    `SELECT count(*)::bigint AS n FROM "kumiko_events" e
+     WHERE e."aggregate_type" = ANY($1::text[])
+       AND e."type" = ANY($2::text[])
+       AND NOT EXISTS (
+         SELECT 1 FROM "kumiko_archived_streams" a
+          WHERE a."tenant_id" = e."tenant_id" AND a."aggregate_id" = e."aggregate_id"
+       )`,
     [aggregateTypes, eventTypes],
   )) as ReadonlyArray<{ n: bigint | string | number | null }>;
   const raw = rows[0]?.n;

package/src/engine/__tests__/build-app-schema.test.ts

@@ -111,6 +111,35 @@ describe("buildAppSchema", () => {
     expect(idField?.["type"]).toBe("text"); // type kommt durch
   });
 
+  test("Reference-Field: entity + labelField + multiple überleben die Projection", () => {
+    // Regression: ohne diese Properties im Client-Schema baut der ReferenceInput
+    // die Options-Query als `<feature>:query::list` (leeres refEntity) → 404 →
+    // Dropdown zeigt „Keine Treffer" obwohl die referenzierte Entity Rows hat.
+    const entity = {
+      fields: {
+        name: { type: "text" },
+        parentId: { type: "reference", entity: "component", labelField: "name" },
+        tags: { type: "reference", entity: "tag", labelField: "label", multiple: true },
+      },
+    } as unknown as EntityDefinition;
+
+    const f = defineFeature("ent", (r) => {
+      r.entity("thing", entity);
+    });
+    const app = buildAppSchema(createRegistry([f]));
+    const fields = (
+      app.features[0]?.entities["thing"] as unknown as {
+        fields: Record<string, Record<string, unknown>>;
+      }
+    ).fields;
+
+    expect(fields["parentId"]?.["type"]).toBe("reference");
+    expect(fields["parentId"]?.["entity"]).toBe("component");
+    expect(fields["parentId"]?.["labelField"]).toBe("name");
+    expect(fields["tags"]?.["entity"]).toBe("tag");
+    expect(fields["tags"]?.["multiple"]).toBe(true);
+  });
+
   test("JSON-Safety: literal Defaults bleiben erhalten", () => {
     const entity = {
       fields: {

package/src/engine/build-app-schema.ts

@@ -343,6 +343,13 @@ function projectField(fieldDef: FieldDefinition): FieldDefinition {
   if (isLiteral(def["default"])) out["default"] = def["default"];
   // Select: options-Liste ist plain JSON, durchschicken.
   if (Array.isArray(def["options"])) out["options"] = def["options"];
+  // Reference: entity-Target + labelField + multiple müssen zum Renderer.
+  // Der ReferenceInput baut die Options-Query aus refEntity/refFeature und
+  // resolved das Label über labelField — ohne diese Properties fällt das
+  // Dropdown leer aus (QN wird `<feature>:query::list` → 404).
+  if (typeof def["entity"] === "string") out["entity"] = def["entity"];
+  if (typeof def["labelField"] === "string") out["labelField"] = def["labelField"];
+  if (typeof def["multiple"] === "boolean") out["multiple"] = def["multiple"];
   return out as FieldDefinition; // @cast-boundary schema-walk
 }
 

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", () => {