@cosmicdrift/kumiko-dev-server 0.15.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.15.0",
+  "version": "0.16.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>",

package/src/__tests__/discover-format.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { formatBuildResult } from "../build-prod-bundle";
+import { discoverServerEntry } from "../build-server-bundle";
+
+describe("discoverServerEntry", () => {
+  test("finds bin/main.ts when present", () => {
+    const dir = mkdtempSync(join(tmpdir(), "kumiko-discover-"));
+    mkdirSync(join(dir, "bin"));
+    writeFileSync(join(dir, "bin/main.ts"), "export {};\n", "utf8");
+    expect(discoverServerEntry(dir)).toBe(join(dir, "bin/main.ts"));
+  });
+
+  test("returns undefined when no entry exists", () => {
+    const dir = mkdtempSync(join(tmpdir(), "kumiko-discover-empty-"));
+    expect(discoverServerEntry(dir)).toBeUndefined();
+  });
+});
+
+describe("formatBuildResult", () => {
+  test("includes outDir and manifest entries", () => {
+    const out = formatBuildResult(
+      { outDir: "dist/client", manifest: { "app.js": "app.abc123.js" } },
+      42,
+    );
+    expect(out).toContain("dist/client");
+    expect(out).toContain("app.js");
+    expect(out).toContain("42ms");
+  });
+});

package/src/codegen/__tests__/render-codegen.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { renderDefineFile, renderInlineSchemasFile, renderTypesAugmentation } from "../render";
+import type { ScannedEvent } from "../scan-events";
+
+describe("renderTypesAugmentation", () => {
+  test("emits empty augmentation when no events", () => {
+    const out = renderTypesAugmentation([], "/tmp/app/.kumiko");
+    expect(out).toContain("interface KumikoEventTypeMap");
+    expect(out).toContain("no r.defineEvent calls discovered yet");
+  });
+});
+
+describe("renderInlineSchemasFile", () => {
+  test("returns undefined when no inline schemas", () => {
+    expect(renderInlineSchemasFile([], "/tmp/app")).toBeUndefined();
+  });
+
+  test("uses app-root-relative paths in source comments", () => {
+    const appRoot = mkdtempSync(join(tmpdir(), "kumiko-codegen-"));
+    const featurePath = join(appRoot, "src", "feature.ts");
+    mkdirSync(join(appRoot, "src"), { recursive: true });
+    writeFileSync(featurePath, "// stub", "utf-8");
+    const events: ScannedEvent[] = [
+      {
+        qualifiedName: "inventory:event:product-archived",
+        schemaSource: {
+          kind: "inline",
+          schemaSource: "z.object({ reason: z.string() })",
+          generatedConstName: "_kg_inventory__productArchived",
+        },
+        featureFilePath: featurePath,
+        source: { file: featurePath, line: 92 },
+      },
+    ];
+    const out = renderInlineSchemasFile(events, appRoot);
+    expect(out).toContain("// inventory:event:product-archived — from src/feature.ts:92");
+    expect(out).not.toContain(appRoot);
+  });
+});
+
+describe("renderDefineFile", () => {
+  test("emits defineWriteHandler wrapper with type reference", () => {
+    const out = renderDefineFile();
+    expect(out).toContain("defineWriteHandler");
+    expect(out).toContain("types.generated.d.ts");
+  });
+});

package/src/codegen/render.ts

@@ -22,6 +22,7 @@
 // actual change, so mtime doesn't tick and the TS language server
 // doesn't reload every 100ms.
 
+import { relative } from "node:path";
 import type { ScannedEvent } from "./scan-events";
 import { rewriteImportPath } from "./scan-events";
 
@@ -115,7 +116,10 @@ export function renderTypesAugmentation(
  * the schema. Returns undefined when no inline-schemas exist (so the
  * runner can skip writing the file entirely).
  */
-export function renderInlineSchemasFile(events: readonly ScannedEvent[]): string | undefined {
+export function renderInlineSchemasFile(
+  events: readonly ScannedEvent[],
+  appRootAbs: string,
+): string | undefined {
   const inlines = events.filter((ev) => ev.schemaSource.kind === "inline");
   if (inlines.length === 0) return undefined;
 
@@ -139,8 +143,9 @@ export function renderInlineSchemasFile(events: readonly ScannedEvent[]): string
   });
   for (const ev of sorted) {
     if (ev.schemaSource.kind !== "inline") continue;
+    const sourcePath = relative(appRootAbs, ev.featureFilePath).split("\\").join("/");
     lines.push(
-      `// ${ev.qualifiedName} — from ${ev.featureFilePath}:${ev.source.line}`,
+      `// ${ev.qualifiedName} — from ${sourcePath}:${ev.source.line}`,
       `export const ${ev.schemaSource.generatedConstName} = ${ev.schemaSource.schemaSource};`,
       "",
     );

package/src/codegen/run-codegen.ts

@@ -68,7 +68,7 @@ export function runCodegen(opts: CodegenOptions): CodegenResult {
 
   const typesContent = renderTypesAugmentation(scan.events, outputDir);
   const defineContent = renderDefineFile();
-  const schemasContent = renderInlineSchemasFile(scan.events);
+  const schemasContent = renderInlineSchemasFile(scan.events, opts.appRoot);
   // package.json — turns `.kumiko/` into a real installable package
   // named `@app/define`. Apps that declare
   //   "@app/define": "link:./.kumiko"

package/src/codegen/scan-events.ts

@@ -41,6 +41,7 @@
 
 import { readdirSync, statSync } from "node:fs";
 import { join, relative, resolve, sep } from "node:path";
+import { toKebab } from "@cosmicdrift/kumiko-framework/engine";
 import {
   type CallExpression,
   type ImportDeclaration,
@@ -51,27 +52,6 @@ import {
   SyntaxKind,
 } from "ts-morph";
 
-/**
- * Replicates `packages/framework/src/engine/qualified-name.ts:toKebab`.
- * Frame's r.defineEvent runs the feature-name + event-name through this
- * helper before joining them — `defineFeature("driverOrders")` writes
- * events under `driver-orders:event:...`. We MUST mirror the same
- * transform here, otherwise the augmentation key drifts from the
- * runtime event-type and strict-mode would catch a phantom mismatch.
- *
- * Inlined (instead of imported from framework) to keep the codegen
- * package boundary clean — codegen doesn't depend on the runtime
- * framework, only the framework-source-tree via paths-mapping at the
- * caller's compile.
- */
-function toKebab(input: string): string {
-  return input
-    .replace(/\./g, "-")
-    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
-    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-    .toLowerCase();
-}
-
 export type ScannedEvent = {
   /** Qualified event-name as it appears in the events table:
    *  `<feature>:event:<inner>`. The KumikoEventTypeMap key. */