@mandujs/core 0.8.1 → 0.8.2

package/src/runtime/compose.ts

@@ -1,222 +1,222 @@
-/**
- * Mandu Middleware Compose 🔗
- * Hono 스타일 미들웨어 조합 패턴
- *
- * @see https://github.com/honojs/hono/blob/main/src/compose.ts
- */
-
-import type { ManduContext } from "../filling/context";
-
-/**
- * Next 함수 타입
- */
-export type Next = () => Promise<void>;
-
-/**
- * 미들웨어 함수 타입
- * - Response 반환: 체인 중단 (Guard 역할)
- * - void 반환: 다음 미들웨어 실행
- */
-export type Middleware = (
-  ctx: ManduContext,
-  next: Next
-) => Response | void | Promise<Response | void>;
-
-/**
- * 에러 핸들러 타입
- */
-export type ErrorHandler = (
-  error: Error,
-  ctx: ManduContext
-) => Response | Promise<Response>;
-
-/**
- * NotFound 핸들러 타입
- */
-export type NotFoundHandler = (ctx: ManduContext) => Response | Promise<Response>;
-
-/**
- * 미들웨어 엔트리 (메타데이터 포함)
- */
-export interface MiddlewareEntry {
-  fn: Middleware;
-  name?: string;
-  isAsync?: boolean;
-}
-
-/**
- * Compose 옵션
- */
-export interface ComposeOptions {
-  onError?: ErrorHandler;
-  onNotFound?: NotFoundHandler;
-}
-
-/**
- * 미들웨어 함수들을 하나의 실행 함수로 조합
- *
- * @example
- * ```typescript
- * const middleware = [
- *   { fn: async (ctx, next) => { console.log('before'); await next(); console.log('after'); } },
- *   { fn: async (ctx, next) => { return ctx.ok({ data: 'hello' }); } },
- * ];
- *
- * const handler = compose(middleware, {
- *   onError: (err, ctx) => ctx.json({ error: err.message }, 500),
- *   onNotFound: (ctx) => ctx.notFound(),
- * });
- *
- * const response = await handler(context);
- * ```
- */
-export function compose(
-  middleware: MiddlewareEntry[],
-  options: ComposeOptions = {}
-): (ctx: ManduContext) => Promise<Response> {
-  const { onError, onNotFound } = options;
-
-  return async (ctx: ManduContext): Promise<Response> => {
-    let index = -1;
-    let finalResponse: Response | undefined;
-
-    /**
-     * 미들웨어 순차 실행
-     * @param i 현재 인덱스
-     */
-    async function dispatch(i: number): Promise<void> {
-      // next() 이중 호출 방지
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-
-      const entry = middleware[i];
-
-      if (!entry) {
-        // 모든 미들웨어 통과 후 핸들러 없음
-        if (!finalResponse && onNotFound) {
-          finalResponse = await onNotFound(ctx);
-        }
-        return;
-      }
-
-      try {
-        const result = await entry.fn(ctx, () => dispatch(i + 1));
-
-        // Response 반환 시 체인 중단
-        if (result instanceof Response) {
-          finalResponse = result;
-          return;
-        }
-      } catch (err) {
-        if (err instanceof Error && onError) {
-          finalResponse = await onError(err, ctx);
-          return;
-        }
-        throw err;
-      }
-    }
-
-    await dispatch(0);
-
-    // 응답이 없으면 404
-    if (!finalResponse) {
-      if (onNotFound) {
-        finalResponse = await onNotFound(ctx);
-      } else {
-        finalResponse = new Response("Not Found", { status: 404 });
-      }
-    }
-
-    return finalResponse;
-  };
-}
-
-/**
- * 미들웨어 배열 생성 헬퍼
- *
- * @example
- * ```typescript
- * const mw = createMiddleware([
- *   authGuard,
- *   rateLimitGuard,
- *   mainHandler,
- * ]);
- * ```
- */
-export function createMiddleware(
-  fns: Middleware[]
-): MiddlewareEntry[] {
-  return fns.map((fn, i) => ({
-    fn,
-    name: fn.name || `middleware_${i}`,
-    isAsync: fn.constructor.name === "AsyncFunction",
-  }));
-}
-
-/**
- * 미들웨어 체인 빌더
- *
- * @example
- * ```typescript
- * const chain = new MiddlewareChain()
- *   .use(authGuard)
- *   .use(rateLimitGuard)
- *   .use(mainHandler)
- *   .onError((err, ctx) => ctx.json({ error: err.message }, 500))
- *   .build();
- *
- * const response = await chain(ctx);
- * ```
- */
-export class MiddlewareChain {
-  private middleware: MiddlewareEntry[] = [];
-  private errorHandler?: ErrorHandler;
-  private notFoundHandler?: NotFoundHandler;
-
-  /**
-   * 미들웨어 추가
-   */
-  use(fn: Middleware, name?: string): this {
-    this.middleware.push({
-      fn,
-      name: name || fn.name || `middleware_${this.middleware.length}`,
-      isAsync: fn.constructor.name === "AsyncFunction",
-    });
-    return this;
-  }
-
-  /**
-   * 에러 핸들러 설정
-   */
-  onError(handler: ErrorHandler): this {
-    this.errorHandler = handler;
-    return this;
-  }
-
-  /**
-   * NotFound 핸들러 설정
-   */
-  onNotFound(handler: NotFoundHandler): this {
-    this.notFoundHandler = handler;
-    return this;
-  }
-
-  /**
-   * 미들웨어 체인 빌드
-   */
-  build(): (ctx: ManduContext) => Promise<Response> {
-    return compose(this.middleware, {
-      onError: this.errorHandler,
-      onNotFound: this.notFoundHandler,
-    });
-  }
-
-  /**
-   * 미들웨어 목록 조회
-   */
-  getMiddleware(): MiddlewareEntry[] {
-    return [...this.middleware];
-  }
-}
+/**
+ * Mandu Middleware Compose 🔗
+ * Hono 스타일 미들웨어 조합 패턴
+ *
+ * @see https://github.com/honojs/hono/blob/main/src/compose.ts
+ */
+
+import type { ManduContext } from "../filling/context";
+
+/**
+ * Next 함수 타입
+ */
+export type Next = () => Promise<void>;
+
+/**
+ * 미들웨어 함수 타입
+ * - Response 반환: 체인 중단 (Guard 역할)
+ * - void 반환: 다음 미들웨어 실행
+ */
+export type Middleware = (
+  ctx: ManduContext,
+  next: Next
+) => Response | void | Promise<Response | void>;
+
+/**
+ * 에러 핸들러 타입
+ */
+export type ErrorHandler = (
+  error: Error,
+  ctx: ManduContext
+) => Response | Promise<Response>;
+
+/**
+ * NotFound 핸들러 타입
+ */
+export type NotFoundHandler = (ctx: ManduContext) => Response | Promise<Response>;
+
+/**
+ * 미들웨어 엔트리 (메타데이터 포함)
+ */
+export interface MiddlewareEntry {
+  fn: Middleware;
+  name?: string;
+  isAsync?: boolean;
+}
+
+/**
+ * Compose 옵션
+ */
+export interface ComposeOptions {
+  onError?: ErrorHandler;
+  onNotFound?: NotFoundHandler;
+}
+
+/**
+ * 미들웨어 함수들을 하나의 실행 함수로 조합
+ *
+ * @example
+ * ```typescript
+ * const middleware = [
+ *   { fn: async (ctx, next) => { console.log('before'); await next(); console.log('after'); } },
+ *   { fn: async (ctx, next) => { return ctx.ok({ data: 'hello' }); } },
+ * ];
+ *
+ * const handler = compose(middleware, {
+ *   onError: (err, ctx) => ctx.json({ error: err.message }, 500),
+ *   onNotFound: (ctx) => ctx.notFound(),
+ * });
+ *
+ * const response = await handler(context);
+ * ```
+ */
+export function compose(
+  middleware: MiddlewareEntry[],
+  options: ComposeOptions = {}
+): (ctx: ManduContext) => Promise<Response> {
+  const { onError, onNotFound } = options;
+
+  return async (ctx: ManduContext): Promise<Response> => {
+    let index = -1;
+    let finalResponse: Response | undefined;
+
+    /**
+     * 미들웨어 순차 실행
+     * @param i 현재 인덱스
+     */
+    async function dispatch(i: number): Promise<void> {
+      // next() 이중 호출 방지
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+
+      const entry = middleware[i];
+
+      if (!entry) {
+        // 모든 미들웨어 통과 후 핸들러 없음
+        if (!finalResponse && onNotFound) {
+          finalResponse = await onNotFound(ctx);
+        }
+        return;
+      }
+
+      try {
+        const result = await entry.fn(ctx, () => dispatch(i + 1));
+
+        // Response 반환 시 체인 중단
+        if (result instanceof Response) {
+          finalResponse = result;
+          return;
+        }
+      } catch (err) {
+        if (err instanceof Error && onError) {
+          finalResponse = await onError(err, ctx);
+          return;
+        }
+        throw err;
+      }
+    }
+
+    await dispatch(0);
+
+    // 응답이 없으면 404
+    if (!finalResponse) {
+      if (onNotFound) {
+        finalResponse = await onNotFound(ctx);
+      } else {
+        finalResponse = new Response("Not Found", { status: 404 });
+      }
+    }
+
+    return finalResponse;
+  };
+}
+
+/**
+ * 미들웨어 배열 생성 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const mw = createMiddleware([
+ *   authGuard,
+ *   rateLimitGuard,
+ *   mainHandler,
+ * ]);
+ * ```
+ */
+export function createMiddleware(
+  fns: Middleware[]
+): MiddlewareEntry[] {
+  return fns.map((fn, i) => ({
+    fn,
+    name: fn.name || `middleware_${i}`,
+    isAsync: fn.constructor.name === "AsyncFunction",
+  }));
+}
+
+/**
+ * 미들웨어 체인 빌더
+ *
+ * @example
+ * ```typescript
+ * const chain = new MiddlewareChain()
+ *   .use(authGuard)
+ *   .use(rateLimitGuard)
+ *   .use(mainHandler)
+ *   .onError((err, ctx) => ctx.json({ error: err.message }, 500))
+ *   .build();
+ *
+ * const response = await chain(ctx);
+ * ```
+ */
+export class MiddlewareChain {
+  private middleware: MiddlewareEntry[] = [];
+  private errorHandler?: ErrorHandler;
+  private notFoundHandler?: NotFoundHandler;
+
+  /**
+   * 미들웨어 추가
+   */
+  use(fn: Middleware, name?: string): this {
+    this.middleware.push({
+      fn,
+      name: name || fn.name || `middleware_${this.middleware.length}`,
+      isAsync: fn.constructor.name === "AsyncFunction",
+    });
+    return this;
+  }
+
+  /**
+   * 에러 핸들러 설정
+   */
+  onError(handler: ErrorHandler): this {
+    this.errorHandler = handler;
+    return this;
+  }
+
+  /**
+   * NotFound 핸들러 설정
+   */
+  onNotFound(handler: NotFoundHandler): this {
+    this.notFoundHandler = handler;
+    return this;
+  }
+
+  /**
+   * 미들웨어 체인 빌드
+   */
+  build(): (ctx: ManduContext) => Promise<Response> {
+    return compose(this.middleware, {
+      onError: this.errorHandler,
+      onNotFound: this.notFoundHandler,
+    });
+  }
+
+  /**
+   * 미들웨어 목록 조회
+   */
+  getMiddleware(): MiddlewareEntry[] {
+    return [...this.middleware];
+  }
+}

package/src/runtime/index.ts

@@ -3,6 +3,6 @@ export * from "./router";
 export * from "./server";
 export * from "./cors";
 export * from "./env";
-export * from "./compose";
-export * from "./lifecycle";
-export * from "./trace";
+export * from "./compose";
+export * from "./lifecycle";
+export * from "./trace";