@mandujs/core 0.53.3 → 0.54.1

package/src/content/watcher.ts

@@ -1,135 +1,135 @@
-/**
- * Content Watcher - 개발 모드 파일 감시
- *
- * 콘텐츠 파일 변경 시 자동 리로드
- */
-
-import type { ContentWatcher } from "./types";
-import chokidar, { type FSWatcher } from "chokidar";
-
-/**
- * ContentWatcher 옵션
- */
-export interface ContentWatcherOptions {
-  /** 루트 디렉토리 */
-  root: string;
-  /** 무시할 패턴 */
-  ignored?: string[];
-  /** 디바운스 (ms) */
-  debounce?: number;
-}
-
-/**
- * ContentWatcher 구현
- */
-class ContentWatcherImpl implements ContentWatcher {
-  private watcher: FSWatcher;
-  private handlers: Map<string, Set<(path: string) => void>> = new Map();
-  private debounceTimers: Map<string, NodeJS.Timeout> = new Map();
-  private debounceMs: number;
-
-  constructor(options: ContentWatcherOptions) {
-    const { root, ignored = ["**/node_modules/**", "**/.git/**"], debounce = 300 } = options;
-
-    this.debounceMs = debounce;
-
-    this.watcher = chokidar.watch([], {
-      cwd: root,
-      ignored,
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: debounce,
-        pollInterval: 100,
-      },
-    });
-
-    // 이벤트 핸들러 연결
-    this.watcher.on("change", (path) => this.emit("change", path));
-    this.watcher.on("add", (path) => this.emit("add", path));
-    this.watcher.on("unlink", (path) => this.emit("unlink", path));
-  }
-
-  /**
-   * 파일/패턴 감시 추가
-   */
-  add(paths: string | string[]): void {
-    this.watcher.add(paths);
-  }
-
-  /**
-   * 파일/패턴 감시 제거
-   */
-  remove(paths: string | string[]): void {
-    this.watcher.unwatch(paths);
-  }
-
-  /**
-   * 이벤트 핸들러 등록
-   */
-  on(event: "change" | "add" | "unlink", handler: (path: string) => void): void {
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, new Set());
-    }
-    this.handlers.get(event)!.add(handler);
-  }
-
-  /**
-   * 이벤트 핸들러 제거
-   */
-  off(event: "change" | "add" | "unlink", handler: (path: string) => void): void {
-    this.handlers.get(event)?.delete(handler);
-  }
-
-  /**
-   * 감시 종료
-   */
-  async close(): Promise<void> {
-    // 모든 디바운스 타이머 정리
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.debounceTimers.clear();
-
-    await this.watcher.close();
-  }
-
-  /**
-   * 이벤트 발생 (디바운스 적용)
-   */
-  private emit(event: "change" | "add" | "unlink", path: string): void {
-    const key = `${event}:${path}`;
-
-    // 기존 타이머 취소
-    if (this.debounceTimers.has(key)) {
-      clearTimeout(this.debounceTimers.get(key)!);
-    }
-
-    // 디바운스 적용
-    const timer = setTimeout(() => {
-      this.debounceTimers.delete(key);
-
-      const handlers = this.handlers.get(event);
-      if (handlers) {
-        for (const handler of handlers) {
-          try {
-            handler(path);
-          } catch (error) {
-            console.error(
-              `[ContentWatcher] Handler error for ${event}:`,
-              error instanceof Error ? error.message : error
-            );
-          }
-        }
-      }
-    }, this.debounceMs);
-
-    this.debounceTimers.set(key, timer);
-  }
-}
-
-/**
- * ContentWatcher 팩토리
- */
-export function createContentWatcher(options: ContentWatcherOptions): ContentWatcher {
-  return new ContentWatcherImpl(options);
-}
+/**
+ * Content Watcher - 개발 모드 파일 감시
+ *
+ * 콘텐츠 파일 변경 시 자동 리로드
+ */
+
+import type { ContentWatcher } from "./types";
+import chokidar, { type FSWatcher } from "chokidar";
+
+/**
+ * ContentWatcher 옵션
+ */
+export interface ContentWatcherOptions {
+  /** 루트 디렉토리 */
+  root: string;
+  /** 무시할 패턴 */
+  ignored?: string[];
+  /** 디바운스 (ms) */
+  debounce?: number;
+}
+
+/**
+ * ContentWatcher 구현
+ */
+class ContentWatcherImpl implements ContentWatcher {
+  private watcher: FSWatcher;
+  private handlers: Map<string, Set<(path: string) => void>> = new Map();
+  private debounceTimers: Map<string, NodeJS.Timeout> = new Map();
+  private debounceMs: number;
+
+  constructor(options: ContentWatcherOptions) {
+    const { root, ignored = ["**/node_modules/**", "**/.git/**"], debounce = 300 } = options;
+
+    this.debounceMs = debounce;
+
+    this.watcher = chokidar.watch([], {
+      cwd: root,
+      ignored,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: debounce,
+        pollInterval: 100,
+      },
+    });
+
+    // 이벤트 핸들러 연결
+    this.watcher.on("change", (path) => this.emit("change", path));
+    this.watcher.on("add", (path) => this.emit("add", path));
+    this.watcher.on("unlink", (path) => this.emit("unlink", path));
+  }
+
+  /**
+   * 파일/패턴 감시 추가
+   */
+  add(paths: string | string[]): void {
+    this.watcher.add(paths);
+  }
+
+  /**
+   * 파일/패턴 감시 제거
+   */
+  remove(paths: string | string[]): void {
+    this.watcher.unwatch(paths);
+  }
+
+  /**
+   * 이벤트 핸들러 등록
+   */
+  on(event: "change" | "add" | "unlink", handler: (path: string) => void): void {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, new Set());
+    }
+    this.handlers.get(event)!.add(handler);
+  }
+
+  /**
+   * 이벤트 핸들러 제거
+   */
+  off(event: "change" | "add" | "unlink", handler: (path: string) => void): void {
+    this.handlers.get(event)?.delete(handler);
+  }
+
+  /**
+   * 감시 종료
+   */
+  async close(): Promise<void> {
+    // 모든 디바운스 타이머 정리
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+
+    await this.watcher.close();
+  }
+
+  /**
+   * 이벤트 발생 (디바운스 적용)
+   */
+  private emit(event: "change" | "add" | "unlink", path: string): void {
+    const key = `${event}:${path}`;
+
+    // 기존 타이머 취소
+    if (this.debounceTimers.has(key)) {
+      clearTimeout(this.debounceTimers.get(key)!);
+    }
+
+    // 디바운스 적용
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(key);
+
+      const handlers = this.handlers.get(event);
+      if (handlers) {
+        for (const handler of handlers) {
+          try {
+            handler(path);
+          } catch (error) {
+            console.error(
+              `[ContentWatcher] Handler error for ${event}:`,
+              error instanceof Error ? error.message : error
+            );
+          }
+        }
+      }
+    }, this.debounceMs);
+
+    this.debounceTimers.set(key, timer);
+  }
+}
+
+/**
+ * ContentWatcher 팩토리
+ */
+export function createContentWatcher(options: ContentWatcherOptions): ContentWatcher {
+  return new ContentWatcherImpl(options);
+}

package/src/contract/client-safe.test.ts

@@ -1,42 +1,42 @@
-import { describe, it, expect } from "bun:test";
-import { z } from "zod";
-import { Mandu, createClientContract } from "../index";
-
-describe("Client-safe contract", () => {
-  const contract = Mandu.contract({
-    request: {
-      GET: {
-        query: z.object({ id: z.string() }),
-      },
-      POST: {
-        body: z.object({ name: z.string() }),
-      },
-    },
-    response: {
-      200: z.object({ ok: z.boolean() }),
-      201: z.object({ id: z.string() }),
-      400: z.object({ error: z.string() }),
-    },
-  });
-
-  it("should pick only selected schemas", () => {
-    const clientContract = createClientContract(contract, {
-      request: {
-        POST: { body: true },
-      },
-      response: [201],
-      includeErrors: true,
-    });
-
-    expect(clientContract.request.GET).toBeUndefined();
-    expect(clientContract.request.POST?.body).toBeDefined();
-    expect(clientContract.response[200]).toBeUndefined();
-    expect(clientContract.response[201]).toBeDefined();
-    expect(clientContract.response[400]).toBeDefined();
-  });
-
-  it("should return original contract when no options are provided", () => {
-    const clientContract = createClientContract(contract);
-    expect(clientContract).toBe(contract);
-  });
-});
+import { describe, it, expect } from "bun:test";
+import { z } from "zod";
+import { Mandu, createClientContract } from "../index";
+
+describe("Client-safe contract", () => {
+  const contract = Mandu.contract({
+    request: {
+      GET: {
+        query: z.object({ id: z.string() }),
+      },
+      POST: {
+        body: z.object({ name: z.string() }),
+      },
+    },
+    response: {
+      200: z.object({ ok: z.boolean() }),
+      201: z.object({ id: z.string() }),
+      400: z.object({ error: z.string() }),
+    },
+  });
+
+  it("should pick only selected schemas", () => {
+    const clientContract = createClientContract(contract, {
+      request: {
+        POST: { body: true },
+      },
+      response: [201],
+      includeErrors: true,
+    });
+
+    expect(clientContract.request.GET).toBeUndefined();
+    expect(clientContract.request.POST?.body).toBeDefined();
+    expect(clientContract.response[200]).toBeUndefined();
+    expect(clientContract.response[201]).toBeDefined();
+    expect(clientContract.response[400]).toBeDefined();
+  });
+
+  it("should return original contract when no options are provided", () => {
+    const clientContract = createClientContract(contract);
+    expect(clientContract).toBe(contract);
+  });
+});

package/src/contract/client-safe.ts

@@ -1,114 +1,114 @@
-/**
- * Mandu Client-safe Contract Utilities
- * Reduce contract exposure for client usage (forms, UI validation)
- */
-
-import type {
-  ContractSchema,
-  ContractMethod,
-  MethodRequestSchema,
-  ClientSafeOptions,
-  ContractRequestSchema,
-  ContractResponseSchema,
-} from "./schema";
-
-const ERROR_STATUS_CODES = [400, 401, 403, 404, 500] as const;
-
-function normalizeResponseSelection(
-  selection: ClientSafeOptions["response"]
-): number[] {
-  if (!selection) return [];
-  if (Array.isArray(selection)) return selection;
-
-  const result: number[] = [];
-  for (const [code, enabled] of Object.entries(selection)) {
-    if (enabled) {
-      const num = Number(code);
-      if (!Number.isNaN(num)) {
-        result.push(num);
-      }
-    }
-  }
-  return result;
-}
-
-function pickRequestSchema(
-  methodSchema: MethodRequestSchema,
-  selection: NonNullable<ClientSafeOptions["request"]>[ContractMethod]
-): MethodRequestSchema | undefined {
-  if (!selection) return undefined;
-
-  const picked: MethodRequestSchema = {};
-
-  if (selection.query && methodSchema.query) {
-    picked.query = methodSchema.query;
-  }
-  if (selection.body && methodSchema.body) {
-    picked.body = methodSchema.body;
-  }
-  if (selection.params && methodSchema.params) {
-    picked.params = methodSchema.params;
-  }
-  if (selection.headers && methodSchema.headers) {
-    picked.headers = methodSchema.headers;
-  }
-
-  return Object.keys(picked).length > 0 ? picked : undefined;
-}
-
-/**
- * Create a client-safe contract by selecting exposed schemas.
- * If options are omitted and contract.clientSafe is not defined,
- * the original contract is returned (with a warning).
- */
-export function createClientContract<T extends ContractSchema>(
-  contract: T,
-  options?: ClientSafeOptions
-): ContractSchema {
-  const resolved = options ?? contract.clientSafe;
-
-  if (!resolved) {
-    console.warn(
-      "[Mandu] clientContract: no clientSafe options provided. Returning original contract."
-    );
-    return contract;
-  }
-
-  const requestSelection = resolved.request ?? {};
-  const responseSelection = normalizeResponseSelection(resolved.response);
-  const safeRequest: ContractRequestSchema = {};
-  const safeResponse: ContractResponseSchema = {};
-
-  for (const method of Object.keys(requestSelection) as ContractMethod[]) {
-    const methodSchema = contract.request[method] as MethodRequestSchema | undefined;
-    if (!methodSchema) continue;
-
-    const picked = pickRequestSchema(methodSchema, requestSelection[method]);
-    if (picked) {
-      safeRequest[method] = picked;
-    }
-  }
-
-  const allowedResponses = new Set(responseSelection);
-
-  if (resolved.includeErrors) {
-    for (const code of ERROR_STATUS_CODES) {
-      if (contract.response[code]) {
-        allowedResponses.add(code);
-      }
-    }
-  }
-
-  for (const code of allowedResponses) {
-    const schema = contract.response[code];
-    if (schema) {
-      safeResponse[code] = schema;
-    }
-  }
-
-  return {
-    ...contract,
-    request: safeRequest,
-    response: safeResponse,
-  };
-}
+/**
+ * Mandu Client-safe Contract Utilities
+ * Reduce contract exposure for client usage (forms, UI validation)
+ */
+
+import type {
+  ContractSchema,
+  ContractMethod,
+  MethodRequestSchema,
+  ClientSafeOptions,
+  ContractRequestSchema,
+  ContractResponseSchema,
+} from "./schema";
+
+const ERROR_STATUS_CODES = [400, 401, 403, 404, 500] as const;
+
+function normalizeResponseSelection(
+  selection: ClientSafeOptions["response"]
+): number[] {
+  if (!selection) return [];
+  if (Array.isArray(selection)) return selection;
+
+  const result: number[] = [];
+  for (const [code, enabled] of Object.entries(selection)) {
+    if (enabled) {
+      const num = Number(code);
+      if (!Number.isNaN(num)) {
+        result.push(num);
+      }
+    }
+  }
+  return result;
+}
+
+function pickRequestSchema(
+  methodSchema: MethodRequestSchema,
+  selection: NonNullable<ClientSafeOptions["request"]>[ContractMethod]
+): MethodRequestSchema | undefined {
+  if (!selection) return undefined;
+
+  const picked: MethodRequestSchema = {};
+
+  if (selection.query && methodSchema.query) {
+    picked.query = methodSchema.query;
+  }
+  if (selection.body && methodSchema.body) {
+    picked.body = methodSchema.body;
+  }
+  if (selection.params && methodSchema.params) {
+    picked.params = methodSchema.params;
+  }
+  if (selection.headers && methodSchema.headers) {
+    picked.headers = methodSchema.headers;
+  }
+
+  return Object.keys(picked).length > 0 ? picked : undefined;
+}
+
+/**
+ * Create a client-safe contract by selecting exposed schemas.
+ * If options are omitted and contract.clientSafe is not defined,
+ * the original contract is returned (with a warning).
+ */
+export function createClientContract<T extends ContractSchema>(
+  contract: T,
+  options?: ClientSafeOptions
+): ContractSchema {
+  const resolved = options ?? contract.clientSafe;
+
+  if (!resolved) {
+    console.warn(
+      "[Mandu] clientContract: no clientSafe options provided. Returning original contract."
+    );
+    return contract;
+  }
+
+  const requestSelection = resolved.request ?? {};
+  const responseSelection = normalizeResponseSelection(resolved.response);
+  const safeRequest: ContractRequestSchema = {};
+  const safeResponse: ContractResponseSchema = {};
+
+  for (const method of Object.keys(requestSelection) as ContractMethod[]) {
+    const methodSchema = contract.request[method] as MethodRequestSchema | undefined;
+    if (!methodSchema) continue;
+
+    const picked = pickRequestSchema(methodSchema, requestSelection[method]);
+    if (picked) {
+      safeRequest[method] = picked;
+    }
+  }
+
+  const allowedResponses = new Set(responseSelection);
+
+  if (resolved.includeErrors) {
+    for (const code of ERROR_STATUS_CODES) {
+      if (contract.response[code]) {
+        allowedResponses.add(code);
+      }
+    }
+  }
+
+  for (const code of allowedResponses) {
+    const schema = contract.response[code];
+    if (schema) {
+      safeResponse[code] = schema;
+    }
+  }
+
+  return {
+    ...contract,
+    request: safeRequest,
+    response: safeResponse,
+  };
+}

package/src/contract/define.ts

@@ -27,15 +27,15 @@
  * ```
  */
 
-import type { ZodType } from 'zod';
-import {
-  getZodTypeName,
-  getZodInnerType,
-  getZodArrayElementType,
-  getZodObjectShape,
-  getZodEnumValues,
-  isZodRequired,
-} from './zod-utils';
+import type { ZodType } from 'zod';
+import {
+  getZodTypeName,
+  getZodInnerType,
+  getZodArrayElementType,
+  getZodObjectShape,
+  getZodEnumValues,
+  isZodRequired,
+} from './zod-utils';
 
 // ============================================================================
 // Types
@@ -166,7 +166,7 @@ export function generateApiHandler<T extends ContractDefinition>(
     throw new Error(`Endpoint "${String(endpointName)}" not found in contract`);
   }
 
-  const { method, path, input, description } = endpoint;
+  const { method, path, input, description } = endpoint;
 
   return `
 import { Mandu } from '@mandujs/core';
@@ -344,7 +344,7 @@ export function generateOpenAPISpec<T extends ContractDefinition>(
   const paths: Record<string, Record<string, unknown>> = {};
 
   for (const [name, endpoint] of Object.entries(contract.__endpoints)) {
-    const { method, path, input, description, tags, errors } = endpoint;
+    const { method, path, input, description, tags, errors } = endpoint;
 
     if (!paths[path]) {
       paths[path] = {};

package/src/contract/index.ts

@@ -38,7 +38,7 @@ export {
 } from "./rpc";
 
 import type { ContractDefinition, ContractInstance } from "./schema";
-
+
 import { defineHandler, defineRoute } from "./handler";
 import { createClient, contractFetch } from "./client";
 import { createClientContract } from "./client-safe";