@cosmicdrift/kumiko-server-runtime 0.328.1 → 0.330.0

package/src/__tests__/run-prod-app-spec.test.ts

@@ -1,167 +0,0 @@
-// Spec-Tests für die Bun.serve-Options + Heartbeat-Cadence. Diese
-// Konstanten/Defaults haben Live-Bugs verursacht und sind 1-Zeile-
-// revertierbar — die Tests pinsen Intent + akzeptablen Range gegen
-// "looks like a leak"-Reverts oder "bisschen rauf, sollte reichen"-
-// Tweaks.
-
-import { describe, expect, test } from "bun:test";
-import {
-  type KumikoServeEnv,
-  type KumikoWebSocketData,
-  SSE_HEARTBEAT_INTERVAL_MS,
-  WEBSOCKET_BACKPRESSURE_LIMIT_BYTES,
-  WEBSOCKET_HEARTBEAT_INTERVAL_MS,
-  WEBSOCKET_MAX_PAYLOAD_BYTES,
-} from "@cosmicdrift/kumiko-framework/api";
-import {
-  createEntity,
-  createFileField,
-  createRegistry,
-  defineFeature,
-} from "@cosmicdrift/kumiko-framework/engine";
-import { createFilesFeature, resolveMaxUploadBodyBytes } from "@cosmicdrift/kumiko-framework/files";
-import {
-  DEFAULT_MAX_REQUEST_BODY_SIZE_BYTES,
-  resolveDerivedMaxRequestBodySize,
-} from "../bun-serve-options";
-import { buildBunServeOptions } from "../run-prod-app";
-
-describe("Bun.serve options for production", () => {
-  test("idleTimeout is 0 (disabled) — required for SSE long-lived connections", () => {
-    // Bun.serve default ist 10s — ohne Override killt das SSE-Streams
-    // mit halbem HTTP/2-RST_STREAM. Spec ist "disabled"; jeder andere
-    // Wert (auch ein vermeintlich "großzügiges" 60) bricht SSE sobald
-    // ein Client den Tab im Hintergrund hat (kein Heartbeat-Read auf
-    // Browser-Seite, Idle-Timer feuert).
-    const opts = buildBunServeOptions(0, () => new Response("ok"));
-    expect(opts.idleTimeout).toBe(0);
-  });
-
-  test("websocket payload cap is 1 MiB and the ping cadence stays under nginx's 60 s", () => {
-    // ingress-nginx's default proxy-read-timeout is 60 s: a quiet socket needs a server ping below it.
-    const opts = buildBunServeOptions(0, () => new Response("ok"));
-    expect(opts.websocket.maxPayloadLength).toBe(1024 * 1024);
-    expect(WEBSOCKET_MAX_PAYLOAD_BYTES).toBe(1024 * 1024);
-    expect(WEBSOCKET_HEARTBEAT_INTERVAL_MS).toBeLessThan(60_000);
-  });
-
-  test("a stalled reader is cut off: 4 MiB backpressure limit, close on limit", () => {
-    const opts = buildBunServeOptions(0, () => new Response("ok"));
-    expect(opts.websocket.backpressureLimit).toBe(4 * 1024 * 1024);
-    expect(WEBSOCKET_BACKPRESSURE_LIMIT_BYTES).toBe(4 * 1024 * 1024);
-    expect(opts.websocket.closeOnBackpressureLimit).toBe(true);
-  });
-
-  test("upgrade requests go to webSocketUpgradeFetch with the server handle, others to fetchHandler", async () => {
-    const plain: string[] = [];
-    const upgraded: KumikoServeEnv[] = [];
-    const opts = buildBunServeOptions(
-      0,
-      (_req, socketAddress) => {
-        plain.push(socketAddress ?? "none");
-        return new Response("plain");
-      },
-      undefined,
-      {
-        upgradeFetch: (_req, serveEnv) => {
-          upgraded.push(serveEnv);
-          return new Response("upgrade");
-        },
-      },
-    );
-    const fakeServer = { requestIP: () => ({ address: "203.0.113.9", port: 1, family: "IPv4" }) };
-    const server = fakeServer as unknown as Bun.Server<KumikoWebSocketData>;
-    await opts.fetch(new Request("http://localhost/api/x"), server);
-    await opts.fetch(
-      new Request("http://localhost/api/ws/x", { headers: { Upgrade: "WebSocket" } }),
-      server,
-    );
-    // An upgrade outside /api/ws/ (dev HMR etc.) stays on the normal fetch path.
-    await opts.fetch(
-      new Request("http://localhost/__hmr", { headers: { Upgrade: "websocket" } }),
-      server,
-    );
-    expect(plain).toEqual(["203.0.113.9", "203.0.113.9"]);
-    expect(upgraded).toHaveLength(1);
-    expect(upgraded[0]?.socketAddress).toBe("203.0.113.9");
-    expect(upgraded[0]?.server).toBe(server);
-  });
-
-  test("port wird 1:1 durchgereicht, fetch reicht req + Socket-Adresse an den Handler weiter", async () => {
-    let received: [Request, string | undefined] | undefined;
-    const fetchHandler = (req: Request, socketAddress?: string) => {
-      received = [req, socketAddress];
-      return new Response("test");
-    };
-    const opts = buildBunServeOptions(3000, fetchHandler);
-    expect(opts.port).toBe(3000);
-    const req = new Request("http://localhost/");
-    const fakeServer = { requestIP: () => ({ address: "203.0.113.1", port: 1, family: "IPv4" }) };
-    await opts.fetch(req, fakeServer as unknown as Bun.Server<unknown>);
-    expect(received?.[0]).toBe(req);
-    expect(received?.[1]).toBe("203.0.113.1");
-  });
-
-  test("maxRequestBodySize defaults well below Bun's own 128 MiB", () => {
-    // Bun.serve's undocumented-in-our-code default (128 MiB) buffers every
-    // concurrent request up to that size before any app-level body-limit
-    // middleware runs. Pins the lowered default against a silent revert to
-    // "just let Bun handle it".
-    const opts = buildBunServeOptions(0, () => new Response("ok"));
-    expect(opts.maxRequestBodySize).toBe(DEFAULT_MAX_REQUEST_BODY_SIZE_BYTES);
-    expect(opts.maxRequestBodySize).toBeLessThan(128 * 1024 * 1024);
-  });
-
-  test("maxRequestBodySize is overridable for apps with larger maxUploadSize", () => {
-    const opts = buildBunServeOptions(0, () => new Response("ok"), 64 * 1024 * 1024);
-    expect(opts.maxRequestBodySize).toBe(64 * 1024 * 1024);
-  });
-});
-
-describe("resolveDerivedMaxRequestBodySize", () => {
-  test("stays above the files route's own derived bodyLimit", () => {
-    // Otherwise Bun's bare rejection would fire before the route's own,
-    // more specific 413 ever runs.
-    const registry = createRegistry([createFilesFeature({ maxUploadSize: "50mb" })]);
-    const routeBodyLimit = resolveMaxUploadBodyBytes({ registry, maxUploadSize: "50mb" });
-    expect(resolveDerivedMaxRequestBodySize(registry)).toBeGreaterThan(routeBodyLimit);
-  });
-
-  test("accounts for a field maxSize configured above the global default", () => {
-    const entity = createEntity({
-      fields: { attachment: createFileField({ maxSize: "50mb" }) },
-    });
-    const feature = defineFeature("attachments", (r) => r.entity("attachment", entity));
-    const registry = createRegistry([feature, createFilesFeature()]);
-    expect(resolveDerivedMaxRequestBodySize(registry)).toBeGreaterThanOrEqual(50 * 1024 * 1024);
-  });
-});
-
-describe("SSE heartbeat cadence", () => {
-  test("liegt unter dem strengsten Edge-Idle-Timeout (Cloudflare 100s)", () => {
-    // Bun.serve idleTimeout ist disabled (siehe buildBunServeOptions),
-    // damit fällt der Bun-default-10s-Layer raus. Die strengsten
-    // verbleibenden Layer sind CDN/LB-Edges:
-    //   - Cloudflare Edge: 100 s   ← strengster realistischer Layer
-    //   - AWS ALB: 60 s
-    //   - Nginx default: keep-alive 60 s, aber nicht für Streams
-    // Heartbeat muss DEUTLICH darunter liegen damit auch ein verschluckter
-    // Frame nicht zur Connection-Death führt — Faktor 5 ist konservativ.
-    expect(SSE_HEARTBEAT_INTERVAL_MS).toBeLessThan(60_000);
-  });
-
-  test("liegt nicht zu hoch — DefenseInDepth gegen Bun-Default-Drift", () => {
-    // Wenn jemand idleTimeout: 0 wieder rausnimmt (Audit, Linter,
-    // Misverständnis), darf der Heartbeat nicht der einzige
-    // Schutzwall sein der unter dem 10s-Bun-default liegt. ≤30s
-    // gibt Cushion + bleibt deutlich unter Bun-default-10s × 3.
-    expect(SSE_HEARTBEAT_INTERVAL_MS).toBeLessThanOrEqual(30_000);
-  });
-
-  test("ist >= 5 s — Frequency-Wall gegen versehentliches Network-Spam", () => {
-    // 1000 anonyme Viewer × Heartbeat-Frequency darf den Server nicht
-    // mit Frames fluten. 5s = 200 frames/s pro 1000 Clients ist OK.
-    // Unter 5s wäre eher ein "tippfehler" als bewusste Wahl.
-    expect(SSE_HEARTBEAT_INTERVAL_MS).toBeGreaterThanOrEqual(5_000);
-  });
-});

package/src/__tests__/run-prod-app-static-files.test.ts

@@ -1,298 +0,0 @@
-// Unit coverage for mimeTypeFor + hostDispatch edge in buildStaticFallback.
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { NO_ROUTE_MATCH_HEADER_NAME } from "@cosmicdrift/kumiko-framework/api";
-import {
-  buildStaticFallback,
-  mimeTypeFor,
-  readStaticFile,
-  serveDiskFile,
-} from "../run-prod-app-static-files";
-
-// Stand-in for a real Hono app's fetch when the test wants "no route
-// matched" — must carry NO_ROUTE_MATCH_HEADER_NAME, same as buildServer's
-// app.notFound() (framework/api/server.ts), otherwise tryHonoFirst treats
-// the fake apiHandler's 404 as a matched route's own deliberate 404 (see
-// kumiko-framework#2435) and never falls through to disk/SPA.
-function noRouteMatchedResponse(): Response {
-  return new Response("404", { status: 404, headers: { [NO_ROUTE_MATCH_HEADER_NAME]: "1" } });
-}
-
-describe("mimeTypeFor", () => {
-  const cases: ReadonlyArray<readonly [string, string]> = [
-    ["x.html", "text/html; charset=utf-8"],
-    ["x.js", "text/javascript; charset=utf-8"],
-    ["x.mjs", "text/javascript; charset=utf-8"],
-    ["x.css", "text/css; charset=utf-8"],
-    ["x.json", "application/json; charset=utf-8"],
-    ["x.svg", "image/svg+xml"],
-    ["x.png", "image/png"],
-    ["x.jpg", "image/jpeg"],
-    ["x.jpeg", "image/jpeg"],
-    ["x.ico", "image/x-icon"],
-    ["x.txt", "text/plain; charset=utf-8"],
-    ["x.xml", "application/xml; charset=utf-8"],
-    ["x.webmanifest", "application/manifest+json"],
-    ["x.bin", "application/octet-stream"],
-    ["noext", "application/octet-stream"],
-  ];
-
-  for (const [path, mime] of cases) {
-    test(`${path} → ${mime}`, () => {
-      expect(mimeTypeFor(path)).toBe(mime);
-    });
-  }
-});
-
-describe("readStaticFile / serveDiskFile", () => {
-  let tmp = "";
-
-  beforeEach(async () => {
-    tmp = await mkdtemp(join(tmpdir(), "kumiko-static-"));
-  });
-
-  afterEach(async () => {
-    await rm(tmp, { recursive: true, force: true });
-  });
-
-  test("readStaticFile returns bytes+mime; ENOENT → undefined", async () => {
-    const path = join(tmp, "a.css");
-    await writeFile(path, "body{}");
-    const file = await readStaticFile(path);
-    expect(file?.mime).toBe("text/css; charset=utf-8");
-    expect(new TextDecoder().decode(file!.bytes)).toBe("body{}");
-    expect(await readStaticFile(join(tmp, "missing.css"))).toBeUndefined();
-  });
-
-  test("readStaticFile on a directory → undefined (EISDIR), not a throw", async () => {
-    const dirPath = join(tmp, "sub");
-    await mkdir(dirPath);
-    expect(await readStaticFile(dirPath)).toBeUndefined();
-  });
-
-  test("readStaticFile through a file used as a directory segment → undefined (ENOTDIR), not a throw (#1504)", async () => {
-    const path = join(tmp, "index.html");
-    await writeFile(path, "<html/>");
-    // GET /index.html/x — "index.html" is a file, so treating it as a
-    // directory segment must fall through to the SPA fallback, not 500.
-    expect(await readStaticFile(join(path, "x"))).toBeUndefined();
-  });
-
-  test("serveDiskFile sets content-type from mime", async () => {
-    const path = join(tmp, "a.svg");
-    await writeFile(path, "<svg/>");
-    const file = await readStaticFile(path);
-    const res = serveDiskFile(new Request("http://t/a.svg"), "/a.svg", file!);
-    expect(res.headers.get("content-type")).toBe("image/svg+xml");
-    expect(await res.text()).toBe("<svg/>");
-  });
-});
-
-describe("buildStaticFallback hostDispatch", () => {
-  let tmp = "";
-
-  beforeEach(async () => {
-    tmp = await mkdtemp(join(tmpdir(), "kumiko-fallback-"));
-  });
-
-  afterEach(async () => {
-    await rm(tmp, { recursive: true, force: true });
-  });
-
-  test("hostDispatch html pointing at missing file → 500", async () => {
-    const handler = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "html", file: "gone.html" }),
-    );
-    const res = await handler(new Request("http://t/"));
-    expect(res.status).toBe(500);
-    expect(await res.text()).toContain("hostDispatch: file not found: gone.html");
-  });
-
-  test("hostDispatch not-found → 404; redirect → 302", async () => {
-    const notFound = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "not-found" }),
-    );
-    expect((await notFound(new Request("http://t/"))).status).toBe(404);
-
-    const redirect = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "redirect", to: "https://example.com/", status: 301 }),
-    );
-    const res = await redirect(new Request("http://t/"));
-    expect(res.status).toBe(301);
-    expect(res.headers.get("location")).toBe("https://example.com/");
-  });
-
-  test("/api/* always hits apiHandler", async () => {
-    const handler = buildStaticFallback(() => new Response("from-api", { status: 200 }), tmp);
-    const res = await handler(new Request("http://t/api/query", { method: "POST" }));
-    expect(res.status).toBe(200);
-    expect(await res.text()).toBe("from-api");
-  });
-
-  test("serves disk asset under staticDir", async () => {
-    await writeFile(join(tmp, "logo.png"), "PNGDATA");
-    const handler = buildStaticFallback(() => noRouteMatchedResponse(), tmp);
-    const res = await handler(new Request("http://t/logo.png"));
-    expect(res.status).toBe(200);
-    expect(res.headers.get("content-type")).toBe("image/png");
-    expect(await res.text()).toBe("PNGDATA");
-  });
-
-  test("a request for a directory copied verbatim from public/ falls back to index.html instead of 500ing", async () => {
-    await mkdir(join(tmp, "sub"));
-    await writeFile(join(tmp, "index.html"), "<!doctype html><html><body>spa-shell</body></html>");
-    const handler = buildStaticFallback(() => noRouteMatchedResponse(), tmp);
-    const res = await handler(new Request("http://t/sub"));
-    expect(res.status).toBe(200);
-    expect(await res.text()).toContain("spa-shell");
-  });
-
-  test("hostDispatch html with CSP + Vary: Host", async () => {
-    await writeFile(join(tmp, "tenant.html"), "<!doctype html><html><body>ok</body></html>");
-    const handler = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({
-        kind: "html",
-        file: "tenant.html",
-        csp: "default-src 'self'",
-      }),
-    );
-    const res = await handler(new Request("http://t/", { headers: { host: "a.example" } }));
-    expect(res.status).toBe(200);
-    expect(res.headers.get("vary")).toBe("Host");
-    expect(res.headers.get("content-security-policy")).toBe("default-src 'self'");
-    expect(await res.text()).toContain("ok");
-  });
-
-  test("a matched route's own deliberate 404 stays 404, not masked as the SPA shell (#2435)", async () => {
-    // An index.html exists on disk, so the OLD status-only heuristic would
-    // have served it with status 200 for ANY 404 — including one from a
-    // matched route (e.g. file-derivatives' public-variant default-deny)
-    // that never carries NO_ROUTE_MATCH_HEADER_NAME.
-    await writeFile(join(tmp, "index.html"), "<!doctype html><html><body>spa-shell</body></html>");
-    const handler = buildStaticFallback(() => new Response("not found", { status: 404 }), tmp);
-    const res = await handler(new Request("http://t/files/deadbeef/thumb"));
-    expect(res.status).toBe(404);
-    expect(await res.text()).toBe("not found");
-  });
-
-  test("an unknown SPA route with no matching handler still gets the SPA shell", async () => {
-    await writeFile(join(tmp, "index.html"), "<!doctype html><html><body>spa-shell</body></html>");
-    const handler = buildStaticFallback(() => noRouteMatchedResponse(), tmp);
-    const res = await handler(new Request("http://t/some/client-side/route"));
-    expect(res.status).toBe(200);
-    expect(await res.text()).toContain("spa-shell");
-  });
-});
-
-describe("buildStaticFallback resolvePageHead", () => {
-  let tmp = "";
-
-  const HTML = "<!doctype html><html><head><title>Offlot</title></head><body>shell</body></html>";
-
-  function stubDispatcher(): { query: () => Promise<unknown> } {
-    return { query: async () => ({}) };
-  }
-
-  beforeEach(async () => {
-    tmp = await mkdtemp(join(tmpdir(), "kumiko-pagehead-"));
-    await writeFile(join(tmp, "tenant.html"), HTML);
-    await writeFile(join(tmp, "index.html"), HTML);
-  });
-
-  afterEach(async () => {
-    await rm(tmp, { recursive: true, force: true });
-  });
-
-  // Exercised through hostDispatch's "html" branch — that's the path
-  // offlot actually uses in production (createOfflotHostDispatch returns
-  // {kind:"html", ...} for every host), not the default single-app path.
-  test("resolver meta → og-tags appear in the hostDispatch HTML response", async () => {
-    const handler = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "html", file: "tenant.html" }),
-      {
-        resolvePageHead: async () => ({
-          title: "Vehicle X",
-          description: "A car",
-          ogImage: "https://x/i.png",
-        }),
-        dispatcher: stubDispatcher(),
-      },
-    );
-    const res = await handler(new Request("http://t/"));
-    expect(res.status).toBe(200);
-    const text = await res.text();
-    expect(text).toContain("<title>Vehicle X</title>");
-    expect(text).toContain('<meta property="og:image" content="https://x/i.png" />');
-  });
-
-  test("resolver throws → 200 with the unchanged shell", async () => {
-    const handler = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "html", file: "tenant.html" }),
-      {
-        resolvePageHead: async () => {
-          throw new Error("boom");
-        },
-        dispatcher: stubDispatcher(),
-      },
-    );
-    const res = await handler(new Request("http://t/"));
-    expect(res.status).toBe(200);
-    expect(await res.text()).toBe(HTML);
-  });
-
-  test("resolver never resolves → 200 with the unchanged shell after the timeout", async () => {
-    const handler = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "html", file: "tenant.html" }),
-      {
-        resolvePageHead: () => new Promise(() => {}),
-        dispatcher: stubDispatcher(),
-      },
-    );
-    const res = await handler(new Request("http://t/"));
-    expect(res.status).toBe(200);
-    expect(await res.text()).toBe(HTML);
-  }, 2000);
-
-  test("two paths with different resolved titles get different ETags", async () => {
-    const handler = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "html", file: "tenant.html" }),
-      {
-        resolvePageHead: async ({ path }) => ({ title: `Title for ${path}` }),
-        dispatcher: stubDispatcher(),
-      },
-    );
-    const resA = await handler(new Request("http://t/a"));
-    const resB = await handler(new Request("http://t/b"));
-    expect(resA.headers.get("etag")).not.toBe(resB.headers.get("etag"));
-  });
-
-  test("no resolvePageHead configured → response is byte-identical to the no-resolver call", async () => {
-    const withoutPageHead = buildStaticFallback(
-      () => noRouteMatchedResponse(),
-      tmp,
-      () => ({ kind: "html", file: "tenant.html" }),
-    );
-    const res = await withoutPageHead(new Request("http://t/"));
-    expect(res.status).toBe(200);
-    expect(await res.text()).toBe(HTML);
-  });
-});