@cosmicdrift/kumiko-framework 0.183.1 → 0.184.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.183.1",
+  "version": "0.184.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>",
@@ -182,7 +182,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-types": "0.183.1",
+    "@cosmicdrift/kumiko-types": "0.184.0",
     "bullmq": "^5.76.7",
     "bun-types": "^1.3.13",
     "hono": "^4.12.27",
@@ -198,7 +198,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.183.1",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.184.0",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/db/__tests__/unique-violation-mapping.integration.test.ts

@@ -15,7 +15,7 @@
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
-import { asRawClient, selectMany } from "../../db/query";
+import { asRawClient, selectMany, transaction } from "../../db/query";
 import { createEntity, createTextField } from "../../engine";
 import { createEventsTable } from "../../event-store";
 import { TestUsers, unsafeCreateEntityTable } from "../../stack";
@@ -142,6 +142,37 @@ describe("F8 — entity-level unique-violation auf update", () => {
 // restore — kein try-catch nötig (drift-pin: dokumentiert die Annahme)
 // =============================================================================
 
+// =============================================================================
+// projection-INSERT savepoint — a step-2 failure inside a shared transaction
+// must not poison the enclosing begin() block
+// =============================================================================
+
+describe("F8 — a projection violation must not poison the enclosing transaction", () => {
+  test("a sibling write in the same tx survives a unique-violation from the projection INSERT", async () => {
+    // The path #1778 already covers for the event append but which was open for
+    // the projection INSERT (step 2): on a pool connection each write
+    // auto-commits on its own, so a 23505 can poison nothing. Only inside a
+    // shared begin() — the kind a real handler runs, whose second write follows
+    // a failed nested one — does postgres.js/Bun.SQL tear the whole block down
+    // once a statement failed, even after the JS layer caught the error.
+    // Without the savepoint around the projection INSERT the sibling write
+    // below throws raw 25P02 instead of running cleanly.
+    const outcome = await transaction(testDb.db, async (tx) => {
+      const txTdb = createTenantDb(tx, admin.tenantId);
+      const first = await exec.create({ email: "dup@x.de", displayName: "A" }, admin, txTdb);
+      const dup = await exec.create({ email: "dup@x.de", displayName: "B" }, admin, txTdb);
+      const sibling = await exec.create({ email: "fresh@x.de", displayName: "C" }, admin, txTdb);
+      return { first, dup, sibling };
+    });
+
+    expect(outcome.first.isSuccess).toBe(true);
+    expect(outcome.dup.isSuccess).toBe(false);
+    if (!outcome.dup.isSuccess) expect(outcome.dup.error.code).toBe("unique_violation");
+    // The point: the tx survives the caught violation.
+    expect(outcome.sibling.isSuccess).toBe(true);
+  });
+});
+
 describe("F8 — restore touch'd nur isDeleted, kein 23505-Pfad", () => {
   test("restore einer soft-gedeleteten row mit unique-field läuft konfliktfrei durch", async () => {
     // Audit-Annahme (advisor-Punkt verifiziert): restore mutiert nur

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

@@ -243,9 +243,17 @@ export function createWriteVerbs(
       //    unhandled exception → 500 internal_error. Map auf
       //    UniqueViolationError 409 damit Designer/Frontend einen sauberen
       //    "duplicate" zeigen können statt cryptic "internal server error".
+      // Savepoint like the append above: an unclassified DB error out of the
+      // projection INSERT would otherwise poison the enclosing tx (Bun.SQL
+      // rejects the whole begin() once any statement in it failed), so a later
+      // write sharing that tx — a sibling write after a failed nested one —
+      // throws raw as a 500 instead of failing cleanly. The savepoint rolls the
+      // failed INSERT back; the error still propagates and stays catchable.
       let result: Awaited<ReturnType<typeof applyEntityEvent>>;
       try {
-        result = await applyEntityEvent(event, table, entity, db.raw);
+        result = await runInSavepointIfSupported(db.raw, (sp) =>
+          applyEntityEvent(event, table, entity, sp as DbRunner),
+        );
       } catch (e) {
         const mapped = tryMapUniqueViolation(e, entityName);
         if (mapped) return mapped;
@@ -443,9 +451,14 @@ export function createWriteVerbs(
         // — ein update das einen unique-Index verletzt (z.B. email-update
         // auf einen schon-existierenden Wert) wird mit 409 unique_violation
         // statt 500 internal_error rückgemeldet.
+        // Savepoint like the create path: a raw DB error out of the projection
+        // UPDATE poisons the enclosing tx otherwise, so a sibling write after a
+        // failed nested one throws 500 instead of failing cleanly.
         let result: Awaited<ReturnType<typeof applyEntityEvent>>;
         try {
-          result = await applyEntityEvent(event, table, entity, db.raw);
+          result = await runInSavepointIfSupported(db.raw, (sp) =>
+            applyEntityEvent(event, table, entity, sp as DbRunner),
+          );
         } catch (e) {
           const mapped = tryMapUniqueViolation(e, entityName);
           if (mapped) return mapped;
@@ -554,7 +567,12 @@ export function createWriteVerbs(
       // wird vom soft/hard-delete-Code gar nicht in die Tabelle geschrieben
       // (nur isDeleted/deletedAt/version-Bump). Live + Replay schreiben
       // dasselbe — kein payload-override nötig.
-      const deleteResult = await applyEntityEvent(event, table, entity, db.raw);
+      // Savepoint like the create/update paths: a raw DB error out of the
+      // projection delete poisons the enclosing tx otherwise, surfacing as a
+      // 500 on the next write that shares it rather than a clean failure.
+      const deleteResult = await runInSavepointIfSupported(db.raw, (sp) =>
+        applyEntityEvent(event, table, entity, sp as DbRunner),
+      );
       if (deleteResult.kind !== "applied") {
         return writeFailure(
           new InternalError({ message: "projection delete: applyEntityEvent skipped" }),