@mandujs/core 0.3.2 → 0.3.4

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/slot/corrector.ts

@@ -0,0 +1,282 @@
+/**
+ * Slot Content Corrector
+ * 슬롯 파일의 자동 수정 가능한 문제를 해결합니다.
+ */
+
+import type { SlotValidationIssue } from "./validator";
+
+export interface CorrectionResult {
+  corrected: boolean;
+  content: string;
+  appliedFixes: AppliedFix[];
+  remainingIssues: SlotValidationIssue[];
+}
+
+export interface AppliedFix {
+  code: string;
+  description: string;
+  before?: string;
+  after?: string;
+}
+
+// 금지된 import를 대체할 안전한 패턴
+const SAFE_ALTERNATIVES: Record<string, string> = {
+  fs: "// Use Bun.file() or Bun.write() instead of fs",
+  "node:fs": "// Use Bun.file() or Bun.write() instead of fs",
+  child_process: "// Use Bun.spawn() or Bun.spawnSync() instead",
+  "node:child_process": "// Use Bun.spawn() or Bun.spawnSync() instead",
+  cluster: "// Clustering should be handled at the infrastructure level",
+  "node:cluster": "// Clustering should be handled at the infrastructure level",
+  worker_threads: "// Use Bun workers or external job queues",
+  "node:worker_threads": "// Use Bun workers or external job queues",
+};
+
+/**
+ * 슬롯 내용을 자동 수정합니다.
+ */
+export function correctSlotContent(
+  content: string,
+  issues: SlotValidationIssue[]
+): CorrectionResult {
+  let correctedContent = content;
+  const appliedFixes: AppliedFix[] = [];
+  const remainingIssues: SlotValidationIssue[] = [];
+
+  for (const issue of issues) {
+    if (!issue.autoFixable) {
+      remainingIssues.push(issue);
+      continue;
+    }
+
+    const result = applyFix(correctedContent, issue);
+    if (result.fixed) {
+      correctedContent = result.content;
+      appliedFixes.push({
+        code: issue.code,
+        description: issue.message,
+        before: result.before,
+        after: result.after,
+      });
+    } else {
+      remainingIssues.push(issue);
+    }
+  }
+
+  return {
+    corrected: appliedFixes.length > 0,
+    content: correctedContent,
+    appliedFixes,
+    remainingIssues,
+  };
+}
+
+interface FixResult {
+  fixed: boolean;
+  content: string;
+  before?: string;
+  after?: string;
+}
+
+function applyFix(content: string, issue: SlotValidationIssue): FixResult {
+  switch (issue.code) {
+    case "FORBIDDEN_IMPORT":
+      return fixForbiddenImport(content, issue);
+
+    case "MISSING_MANDU_IMPORT":
+      return fixMissingManduImport(content);
+
+    case "MISSING_DEFAULT_EXPORT":
+      return fixMissingDefaultExport(content);
+
+    default:
+      return { fixed: false, content };
+  }
+}
+
+/**
+ * 금지된 import를 제거하고 주석으로 대체
+ */
+function fixForbiddenImport(
+  content: string,
+  issue: SlotValidationIssue
+): FixResult {
+  const lines = content.split("\n");
+
+  if (!issue.line) {
+    return { fixed: false, content };
+  }
+
+  const lineIndex = issue.line - 1;
+  const originalLine = lines[lineIndex];
+
+  // 어떤 금지된 모듈인지 찾기
+  let forbiddenModule = "";
+  for (const [module, alternative] of Object.entries(SAFE_ALTERNATIVES)) {
+    if (originalLine.includes(`'${module}'`) || originalLine.includes(`"${module}"`)) {
+      forbiddenModule = module;
+      break;
+    }
+  }
+
+  if (!forbiddenModule) {
+    return { fixed: false, content };
+  }
+
+  // import 문을 주석으로 대체
+  const alternative = SAFE_ALTERNATIVES[forbiddenModule];
+  lines[lineIndex] = `// REMOVED: ${originalLine.trim()}\n${alternative}`;
+
+  return {
+    fixed: true,
+    content: lines.join("\n"),
+    before: originalLine,
+    after: lines[lineIndex],
+  };
+}
+
+/**
+ * Mandu import 추가
+ */
+function fixMissingManduImport(content: string): FixResult {
+  const manduImport = `import { Mandu } from "@mandujs/core";\n`;
+
+  // 이미 다른 import가 있는지 확인
+  const hasImports = /^import\s+/m.test(content);
+
+  let newContent: string;
+  if (hasImports) {
+    // 첫 번째 import 앞에 추가
+    newContent = content.replace(/^(import\s+)/m, `${manduImport}$1`);
+  } else {
+    // 파일 맨 앞에 추가
+    newContent = manduImport + content;
+  }
+
+  return {
+    fixed: true,
+    content: newContent,
+    before: "(없음)",
+    after: manduImport.trim(),
+  };
+}
+
+/**
+ * default export 추가
+ */
+function fixMissingDefaultExport(content: string): FixResult {
+  // Mandu.filling()이 있는지 확인
+  const fillingMatch = content.match(/Mandu\s*\.\s*filling\s*\(\s*\)/);
+
+  if (!fillingMatch) {
+    // filling 패턴이 없으면 수정 불가
+    return { fixed: false, content };
+  }
+
+  // export default가 없는 Mandu.filling() 찾기
+  // 예: const handler = Mandu.filling()... -> export default Mandu.filling()...
+  const patterns = [
+    // const/let/var handler = Mandu.filling()
+    /^(\s*)(const|let|var)\s+\w+\s*=\s*(Mandu\s*\.\s*filling\s*\(\s*\))/m,
+    // 단독 Mandu.filling()
+    /^(\s*)(Mandu\s*\.\s*filling\s*\(\s*\))/m,
+  ];
+
+  for (const pattern of patterns) {
+    if (pattern.test(content)) {
+      const newContent = content.replace(pattern, "$1export default $3");
+      return {
+        fixed: true,
+        content: newContent,
+        before: content.match(pattern)?.[0],
+        after: newContent.match(/export default Mandu\.filling\(\)/)?.[0],
+      };
+    }
+  }
+
+  // 파일 끝에 export default 추가 시도
+  if (content.includes("Mandu.filling()") && !content.includes("export default")) {
+    // 마지막 세미콜론 또는 중괄호 뒤에 추가
+    const lastLine = content.trimEnd();
+    if (!lastLine.endsWith(";") && !lastLine.endsWith("}")) {
+      return { fixed: false, content };
+    }
+  }
+
+  return { fixed: false, content };
+}
+
+/**
+ * 여러 번의 수정 시도 (Self-correction loop)
+ */
+export async function runSlotCorrection(
+  content: string,
+  validateFn: (content: string) => { valid: boolean; issues: SlotValidationIssue[] },
+  maxRetries: number = 3
+): Promise<{
+  success: boolean;
+  finalContent: string;
+  attempts: number;
+  allFixes: AppliedFix[];
+  remainingIssues: SlotValidationIssue[];
+}> {
+  let currentContent = content;
+  let attempts = 0;
+  const allFixes: AppliedFix[] = [];
+
+  while (attempts < maxRetries) {
+    attempts++;
+
+    // 1. 검증
+    const validation = validateFn(currentContent);
+
+    if (validation.valid) {
+      return {
+        success: true,
+        finalContent: currentContent,
+        attempts,
+        allFixes,
+        remainingIssues: [],
+      };
+    }
+
+    // 2. 자동 수정 가능한 문제가 있는지 확인
+    const autoFixable = validation.issues.filter((i) => i.autoFixable);
+    if (autoFixable.length === 0) {
+      // 자동 수정 불가능한 문제만 남음
+      return {
+        success: false,
+        finalContent: currentContent,
+        attempts,
+        allFixes,
+        remainingIssues: validation.issues,
+      };
+    }
+
+    // 3. 수정 적용
+    const correction = correctSlotContent(currentContent, validation.issues);
+    allFixes.push(...correction.appliedFixes);
+
+    if (!correction.corrected) {
+      // 수정이 적용되지 않음
+      return {
+        success: false,
+        finalContent: currentContent,
+        attempts,
+        allFixes,
+        remainingIssues: validation.issues,
+      };
+    }
+
+    currentContent = correction.content;
+  }
+
+  // maxRetries 도달
+  const finalValidation = validateFn(currentContent);
+  return {
+    success: finalValidation.valid,
+    finalContent: currentContent,
+    attempts,
+    allFixes,
+    remainingIssues: finalValidation.issues,
+  };
+}