@cosmicdrift/kumiko-server-runtime 0.231.0 → 0.232.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-server-runtime",
-  "version": "0.231.0",
+  "version": "0.232.0",
   "description": "Production server-boot runtime for Kumiko apps: connections, schema-drift-gate, seeds, lifecycle, graceful shutdown. Symmetric to kumiko-dev-server's runDevApp, without dev/scaffold/codegen tooling.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -80,8 +80,8 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.231.0",
-    "@cosmicdrift/kumiko-framework": "0.231.0",
+    "@cosmicdrift/kumiko-bundled-features": "0.232.0",
+    "@cosmicdrift/kumiko-framework": "0.232.0",
     "temporal-polyfill": "^0.3.2"
   },
   "publishConfig": {

package/src/boot/__tests__/job-run-logger.integration.test.ts

@@ -4,23 +4,38 @@
 // forever. `runners.length` alone can't catch that — a lane with no consumer
 // still produces a runner object. This dispatches a real job and waits for
 // its side effect to prove the lane is actually being consumed.
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import {
   createJobsFeature,
   jobRunLogsTable,
   jobRunsTable,
 } from "@cosmicdrift/kumiko-bundled-features/jobs";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import { createRegistry, defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  buildEntityTable,
+  createEventStoreExecutor,
+  selectMany,
+} from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEntity,
+  createRegistry,
+  createTextField,
+  defineFeature,
+} from "@cosmicdrift/kumiko-framework/engine";
 import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import { createDispatcher } from "@cosmicdrift/kumiko-framework/pipeline";
 import {
   createTestDb,
   createTestRedis,
+  setupTestStack,
   type TestDb,
   type TestRedis,
+  TestUsers,
+  unsafeCreateEntityTable,
   unsafePushTables,
 } from "@cosmicdrift/kumiko-framework/stack";
 import { waitFor } from "@cosmicdrift/kumiko-framework/testing";
+import { z } from "zod";
 import { startDevJobRunners } from "../job-run-logger";
 
 let testDb: TestDb;
@@ -58,6 +73,10 @@ describe("startDevJobRunners", () => {
       db,
       context: {},
       redisUrl: testRedis.redisUrl,
+      // Construction-only — this job never calls ctx.write/ctx.queryAs, so a
+      // dispatcher built against a bare `{}` context is enough to satisfy
+      // the (now required) opts.dispatcher without wiring a full stack.
+      dispatcher: createDispatcher(registry, {}),
     });
 
     try {
@@ -75,3 +94,101 @@ describe("startDevJobRunners", () => {
     }
   });
 });
+
+// kumiko-framework#2553: startDevJobRunners built its per-lane JobRunners but
+// never called attachDispatcher() on them (unlike createApiEntrypoint /
+// createWorkerEntrypoint / createAllInOneEntrypoint, which all do this
+// automatically) — so ctx.write/ctx.queryAs inside a dev-run job always hit
+// the "dispatcher attached — call attachDispatcher() first" stub. This
+// mirrors create-kumiko-server.ts's real wiring (setupTestStack + a separate
+// startDevJobRunners as the lane consumer) and drives a job that calls both
+// ctx.write and ctx.queryAs end-to-end.
+const attachNoteEntity = createEntity({
+  table: "job_attach_notes",
+  fields: { text: createTextField({ required: true }) },
+});
+const attachNoteTable = buildEntityTable("note", attachNoteEntity);
+
+const attachResults: Array<{ writeOk: boolean; rowCount: number }> = [];
+const attachFailures: string[] = [];
+
+const attachDispatcherFeature = defineFeature("jobattach", (r) => {
+  r.entity("note", attachNoteEntity);
+
+  r.writeHandler(
+    "create",
+    z.object({ text: z.string() }),
+    async (event, ctx) => {
+      const crud = createEventStoreExecutor(attachNoteTable, attachNoteEntity, {
+        entityName: "note",
+      });
+      return crud.create(event.payload, event.user, ctx.db);
+    },
+    { access: { openToAll: true } },
+  );
+
+  r.queryHandler("list", z.object({}), async (_query, ctx) => selectMany(ctx.db, attachNoteTable), {
+    access: { openToAll: true },
+  });
+
+  r.job("record", { trigger: { manual: true }, retries: 0 }, async (payload, ctx) => {
+    try {
+      const text = (payload as { text: string }).text;
+      const writeResult = await ctx.write("jobattach:write:create", { text });
+      const rows = await ctx.queryAs(TestUsers.admin, "jobattach:query:list", {});
+      attachResults.push({
+        writeOk: writeResult.isSuccess,
+        rowCount: (rows as unknown[]).length,
+      });
+    } catch (error) {
+      attachFailures.push(error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  });
+});
+
+describe("startDevJobRunners attaches the dispatcher (kumiko-framework#2553)", () => {
+  afterEach(() => {
+    attachResults.length = 0;
+    attachFailures.length = 0;
+  });
+
+  test("a dev-run job's ctx.write and ctx.queryAs both succeed", async () => {
+    const stack = await setupTestStack({
+      features: [attachDispatcherFeature, createJobsFeature()],
+      // Enqueuer-only — startDevJobRunners below is the sole consumer,
+      // mirroring create-kumiko-server.ts.
+      jobs: {},
+    });
+    await unsafeCreateEntityTable(stack.db, attachNoteEntity);
+
+    try {
+      const { runners, stop } = await startDevJobRunners({
+        registry: stack.registry,
+        db: stack.db,
+        context: stack.context,
+        redisUrl: stack.redis.redisUrl,
+        dispatcher: stack.dispatcher,
+      });
+
+      try {
+        const runner = runners[0];
+        if (runner === undefined) throw new Error("expected a runner");
+
+        await runner.dispatch("jobattach:job:record", { text: "hello-from-dev-runner" });
+
+        await waitFor(() => {
+          expect(attachResults.length + attachFailures.length).toBeGreaterThan(0);
+        });
+        if (attachFailures.length > 0) {
+          throw new Error(`job failed: ${attachFailures.join(", ")}`);
+        }
+        expect(attachResults[0]).toEqual({ writeOk: true, rowCount: 1 });
+      } finally {
+        await stop();
+      }
+    } finally {
+      await stack.cleanup();
+    }
+  }, 15000);
+});

package/src/boot/job-run-logger.ts

@@ -1,8 +1,13 @@
 import { createJobRunLogger } from "@cosmicdrift/kumiko-bundled-features/jobs";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
 import type { Registry } from "@cosmicdrift/kumiko-framework/engine";
-import type { AppContext, JobRunIn } from "@cosmicdrift/kumiko-framework/engine/types";
+import type {
+  AppContext,
+  DispatchWriteRef,
+  JobRunIn,
+} from "@cosmicdrift/kumiko-framework/engine/types";
 import { createJobRunner, type JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+import type { Dispatcher } from "@cosmicdrift/kumiko-framework/pipeline";
 
 export function jobRunLoggerCallbacks(
   registry: Registry,
@@ -12,12 +17,25 @@ export function jobRunLoggerCallbacks(
   return createJobRunLogger({ db, registry });
 }
 
+// Same adapter as the prod entrypoints' dispatcherToWriteRef (entrypoint/
+// index.ts) — DispatchWriteRef's (user, qn, payload) shape vs. Dispatcher's
+// (type, payload, user). Duplicated here because the entrypoint's version
+// isn't exported: dev boot builds its own dispatcher via setupTestStack
+// rather than going through createApiEntrypoint/createWorkerEntrypoint.
+function dispatcherToWriteRef(dispatcher: Dispatcher): DispatchWriteRef {
+  return {
+    write: (user, qn, payload) => dispatcher.write(qn, payload, user),
+    queryAs: (user, qn, payload) => dispatcher.query(qn, payload, user),
+  };
+}
+
 /** Dev-server parity: consume api + worker lanes when jobs are registered. */
 export async function startDevJobRunners(opts: {
   readonly registry: Registry;
   readonly db: DbConnection;
   readonly context: AppContext;
   readonly redisUrl: string;
+  readonly dispatcher: Dispatcher;
 }): Promise<{ readonly runners: readonly JobRunner[]; readonly stop: () => Promise<void> }> {
   const jobs = [...opts.registry.getAllJobs().values()];
   if (opts.registry.getFeature("jobs") === undefined || jobs.length === 0) {
@@ -39,6 +57,12 @@ export async function startDevJobRunners(opts: {
       consumerLane: lane,
       ...logger,
     });
+    // Without this, ctx.write/ctx.queryAs inside a dev-run job throw
+    // "dispatcher attached — call attachDispatcher() first" on their first
+    // call — the prod entrypoints (createApiEntrypoint/createWorkerEntrypoint/
+    // createAllInOneEntrypoint) do this automatically, dev boot must too
+    // (kumiko-framework#2553).
+    jr.attachDispatcher(dispatcherToWriteRef(opts.dispatcher));
     await jr.start();
     runners.push(jr);
   }