@mandujs/core 0.3.2 → 0.3.3

package/src/runtime/server.ts

@@ -1,139 +1,189 @@
-import type { Server } from "bun";
-import type { RoutesManifest } from "../spec/schema";
-import { Router } from "./router";
-import { renderSSR } from "./ssr";
-import React from "react";
-
-export interface ServerOptions {
-  port?: number;
-  hostname?: string;
-}
-
-export interface ManduServer {
-  server: Server;
-  router: Router;
-  stop: () => void;
-}
-
-export type ApiHandler = (req: Request, params: Record<string, string>) => Response | Promise<Response>;
-export type PageLoader = () => Promise<{ default: React.ComponentType<{ params: Record<string, string> }> }>;
-
-export interface AppContext {
-  routeId: string;
-  url: string;
-  params: Record<string, string>;
-}
-
-type RouteComponent = (props: { params: Record<string, string> }) => React.ReactElement;
-type CreateAppFn = (context: AppContext) => React.ReactElement;
-
-// Registry
-const apiHandlers: Map<string, ApiHandler> = new Map();
-const pageLoaders: Map<string, PageLoader> = new Map();
-const routeComponents: Map<string, RouteComponent> = new Map();
-let createAppFn: CreateAppFn | null = null;
-
-export function registerApiHandler(routeId: string, handler: ApiHandler): void {
-  apiHandlers.set(routeId, handler);
-}
-
-export function registerPageLoader(routeId: string, loader: PageLoader): void {
-  pageLoaders.set(routeId, loader);
-}
-
-export function registerRouteComponent(routeId: string, component: RouteComponent): void {
-  routeComponents.set(routeId, component);
-}
-
-export function setCreateApp(fn: CreateAppFn): void {
-  createAppFn = fn;
-}
-
-// Default createApp implementation
-function defaultCreateApp(context: AppContext): React.ReactElement {
-  const Component = routeComponents.get(context.routeId);
-
-  if (!Component) {
-    return React.createElement("div", null,
-      React.createElement("h1", null, "404 - Route Not Found"),
-      React.createElement("p", null, `Route ID: ${context.routeId}`)
-    );
-  }
-
-  return React.createElement(Component, { params: context.params });
-}
-
-async function handleRequest(req: Request, router: Router): Promise<Response> {
-  const url = new URL(req.url);
-  const pathname = url.pathname;
-
-  const match = router.match(pathname);
-
-  if (!match) {
-    return new Response("Not Found", { status: 404 });
-  }
-
-  const { route, params } = match;
-
-  if (route.kind === "api") {
-    const handler = apiHandlers.get(route.id);
-    if (!handler) {
-      return Response.json({ error: "Handler not found" }, { status: 500 });
-    }
-    return handler(req, params);
-  }
-
-  if (route.kind === "page") {
-    const loader = pageLoaders.get(route.id);
-    if (loader) {
-      try {
-        const module = await loader();
-        registerRouteComponent(route.id, module.default);
-      } catch (error) {
-        console.error(`Failed to load page module for ${route.id}:`, error);
-        return new Response("Internal Server Error", { status: 500 });
-      }
-    }
-
-    const appCreator = createAppFn || defaultCreateApp;
-    const app = appCreator({
-      routeId: route.id,
-      url: req.url,
-      params,
-    });
-
-    return renderSSR(app, { title: `${route.id} - Mandu` });
-  }
-
-  return new Response("Unknown route kind", { status: 500 });
-}
-
-export function startServer(manifest: RoutesManifest, options: ServerOptions = {}): ManduServer {
-  const { port = 3000, hostname = "localhost" } = options;
-
-  const router = new Router(manifest.routes);
-
-  const server = Bun.serve({
-    port,
-    hostname,
-    fetch: (req) => handleRequest(req, router),
-  });
-
-  console.log(`🥟 Mandu server running at http://${hostname}:${port}`);
-
-  return {
-    server,
-    router,
-    stop: () => server.stop(),
-  };
-}
-
-// Clear registries (useful for testing)
-export function clearRegistry(): void {
-  apiHandlers.clear();
-  pageLoaders.clear();
-  routeComponents.clear();
-  createAppFn = null;
-}
-
-export { apiHandlers, pageLoaders, routeComponents };
+import type { Server } from "bun";
+import type { RoutesManifest } from "../spec/schema";
+import { Router } from "./router";
+import { renderSSR } from "./ssr";
+import React from "react";
+import {
+  formatErrorResponse,
+  createNotFoundResponse,
+  createHandlerNotFoundResponse,
+  createPageLoadErrorResponse,
+  createSSRErrorResponse,
+} from "../error";
+
+export interface ServerOptions {
+  port?: number;
+  hostname?: string;
+}
+
+export interface ManduServer {
+  server: Server;
+  router: Router;
+  stop: () => void;
+}
+
+export type ApiHandler = (req: Request, params: Record<string, string>) => Response | Promise<Response>;
+export type PageLoader = () => Promise<{ default: React.ComponentType<{ params: Record<string, string> }> }>;
+
+export interface AppContext {
+  routeId: string;
+  url: string;
+  params: Record<string, string>;
+}
+
+type RouteComponent = (props: { params: Record<string, string> }) => React.ReactElement;
+type CreateAppFn = (context: AppContext) => React.ReactElement;
+
+// Registry
+const apiHandlers: Map<string, ApiHandler> = new Map();
+const pageLoaders: Map<string, PageLoader> = new Map();
+const routeComponents: Map<string, RouteComponent> = new Map();
+let createAppFn: CreateAppFn | null = null;
+
+export function registerApiHandler(routeId: string, handler: ApiHandler): void {
+  apiHandlers.set(routeId, handler);
+}
+
+export function registerPageLoader(routeId: string, loader: PageLoader): void {
+  pageLoaders.set(routeId, loader);
+}
+
+export function registerRouteComponent(routeId: string, component: RouteComponent): void {
+  routeComponents.set(routeId, component);
+}
+
+export function setCreateApp(fn: CreateAppFn): void {
+  createAppFn = fn;
+}
+
+// Default createApp implementation
+function defaultCreateApp(context: AppContext): React.ReactElement {
+  const Component = routeComponents.get(context.routeId);
+
+  if (!Component) {
+    return React.createElement("div", null,
+      React.createElement("h1", null, "404 - Route Not Found"),
+      React.createElement("p", null, `Route ID: ${context.routeId}`)
+    );
+  }
+
+  return React.createElement(Component, { params: context.params });
+}
+
+async function handleRequest(req: Request, router: Router): Promise<Response> {
+  const url = new URL(req.url);
+  const pathname = url.pathname;
+
+  const match = router.match(pathname);
+
+  if (!match) {
+    const error = createNotFoundResponse(pathname);
+    const response = formatErrorResponse(error, {
+      isDev: process.env.NODE_ENV !== "production",
+    });
+    return Response.json(response, { status: 404 });
+  }
+
+  const { route, params } = match;
+
+  if (route.kind === "api") {
+    const handler = apiHandlers.get(route.id);
+    if (!handler) {
+      const error = createHandlerNotFoundResponse(route.id, route.pattern);
+      const response = formatErrorResponse(error, {
+        isDev: process.env.NODE_ENV !== "production",
+      });
+      return Response.json(response, { status: 500 });
+    }
+    return handler(req, params);
+  }
+
+  if (route.kind === "page") {
+    const loader = pageLoaders.get(route.id);
+    if (loader) {
+      try {
+        const module = await loader();
+        registerRouteComponent(route.id, module.default);
+      } catch (err) {
+        const pageError = createPageLoadErrorResponse(
+          route.id,
+          route.pattern,
+          err instanceof Error ? err : new Error(String(err))
+        );
+        console.error(`[Mandu] ${pageError.errorType}:`, pageError.message);
+        const response = formatErrorResponse(pageError, {
+          isDev: process.env.NODE_ENV !== "production",
+        });
+        return Response.json(response, { status: 500 });
+      }
+    }
+
+    const appCreator = createAppFn || defaultCreateApp;
+    try {
+      const app = appCreator({
+        routeId: route.id,
+        url: req.url,
+        params,
+      });
+
+      return renderSSR(app, { title: `${route.id} - Mandu` });
+    } catch (err) {
+      const ssrError = createSSRErrorResponse(
+        route.id,
+        route.pattern,
+        err instanceof Error ? err : new Error(String(err))
+      );
+      console.error(`[Mandu] ${ssrError.errorType}:`, ssrError.message);
+      const response = formatErrorResponse(ssrError, {
+        isDev: process.env.NODE_ENV !== "production",
+      });
+      return Response.json(response, { status: 500 });
+    }
+  }
+
+  return Response.json({
+    errorType: "FRAMEWORK_BUG",
+    code: "MANDU_F003",
+    message: `Unknown route kind: ${route.kind}`,
+    summary: "알 수 없는 라우트 종류 - 프레임워크 버그",
+    fix: {
+      file: "spec/routes.manifest.json",
+      suggestion: "라우트의 kind는 'api' 또는 'page'여야 합니다",
+    },
+    route: {
+      id: route.id,
+      pattern: route.pattern,
+    },
+    timestamp: new Date().toISOString(),
+  }, { status: 500 });
+}
+
+export function startServer(manifest: RoutesManifest, options: ServerOptions = {}): ManduServer {
+  const { port = 3000, hostname = "localhost" } = options;
+
+  const router = new Router(manifest.routes);
+
+  const server = Bun.serve({
+    port,
+    hostname,
+    fetch: (req) => handleRequest(req, router),
+  });
+
+  console.log(`🥟 Mandu server running at http://${hostname}:${port}`);
+
+  return {
+    server,
+    router,
+    stop: () => server.stop(),
+  };
+}
+
+// Clear registries (useful for testing)
+export function clearRegistry(): void {
+  apiHandlers.clear();
+  pageLoaders.clear();
+  routeComponents.clear();
+  createAppFn = null;
+}
+
+export { apiHandlers, pageLoaders, routeComponents };

package/src/runtime/ssr.ts

@@ -1,38 +1,38 @@
-import { renderToString } from "react-dom/server";
-import type { ReactElement } from "react";
-
-export interface SSROptions {
-  title?: string;
-  lang?: string;
-}
-
-export function renderToHTML(element: ReactElement, options: SSROptions = {}): string {
-  const { title = "Mandu App", lang = "ko" } = options;
-  const content = renderToString(element);
-
-  return `<!doctype html>
-<html lang="${lang}">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${title}</title>
-</head>
-<body>
-  <div id="root">${content}</div>
-</body>
-</html>`;
-}
-
-export function createHTMLResponse(html: string, status: number = 200): Response {
-  return new Response(html, {
-    status,
-    headers: {
-      "Content-Type": "text/html; charset=utf-8",
-    },
-  });
-}
-
-export function renderSSR(element: ReactElement, options: SSROptions = {}): Response {
-  const html = renderToHTML(element, options);
-  return createHTMLResponse(html);
-}
+import { renderToString } from "react-dom/server";
+import type { ReactElement } from "react";
+
+export interface SSROptions {
+  title?: string;
+  lang?: string;
+}
+
+export function renderToHTML(element: ReactElement, options: SSROptions = {}): string {
+  const { title = "Mandu App", lang = "ko" } = options;
+  const content = renderToString(element);
+
+  return `<!doctype html>
+<html lang="${lang}">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+</head>
+<body>
+  <div id="root">${content}</div>
+</body>
+</html>`;
+}
+
+export function createHTMLResponse(html: string, status: number = 200): Response {
+  return new Response(html, {
+    status,
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+    },
+  });
+}
+
+export function renderSSR(element: ReactElement, options: SSROptions = {}): Response {
+  const html = renderToHTML(element, options);
+  return createHTMLResponse(html);
+}

package/src/spec/index.ts

@@ -1,3 +1,3 @@
-export * from "./schema";
-export * from "./load";
-export * from "./lock";
+export * from "./schema";
+export * from "./load";
+export * from "./lock";

package/src/spec/load.ts

@@ -1,76 +1,76 @@
-import { RoutesManifest, type RoutesManifest as RoutesManifestType } from "./schema";
-import { ZodError } from "zod";
-
-export interface LoadResult {
-  success: boolean;
-  data?: RoutesManifestType;
-  errors?: string[];
-}
-
-export function formatZodError(error: ZodError): string[] {
-  return error.errors.map((e) => {
-    const path = e.path.length > 0 ? `[${e.path.join(".")}] ` : "";
-    return `${path}${e.message}`;
-  });
-}
-
-export async function loadManifest(filePath: string): Promise<LoadResult> {
-  try {
-    const file = Bun.file(filePath);
-    const exists = await file.exists();
-
-    if (!exists) {
-      return {
-        success: false,
-        errors: [`파일을 찾을 수 없습니다: ${filePath}`],
-      };
-    }
-
-    const content = await file.text();
-    let json: unknown;
-
-    try {
-      json = JSON.parse(content);
-    } catch {
-      return {
-        success: false,
-        errors: ["JSON 파싱 실패: 올바른 JSON 형식이 아닙니다"],
-      };
-    }
-
-    const result = RoutesManifest.safeParse(json);
-
-    if (!result.success) {
-      return {
-        success: false,
-        errors: formatZodError(result.error),
-      };
-    }
-
-    return {
-      success: true,
-      data: result.data,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      errors: [`예상치 못한 오류: ${error instanceof Error ? error.message : String(error)}`],
-    };
-  }
-}
-
-export function validateManifest(data: unknown): LoadResult {
-  const result = RoutesManifest.safeParse(data);
-
-  if (!result.success) {
-    return {
-      success: false,
-      errors: formatZodError(result.error),
-    };
-  }
-
-  return {
-    success: true,
-    data: result.data,
-  };
-}
+import { RoutesManifest, type RoutesManifest as RoutesManifestType } from "./schema";
+import { ZodError } from "zod";
+
+export interface LoadResult {
+  success: boolean;
+  data?: RoutesManifestType;
+  errors?: string[];
+}
+
+export function formatZodError(error: ZodError): string[] {
+  return error.errors.map((e) => {
+    const path = e.path.length > 0 ? `[${e.path.join(".")}] ` : "";
+    return `${path}${e.message}`;
+  });
+}
+
+export async function loadManifest(filePath: string): Promise<LoadResult> {
+  try {
+    const file = Bun.file(filePath);
+    const exists = await file.exists();
+
+    if (!exists) {
+      return {
+        success: false,
+        errors: [`파일을 찾을 수 없습니다: ${filePath}`],
+      };
+    }
+
+    const content = await file.text();
+    let json: unknown;
+
+    try {
+      json = JSON.parse(content);
+    } catch {
+      return {
+        success: false,
+        errors: ["JSON 파싱 실패: 올바른 JSON 형식이 아닙니다"],
+      };
+    }
+
+    const result = RoutesManifest.safeParse(json);
+
+    if (!result.success) {
+      return {
+        success: false,
+        errors: formatZodError(result.error),
+      };
+    }
+
+    return {
+      success: true,
+      data: result.data,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [`예상치 못한 오류: ${error instanceof Error ? error.message : String(error)}`],
+    };
+  }
+}
+
+export function validateManifest(data: unknown): LoadResult {
+  const result = RoutesManifest.safeParse(data);
+
+  if (!result.success) {
+    return {
+      success: false,
+      errors: formatZodError(result.error),
+    };
+  }
+
+  return {
+    success: true,
+    data: result.data,
+  };
+}