@cosmicdrift/kumiko-dev-server 0.329.0 → 0.330.0

package/src/codegen/__tests__/strict-mode-diagnostics.test.ts

@@ -1,347 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-// TS7's package.json exports only version.cjs at ".", so the classic
-// createProgram/ScriptTarget Compiler API is unreachable via `import *
-// as ts from "typescript"` anymore; ts-morph's vendored (older) compiler
-// build is the only way to get that surface, so diagnostics here run
-// against a different compiler than the repo's own tsc.
-import { ts } from "ts-morph";
-import { runCodegen } from "../run-codegen";
-
-const REPO_ROOT = join(__dirname, "../../../../..");
-const FRAMEWORK_SRC = join(REPO_ROOT, "packages/framework/src");
-
-const TEST_FIXTURE_DIR = join(__dirname, ".tmp-fixtures");
-const createdDirs: string[] = [];
-
-function makeAppDir(): string {
-  mkdirSync(TEST_FIXTURE_DIR, { recursive: true });
-  const dir = mkdtempSync(join(TEST_FIXTURE_DIR, "app-"));
-  createdDirs.push(dir);
-  return dir;
-}
-
-afterAll(() => {
-  for (const d of createdDirs) {
-    try {
-      rmSync(d, { recursive: true, force: true });
-    } catch {}
-  }
-  try {
-    rmSync(TEST_FIXTURE_DIR, { recursive: true, force: true });
-  } catch {}
-});
-
-function write(dir: string, relPath: string, content: string): string {
-  const full = join(dir, relPath);
-  mkdirSync(dirname(full), { recursive: true });
-  writeFileSync(full, content, "utf-8");
-  return full;
-}
-
-function compileApp(appRoot: string): readonly ts.Diagnostic[] {
-  const compilerOptions: ts.CompilerOptions = {
-    target: ts.ScriptTarget.ESNext,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    strict: true,
-    skipLibCheck: true,
-    esModuleInterop: true,
-    noEmit: true,
-    baseUrl: REPO_ROOT,
-    paths: {
-      "@cosmicdrift/kumiko-framework/*": [join(FRAMEWORK_SRC, "*/index.ts")],
-    },
-    types: [],
-  };
-
-  const program = ts.createProgram({
-    rootNames: collectFiles(appRoot),
-    options: compilerOptions,
-  });
-  return ts.getPreEmitDiagnostics(program);
-}
-
-function collectFiles(dir: string): string[] {
-  const out: string[] = [];
-  const fs = require("node:fs");
-  const walk = (d: string) => {
-    let entries: string[];
-    try {
-      entries = fs.readdirSync(d);
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (e.startsWith(".") && e !== ".kumiko") continue;
-      if (e === "node_modules") continue;
-      const full = join(d, e);
-      const stat = fs.statSync(full);
-      if (stat.isDirectory()) walk(full);
-      else if (stat.isFile() && (e.endsWith(".ts") || e.endsWith(".tsx")) && !e.endsWith(".d.ts"))
-        out.push(full);
-    }
-  };
-  walk(join(dir, "src"));
-  walk(join(dir, ".kumiko"));
-  return out;
-}
-
-function writeOrderPlacedSchema(appRoot: string): void {
-  write(
-    appRoot,
-    "src/feature/events.ts",
-    [
-      'import { z } from "zod";',
-      "export const orderPlacedSchema = z.object({",
-      "  orderId: z.string(),",
-      "  customerId: z.string(),",
-      "  amount: z.number(),",
-      "});",
-      "",
-    ].join("\n"),
-  );
-}
-
-describe("strict-mode diagnostics -- the actual contract of the codegen", () => {
-  let appRoot: string;
-  let allDiagnostics: readonly ts.Diagnostic[];
-
-  beforeAll(() => {
-    appRoot = makeAppDir();
-    writeOrderPlacedSchema(appRoot);
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      [
-        'import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";',
-        'import { orderPlacedSchema } from "./events";',
-        "",
-        'export const ordersFeature = defineFeature("orders", (r) => ({',
-        '  placed: r.defineEvent("placed", orderPlacedSchema),',
-        "}));",
-        "",
-      ].join("\n"),
-    );
-    runCodegen({ appRoot });
-
-    write(
-      appRoot,
-      "src/feature/handler-good.ts",
-      [
-        'import { defineWriteHandler } from "../../.kumiko/define";',
-        'import { z } from "zod";',
-        "",
-        "export const placeOrder = defineWriteHandler({",
-        '  name: "orders.placeOrder",',
-        "  schema: z.object({}),",
-        '  access: { roles: ["Admin"] },',
-        "  handler: async (_event, ctx) => {",
-        "    await ctx.appendEvent({",
-        '      aggregateId: "x",',
-        '      aggregateType: "order",',
-        '      type: "orders:event:placed",',
-        '      payload: { orderId: "o1", customerId: "c1", amount: 99 },',
-        "    });",
-        '    return { isSuccess: true as const, data: { id: "o1" } };',
-        "  },",
-        "});",
-        "",
-      ].join("\n"),
-    );
-
-    write(
-      appRoot,
-      "src/feature/handler-unknown-type.ts",
-      [
-        'import { defineWriteHandler } from "../../.kumiko/define";',
-        'import { z } from "zod";',
-        "",
-        "export const placeOrder = defineWriteHandler({",
-        '  name: "orders.placeOrder",',
-        "  schema: z.object({}),",
-        '  access: { roles: ["Admin"] },',
-        "  handler: async (_event, ctx) => {",
-        "    await ctx.appendEvent({",
-        '      aggregateId: "x",',
-        '      aggregateType: "order",',
-        '      type: "totally:made:up",',
-        "      payload: { whatever: 1 },",
-        "    });",
-        '    return { isSuccess: true as const, data: { id: "x" } };',
-        "  },",
-        "});",
-        "",
-      ].join("\n"),
-    );
-
-    write(
-      appRoot,
-      "src/feature/handler-payload-mismatch.ts",
-      [
-        'import { defineWriteHandler } from "../../.kumiko/define";',
-        'import { z } from "zod";',
-        "",
-        "export const placeOrder = defineWriteHandler({",
-        '  name: "orders.placeOrder",',
-        "  schema: z.object({}),",
-        '  access: { roles: ["Admin"] },',
-        "  handler: async (_event, ctx) => {",
-        "    await ctx.appendEvent({",
-        '      aggregateId: "x",',
-        '      aggregateType: "order",',
-        '      type: "orders:event:placed",',
-        '      payload: { orderId: "o1", customerId: "c1", amount: 99, bogus: "extra" },',
-        "    });",
-        '    return { isSuccess: true as const, data: { id: "o1" } };',
-        "  },",
-        "});",
-        "",
-      ].join("\n"),
-    );
-
-    write(
-      appRoot,
-      "src/feature/handler-direct.ts",
-      [
-        'import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";',
-        'import { z } from "zod";',
-        "",
-        "export const placeOrder = defineWriteHandler({",
-        '  name: "orders.placeOrder",',
-        "  schema: z.object({}),",
-        '  access: { roles: ["Admin"] },',
-        "  handler: async (_event, ctx) => {",
-        "    await ctx.appendEvent({",
-        '      aggregateId: "x",',
-        '      aggregateType: "order",',
-        '      type: "orders:event:placed",',
-        '      payload: { orderId: "o1", customerId: "c1", amount: 99 },',
-        "    });",
-        '    return { isSuccess: true as const, data: { id: "o1" } };',
-        "  },",
-        "});",
-        "",
-      ].join("\n"),
-    );
-
-    write(
-      appRoot,
-      "src/feature/handler-byname-good.ts",
-      [
-        'import { defineWriteHandler } from "../../.kumiko/define";',
-        'import { z } from "zod";',
-        'import { ordersFeature } from "./feature";',
-        "",
-        "const { placed } = ordersFeature.exports;",
-        "",
-        "export const placeOrder = defineWriteHandler({",
-        '  name: "orders.placeOrder",',
-        "  schema: z.object({}),",
-        '  access: { roles: ["Admin"] },',
-        "  handler: async (_event, ctx) => {",
-        "    await ctx.appendEvent({",
-        '      aggregateId: "x",',
-        '      aggregateType: "order",',
-        "      type: placed.name,",
-        '      payload: { orderId: "o1", customerId: "c1", amount: 99 },',
-        "    });",
-        '    return { isSuccess: true as const, data: { id: "o1" } };',
-        "  },",
-        "});",
-        "",
-      ].join("\n"),
-    );
-
-    write(
-      appRoot,
-      "src/feature/handler-byname-bad.ts",
-      [
-        'import { defineWriteHandler } from "../../.kumiko/define";',
-        'import { z } from "zod";',
-        'import { ordersFeature } from "./feature";',
-        "",
-        "const { placed } = ordersFeature.exports;",
-        "",
-        "export const placeOrder = defineWriteHandler({",
-        '  name: "orders.placeOrder",',
-        "  schema: z.object({}),",
-        '  access: { roles: ["Admin"] },',
-        "  handler: async (_event, ctx) => {",
-        "    await ctx.appendEvent({",
-        '      aggregateId: "x",',
-        '      aggregateType: "order",',
-        "      type: placed.name,",
-        '      payload: { orderId: "o1", customerId: "c1", amount: 99, bogus: "extra" },',
-        "    });",
-        '    return { isSuccess: true as const, data: { id: "o1" } };',
-        "  },",
-        "});",
-        "",
-      ].join("\n"),
-    );
-
-    allDiagnostics = compileApp(appRoot);
-  }, 120_000);
-
-  test("good ctx.appendEvent compiles cleanly", () => {
-    const handlerErrors = allDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-good.ts"),
-    );
-    expect(handlerErrors).toHaveLength(0);
-  });
-
-  test("unknown event-type triggers TS2322 with augmented map in error message", () => {
-    const handlerErrors = allDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-unknown-type.ts"),
-    );
-    const ts2322 = handlerErrors.filter((d) => d.code === 2322);
-    expect(ts2322.length).toBeGreaterThan(0);
-    const flattened = ts2322
-      .map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n"))
-      .join("\n");
-    expect(flattened).toMatch(/keyof KumikoEventTypeMap|"orders:event:placed"/);
-  });
-
-  test("payload-shape mismatch triggers a property-error", () => {
-    const handlerErrors = allDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-payload-mismatch.ts"),
-    );
-    const propErrors = handlerErrors.filter((d) => d.code === 2353);
-    expect(propErrors.length).toBeGreaterThan(0);
-    const flattened = propErrors
-      .map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n"))
-      .join("\n");
-    expect(flattened).toMatch(/'bogus'/);
-  });
-
-  test("direct framework-import + augmentation-included compiles strict too", () => {
-    const handlerErrors = allDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-direct.ts"),
-    );
-    expect(handlerErrors).toHaveLength(0);
-  });
-
-  test("eventDef.name pattern: literal-typed name resolves to correct payload-shape", () => {
-    const goodErrors = allDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-byname-good.ts"),
-    );
-    if (goodErrors.length > 0) {
-      const msgs = goodErrors
-        .map((d) => `  TS${d.code}: ${ts.flattenDiagnosticMessageText(d.messageText, "\n")}`)
-        .join("\n");
-      throw new Error(`expected handler-byname-good.ts to compile cleanly, got:\n${msgs}`);
-    }
-
-    const badErrors = allDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-byname-bad.ts"),
-    );
-    const propErrors = badErrors.filter((d) => d.code === 2353);
-    expect(propErrors.length).toBeGreaterThan(0);
-    const flattened = propErrors
-      .map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n"))
-      .join("\n");
-    expect(flattened).toMatch(/'bogus'/);
-  });
-});

package/src/codegen/__tests__/watch.test.ts

@@ -1,222 +0,0 @@
-// watchAndRegenerate — file-watcher-Tests. Verifiziert: initial-Pass
-// läuft synchron, file-changes triggern einen erneuten Pass mit Debounce,
-// close() ist idempotent.
-//
-// Fixtures liegen wie bei strict-mode-diagnostics.test.ts unter
-// `__tests__/.tmp-fixtures/` (gitignored), damit Node's natürliches
-// `node_modules`-Hochsuchen 'zod' findet — auch wenn watch-Tests
-// 'zod' nicht direct nutzen, runCodegen scant feature-files die
-// `import { z } from "zod"` haben.
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import type { CodegenResult } from "../run-codegen";
-import { watchAndRegenerate } from "../watch";
-
-const TEST_FIXTURE_DIR = join(__dirname, ".tmp-fixtures");
-const createdDirs: string[] = [];
-
-function makeAppDir(): string {
-  mkdirSync(TEST_FIXTURE_DIR, { recursive: true });
-  const dir = mkdtempSync(join(TEST_FIXTURE_DIR, "watch-"));
-  createdDirs.push(dir);
-  return dir;
-}
-
-function writeFile(dir: string, relPath: string, content: string): string {
-  const full = join(dir, relPath);
-  mkdirSync(dirname(full), { recursive: true });
-  writeFileSync(full, content, "utf-8");
-  return full;
-}
-
-afterAll(() => {
-  for (const d of createdDirs) {
-    try {
-      rmSync(d, { recursive: true, force: true });
-    } catch {
-      /* best-effort */
-    }
-  }
-});
-
-/**
- * Polls a predicate at `interval` ms until it returns true, or rejects
- * after `timeout`. Replaces fixed `setTimeout(...)` waits — those
- * implicitly assume "this many ms is enough", which is brittle on
- * loaded CI runners. The polling form converges as fast as the system
- * allows AND fails loudly with a useful message if the event never lands.
- *
- * `retry`/`retryIntervalMs`: for predicates gated on a native `fs.watch`
- * event, a single write only gets one chance at delivery — under macOS
- * FSEvents backlog (hundreds of concurrent recursive watches in a full
- * `bun test` run), events aren't just delayed, they're sometimes dropped
- * entirely, and Node doesn't surface a rescan signal. `retry` re-fires the
- * triggering action on a cadence so a dropped event costs one interval,
- * not the whole timeout. `retryIntervalMs` must stay well above the
- * watcher's `debounceMs` — a retry that lands mid-debounce just resets
- * the timer and can starve `fire()` forever.
- */
-async function waitFor(
-  predicate: () => boolean,
-  opts: {
-    timeout?: number;
-    interval?: number;
-    label?: string;
-    retry?: () => void;
-    retryIntervalMs?: number;
-  } = {},
-): Promise<void> {
-  const timeout = opts.timeout ?? 5000;
-  const interval = opts.interval ?? 25;
-  const retryIntervalMs = opts.retryIntervalMs ?? 250;
-  const deadline = Date.now() + timeout;
-  let nextRetryAt = Date.now() + retryIntervalMs;
-  // @timeout-exception: #3118 fs.watch can drop the trigger; retry re-fires it, unlike the shared waitFor
-  while (!predicate()) {
-    if (Date.now() > deadline) {
-      throw new Error(`waitFor: ${opts.label ?? "predicate"} not satisfied within ${timeout}ms`);
-    }
-    if (opts.retry && Date.now() >= nextRetryAt) {
-      opts.retry();
-      nextRetryAt = Date.now() + retryIntervalMs;
-    }
-    await new Promise((r) => setTimeout(r, interval));
-  }
-}
-
-const FEATURE_TEMPLATE = (featureName: string, eventName: string) => `
-import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-
-export default defineFeature("${featureName}", (r) => {
-  r.defineEvent("${eventName}", z.object({ id: z.string() }));
-});
-`;
-
-describe("watchAndRegenerate", () => {
-  test("initial run produces output synchronously", () => {
-    const appRoot = makeAppDir();
-    writeFile(appRoot, "src/feature.ts", FEATURE_TEMPLATE("billing", "first-event"));
-
-    const results: CodegenResult[] = [];
-    const handle = watchAndRegenerate({
-      appRoot,
-      onResult: (r) => results.push(r),
-    });
-
-    expect(results).toHaveLength(1);
-    expect(results[0]?.eventCount).toBe(1);
-    handle.close();
-  });
-
-  test("file change triggers a re-run after debounce", async () => {
-    const appRoot = makeAppDir();
-    writeFile(appRoot, "src/feature.ts", FEATURE_TEMPLATE("orders", "first"));
-
-    const results: CodegenResult[] = [];
-    const handle = watchAndRegenerate({
-      appRoot,
-      debounceMs: 30,
-      onResult: (r) => results.push(r),
-    });
-
-    expect(results).toHaveLength(1);
-    expect(results[0]?.eventCount).toBe(1);
-
-    const rewrite = () =>
-      writeFile(
-        appRoot,
-        "src/feature.ts",
-        `
-import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-
-export default defineFeature("orders", (r) => {
-  r.defineEvent("first", z.object({ id: z.string() }));
-  r.defineEvent("second", z.object({ tag: z.string() }));
-});
-`,
-      );
-
-    // Add a second event-definition by rewriting the feature.
-    rewrite();
-
-    // Poll until the watcher's debounced re-run has landed, re-touching
-    // the file every 250ms in case the triggering fs.watch event was
-    // dropped rather than merely delayed (see waitFor's `retry` doc).
-    // Waits on the expected *state* (eventCount 2), not just a length
-    // bump — writeFileSync truncates then writes, so an event fired
-    // mid-write would satisfy a length-only predicate with a stale
-    // (0 or 1) eventCount, especially with retries widening that window.
-    try {
-      await waitFor(() => results.some((r) => r.eventCount === 2), {
-        timeout: 12000,
-        label: "second codegen result",
-        retry: rewrite,
-      });
-      expect(results.at(-1)?.eventCount).toBe(2);
-    } finally {
-      handle.close();
-    }
-  }, 15000);
-
-  test("close() is idempotent", () => {
-    const appRoot = makeAppDir();
-    writeFile(appRoot, "src/feature.ts", FEATURE_TEMPLATE("nope", "evt"));
-    const handle = watchAndRegenerate({ appRoot, onResult: () => {} });
-    handle.close();
-    expect(() => handle.close()).not.toThrow();
-  });
-
-  test("non-ts file changes do not trigger codegen", async () => {
-    // Negative-assertion shape: prove that .css/.md changes do NOT add
-    // a codegen result. Naïve "sleep N ms then assert length stayed"
-    // is racy on macOS, where fs.watch can deliver stale events from
-    // pre-watcher writes after the watcher is attached. We sidestep
-    // that by anchoring on a POSITIVE control: a known-triggering .ts
-    // change at the end. waitFor proves the watcher is alive — so the
-    // pre-trigger count is trustworthy.
-    const appRoot = makeAppDir();
-    writeFile(appRoot, "src/feature.ts", FEATURE_TEMPLATE("ignore-css", "evt"));
-
-    const results: CodegenResult[] = [];
-    const handle = watchAndRegenerate({
-      appRoot,
-      debounceMs: 30,
-      onResult: (r) => results.push(r),
-    });
-    expect(results).toHaveLength(1);
-
-    // Drain any stale events from the pre-watcher feature.ts write —
-    // some platforms deliver these to a watcher attached after the
-    // write. Long enough to outlast debounce + scheduler jitter.
-    await new Promise((r) => setTimeout(r, 200));
-    const baseline = results.length;
-
-    // Non-ts writes — the regression we want to catch.
-    writeFile(appRoot, "src/styles.css", `body { color: red; }`);
-    writeFile(appRoot, "src/README.md", `# hi`);
-    await new Promise((r) => setTimeout(r, 200));
-    const afterNonTs = results.length;
-
-    // Positive control: a .ts change MUST trigger. waitFor exits as
-    // soon as the new result lands, confirming the watcher is alive.
-    // Re-touched on retry in case the triggering event is dropped
-    // rather than merely delayed under a loaded fs.watch backlog.
-    const triggerRewrite = () =>
-      writeFile(appRoot, "src/feature.ts", FEATURE_TEMPLATE("ignore-css", "after"));
-    triggerRewrite();
-    await waitFor(() => results.length > afterNonTs, {
-      timeout: 12000,
-      label: "ts-change result after non-ts noise",
-      retry: triggerRewrite,
-    });
-
-    // The non-ts writes should not have advanced the count past the
-    // baseline. If they did, the watcher's filter is broken.
-    expect(afterNonTs).toBe(baseline);
-    handle.close();
-  }, 15000);
-});

package/src/codegen/index.ts

@@ -1,19 +0,0 @@
-export {
-  renderDefineFile,
-  renderInlineSchemasFile,
-  renderTypesAugmentation,
-  renderWriteHandlerTypes,
-} from "./render";
-export { type CodegenOptions, type CodegenResult, runCodegen } from "./run-codegen";
-export {
-  formatScanWarning,
-  qualifiedNameToConstName,
-  rewriteImportPath,
-  type ScannedEvent,
-  type ScanOptions,
-  type ScanResult,
-  type ScanWarning,
-  type SchemaSource,
-  scanEvents,
-} from "./scan-events";
-export { type WatchHandle, type WatchOptions, watchAndRegenerate } from "./watch";