@cosmicdrift/kumiko-framework 0.41.0 → 0.41.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "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>",

package/src/db/__tests__/event-store-executor.integration.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { asRawClient } from "../../db/query";
 import { createBooleanField, createEntity, createTextField } from "../../engine";
-import { createEventsTable } from "../../event-store";
+import { append, createEventsTable } from "../../event-store";
 import {
   createTestDb,
   type TestDb,
@@ -246,3 +246,42 @@ describe("event-store-executor — sensitive fields", () => {
     expect(event.payload.previous.apiToken).toBeUndefined();
   });
 });
+
+describe("event-store-executor — detail liefert die Stream-Version", () => {
+  const crud = createEventStoreExecutor(table, entity, { entityName: "esExecUser" });
+
+  // Lifecycle-Writes (ctx.appendEvent) bumpen den Stream, ohne row.version
+  // anzufassen — gäbe detail die stale Row-Version heraus, liefe jedes
+  // darauf gebaute CRUD-Update (entityEdit nutzt detail.version als
+  // optimistic-lock-Basis) in ein garantiertes version_conflict.
+  // Prod-Repro: incident:open appended das Eröffnungs-Update → Stream v2,
+  // Row v1 → incident-edit konnte nie speichern.
+  test("nach ctx.appendEvent-artigem Stream-Bump: detail.version == Stream, Update damit erfolgreich", async () => {
+    const created = await crud.create({ email: "stream@test.de" }, adminUser, tdb);
+    expect(created.isSuccess).toBe(true);
+    if (!created.isSuccess) return;
+    const id = created.data.id;
+
+    // Hand-emittiertes Event auf demselben Aggregat (wie incident:post-update).
+    await append(testDb.db, {
+      aggregateId: String(id),
+      aggregateType: "esExecUser",
+      tenantId: adminUser.tenantId,
+      expectedVersion: 1,
+      type: "esExecUser.lifecycle-bumped",
+      payload: { note: "stream moved past the row" },
+      metadata: { userId: String(adminUser.id) },
+    });
+
+    const detail = await crud.detail({ id }, adminUser, tdb);
+    expect(detail).not.toBeNull();
+    expect(detail?.["version"]).toBe(2);
+
+    const updated = await crud.update(
+      { id, version: 2, changes: { firstName: "After" } },
+      adminUser,
+      tdb,
+    );
+    expect(updated.isSuccess).toBe(true);
+  });
+});

package/src/db/event-store-executor.ts

@@ -969,6 +969,19 @@ export function createEventStoreExecutor(
 
       const idWhere = idFilter(payload.id);
 
+      // Stream-version authoritative (same policy as update/Block 0):
+      // ctx.appendEvent (lifecycle-writes like incident:post-update) bumps
+      // the stream WITHOUT touching row.version — a detail-read that hands
+      // out the stale row.version dooms the next CRUD update built on it
+      // (entityEdit loads detail.version as its optimistic-lock base) to a
+      // guaranteed version_conflict.
+      const withStreamVersion = async (
+        row: Record<string, unknown>,
+      ): Promise<Record<string, unknown>> => {
+        const streamVersion = await getStreamVersion(db.raw, String(payload.id), user.tenantId);
+        return streamVersion > 0 ? { ...row, version: streamVersion } : row;
+      };
+
       if (entityCache && entityName) {
         const cached = await entityCache.get(user.tenantId, entityName, payload.id);
         if (cached) {
@@ -978,7 +991,7 @@ export function createEventStoreExecutor(
             const checkRows = await loadWithOwnership(db, idWhere, ownership);
             if (checkRows.length === 0) return null;
           }
-          return cached;
+          return withStreamVersion(cached);
         }
       }
 
@@ -993,7 +1006,7 @@ export function createEventStoreExecutor(
         await entityCache.set(user.tenantId, entityName, payload.id, coerced);
       }
 
-      return coerced;
+      return withStreamVersion(coerced);
     },
   };
 }