@cosmicdrift/kumiko-framework 0.193.1 → 0.195.0

package/src/pipeline/__tests__/ctx-bridge.integration.test.ts

@@ -125,11 +125,11 @@ const bridgeFeature = defineFeature("ctxbridge", (r) => {
     async (event, ctx) => {
       const crud = createEventStoreExecutor(bagTable, bagEntity, { entityName: "bag" });
       await crud.create({ label: `${event.payload.label}-inside-tx` }, event.user, ctx.db);
-      await crud.create(
-        { label: `${event.payload.label}-outside-tx` },
-        event.user,
-        ctx.dbOutsideTransaction,
-      );
+      const outsideTx = ctx.dbOutsideTransaction;
+      if (!outsideTx) {
+        throw new Error("bag:create-outside-tx-then-fail requires ctx.dbOutsideTransaction");
+      }
+      await crud.create({ label: `${event.payload.label}-outside-tx` }, event.user, outsideTx);
       return writeFailure(new UnprocessableError("intentional_failure"));
     },
     { access: { roles: ["Admin"] } },
@@ -149,6 +149,39 @@ const bridgeFeature = defineFeature("ctxbridge", (r) => {
     { access: { roles: ["Admin"] } },
   );
 
+  // Records whether ctx.db threw (should, once the request signal is
+  // aborted) and whether the ctx.dbOutsideTransaction insert still landed
+  // (should — durability writes must survive a client disconnect).
+  //
+  // The throwing side reads via ctx.db.selectMany, not the event-store
+  // executor's create() — the latter writes through db.raw (bypassing
+  // TenantDb's withDbSpan/signal check entirely), so it wouldn't exercise
+  // the signal wiring this test is meant to prove. insertOne isn't an
+  // option either: bagTable is executor-managed (WritableTable rejects its
+  // EXECUTOR_ONLY brand) — direct writes would drift it past its event
+  // stream. selectMany has no such restriction (reads keep the plain
+  // SchemaTable param) and still goes through the same signal check.
+  r.writeHandler(
+    "bag:create-signal-probe",
+    z.object({ label: z.string() }),
+    async (event, ctx) => {
+      const crud = createEventStoreExecutor(bagTable, bagEntity, { entityName: "bag" });
+      let dbThrewAbortError = false;
+      try {
+        await ctx.db?.selectMany(bagTable, {});
+      } catch (err) {
+        dbThrewAbortError = err instanceof Error && err.name === "AbortError";
+      }
+      const outsideTx = ctx.dbOutsideTransaction;
+      if (!outsideTx) {
+        throw new Error("bag:create-signal-probe requires ctx.dbOutsideTransaction");
+      }
+      await crud.create({ label: `${event.payload.label}-outside-tx` }, event.user, outsideTx);
+      return { isSuccess: true as const, data: { dbThrewAbortError } };
+    },
+    { access: { roles: ["Admin"] } },
+  );
+
   // afterCommit hook on bag — fires once per outer commit.
   r.hook("postSave", { allOf: bag }, async (result) => {
     afterCommitLog.push(`bag:${result.data["label"]}`);
@@ -266,4 +299,35 @@ describe("ctx.dbOutsideTransaction", () => {
     const labels = (bags as Array<Record<string, unknown>>).map((row) => row["label"]);
     expect(labels).toEqual(["probe-outside-tx"]);
   });
+
+  test("an already-aborted request signal fails ctx.db but not ctx.dbOutsideTransaction", async () => {
+    const controller = new AbortController();
+    controller.abort();
+    const token = await stack.jwt.sign(admin);
+
+    const res = await stack.app.request(
+      new Request("http://test.local/api/write", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({
+          type: "ctxbridge:write:bag:create-signal-probe",
+          payload: { label: "signal-probe" },
+        }),
+        signal: controller.signal,
+      }),
+    );
+
+    const body = (await res.json()) as {
+      isSuccess: boolean;
+      data?: { dbThrewAbortError: boolean };
+    };
+    expect(body.isSuccess).toBe(true);
+    expect(body.data?.dbThrewAbortError).toBe(true);
+
+    // Only the outside-tx insert landed — ctx.db's insert threw before it
+    // could write, and there was nothing to roll back for it.
+    const bags = await selectMany(stack.db, bagTable);
+    const labels = (bags as Array<Record<string, unknown>>).map((row) => row["label"]);
+    expect(labels).toEqual(["signal-probe-outside-tx"]);
+  });
 });

package/src/pipeline/dispatch-shared.ts

@@ -170,24 +170,27 @@ export async function buildHandlerContext(
   // but at this point we're the root of the pipeline — cast is safe.
   const dbSource = resolveDbSource(ctx, tx);
   const reqCtx = requestContext.get();
-  const buildTenantScopedDb = (source: DbConnection | DbTx) =>
+  const buildTenantScopedDb = (source: DbConnection | DbTx, signal: AbortSignal | undefined) =>
     createTenantDb(
       source,
       user.tenantId,
       isSystem ? "system" : "tenant",
       context.tracer,
       context.meter,
-      // Propagate the request's AbortSignal so every TenantDb query
-      // throws when the client has disconnected — handlers with many
-      // sequential queries skip the rest of the chain instead of
-      // burning DB-CPU for results no one reads.
-      reqCtx?.signal,
+      signal,
     );
-  const db = dbSource ? buildTenantScopedDb(dbSource) : undefined;
+  // Propagate the request's AbortSignal so every TenantDb query throws when
+  // the client has disconnected — handlers with many sequential queries skip
+  // the rest of the chain instead of burning DB-CPU for results no one reads.
+  const db = dbSource ? buildTenantScopedDb(dbSource, reqCtx?.signal) : undefined;
   // Unbound pool, tenant-scoped like `db` but never tx-bound — writes
-  // through it survive a rollback of the handler's own transaction.
+  // through it survive a rollback of the handler's own transaction. No
+  // AbortSignal here: a client disconnect must not abort a durability write
+  // that is meant to outlive the request.
   const outsideTxSource = resolveDbSource(ctx, undefined);
-  const dbOutsideTransaction = outsideTxSource ? buildTenantScopedDb(outsideTxSource) : undefined;
+  const dbOutsideTransaction = outsideTxSource
+    ? buildTenantScopedDb(outsideTxSource, undefined)
+    : undefined;
   const log = context.log?.child({
     handler: type,
     tenantId: user.tenantId,

package/src/ui-types/index.ts

@@ -38,6 +38,7 @@ export {
 export type {
   BooleanFieldDef,
   DateFieldDef,
+  EmbeddedDerivedCellDef,
   EntityDefinition,
   FieldDefinition,
   FileFieldDef,