@cosmicdrift/kumiko-dev-server 0.1.0

package/src/__tests__/build-prod-bundle.test.ts

@@ -0,0 +1,262 @@
+// Unit-Tests für die Pure-Logic-Helpers von build-prod-bundle.
+//
+// Bun.build und Tailwind-CLI brauchen einen Bun-Runtime, deshalb
+// werden die hier nicht aufgerufen — nur Discovery + HTML-Injection
+// die unter Node funktionieren. End-to-End-Tests (mit echtem Bun.build)
+// laufen im CI als `yarn build` auf der Showcase-App; das ist der
+// ehrlichere Smoke-Test.
+
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import {
+  type ClientEntry,
+  discoverClientEntries,
+  discoverClientEntry,
+  discoverHtmlTemplate,
+  injectAssetTags,
+} from "../build-prod-bundle";
+
+// Synthetic single-entry helper. Realer Build erzeugt das via
+// discoverClientEntries; hier reicht die Form für injectAssetTags-Tests.
+function clientEntry(): ClientEntry {
+  return {
+    name: "client",
+    sourceFile: "src/client.tsx",
+    manifestKey: "client.js",
+    htmlPath: "index.html",
+  };
+}
+
+function namedEntry(name: string): ClientEntry {
+  return {
+    name,
+    sourceFile: `src/client-${name}.tsx`,
+    manifestKey: `client-${name}.js`,
+    htmlPath: name === "public" ? "index.html" : `${name}.html`,
+  };
+}
+
+describe("build-prod-bundle/discovery", () => {
+  let workDir = "";
+
+  beforeEach(async () => {
+    workDir = await mkdtemp(join(tmpdir(), "kumiko-build-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(workDir, { recursive: true, force: true });
+  });
+
+  test("discoverClientEntry findet src/client.tsx wenn vorhanden", async () => {
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await writeFile(join(workDir, "src/client.tsx"), "// noop");
+
+    const entry = discoverClientEntry(workDir);
+
+    expect(entry).toBe(join(workDir, "src/client.tsx"));
+  });
+
+  test("discoverClientEntry findet src/client.ts als Fallback", async () => {
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await writeFile(join(workDir, "src/client.ts"), "// noop");
+
+    const entry = discoverClientEntry(workDir);
+
+    expect(entry).toBe(join(workDir, "src/client.ts"));
+  });
+
+  test("discoverClientEntry bevorzugt .tsx über .ts wenn beide existieren", async () => {
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await writeFile(join(workDir, "src/client.tsx"), "// jsx");
+    await writeFile(join(workDir, "src/client.ts"), "// ts");
+
+    const entry = discoverClientEntry(workDir);
+
+    expect(entry).toBe(join(workDir, "src/client.tsx"));
+  });
+
+  test("discoverClientEntry gibt undefined zurück wenn nichts da ist", () => {
+    expect(discoverClientEntry(workDir)).toBeUndefined();
+  });
+
+  test("discoverClientEntries findet single-mode src/client.tsx", async () => {
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await writeFile(join(workDir, "src/client.tsx"), "// single");
+
+    const entries = discoverClientEntries(workDir);
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.name).toBe("client");
+    expect(entries[0]?.manifestKey).toBe("client.js");
+    expect(entries[0]?.htmlPath).toBe("index.html");
+  });
+
+  test("discoverClientEntries findet multi-mode client-public + client-admin", async () => {
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await writeFile(join(workDir, "src/client-public.tsx"), "// public");
+    await writeFile(join(workDir, "src/client-admin.tsx"), "// admin");
+
+    const entries = discoverClientEntries(workDir);
+
+    // Sortiert nach name.
+    expect(entries.map((e) => e.name)).toEqual(["admin", "public"]);
+
+    const admin = entries.find((e) => e.name === "admin");
+    expect(admin?.manifestKey).toBe("client-admin.js");
+    expect(admin?.htmlPath).toBe("admin.html");
+
+    const pub = entries.find((e) => e.name === "public");
+    expect(pub?.manifestKey).toBe("client-public.js");
+    // "public" mappt auf das Default-Template (index.html), nicht
+    // public.html — das ist Convention damit das default-served-Template
+    // den vom-User-erwarteten Namen behält.
+    expect(pub?.htmlPath).toBe("index.html");
+  });
+
+  test("discoverClientEntries multi-mode dominiert über single-mode wenn beide da", async () => {
+    await mkdir(join(workDir, "src"), { recursive: true });
+    await writeFile(join(workDir, "src/client.tsx"), "// single");
+    await writeFile(join(workDir, "src/client-admin.tsx"), "// admin");
+
+    const entries = discoverClientEntries(workDir);
+
+    // Multi-mode aktiv → "client" wird ignoriert.
+    expect(entries.map((e) => e.name)).toEqual(["admin"]);
+  });
+
+  test("discoverClientEntries gibt leeres Array zurück wenn nichts da", () => {
+    expect(discoverClientEntries(workDir)).toEqual([]);
+  });
+
+  test("discoverHtmlTemplate findet index.html im cwd", async () => {
+    await writeFile(join(workDir, "index.html"), "<html></html>");
+
+    expect(discoverHtmlTemplate(workDir)).toBe(join(workDir, "index.html"));
+  });
+
+  test("discoverHtmlTemplate findet public/index.html als Fallback", async () => {
+    await mkdir(join(workDir, "public"), { recursive: true });
+    await writeFile(join(workDir, "public/index.html"), "<html></html>");
+
+    expect(discoverHtmlTemplate(workDir)).toBe(join(workDir, "public/index.html"));
+  });
+
+  test("discoverHtmlTemplate bevorzugt cwd-index.html über public/index.html", async () => {
+    await mkdir(join(workDir, "public"), { recursive: true });
+    await writeFile(join(workDir, "index.html"), "<!-- root -->");
+    await writeFile(join(workDir, "public/index.html"), "<!-- public -->");
+
+    expect(discoverHtmlTemplate(workDir)).toBe(join(workDir, "index.html"));
+  });
+
+  test("discoverHtmlTemplate gibt undefined zurück wenn nichts da ist", () => {
+    expect(existsSync(workDir)).toBe(true);
+    expect(discoverHtmlTemplate(workDir)).toBeUndefined();
+  });
+});
+
+describe("build-prod-bundle/injectAssetTags", () => {
+  test("ersetzt /client.js durch hashed URL im script-tag", () => {
+    const html = `<html><body><script type="module" src="/client.js"></script></body></html>`;
+    const result = injectAssetTags(
+      html,
+      { "client.js": "/assets/client-abc123.js" },
+      clientEntry(),
+    );
+
+    expect(result).toContain('src="/assets/client-abc123.js"');
+    expect(result).not.toContain('src="/client.js"');
+  });
+
+  test("ersetzt /styles.css durch hashed URL im link-tag", () => {
+    const html = `<html><head><link rel="stylesheet" href="/styles.css" /></head><body></body></html>`;
+    const result = injectAssetTags(
+      html,
+      { "styles.css": "/assets/styles-def456.css" },
+      clientEntry(),
+    );
+
+    expect(result).toContain('href="/assets/styles-def456.css"');
+    expect(result).not.toContain('href="/styles.css"');
+  });
+
+  test("wirft mit Anweisung wenn /client.js Placeholder fehlt", () => {
+    const html = `<html><body><div id="root"></div></body></html>`;
+
+    expect(() =>
+      injectAssetTags(html, { "client.js": "/assets/client-abc.js" }, clientEntry()),
+    ).toThrow(/keinen Entry-Tag für \/client\.js/);
+    expect(() =>
+      injectAssetTags(html, { "client.js": "/assets/client-abc.js" }, clientEntry()),
+    ).toThrow(/<script type="module" src="\/client\.js"><\/script>/);
+  });
+
+  test("wirft mit Anweisung wenn /styles.css Placeholder fehlt", () => {
+    const html = `<html><head><title>App</title></head><body></body></html>`;
+
+    expect(() =>
+      injectAssetTags(html, { "styles.css": "/assets/styles-xyz.css" }, clientEntry()),
+    ).toThrow(/keinen Entry-Tag für \/styles\.css/);
+    expect(() =>
+      injectAssetTags(html, { "styles.css": "/assets/styles-xyz.css" }, clientEntry()),
+    ).toThrow(/<link rel="stylesheet" href="\/styles\.css" \/>/);
+  });
+
+  test("ist idempotent — zweite Injection auf bereits ersetztem HTML ändert nichts", () => {
+    const html = `<html><body><script type="module" src="/client.js"></script></body></html>`;
+    const manifest = { "client.js": "/assets/client-abc.js" };
+    const first = injectAssetTags(html, manifest, clientEntry());
+    const second = injectAssetTags(first, manifest, clientEntry());
+
+    expect(first).toBe(second);
+    expect(first).toContain('src="/assets/client-abc.js"');
+  });
+
+  test("ändert template ohne client/styles im manifest nicht", () => {
+    const html = `<html><body>Hello</body></html>`;
+    const result = injectAssetTags(html, {}, clientEntry());
+
+    expect(result).toBe(html);
+  });
+
+  test("verträgt mehrere script-tags und ersetzt nur den /client.js", () => {
+    const html = `<html><body>
+      <script>console.log("inline");</script>
+      <script type="module" src="/client.js"></script>
+    </body></html>`;
+    const result = injectAssetTags(html, { "client.js": "/assets/client-x.js" }, clientEntry());
+
+    expect(result).toContain('console.log("inline")');
+    expect(result).toContain('src="/assets/client-x.js"');
+    expect(result).not.toContain('src="/client.js"');
+  });
+
+  test("multi-mode: admin-entry ersetzt nur /client-admin.js, lässt /client-public.js liegen", () => {
+    const html = `<html><body>
+      <script type="module" src="/client-admin.js"></script>
+      <script type="module" src="/client-public.js"></script>
+    </body></html>`;
+    const manifest = {
+      "client-admin.js": "/assets/client-admin-aaa.js",
+      "client-public.js": "/assets/client-public-bbb.js",
+    };
+    const result = injectAssetTags(html, manifest, namedEntry("admin"));
+
+    expect(result).toContain('src="/assets/client-admin-aaa.js"');
+    // public-bundle bleibt unangetastet — admin.html lädt nur sein eigenes Bundle.
+    expect(result).toContain('src="/client-public.js"');
+    expect(result).not.toContain('src="/client-admin.js"');
+  });
+
+  test("multi-mode: error-message nennt den richtigen Template-Namen", () => {
+    const html = `<html><body>no admin script</body></html>`;
+    const manifest = { "client-admin.js": "/assets/client-admin-x.js" };
+
+    expect(() => injectAssetTags(html, manifest, namedEntry("admin"))).toThrow(
+      /admin\.html hat keinen Entry-Tag für \/client-admin\.js/,
+    );
+  });
+});

package/src/__tests__/cache-headers.test.ts

@@ -0,0 +1,70 @@
+// Unit-Tests für cacheHeadersFor — die Cache-Strategie hinter
+// runProdApp's static-fallback. Pure function, leicht zu testen.
+//
+// Strategie (siehe run-prod-app.ts):
+//   /assets/*               → max-age=31536000, immutable
+//   /, /index.html          → no-cache, must-revalidate
+//   /manifest.json, /sw.js  → no-cache
+//   alles andere            → kein expliziter Header
+
+import { describe, expect, test } from "vitest";
+import { cacheHeadersFor } from "../run-prod-app";
+
+describe("cacheHeadersFor", () => {
+  test("hashed asset → immutable + 1 Jahr", () => {
+    expect(cacheHeadersFor("/assets/client-abc123.js")).toEqual({
+      "cache-control": "public, max-age=31536000, immutable",
+    });
+  });
+
+  test("hashed CSS asset → immutable + 1 Jahr", () => {
+    expect(cacheHeadersFor("/assets/styles-def456.css")).toEqual({
+      "cache-control": "public, max-age=31536000, immutable",
+    });
+  });
+
+  test("nested asset path → immutable", () => {
+    expect(cacheHeadersFor("/assets/chunks/foo-789.js")).toEqual({
+      "cache-control": "public, max-age=31536000, immutable",
+    });
+  });
+
+  test("/ → no-cache, must-revalidate", () => {
+    expect(cacheHeadersFor("/")).toEqual({
+      "cache-control": "no-cache, must-revalidate",
+    });
+  });
+
+  test("/index.html → no-cache, must-revalidate", () => {
+    expect(cacheHeadersFor("/index.html")).toEqual({
+      "cache-control": "no-cache, must-revalidate",
+    });
+  });
+
+  test("/manifest.json → no-cache", () => {
+    expect(cacheHeadersFor("/manifest.json")).toEqual({
+      "cache-control": "no-cache",
+    });
+  });
+
+  test("/sw.js → no-cache", () => {
+    expect(cacheHeadersFor("/sw.js")).toEqual({
+      "cache-control": "no-cache",
+    });
+  });
+
+  test("public-folder file (favicon) → kein expliziter Header", () => {
+    expect(cacheHeadersFor("/favicon.ico")).toEqual({});
+  });
+
+  test("public-folder file (og-image) → kein expliziter Header", () => {
+    expect(cacheHeadersFor("/og-image.png")).toEqual({});
+  });
+
+  test("path mit assets als Substring (kein /assets/ prefix) → kein immutable", () => {
+    // Schutz: /myassets/foo.js soll NICHT immutable kriegen — wäre ein Bug
+    // weil die nicht gehashed sind.
+    expect(cacheHeadersFor("/myassets/foo.js")).toEqual({});
+    expect(cacheHeadersFor("/foo/assets/bar.js")).toEqual({});
+  });
+});

package/src/__tests__/classify-change.test.ts

@@ -0,0 +1,87 @@
+// Heuristik für die Watcher-Loop: server-side Änderungen brauchen
+// Process-Restart (Bun cached Module-Imports), Client-Side reicht
+// Hot-Reload, Tests/non-TS sollen den Watcher gar nicht triggern.
+// Wenn die Klassifikation drift bekommt, kommen entweder unnötige
+// Restarts (DX schlecht) oder echte Schema-Änderungen schlagen
+// nicht durch (UX broken). Beide sind teuer — daher pinnen wir.
+
+import { describe, expect, test } from "vitest";
+import { classifyChange } from "../create-kumiko-server";
+
+describe("classifyChange", () => {
+  test("server-side feature.ts → restart", () => {
+    expect(classifyChange("/abs/samples/foo/src/features/items/feature.ts")).toBe("restart");
+  });
+
+  test("server-side schema-Datei → restart", () => {
+    expect(classifyChange("/abs/samples/foo/src/features/items/schema/item.ts")).toBe("restart");
+  });
+
+  test("server-side bin/server.ts → restart", () => {
+    expect(classifyChange("/abs/samples/foo/bin/server.ts")).toBe("restart");
+  });
+
+  test("client-side web/index.ts → hot-reload", () => {
+    expect(classifyChange("/abs/samples/foo/src/features/items/web/index.ts")).toBe("hot-reload");
+  });
+
+  test("client-side web/page.tsx → hot-reload", () => {
+    expect(classifyChange("/abs/samples/foo/src/features/items/web/page.tsx")).toBe("hot-reload");
+  });
+
+  test("client.tsx Entry → hot-reload", () => {
+    expect(classifyChange("/abs/samples/foo/src/app/client.tsx")).toBe("hot-reload");
+  });
+
+  test("client.ts Entry → hot-reload", () => {
+    expect(classifyChange("/abs/samples/foo/src/app/client.ts")).toBe("hot-reload");
+  });
+
+  test("Test-Datei *.test.ts → ignore", () => {
+    expect(classifyChange("/abs/samples/foo/src/feature.test.ts")).toBe("ignore");
+  });
+
+  test("Test-Datei *.test.tsx → ignore", () => {
+    expect(classifyChange("/abs/samples/foo/src/component.test.tsx")).toBe("ignore");
+  });
+
+  test("__tests__/ Subdir → ignore (auch wenn die Datei selbst nicht *.test.ts heißt)", () => {
+    expect(classifyChange("/abs/samples/foo/src/__tests__/test-utils.ts")).toBe("ignore");
+  });
+
+  test("Integration-Test → ignore (würde sonst Schema-Restart auslösen)", () => {
+    expect(classifyChange("/abs/samples/foo/src/feature.integration.ts")).toBe("ignore");
+  });
+
+  test("E2E-Test → ignore", () => {
+    expect(classifyChange("/abs/samples/foo/src/something.e2e.ts")).toBe("ignore");
+  });
+
+  test("CSS/JSON/sonstiges → ignore", () => {
+    expect(classifyChange("/abs/samples/foo/src/styles.css")).toBe("ignore");
+    expect(classifyChange("/abs/samples/foo/src/data.json")).toBe("ignore");
+    expect(classifyChange("/abs/samples/foo/public/index.html")).toBe("ignore");
+  });
+
+  test("Windows-Pfad-Trenner: web\\ → hot-reload", () => {
+    expect(classifyChange("C:\\abs\\samples\\foo\\src\\features\\items\\web\\page.tsx")).toBe(
+      "hot-reload",
+    );
+  });
+
+  // Sample-Conventions: publicstatus splittet `/admin/` (Admin-Bundle)
+  // und `/public/` (Public-Bundle). Beide sind client-side, müssen
+  // hot-reload sein — sonst kostet jeder Bridge-Edit einen Restart +
+  // DB-Reset. Andere Samples machen das eventuell auch so.
+  test("admin/-Subdir → hot-reload", () => {
+    expect(classifyChange("/abs/samples/foo/src/admin/branding-settings.tsx")).toBe("hot-reload");
+  });
+
+  test("public/-Subdir → hot-reload", () => {
+    expect(classifyChange("/abs/samples/foo/src/public/StatusPage.tsx")).toBe("hot-reload");
+  });
+
+  test("client/-Subdir → hot-reload", () => {
+    expect(classifyChange("/abs/samples/foo/src/client/widgets.tsx")).toBe("hot-reload");
+  });
+});