@mandujs/core 0.2.1 → 0.3.0

package/README.ko.md

@@ -0,0 +1,191 @@
+# @mandujs/core
+
+> **[English](./README.md)** | 한국어
+
+Mandu Framework Core - Spec, Generator, Guard, Runtime
+
+## 설치
+
+```bash
+bun add @mandujs/core
+```
+
+> 일반적으로 `@mandujs/cli`를 통해 사용합니다. 직접 사용은 고급 사용 사례입니다.
+
+## 모듈 구조
+
+```
+@mandujs/core
+├── spec/      # Spec 스키마 및 로딩
+├── generator/ # 코드 생성
+├── guard/     # 아키텍처 검사 및 자동 수정
+├── runtime/   # 서버 및 라우터
+└── report/    # Guard 리포트 생성
+```
+
+## Spec 모듈
+
+라우트 manifest 스키마 정의 및 로딩.
+
+```typescript
+import { loadManifest, RoutesManifest, RouteSpec } from "@mandujs/core";
+
+// manifest 로드 및 검증
+const result = await loadManifest("spec/routes.manifest.json");
+
+if (result.success && result.data) {
+  const manifest: RoutesManifest = result.data;
+  manifest.routes.forEach((route: RouteSpec) => {
+    console.log(route.id, route.pattern, route.kind);
+  });
+}
+```
+
+### Lock 파일
+
+```typescript
+import { writeLock, readLock } from "@mandujs/core";
+
+// lock 파일 쓰기
+const lock = await writeLock("spec/spec.lock.json", manifest);
+console.log(lock.routesHash);
+
+// lock 파일 읽기
+const existing = await readLock("spec/spec.lock.json");
+```
+
+## Generator 모듈
+
+Spec 기반 코드 생성.
+
+```typescript
+import { generateRoutes, GenerateResult } from "@mandujs/core";
+
+const result: GenerateResult = await generateRoutes(manifest, "./");
+
+console.log("생성됨:", result.created);
+console.log("건너뜀:", result.skipped);  // 이미 존재하는 slot 파일
+```
+
+### 템플릿 함수
+
+```typescript
+import {
+  generateApiHandler,
+  generateApiHandlerWithSlot,
+  generateSlotLogic,
+  generatePageComponent
+} from "@mandujs/core";
+
+// API 핸들러 생성
+const code = generateApiHandler(route);
+
+// Slot이 있는 API 핸들러
+const codeWithSlot = generateApiHandlerWithSlot(route);
+
+// Slot 로직 파일
+const slotCode = generateSlotLogic(route);
+```
+
+## Guard 모듈
+
+아키텍처 규칙 검사 및 자동 수정.
+
+```typescript
+import {
+  runGuardCheck,
+  runAutoCorrect,
+  GuardResult,
+  GuardViolation
+} from "@mandujs/core";
+
+// 검사 실행
+const result: GuardResult = await runGuardCheck(manifest, "./");
+
+if (!result.passed) {
+  result.violations.forEach((v: GuardViolation) => {
+    console.log(`${v.rule}: ${v.message}`);
+  });
+
+  // 자동 수정 실행
+  const corrected = await runAutoCorrect(result.violations, manifest, "./");
+  console.log("수정됨:", corrected.steps);
+  console.log("남은 위반:", corrected.remainingViolations);
+}
+```
+
+### Guard 규칙
+
+| 규칙 ID | 설명 | 자동 수정 |
+|---------|------|----------|
+| `SPEC_HASH_MISMATCH` | spec과 lock 해시 불일치 | ✅ |
+| `GENERATED_MANUAL_EDIT` | generated 파일 수동 수정 | ✅ |
+| `HANDLER_NOT_FOUND` | 핸들러 파일 없음 | ❌ |
+| `COMPONENT_NOT_FOUND` | 컴포넌트 파일 없음 | ❌ |
+| `SLOT_NOT_FOUND` | slot 파일 없음 | ✅ |
+
+## Runtime 모듈
+
+서버 시작 및 라우팅.
+
+```typescript
+import {
+  startServer,
+  registerApiHandler,
+  registerPageLoader
+} from "@mandujs/core";
+
+// API 핸들러 등록
+registerApiHandler("getUsers", async (req) => {
+  return { users: [] };
+});
+
+// 페이지 로더 등록
+registerPageLoader("homePage", () => import("./pages/Home"));
+
+// 서버 시작
+const server = startServer(manifest, { port: 3000 });
+
+// 종료
+server.stop();
+```
+
+## Report 모듈
+
+Guard 결과 리포트 생성.
+
+```typescript
+import { buildGuardReport } from "@mandujs/core";
+
+const report = buildGuardReport(guardResult, lockPath);
+console.log(report);  // 포맷된 텍스트 리포트
+```
+
+## 타입
+
+```typescript
+import type {
+  RoutesManifest,
+  RouteSpec,
+  RouteKind,
+  SpecLock,
+  GuardResult,
+  GuardViolation,
+  GenerateResult,
+  AutoCorrectResult,
+} from "@mandujs/core";
+```
+
+## 요구 사항
+
+- Bun >= 1.0.0
+- React >= 18.0.0
+- Zod >= 3.0.0
+
+## 관련 패키지
+
+- [@mandujs/cli](https://www.npmjs.com/package/@mandujs/cli) - CLI 도구
+
+## 라이선스
+
+MIT

package/README.md

@@ -1,34 +1,36 @@
 # @mandujs/core
 
+> English | **[한국어](./README.ko.md)**
+
 Mandu Framework Core - Spec, Generator, Guard, Runtime
 
-## 설치
+## Installation
 
 ```bash
 bun add @mandujs/core
 ```
 
-> 일반적으로 `@mandujs/cli`를 통해 사용합니다. 직접 사용은 고급 사용 사례입니다.
+> Typically used through `@mandujs/cli`. Direct usage is for advanced use cases.
 
-## 모듈 구조
+## Module Structure
 
 ```
 @mandujs/core
-├── spec/      # Spec 스키마 및 로딩
-├── generator/ # 코드 생성
-├── guard/     # 아키텍처 검사 및 자동 수정
-├── runtime/   # 서버 및 라우터
-└── report/    # Guard 리포트 생성
+├── spec/      # Spec schema and loading
+├── generator/ # Code generation
+├── guard/     # Architecture checking and auto-correction
+├── runtime/   # Server and router
+└── report/    # Guard report generation
 ```
 
-## Spec 모듈
+## Spec Module
 
-라우트 manifest 스키마 정의 및 로딩.
+Route manifest schema definition and loading.
 
 ```typescript
 import { loadManifest, RoutesManifest, RouteSpec } from "@mandujs/core";
 
-// manifest 로드 및 검증
+// Load and validate manifest
 const result = await loadManifest("spec/routes.manifest.json");
 
 if (result.success && result.data) {
@@ -39,33 +41,33 @@ if (result.success && result.data) {
 }
 ```
 
-### Lock 파일
+### Lock File
 
 ```typescript
 import { writeLock, readLock } from "@mandujs/core";
 
-// lock 파일 쓰기
+// Write lock file
 const lock = await writeLock("spec/spec.lock.json", manifest);
 console.log(lock.routesHash);
 
-// lock 파일 읽기
+// Read lock file
 const existing = await readLock("spec/spec.lock.json");
 ```
 
-## Generator 모듈
+## Generator Module
 
-Spec 기반 코드 생성.
+Spec-based code generation.
 
 ```typescript
 import { generateRoutes, GenerateResult } from "@mandujs/core";
 
 const result: GenerateResult = await generateRoutes(manifest, "./");
 
-console.log("생성됨:", result.created);
-console.log("건너뜀:", result.skipped);  // 이미 존재하는 slot 파일
+console.log("Created:", result.created);
+console.log("Skipped:", result.skipped);  // Existing slot files
 ```
 
-### 템플릿 함수
+### Template Functions
 
 ```typescript
 import {
@@ -75,19 +77,19 @@ import {
   generatePageComponent
 } from "@mandujs/core";
 
-// API 핸들러 생성
+// Generate API handler
 const code = generateApiHandler(route);
 
-// Slot이 있는 API 핸들러
+// API handler with slot
 const codeWithSlot = generateApiHandlerWithSlot(route);
 
-// Slot 로직 파일
+// Slot logic file
 const slotCode = generateSlotLogic(route);
 ```
 
-## Guard 모듈
+## Guard Module
 
-아키텍처 규칙 검사 및 자동 수정.
+Architecture rule checking and auto-correction.
 
 ```typescript
 import {
@@ -97,7 +99,7 @@ import {
   GuardViolation
 } from "@mandujs/core";
 
-// 검사 실행
+// Run check
 const result: GuardResult = await runGuardCheck(manifest, "./");
 
 if (!result.passed) {
@@ -105,26 +107,26 @@ if (!result.passed) {
     console.log(`${v.rule}: ${v.message}`);
   });
 
-  // 자동 수정 실행
+  // Run auto-correction
   const corrected = await runAutoCorrect(result.violations, manifest, "./");
-  console.log("수정됨:", corrected.steps);
-  console.log("남은 위반:", corrected.remainingViolations);
+  console.log("Fixed:", corrected.steps);
+  console.log("Remaining violations:", corrected.remainingViolations);
 }
 ```
 
-### Guard 규칙
+### Guard Rules
 
-| 규칙 ID | 설명 | 자동 수정 |
-|---------|------|----------|
-| `SPEC_HASH_MISMATCH` | spec과 lock 해시 불일치 | ✅ |
-| `GENERATED_MANUAL_EDIT` | generated 파일 수동 수정 | ✅ |
-| `HANDLER_NOT_FOUND` | 핸들러 파일 없음 | ❌ |
-| `COMPONENT_NOT_FOUND` | 컴포넌트 파일 없음 | ❌ |
-| `SLOT_NOT_FOUND` | slot 파일 없음 | ✅ |
+| Rule ID | Description | Auto-correctable |
+|---------|-------------|------------------|
+| `SPEC_HASH_MISMATCH` | Spec and lock hash mismatch | ✅ |
+| `GENERATED_MANUAL_EDIT` | Manual edit to generated file | ✅ |
+| `HANDLER_NOT_FOUND` | Handler file not found | ❌ |
+| `COMPONENT_NOT_FOUND` | Component file not found | ❌ |
+| `SLOT_NOT_FOUND` | Slot file not found | ✅ |
 
-## Runtime 모듈
+## Runtime Module
 
-서버 시작 및 라우팅.
+Server startup and routing.
 
 ```typescript
 import {
@@ -133,33 +135,33 @@ import {
   registerPageLoader
 } from "@mandujs/core";
 
-// API 핸들러 등록
+// Register API handler
 registerApiHandler("getUsers", async (req) => {
   return { users: [] };
 });
 
-// 페이지 로더 등록
+// Register page loader
 registerPageLoader("homePage", () => import("./pages/Home"));
 
-// 서버 시작
+// Start server
 const server = startServer(manifest, { port: 3000 });
 
-// 종료
+// Stop
 server.stop();
 ```
 
-## Report 모듈
+## Report Module
 
-Guard 결과 리포트 생성.
+Guard result report generation.
 
 ```typescript
 import { buildGuardReport } from "@mandujs/core";
 
 const report = buildGuardReport(guardResult, lockPath);
-console.log(report);  // 포맷된 텍스트 리포트
+console.log(report);  // Formatted text report
 ```
 
-## 타입
+## Types
 
 ```typescript
 import type {
@@ -174,16 +176,16 @@ import type {
 } from "@mandujs/core";
 ```
 
-## 요구 사항
+## Requirements
 
 - Bun >= 1.0.0
 - React >= 18.0.0
 - Zod >= 3.0.0
 
-## 관련 패키지
+## Related Packages
 
-- [@mandujs/cli](https://www.npmjs.com/package/@mandujs/cli) - CLI 도구
+- [@mandujs/cli](https://www.npmjs.com/package/@mandujs/cli) - CLI tool
 
-## 라이선스
+## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Mandu Framework Core - Spec, Generator, Guard, Runtime",
   "type": "module",
   "main": "./src/index.ts",

package/src/filling/context.ts

@@ -0,0 +1,219 @@
+/**
+ * Mandu Context - 만두 접시 🥟
+ * Request/Response를 래핑하여 편리한 API 제공
+ */
+
+import type { ZodSchema } from "zod";
+
+export class ManduContext {
+  private store: Map<string, unknown> = new Map();
+  private _params: Record<string, string>;
+  private _query: Record<string, string>;
+  private _shouldContinue: boolean = true;
+  private _response: Response | null = null;
+
+  constructor(
+    public readonly request: Request,
+    params: Record<string, string> = {}
+  ) {
+    this._params = params;
+    this._query = this.parseQuery();
+  }
+
+  private parseQuery(): Record<string, string> {
+    const url = new URL(this.request.url);
+    const query: Record<string, string> = {};
+    url.searchParams.forEach((value, key) => {
+      query[key] = value;
+    });
+    return query;
+  }
+
+  // ============================================
+  // 🥟 Request 읽기
+  // ============================================
+
+  /** Path parameters (e.g., /users/:id → { id: '123' }) */
+  get params(): Record<string, string> {
+    return this._params;
+  }
+
+  /** Query parameters (e.g., ?name=mandu → { name: 'mandu' }) */
+  get query(): Record<string, string> {
+    return this._query;
+  }
+
+  /** Request headers */
+  get headers(): Headers {
+    return this.request.headers;
+  }
+
+  /** HTTP method */
+  get method(): string {
+    return this.request.method;
+  }
+
+  /** Request URL */
+  get url(): string {
+    return this.request.url;
+  }
+
+  /**
+   * Parse request body with optional Zod validation
+   * @example
+   * const data = await ctx.body() // any
+   * const data = await ctx.body(UserSchema) // typed & validated
+   */
+  async body<T = unknown>(schema?: ZodSchema<T>): Promise<T> {
+    const contentType = this.request.headers.get("content-type") || "";
+    let data: unknown;
+
+    if (contentType.includes("application/json")) {
+      data = await this.request.json();
+    } else if (contentType.includes("application/x-www-form-urlencoded")) {
+      const formData = await this.request.formData();
+      data = Object.fromEntries(formData.entries());
+    } else if (contentType.includes("multipart/form-data")) {
+      const formData = await this.request.formData();
+      data = Object.fromEntries(formData.entries());
+    } else {
+      data = await this.request.text();
+    }
+
+    if (schema) {
+      const result = schema.safeParse(data);
+      if (!result.success) {
+        throw new ValidationError(result.error.errors);
+      }
+      return result.data;
+    }
+
+    return data as T;
+  }
+
+  // ============================================
+  // 🥟 Response 보내기
+  // ============================================
+
+  /** 200 OK */
+  ok<T>(data: T): Response {
+    return this.json(data, 200);
+  }
+
+  /** 201 Created */
+  created<T>(data: T): Response {
+    return this.json(data, 201);
+  }
+
+  /** 204 No Content */
+  noContent(): Response {
+    return new Response(null, { status: 204 });
+  }
+
+  /** 400 Bad Request */
+  error(message: string, details?: unknown): Response {
+    return this.json({ status: "error", message, details }, 400);
+  }
+
+  /** 401 Unauthorized */
+  unauthorized(message: string = "Unauthorized"): Response {
+    return this.json({ status: "error", message }, 401);
+  }
+
+  /** 403 Forbidden */
+  forbidden(message: string = "Forbidden"): Response {
+    return this.json({ status: "error", message }, 403);
+  }
+
+  /** 404 Not Found */
+  notFound(message: string = "Not Found"): Response {
+    return this.json({ status: "error", message }, 404);
+  }
+
+  /** 500 Internal Server Error */
+  fail(message: string = "Internal Server Error"): Response {
+    return this.json({ status: "error", message }, 500);
+  }
+
+  /** Custom JSON response */
+  json<T>(data: T, status: number = 200): Response {
+    return Response.json(data, { status });
+  }
+
+  /** Custom text response */
+  text(data: string, status: number = 200): Response {
+    return new Response(data, {
+      status,
+      headers: { "Content-Type": "text/plain" },
+    });
+  }
+
+  /** Custom HTML response */
+  html(data: string, status: number = 200): Response {
+    return new Response(data, {
+      status,
+      headers: { "Content-Type": "text/html" },
+    });
+  }
+
+  /** Redirect response */
+  redirect(url: string, status: 301 | 302 | 307 | 308 = 302): Response {
+    return Response.redirect(url, status);
+  }
+
+  // ============================================
+  // 🥟 상태 저장 (Guard → Handler 전달)
+  // ============================================
+
+  /** Store value for later use */
+  set<T>(key: string, value: T): void {
+    this.store.set(key, value);
+  }
+
+  /** Get stored value */
+  get<T>(key: string): T | undefined {
+    return this.store.get(key) as T | undefined;
+  }
+
+  /** Check if key exists */
+  has(key: string): boolean {
+    return this.store.has(key);
+  }
+
+  // ============================================
+  // 🥟 Guard 제어
+  // ============================================
+
+  /** Continue to next guard/handler */
+  next(): symbol {
+    this._shouldContinue = true;
+    return NEXT_SYMBOL;
+  }
+
+  /** Check if should continue */
+  get shouldContinue(): boolean {
+    return this._shouldContinue;
+  }
+
+  /** Set early response (from guard) */
+  setResponse(response: Response): void {
+    this._shouldContinue = false;
+    this._response = response;
+  }
+
+  /** Get early response */
+  getResponse(): Response | null {
+    return this._response;
+  }
+}
+
+/** Symbol to indicate continue to next */
+export const NEXT_SYMBOL = Symbol("mandu:next");
+
+/** Validation error with details */
+export class ValidationError extends Error {
+  constructor(public readonly errors: unknown[]) {
+    super("Validation failed");
+    this.name = "ValidationError";
+  }
+}

package/src/filling/filling.ts

@@ -0,0 +1,234 @@
+/**
+ * Mandu Filling - 만두소 🥟
+ * 체이닝 API로 비즈니스 로직 정의
+ */
+
+import { ManduContext, NEXT_SYMBOL, ValidationError } from "./context";
+
+/** Handler function type */
+export type Handler = (ctx: ManduContext) => Response | Promise<Response>;
+
+/** Guard function type - returns next() or Response */
+export type Guard = (ctx: ManduContext) => symbol | Response | Promise<symbol | Response>;
+
+/** HTTP methods */
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+
+interface FillingConfig {
+  handlers: Map<HttpMethod, Handler>;
+  guards: Guard[];
+  methodGuards: Map<HttpMethod, Guard[]>;
+}
+
+/**
+ * Mandu Filling Builder
+ * @example
+ * ```typescript
+ * export default Mandu.filling()
+ *   .guard(authCheck)
+ *   .get(ctx => ctx.ok({ message: 'Hello!' }))
+ *   .post(ctx => ctx.created({ id: 1 }))
+ * ```
+ */
+export class ManduFilling {
+  private config: FillingConfig = {
+    handlers: new Map(),
+    guards: [],
+    methodGuards: new Map(),
+  };
+
+  // ============================================
+  // 🥟 HTTP Method Handlers
+  // ============================================
+
+  /** Handle GET requests */
+  get(handler: Handler): this {
+    this.config.handlers.set("GET", handler);
+    return this;
+  }
+
+  /** Handle POST requests */
+  post(handler: Handler): this {
+    this.config.handlers.set("POST", handler);
+    return this;
+  }
+
+  /** Handle PUT requests */
+  put(handler: Handler): this {
+    this.config.handlers.set("PUT", handler);
+    return this;
+  }
+
+  /** Handle PATCH requests */
+  patch(handler: Handler): this {
+    this.config.handlers.set("PATCH", handler);
+    return this;
+  }
+
+  /** Handle DELETE requests */
+  delete(handler: Handler): this {
+    this.config.handlers.set("DELETE", handler);
+    return this;
+  }
+
+  /** Handle HEAD requests */
+  head(handler: Handler): this {
+    this.config.handlers.set("HEAD", handler);
+    return this;
+  }
+
+  /** Handle OPTIONS requests */
+  options(handler: Handler): this {
+    this.config.handlers.set("OPTIONS", handler);
+    return this;
+  }
+
+  /** Handle all methods with single handler */
+  all(handler: Handler): this {
+    const methods: HttpMethod[] = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+    methods.forEach((method) => this.config.handlers.set(method, handler));
+    return this;
+  }
+
+  // ============================================
+  // 🥟 Guards (만두 찜기)
+  // ============================================
+
+  /**
+   * Add guard for all methods or specific methods
+   * @example
+   * .guard(authCheck)                    // all methods
+   * .guard(authCheck, 'POST', 'PUT')     // specific methods
+   */
+  guard(guardFn: Guard, ...methods: HttpMethod[]): this {
+    if (methods.length === 0) {
+      // Apply to all methods
+      this.config.guards.push(guardFn);
+    } else {
+      // Apply to specific methods
+      methods.forEach((method) => {
+        const guards = this.config.methodGuards.get(method) || [];
+        guards.push(guardFn);
+        this.config.methodGuards.set(method, guards);
+      });
+    }
+    return this;
+  }
+
+  /** Alias for guard - more semantic for middleware */
+  use(guardFn: Guard, ...methods: HttpMethod[]): this {
+    return this.guard(guardFn, ...methods);
+  }
+
+  // ============================================
+  // 🥟 Execution
+  // ============================================
+
+  /**
+   * Handle incoming request
+   * Called by generated route handler
+   */
+  async handle(request: Request, params: Record<string, string> = {}): Promise<Response> {
+    const ctx = new ManduContext(request, params);
+    const method = request.method.toUpperCase() as HttpMethod;
+
+    try {
+      // Run global guards
+      for (const guard of this.config.guards) {
+        const result = await guard(ctx);
+        if (result !== NEXT_SYMBOL) {
+          return result as Response;
+        }
+        if (!ctx.shouldContinue) {
+          return ctx.getResponse()!;
+        }
+      }
+
+      // Run method-specific guards
+      const methodGuards = this.config.methodGuards.get(method) || [];
+      for (const guard of methodGuards) {
+        const result = await guard(ctx);
+        if (result !== NEXT_SYMBOL) {
+          return result as Response;
+        }
+        if (!ctx.shouldContinue) {
+          return ctx.getResponse()!;
+        }
+      }
+
+      // Get handler for method
+      const handler = this.config.handlers.get(method);
+      if (!handler) {
+        return ctx.json(
+          {
+            status: "error",
+            message: `Method ${method} not allowed`,
+            allowed: Array.from(this.config.handlers.keys()),
+          },
+          405
+        );
+      }
+
+      // Execute handler
+      return await handler(ctx);
+    } catch (error) {
+      // Handle validation errors
+      if (error instanceof ValidationError) {
+        return ctx.json(
+          {
+            status: "error",
+            message: "Validation failed",
+            errors: error.errors,
+          },
+          400
+        );
+      }
+
+      // Handle other errors
+      console.error(`[Mandu] Handler error:`, error);
+      return ctx.fail(
+        error instanceof Error ? error.message : "Internal Server Error"
+      );
+    }
+  }
+
+  /**
+   * Get list of registered methods
+   */
+  getMethods(): HttpMethod[] {
+    return Array.from(this.config.handlers.keys());
+  }
+
+  /**
+   * Check if method is registered
+   */
+  hasMethod(method: HttpMethod): boolean {
+    return this.config.handlers.has(method);
+  }
+}
+
+/**
+ * Mandu namespace with factory methods
+ */
+export const Mandu = {
+  /**
+   * Create a new filling (slot logic builder)
+   * @example
+   * ```typescript
+   * import { Mandu } from '@mandujs/core'
+   *
+   * export default Mandu.filling()
+   *   .get(ctx => ctx.ok({ message: 'Hello!' }))
+   * ```
+   */
+  filling(): ManduFilling {
+    return new ManduFilling();
+  },
+
+  /**
+   * Create context manually (for testing)
+   */
+  context(request: Request, params?: Record<string, string>): ManduContext {
+    return new ManduContext(request, params);
+  },
+};

package/src/filling/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Mandu Filling Module - 만두소 🥟
+ */
+
+export { ManduContext, NEXT_SYMBOL, ValidationError } from "./context";
+export { ManduFilling, Mandu } from "./filling";
+export type { Handler, Guard, HttpMethod } from "./filling";

package/src/generator/templates.ts

@@ -25,7 +25,6 @@ export default function handler(req: Request, params: Record<string, string>): R
 
 export function generateApiHandlerWithSlot(route: RouteSpec): string {
   const slotImportPath = computeSlotImportPath(route.slotModule!, "apps/server/generated/routes");
-  const logicFunctionName = `${route.id}Logic`;
 
   return `// Generated by Mandu - DO NOT EDIT DIRECTLY
 // Route ID: ${route.id}
@@ -33,69 +32,61 @@ export function generateApiHandlerWithSlot(route: RouteSpec): string {
 // Slot Module: ${route.slotModule}
 
 import type { Request } from "bun";
-import { ${logicFunctionName} } from "${slotImportPath}";
+import filling from "${slotImportPath}";
 
 export default async function handler(
   req: Request,
   params: Record<string, string>
 ): Promise<Response> {
-  try {
-    const result = await ${logicFunctionName}(req, params);
-    return Response.json(result);
-  } catch (error) {
-    console.error(\`[${route.id}] Handler error:\`, error);
-    return Response.json(
-      { status: "error", message: "Internal server error" },
-      { status: 500 }
-    );
-  }
+  return filling.handle(req, params);
 }
 `;
 }
 
 export function generateSlotLogic(route: RouteSpec): string {
-  const logicFunctionName = `${route.id}Logic`;
-  const resultTypeName = `${capitalize(route.id)}Result`;
-
-  return `// Slot logic for route: ${route.id}
+  return `// 🥟 Mandu Filling - ${route.id}
 // Pattern: ${route.pattern}
 // 이 파일에서 비즈니스 로직을 구현하세요.
 
-import type { Request } from "bun";
-
-export interface ${resultTypeName} {
-  status: "ok" | "error";
-  data?: unknown;
-  message?: string;
-}
+import { Mandu } from "@mandujs/core";
+
+export default Mandu.filling()
+  // 📋 GET ${route.pattern}
+  .get((ctx) => {
+    return ctx.ok({
+      message: "Hello from ${route.id}!",
+      timestamp: new Date().toISOString(),
+    });
+  })
+
+  // ➕ POST ${route.pattern}
+  .post(async (ctx) => {
+    const body = await ctx.body();
+    return ctx.created({
+      message: "Created!",
+      received: body,
+    });
+  });
 
-export async function ${logicFunctionName}(
-  req: Request,
-  params: Record<string, string>
-): Promise<${resultTypeName}> {
-  const method = req.method;
-
-  // TODO: 비즈니스 로직 구현
-  switch (method) {
-    case "GET":
-      return {
-        status: "ok",
-        data: { routeId: "${route.id}", message: "GET 로직 미구현" },
-      };
-
-    case "POST":
-      return {
-        status: "ok",
-        data: { routeId: "${route.id}", message: "POST 로직 미구현" },
-      };
-
-    default:
-      return {
-        status: "error",
-        message: \`Method \${method} not allowed\`,
-      };
-  }
-}
+// 💡 사용 가능한 메서드:
+// .get(ctx => ...)     - GET 요청 처리
+// .post(ctx => ...)    - POST 요청 처리
+// .put(ctx => ...)     - PUT 요청 처리
+// .delete(ctx => ...)  - DELETE 요청 처리
+// .guard(ctx => ...)   - 인증/검증 미들웨어
+//
+// 💡 Context (ctx) API:
+// ctx.query            - Query parameters { name: 'value' }
+// ctx.params           - Path parameters { id: '123' }
+// ctx.body()           - Request body (자동 파싱)
+// ctx.body(zodSchema)  - Body with validation
+// ctx.headers          - Request headers
+// ctx.ok(data)         - 200 OK
+// ctx.created(data)    - 201 Created
+// ctx.error(msg)       - 400 Bad Request
+// ctx.notFound(msg)    - 404 Not Found
+// ctx.set(key, value)  - Guard에서 Handler로 데이터 전달
+// ctx.get(key)         - Guard에서 설정한 데이터 읽기
 `;
 }
 

package/src/index.ts

@@ -3,3 +3,4 @@ export * from "./runtime";
 export * from "./generator";
 export * from "./guard";
 export * from "./report";
+export * from "./filling";