@cosmicdrift/kumiko-dev-server 0.126.0 → 0.127.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.126.0",
+  "version": "0.127.0",
   "description": "Development server bootstrap for Kumiko apps. Bundles the client, mints dev-JWTs, injects the resolved AppSchema, and seeds an admin. Not for production.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -50,8 +50,8 @@
     "kumiko-schema-check": "./bin/kumiko-schema-check.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.126.0",
-    "@cosmicdrift/kumiko-framework": "0.126.0",
+    "@cosmicdrift/kumiko-bundled-features": "0.127.0",
+    "@cosmicdrift/kumiko-framework": "0.127.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

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

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import { createJobsFeature } from "@cosmicdrift/kumiko-bundled-features/jobs";
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { createRegistry, defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import { jobRunLoggerCallbacks } from "../job-run-logger";
+
+// ponytail: callbacks shape only — no DB I/O; createTestDb needs TEST_DATABASE_URL (CI unit job has none).
+const mockDb = {} as DbConnection;
+
+describe("jobRunLoggerCallbacks", () => {
+  test("returns undefined when jobs feature is not registered", () => {
+    const registry = createRegistry([
+      defineFeature("empty", () => ({ handlers: {}, queries: {} })),
+    ]);
+    expect(jobRunLoggerCallbacks(registry, mockDb)).toBeUndefined();
+  });
+
+  test("returns logger callbacks when jobs feature is registered", () => {
+    const registry = createRegistry([createJobsFeature()]);
+    const callbacks = jobRunLoggerCallbacks(registry, mockDb);
+    expect(callbacks).toBeDefined();
+    expect(typeof callbacks?.onJobStart).toBe("function");
+    expect(typeof callbacks?.onJobComplete).toBe("function");
+    expect(typeof callbacks?.onJobFailed).toBe("function");
+  });
+});

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

@@ -0,0 +1,51 @@
+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 { JobRunIn } from "@cosmicdrift/kumiko-framework/engine/types";
+import { createJobRunner, type JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+
+export function jobRunLoggerCallbacks(
+  registry: Registry,
+  db: DbConnection,
+): ReturnType<typeof createJobRunLogger> | undefined {
+  if (registry.getFeature("jobs") === undefined) return undefined;
+  return createJobRunLogger({ db, registry });
+}
+
+/** Dev-server parity: consume api + worker lanes when jobs are registered. */
+export async function startDevJobRunners(opts: {
+  readonly registry: Registry;
+  readonly db: DbConnection;
+  readonly context: Record<string, unknown>;
+  readonly redisUrl: string;
+}): Promise<{ readonly runners: readonly JobRunner[]; readonly stop: () => Promise<void> }> {
+  const jobs = [...opts.registry.getAllJobs().values()];
+  if (opts.registry.getFeature("jobs") === undefined || jobs.length === 0) {
+    return { runners: [], stop: async () => {} };
+  }
+
+  const logger = createJobRunLogger({ db: opts.db, registry: opts.registry });
+  const runners: JobRunner[] = [];
+  const lanes = new Set(
+    jobs.map((j) => j.runIn).filter((lane): lane is JobRunIn => lane !== undefined),
+  );
+
+  for (const lane of lanes) {
+    const jr = createJobRunner({
+      registry: opts.registry,
+      context: { ...opts.context, db: opts.db },
+      redisUrl: opts.redisUrl,
+      consumerLane: lane,
+      ...logger,
+    });
+    await jr.start();
+    runners.push(jr);
+  }
+
+  return {
+    runners,
+    stop: async () => {
+      for (const runner of runners) await runner.stop();
+    },
+  };
+}

package/src/create-kumiko-server.ts

@@ -29,6 +29,7 @@ import {
   type TestStackOptions,
   TestUsers,
 } from "@cosmicdrift/kumiko-framework/stack";
+import { startDevJobRunners } from "./boot/job-run-logger";
 import { type ExtraRoutesSystemDeps, makeDispatchSystemWrite } from "./extra-routes-deps";
 import { injectSchema } from "./inject-schema";
 import { canResolveTailwindStylesheet, resolveTailwindCli } from "./resolve-tailwind-cli";
@@ -707,6 +708,14 @@ export async function createKumikoServer(
     await stack.eventDispatcher.start();
   }
 
+  const redisUrl = `redis://${stack.redis.redis.options.host}:${stack.redis.redis.options.port}/${stack.redis.redis.options.db}`;
+  const devJobRunners = await startDevJobRunners({
+    registry: stack.registry,
+    db: stack.db,
+    context: { db: stack.db, registry: stack.registry },
+    redisUrl,
+  });
+
   // Dev user = TestUsers.admin. Demo features are openToAll but the
   // auth-middleware still needs a valid JWT to let the request past.
   // Nicht genutzt wenn `options.auth` gesetzt ist — dann macht der Client
@@ -977,6 +986,7 @@ export async function createKumikoServer(
     if (stack.eventDispatcher) {
       await stack.eventDispatcher.stop();
     }
+    await devJobRunners.stop();
     await stack.cleanup();
   };
 

package/src/run-prod-app.ts

@@ -138,6 +138,7 @@ import { warnIfNonUtcServerTimeZone } from "@cosmicdrift/kumiko-framework/time";
 import Redis from "ioredis";
 import { applyBootSeeds } from "./boot/apply-boot-seeds";
 import { type BootCrypto, resolveBootCrypto } from "./boot/boot-crypto";
+import { jobRunLoggerCallbacks } from "./boot/job-run-logger";
 import { ASSETS_DIR } from "./build-prod-bundle";
 import { buildComposeAuthOptions, composeFeatures } from "./compose-features";
 import { type ExtraRoutesSystemDeps, makeDispatchSystemWrite } from "./extra-routes-deps";
@@ -1133,6 +1134,7 @@ export async function runProdApp(options: RunProdAppOptions): Promise<ProdAppHan
   const runSingleInstance = options.runSingleInstance ?? options.eventDispatcher?.disabled !== true;
   const hasJobs = registry.getAllJobs().size > 0;
   const queueNamePrefix = options.jobs?.queueNamePrefix;
+  const jobLogger = jobRunLoggerCallbacks(registry, db);
   const dispatcherTunables =
     options.eventDispatcher?.pollIntervalMs !== undefined
       ? { pollIntervalMs: options.eventDispatcher.pollIntervalMs }
@@ -1141,20 +1143,18 @@ export async function runProdApp(options: RunProdAppOptions): Promise<ProdAppHan
   const entrypoint: ApiEntrypoint | AllInOneEntrypoint = runSingleInstance
     ? createAllInOneEntrypoint({
         ...baseEntrypointOptions,
-        // Worker-Seite liest die JobsBlock TOP-LEVEL (nicht nested `jobs` wie
-        // die api-Seite); beide Lane-Runner ziehen redisUrl/prefix von hier.
         redisUrl,
+        ...jobLogger,
         ...(queueNamePrefix !== undefined && { queueNamePrefix }),
         ...(!options.eventDispatcher?.disabled && { eventDispatcher: dispatcherTunables }),
       })
     : createApiEntrypoint({
         ...baseEntrypointOptions,
-        // API-only: api-Lane-Jobs laufen lokal, ein dezidierter Worker fährt
-        // worker-Lane + MSPs. createApiEntrypoint liest den nested `jobs`-Block.
         ...(hasJobs && {
           jobs: {
             redisUrl,
             runLocalJobs: true,
+            ...jobLogger,
             ...(queueNamePrefix !== undefined && { queueNamePrefix }),
           },
         }),