@mandujs/core 0.2.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.2.2",
+  "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";