@cosmicdrift/kumiko-framework 0.171.1 → 0.172.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.171.1",
+  "version": "0.172.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.171.1",
+    "@cosmicdrift/kumiko-types": "0.172.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.171.1",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.172.0",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/entrypoint/__tests__/split-deploy.integration.test.ts

@@ -5,7 +5,8 @@
 // pin the public guarantees:
 //
 //   1. API entrypoint has no eventDispatcher/jobRunner handles.
-//   2. Worker entrypoint has no HTTP app.
+//   2. Worker entrypoint has no HTTP app, but does hand out the
+//      command-dispatcher — app-wired background components need it.
 //   3. All-in-one has both.
 //   4. Worker throws when there's literally nothing to consume (defensive
 //      guard — buildServer always wires an SSE consumer so this only
@@ -14,10 +15,11 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
 import { createRegistry, defineFeature } from "../../engine";
 import { createArchivedStreamsTable, createEventsTable } from "../../event-store";
 import { createEventConsumerStateTable } from "../../pipeline";
-import { createTestRedis, type TestRedis } from "../../stack";
+import { createTestRedis, type TestRedis, TestUsers } from "../../stack";
 import { createAllInOneEntrypoint, createApiEntrypoint, createWorkerEntrypoint } from "../index";
 
 const splitFeature = defineFeature("split", (r) => {
@@ -30,6 +32,24 @@ const splitFeature = defineFeature("split", (r) => {
   });
 });
 
+const workerWriteFeature = defineFeature("workerWrite", (r) => {
+  const noted = r.defineEvent("noted", z.object({ note: z.string() }), { version: 1 });
+  r.writeHandler(
+    "note",
+    z.object({ note: z.string() }),
+    async (event, ctx) => {
+      await ctx.unsafeAppendEvent({
+        aggregateId: crypto.randomUUID(),
+        aggregateType: "worker-note",
+        type: noted.name,
+        payload: { note: event.payload.note },
+      });
+      return { isSuccess: true as const, data: { note: event.payload.note } };
+    },
+    { access: { openToAll: true } },
+  );
+});
+
 const JWT = "split-deploy-test-secret-must-be-32-chars!!";
 
 // Per-test queue-name with a random suffix. Date.now() alone collided
@@ -86,6 +106,7 @@ describe("entrypoint factories", () => {
     expect(worker.mode).toBe("worker");
     expect(worker.eventDispatcher).toBeDefined();
     expect(worker.jobRunner).toBeDefined();
+    expect(worker.dispatcher).toBeDefined();
     expect("app" in worker).toBe(false);
     expect("jwt" in worker).toBe(false);
 
@@ -95,6 +116,42 @@ describe("entrypoint factories", () => {
     await worker.stop();
   });
 
+  // An app-wired component running in the worker (analysis service, IMAP
+  // supervisor) has to persist its result, and persisting goes through the
+  // write-path — JobContext has no write/query. The dispatcher is the only
+  // way in, so a worker that doesn't hand it out forces such a component
+  // into the API process, which defeats the split.
+  test("Worker dispatcher runs a write end-to-end — handler executes, event lands in the store", async () => {
+    const registry = createRegistry([workerWriteFeature]);
+    const redisUrl = `redis://${testRedis.redis.options.host}:${testRedis.redis.options.port}/${testRedis.redis.options.db}`;
+    const worker = createWorkerEntrypoint({
+      registry,
+      context: { db: testDb.db, redis: testRedis.redis },
+      jwtSecret: JWT,
+      redisUrl,
+      queueNamePrefix: uniquePrefix("split-dispatch"),
+    });
+
+    try {
+      const result = await worker.dispatcher.write(
+        "worker-write:write:note",
+        { note: "written from the worker" },
+        TestUsers.admin,
+      );
+      expect(result.isSuccess).toBe(true);
+
+      const rows = await asRawClient(testDb.db).unsafe(
+        `SELECT payload FROM kumiko_events WHERE type = 'worker-write:event:noted'`,
+      );
+      expect(rows).toHaveLength(1);
+      expect((rows[0] as { payload: { note: string } }).payload.note).toBe(
+        "written from the worker",
+      );
+    } finally {
+      await worker.stop();
+    }
+  });
+
   test("All-in-one entrypoint has both HTTP surface and background workers", async () => {
     const registry = createRegistry([splitFeature]);
     const redisUrl = process.env["REDIS_URL"] ?? "redis://localhost:16379";

package/src/entrypoint/index.ts

@@ -142,6 +142,12 @@ export type WorkerEntrypoint = {
   readonly eventDispatcher: EventDispatcher;
   readonly jobRunner: JobRunner;
   readonly observability: ObservabilityProvider;
+  // Same dispatcher the API process exposes — a worker builds the identical
+  // server, only without routes. App-wired components that run in the worker
+  // and must persist their result need it: JobContext has no write/query
+  // (handlers.ts JobContext), so writing goes through dispatchSystemWrite,
+  // the pattern inbound-mail-foundation/watch-supervisor.ts established.
+  readonly dispatcher: Dispatcher;
   readonly mode: "worker";
   // Starts event-dispatcher poll + BullMQ worker. SIGTERM triggers
   // `lifecycle.drain()`, which stops both via registered hooks.
@@ -428,6 +434,7 @@ export function createWorkerEntrypoint(options: WorkerEntrypointOptions): Worker
     eventDispatcher,
     jobRunner,
     observability: server.observability,
+    dispatcher: server.dispatcher,
     mode: "worker",
     async start() {
       await eventDispatcher.start();