@mandujs/core 0.9.2 → 0.9.4

package/src/filling/filling.ts

@@ -293,7 +293,11 @@ export class ManduFilling<TLoaderData = unknown> {
   }
 }
 
-export const Mandu = {
+/**
+ * Mandu Filling factory functions
+ * Note: These are also available via the main `Mandu` namespace
+ */
+export const ManduFillingFactory = {
   filling<TLoaderData = unknown>(): ManduFilling<TLoaderData> {
     return new ManduFilling<TLoaderData>();
   },

package/src/filling/index.ts

@@ -4,7 +4,7 @@
 
 export { ManduContext, ValidationError, CookieManager } from "./context";
 export type { CookieOptions } from "./context";
-export { ManduFilling, Mandu, LoaderTimeoutError } from "./filling";
+export { ManduFilling, ManduFillingFactory, LoaderTimeoutError } from "./filling";
 export type { Handler, Guard, HttpMethod, Loader, LoaderOptions } from "./filling";
 
 // Auth Guards

package/src/generator/index.ts

@@ -1,3 +1,3 @@
-export * from "./generate";
-export * from "./templates";
-export * from "./contract-glue";
+export * from "./generate";
+export * from "./templates";
+export * from "./contract-glue";

package/src/index.ts

@@ -12,3 +12,78 @@ export * from "./contract";
 export * from "./openapi";
 export * from "./brain";
 export * from "./watcher";
+
+// Consolidated Mandu namespace
+import { ManduFilling, ManduContext, ManduFillingFactory } from "./filling";
+import { createContract, defineHandler, defineRoute, createClient, contractFetch } from "./contract";
+import type { ContractDefinition, ContractInstance, ContractSchema } from "./contract";
+import type { ContractHandlers, ClientOptions } from "./contract";
+
+/**
+ * Mandu - Unified Namespace
+ *
+ * 통합된 Mandu API 인터페이스
+ *
+ * @example
+ * ```typescript
+ * import { Mandu } from "@mandujs/core";
+ * import { z } from "zod";
+ *
+ * // Filling (Handler) API
+ * export default Mandu.filling()
+ *   .get(async (ctx) => ctx.json({ message: "Hello" }));
+ *
+ * // Contract API
+ * const contract = Mandu.contract({
+ *   request: { GET: { query: z.object({ id: z.string() }) } },
+ *   response: { 200: z.object({ data: z.string() }) },
+ * });
+ *
+ * // Handler API (with type inference)
+ * const handlers = Mandu.handler(contract, {
+ *   GET: (ctx) => ({ data: ctx.query.id }),
+ * });
+ *
+ * // Client API (type-safe fetch)
+ * const client = Mandu.client(contract, { baseUrl: "/api" });
+ * const result = await client.GET({ query: { id: "123" } });
+ * ```
+ */
+export const Mandu = {
+  // === Filling (Handler) API ===
+  /**
+   * Create a new filling (handler chain)
+   */
+  filling: ManduFillingFactory.filling,
+
+  /**
+   * Create a ManduContext from a Request
+   */
+  context: ManduFillingFactory.context,
+
+  // === Contract API ===
+  /**
+   * Define a typed API contract
+   */
+  contract: createContract,
+
+  /**
+   * Create typed handlers for a contract
+   */
+  handler: defineHandler,
+
+  /**
+   * Define a complete route (contract + handler)
+   */
+  route: defineRoute,
+
+  /**
+   * Create a type-safe API client
+   */
+  client: createClient,
+
+  /**
+   * Make a type-safe fetch call
+   */
+  fetch: contractFetch,
+} as const;

package/src/report/index.ts

@@ -1 +1 @@
-export * from "./build";
+export * from "./build";

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";