@mandujs/core 0.53.3 → 0.54.1

package/src/runtime/__tests__/http-errors.test.ts

@@ -1,117 +1,117 @@
-/**
- * Unit tests for the module-level HTTP error helpers (Phase 6.3).
- *
- * Companion to the ctx.unauthorized() / ctx.forbidden() / ctx.error()
- * methods on ManduContext — those live in filling/context.ts. These
- * standalone helpers must match ctx behavior for body shape while also
- * covering the header-merging contract (WWW-Authenticate, custom headers).
- */
-
-import { describe, it, expect } from "bun:test";
-import { unauthorized, forbidden, badRequest } from "../http-errors";
-
-async function readJson(res: Response): Promise<unknown> {
-  const clone = res.clone();
-  const text = await clone.text();
-  return text.length > 0 ? JSON.parse(text) : null;
-}
-
-describe("unauthorized()", () => {
-  it("returns 401 with the default WWW-Authenticate: Bearer header", async () => {
-    const res = unauthorized();
-    expect(res.status).toBe(401);
-    expect(res.headers.get("WWW-Authenticate")).toBe("Bearer");
-    expect(await readJson(res)).toEqual({ error: "Unauthorized" });
-  });
-
-  it("includes the caller-provided message in the JSON body", async () => {
-    const res = unauthorized("login required");
-    expect(res.status).toBe(401);
-    expect(await readJson(res)).toEqual({ error: "login required" });
-  });
-
-  it("merges custom headers alongside WWW-Authenticate", async () => {
-    const res = unauthorized(undefined, { headers: { "x-custom": "1" } });
-    expect(res.status).toBe(401);
-    expect(res.headers.get("x-custom")).toBe("1");
-    expect(res.headers.get("WWW-Authenticate")).toBe("Bearer");
-    expect(res.headers.get("Content-Type")).toContain("application/json");
-  });
-
-  it("lets callers override WWW-Authenticate (e.g. Basic realm)", () => {
-    const res = unauthorized("Token expired", {
-      headers: { "WWW-Authenticate": 'Basic realm="app"' },
-    });
-    expect(res.headers.get("WWW-Authenticate")).toBe('Basic realm="app"');
-  });
-});
-
-describe("forbidden()", () => {
-  it("returns 403 with the default JSON body", async () => {
-    const res = forbidden();
-    expect(res.status).toBe(403);
-    expect(await readJson(res)).toEqual({ error: "Forbidden" });
-    expect(res.headers.get("Content-Type")).toContain("application/json");
-  });
-
-  it("carries the provided message", async () => {
-    const res = forbidden("role mismatch");
-    expect(res.status).toBe(403);
-    expect(await readJson(res)).toEqual({ error: "role mismatch" });
-  });
-
-  it("merges custom response headers", () => {
-    const res = forbidden("no", { headers: { "x-trace": "abc" } });
-    expect(res.headers.get("x-trace")).toBe("abc");
-    expect(res.status).toBe(403);
-  });
-});
-
-describe("badRequest()", () => {
-  it("string input produces { error: <string> }", async () => {
-    const res = badRequest("string-only");
-    expect(res.status).toBe(400);
-    expect(await readJson(res)).toEqual({ error: "string-only" });
-  });
-
-  it("object input with message + errors produces { error, errors }", async () => {
-    const res = badRequest({
-      message: "invalid",
-      errors: { email: ["required"] },
-    });
-    expect(res.status).toBe(400);
-    expect(await readJson(res)).toEqual({
-      error: "invalid",
-      errors: { email: ["required"] },
-    });
-  });
-
-  it("object input without errors omits the key (no `errors: undefined` leak)", async () => {
-    const res = badRequest({ message: "simple" });
-    const body = (await readJson(res)) as Record<string, unknown>;
-    expect(body).toEqual({ error: "simple" });
-    // Explicit: `errors` key must not appear at all — users pattern-match on presence.
-    expect(Object.prototype.hasOwnProperty.call(body, "errors")).toBe(false);
-  });
-
-  it("no-args call defaults to 'Bad Request'", async () => {
-    const res = badRequest();
-    expect(res.status).toBe(400);
-    expect(await readJson(res)).toEqual({ error: "Bad Request" });
-  });
-
-  it("merges custom headers on both string and object inputs", () => {
-    const resA = badRequest("x", { headers: { "x-a": "1" } });
-    expect(resA.headers.get("x-a")).toBe("1");
-
-    const resB = badRequest({ message: "y" }, { headers: { "x-b": "2" } });
-    expect(resB.headers.get("x-b")).toBe("2");
-  });
-
-  it("response content-type is application/json; charset=utf-8", () => {
-    const res = badRequest("z");
-    const ct = res.headers.get("Content-Type") ?? "";
-    expect(ct).toContain("application/json");
-    expect(ct).toContain("charset=utf-8");
-  });
-});
+/**
+ * Unit tests for the module-level HTTP error helpers (Phase 6.3).
+ *
+ * Companion to the ctx.unauthorized() / ctx.forbidden() / ctx.error()
+ * methods on ManduContext — those live in filling/context.ts. These
+ * standalone helpers must match ctx behavior for body shape while also
+ * covering the header-merging contract (WWW-Authenticate, custom headers).
+ */
+
+import { describe, it, expect } from "bun:test";
+import { unauthorized, forbidden, badRequest } from "../http-errors";
+
+async function readJson(res: Response): Promise<unknown> {
+  const clone = res.clone();
+  const text = await clone.text();
+  return text.length > 0 ? JSON.parse(text) : null;
+}
+
+describe("unauthorized()", () => {
+  it("returns 401 with the default WWW-Authenticate: Bearer header", async () => {
+    const res = unauthorized();
+    expect(res.status).toBe(401);
+    expect(res.headers.get("WWW-Authenticate")).toBe("Bearer");
+    expect(await readJson(res)).toEqual({ error: "Unauthorized" });
+  });
+
+  it("includes the caller-provided message in the JSON body", async () => {
+    const res = unauthorized("login required");
+    expect(res.status).toBe(401);
+    expect(await readJson(res)).toEqual({ error: "login required" });
+  });
+
+  it("merges custom headers alongside WWW-Authenticate", async () => {
+    const res = unauthorized(undefined, { headers: { "x-custom": "1" } });
+    expect(res.status).toBe(401);
+    expect(res.headers.get("x-custom")).toBe("1");
+    expect(res.headers.get("WWW-Authenticate")).toBe("Bearer");
+    expect(res.headers.get("Content-Type")).toContain("application/json");
+  });
+
+  it("lets callers override WWW-Authenticate (e.g. Basic realm)", () => {
+    const res = unauthorized("Token expired", {
+      headers: { "WWW-Authenticate": 'Basic realm="app"' },
+    });
+    expect(res.headers.get("WWW-Authenticate")).toBe('Basic realm="app"');
+  });
+});
+
+describe("forbidden()", () => {
+  it("returns 403 with the default JSON body", async () => {
+    const res = forbidden();
+    expect(res.status).toBe(403);
+    expect(await readJson(res)).toEqual({ error: "Forbidden" });
+    expect(res.headers.get("Content-Type")).toContain("application/json");
+  });
+
+  it("carries the provided message", async () => {
+    const res = forbidden("role mismatch");
+    expect(res.status).toBe(403);
+    expect(await readJson(res)).toEqual({ error: "role mismatch" });
+  });
+
+  it("merges custom response headers", () => {
+    const res = forbidden("no", { headers: { "x-trace": "abc" } });
+    expect(res.headers.get("x-trace")).toBe("abc");
+    expect(res.status).toBe(403);
+  });
+});
+
+describe("badRequest()", () => {
+  it("string input produces { error: <string> }", async () => {
+    const res = badRequest("string-only");
+    expect(res.status).toBe(400);
+    expect(await readJson(res)).toEqual({ error: "string-only" });
+  });
+
+  it("object input with message + errors produces { error, errors }", async () => {
+    const res = badRequest({
+      message: "invalid",
+      errors: { email: ["required"] },
+    });
+    expect(res.status).toBe(400);
+    expect(await readJson(res)).toEqual({
+      error: "invalid",
+      errors: { email: ["required"] },
+    });
+  });
+
+  it("object input without errors omits the key (no `errors: undefined` leak)", async () => {
+    const res = badRequest({ message: "simple" });
+    const body = (await readJson(res)) as Record<string, unknown>;
+    expect(body).toEqual({ error: "simple" });
+    // Explicit: `errors` key must not appear at all — users pattern-match on presence.
+    expect(Object.prototype.hasOwnProperty.call(body, "errors")).toBe(false);
+  });
+
+  it("no-args call defaults to 'Bad Request'", async () => {
+    const res = badRequest();
+    expect(res.status).toBe(400);
+    expect(await readJson(res)).toEqual({ error: "Bad Request" });
+  });
+
+  it("merges custom headers on both string and object inputs", () => {
+    const resA = badRequest("x", { headers: { "x-a": "1" } });
+    expect(resA.headers.get("x-a")).toBe("1");
+
+    const resB = badRequest({ message: "y" }, { headers: { "x-b": "2" } });
+    expect(resB.headers.get("x-b")).toBe("2");
+  });
+
+  it("response content-type is application/json; charset=utf-8", () => {
+    const res = badRequest("z");
+    const ct = res.headers.get("Content-Type") ?? "";
+    expect(ct).toContain("application/json");
+    expect(ct).toContain("charset=utf-8");
+  });
+});

package/src/runtime/__tests__/not-found.test.ts

@@ -1,152 +1,152 @@
-/**
- * Unit tests for `notFound()` / `isNotFoundResponse()` (Phase 6.3).
- *
- * Mirrors the shape of the redirect() tests (see packages/core/tests/server/
- * redirect-loader.test.ts). These stay local to the helper — integration
- * coverage that exercises the full SSR pipeline lives in the server test
- * at packages/core/tests/server/not-found-page.test.ts.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-  notFound,
-  isNotFoundResponse,
-  NOT_FOUND_BRAND,
-} from "../not-found";
-import { redirect } from "../redirect";
-import { ManduFilling } from "../../filling/filling";
-import { ManduContext } from "../../filling/context";
-
-describe("notFound()", () => {
-  it("returns a Response with status 404", () => {
-    const res = notFound();
-    expect(res).toBeInstanceOf(Response);
-    expect(res.status).toBe(404);
-  });
-
-  it("carries the provided message in its body", async () => {
-    const res = notFound({ message: "Post not found" });
-    const body = await res.text();
-    expect(body).toBe("Post not found");
-  });
-
-  it("is recognized by isNotFoundResponse()", () => {
-    expect(isNotFoundResponse(notFound())).toBe(true);
-    expect(isNotFoundResponse(notFound({ message: "x" }))).toBe(true);
-  });
-
-  it("rejects a bare `new Response(null, { status: 404 })` (brand check)", () => {
-    const bare = new Response(null, { status: 404 });
-    expect(isNotFoundResponse(bare)).toBe(false);
-    // Double-check: something we know is 404 but not ours (e.g. upstream proxy)
-    const proxied = new Response("upstream 404", {
-      status: 404,
-      headers: { "Content-Type": "text/plain" },
-    });
-    expect(isNotFoundResponse(proxied)).toBe(false);
-  });
-
-  it("rejects a redirect() Response (notFound is a distinct brand)", () => {
-    expect(isNotFoundResponse(redirect("/foo"))).toBe(false);
-  });
-
-  it("rejects null / undefined / {} / primitives (type guard is strict)", () => {
-    expect(isNotFoundResponse(null)).toBe(false);
-    expect(isNotFoundResponse(undefined)).toBe(false);
-    expect(isNotFoundResponse({})).toBe(false);
-    expect(isNotFoundResponse("string")).toBe(false);
-    expect(isNotFoundResponse(404)).toBe(false);
-    expect(isNotFoundResponse(new Error("not a response"))).toBe(false);
-  });
-
-  it("status is always 404 regardless of the message", () => {
-    expect(notFound().status).toBe(404);
-    expect(notFound({ message: "a" }).status).toBe(404);
-    expect(notFound({ message: "" }).status).toBe(404); // empty still 404
-    expect(notFound({ message: "x".repeat(1000) }).status).toBe(404);
-  });
-
-  it("body is text/plain (not JSON) — explicit content-type contract", async () => {
-    const res = notFound({ message: "missing" });
-    const ct = res.headers.get("content-type") ?? "";
-    expect(ct).toContain("text/plain");
-    expect(ct).toContain("charset=utf-8");
-    // Body must be the literal message, not a JSON envelope.
-    expect(await res.text()).toBe("missing");
-  });
-
-  it("default body (no args) is the literal 'Not Found'", async () => {
-    const res = notFound();
-    expect(await res.text()).toBe("Not Found");
-  });
-
-  it("loader returning notFound() is picked up by isNotFoundResponse", async () => {
-    const filling = new ManduFilling();
-    filling.loader(() => notFound({ message: "post gone" }));
-
-    const ctx = new ManduContext(new Request("http://test/post/1"), { id: "1" });
-    const returned = await filling.executeLoader(ctx);
-    expect(isNotFoundResponse(returned)).toBe(true);
-    // And the body survived.
-    const body = await (returned as Response).text();
-    expect(body).toBe("post gone");
-  });
-
-  it("loader throwing notFound() is picked up the same way (Remix idiom)", async () => {
-    const filling = new ManduFilling();
-    filling.loader(() => {
-      throw notFound({ message: "thrown" });
-    });
-
-    const ctx = new ManduContext(new Request("http://test/x"), {});
-    let caught: unknown = null;
-    try {
-      await filling.executeLoader(ctx);
-    } catch (e) {
-      caught = e;
-    }
-    expect(isNotFoundResponse(caught)).toBe(true);
-    expect(await (caught as Response).text()).toBe("thrown");
-  });
-
-  it("integration simulation: loadPageData-like branch distinguishes return vs throw", async () => {
-    // Emulates the exact shape of the SSR pipeline's try/catch: `returned`
-    // and `thrown` both route through `isNotFoundResponse`. This is the
-    // contract the server integration relies on.
-    const returnCase = notFound({ message: "A" });
-    const throwCase = notFound({ message: "B" });
-
-    // Both must be recognised.
-    expect(isNotFoundResponse(returnCase)).toBe(true);
-    expect(isNotFoundResponse(throwCase)).toBe(true);
-
-    // And each preserves its own message (no shared mutable state).
-    expect(await returnCase.text()).toBe("A");
-    expect(await throwCase.text()).toBe("B");
-  });
-
-  it("accepts a call with no arguments and still produces a valid sentinel", () => {
-    const res = notFound();
-    expect(res).toBeInstanceOf(Response);
-    expect(res.status).toBe(404);
-    expect(isNotFoundResponse(res)).toBe(true);
-  });
-
-  it("exports NOT_FOUND_BRAND as a unique symbol keyed to the package", () => {
-    // The brand must be a Symbol.for() so multiple copies of @mandujs/core
-    // (e.g. monorepo duplication) agree on identity. If this changes we've
-    // broken cross-package detection — regression guard.
-    expect(typeof NOT_FOUND_BRAND).toBe("symbol");
-    expect(Symbol.keyFor(NOT_FOUND_BRAND)).toBe("@mandujs/core/not-found");
-  });
-
-  it("two separate notFound() calls produce independently-branded Responses", () => {
-    // WeakSet membership is per-instance — the brand on one must not
-    // leak to another. Important for test isolation.
-    const a = notFound();
-    const b = notFound();
-    expect(a).not.toBe(b);
-    expect(isNotFoundResponse(a)).toBe(true);
-    expect(isNotFoundResponse(b)).toBe(true);
-  });
-});
+/**
+ * Unit tests for `notFound()` / `isNotFoundResponse()` (Phase 6.3).
+ *
+ * Mirrors the shape of the redirect() tests (see packages/core/tests/server/
+ * redirect-loader.test.ts). These stay local to the helper — integration
+ * coverage that exercises the full SSR pipeline lives in the server test
+ * at packages/core/tests/server/not-found-page.test.ts.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  notFound,
+  isNotFoundResponse,
+  NOT_FOUND_BRAND,
+} from "../not-found";
+import { redirect } from "../redirect";
+import { ManduFilling } from "../../filling/filling";
+import { ManduContext } from "../../filling/context";
+
+describe("notFound()", () => {
+  it("returns a Response with status 404", () => {
+    const res = notFound();
+    expect(res).toBeInstanceOf(Response);
+    expect(res.status).toBe(404);
+  });
+
+  it("carries the provided message in its body", async () => {
+    const res = notFound({ message: "Post not found" });
+    const body = await res.text();
+    expect(body).toBe("Post not found");
+  });
+
+  it("is recognized by isNotFoundResponse()", () => {
+    expect(isNotFoundResponse(notFound())).toBe(true);
+    expect(isNotFoundResponse(notFound({ message: "x" }))).toBe(true);
+  });
+
+  it("rejects a bare `new Response(null, { status: 404 })` (brand check)", () => {
+    const bare = new Response(null, { status: 404 });
+    expect(isNotFoundResponse(bare)).toBe(false);
+    // Double-check: something we know is 404 but not ours (e.g. upstream proxy)
+    const proxied = new Response("upstream 404", {
+      status: 404,
+      headers: { "Content-Type": "text/plain" },
+    });
+    expect(isNotFoundResponse(proxied)).toBe(false);
+  });
+
+  it("rejects a redirect() Response (notFound is a distinct brand)", () => {
+    expect(isNotFoundResponse(redirect("/foo"))).toBe(false);
+  });
+
+  it("rejects null / undefined / {} / primitives (type guard is strict)", () => {
+    expect(isNotFoundResponse(null)).toBe(false);
+    expect(isNotFoundResponse(undefined)).toBe(false);
+    expect(isNotFoundResponse({})).toBe(false);
+    expect(isNotFoundResponse("string")).toBe(false);
+    expect(isNotFoundResponse(404)).toBe(false);
+    expect(isNotFoundResponse(new Error("not a response"))).toBe(false);
+  });
+
+  it("status is always 404 regardless of the message", () => {
+    expect(notFound().status).toBe(404);
+    expect(notFound({ message: "a" }).status).toBe(404);
+    expect(notFound({ message: "" }).status).toBe(404); // empty still 404
+    expect(notFound({ message: "x".repeat(1000) }).status).toBe(404);
+  });
+
+  it("body is text/plain (not JSON) — explicit content-type contract", async () => {
+    const res = notFound({ message: "missing" });
+    const ct = res.headers.get("content-type") ?? "";
+    expect(ct).toContain("text/plain");
+    expect(ct).toContain("charset=utf-8");
+    // Body must be the literal message, not a JSON envelope.
+    expect(await res.text()).toBe("missing");
+  });
+
+  it("default body (no args) is the literal 'Not Found'", async () => {
+    const res = notFound();
+    expect(await res.text()).toBe("Not Found");
+  });
+
+  it("loader returning notFound() is picked up by isNotFoundResponse", async () => {
+    const filling = new ManduFilling();
+    filling.loader(() => notFound({ message: "post gone" }));
+
+    const ctx = new ManduContext(new Request("http://test/post/1"), { id: "1" });
+    const returned = await filling.executeLoader(ctx);
+    expect(isNotFoundResponse(returned)).toBe(true);
+    // And the body survived.
+    const body = await (returned as Response).text();
+    expect(body).toBe("post gone");
+  });
+
+  it("loader throwing notFound() is picked up the same way (Remix idiom)", async () => {
+    const filling = new ManduFilling();
+    filling.loader(() => {
+      throw notFound({ message: "thrown" });
+    });
+
+    const ctx = new ManduContext(new Request("http://test/x"), {});
+    let caught: unknown = null;
+    try {
+      await filling.executeLoader(ctx);
+    } catch (e) {
+      caught = e;
+    }
+    expect(isNotFoundResponse(caught)).toBe(true);
+    expect(await (caught as Response).text()).toBe("thrown");
+  });
+
+  it("integration simulation: loadPageData-like branch distinguishes return vs throw", async () => {
+    // Emulates the exact shape of the SSR pipeline's try/catch: `returned`
+    // and `thrown` both route through `isNotFoundResponse`. This is the
+    // contract the server integration relies on.
+    const returnCase = notFound({ message: "A" });
+    const throwCase = notFound({ message: "B" });
+
+    // Both must be recognised.
+    expect(isNotFoundResponse(returnCase)).toBe(true);
+    expect(isNotFoundResponse(throwCase)).toBe(true);
+
+    // And each preserves its own message (no shared mutable state).
+    expect(await returnCase.text()).toBe("A");
+    expect(await throwCase.text()).toBe("B");
+  });
+
+  it("accepts a call with no arguments and still produces a valid sentinel", () => {
+    const res = notFound();
+    expect(res).toBeInstanceOf(Response);
+    expect(res.status).toBe(404);
+    expect(isNotFoundResponse(res)).toBe(true);
+  });
+
+  it("exports NOT_FOUND_BRAND as a unique symbol keyed to the package", () => {
+    // The brand must be a Symbol.for() so multiple copies of @mandujs/core
+    // (e.g. monorepo duplication) agree on identity. If this changes we've
+    // broken cross-package detection — regression guard.
+    expect(typeof NOT_FOUND_BRAND).toBe("symbol");
+    expect(Symbol.keyFor(NOT_FOUND_BRAND)).toBe("@mandujs/core/not-found");
+  });
+
+  it("two separate notFound() calls produce independently-branded Responses", () => {
+    // WeakSet membership is per-instance — the brand on one must not
+    // leak to another. Important for test isolation.
+    const a = notFound();
+    const b = notFound();
+    expect(a).not.toBe(b);
+    expect(isNotFoundResponse(a)).toBe(true);
+    expect(isNotFoundResponse(b)).toBe(true);
+  });
+});

package/src/runtime/adapter.ts

@@ -1,47 +1,47 @@
-/**
- * Mandu Adapter Interface
- * 런타임 중립적 서버 어댑터 추상화
- */
-
-import type { RoutesManifest } from "../spec/schema";
-import type { BundleManifest } from "../bundler/types";
-import type { ServerOptions } from "./server";
-
-// ========== Types ==========
-
-export interface AdapterOptions {
-  manifest: RoutesManifest;
-  bundleManifest?: BundleManifest;
-  rootDir: string;
-  serverOptions: ServerOptions;
-}
-
-export interface AdapterServer {
-  /** fetch handler (Web Fetch API — 런타임 중립) */
-  fetch: (request: Request) => Promise<Response>;
-  /** 서버 시작 */
-  listen(port: number, hostname?: string): Promise<{ port: number; hostname: string }>;
-  /** 서버 중지 */
-  close(): Promise<void>;
-}
-
-/**
- * Mandu Adapter 인터페이스
- *
- * @example
- * ```typescript
- * // mandu.config.ts
- * import adapterBun from "@mandujs/adapter-bun";
- *
- * export default {
- *   adapter: adapterBun(),
- * };
- * ```
- */
-export interface ManduAdapter {
-  name: string;
-  /** 빌드 타임: 배포 산출물 생성 (SSG, 서버리스 번들 등) */
-  build?(options: AdapterOptions): Promise<void>;
-  /** 런타임: 서버 인스턴스 생성 */
-  createServer(options: AdapterOptions): AdapterServer;
-}
+/**
+ * Mandu Adapter Interface
+ * 런타임 중립적 서버 어댑터 추상화
+ */
+
+import type { RoutesManifest } from "../spec/schema";
+import type { BundleManifest } from "../bundler/types";
+import type { ServerOptions } from "./server";
+
+// ========== Types ==========
+
+export interface AdapterOptions {
+  manifest: RoutesManifest;
+  bundleManifest?: BundleManifest;
+  rootDir: string;
+  serverOptions: ServerOptions;
+}
+
+export interface AdapterServer {
+  /** fetch handler (Web Fetch API — 런타임 중립) */
+  fetch: (request: Request) => Promise<Response>;
+  /** 서버 시작 */
+  listen(port: number, hostname?: string): Promise<{ port: number; hostname: string }>;
+  /** 서버 중지 */
+  close(): Promise<void>;
+}
+
+/**
+ * Mandu Adapter 인터페이스
+ *
+ * @example
+ * ```typescript
+ * // mandu.config.ts
+ * import adapterBun from "@mandujs/adapter-bun";
+ *
+ * export default {
+ *   adapter: adapterBun(),
+ * };
+ * ```
+ */
+export interface ManduAdapter {
+  name: string;
+  /** 빌드 타임: 배포 산출물 생성 (SSG, 서버리스 번들 등) */
+  build?(options: AdapterOptions): Promise<void>;
+  /** 런타임: 서버 인스턴스 생성 */
+  createServer(options: AdapterOptions): AdapterServer;
+}