@mandujs/core 0.12.1 → 0.13.0

package/src/slot/validator.ts

@@ -25,19 +25,19 @@ export interface SlotValidationResult {
 }
 
 // 금지된 import 모듈들
-const FORBIDDEN_IMPORTS = [
-  "fs",
-  "child_process",
-  "cluster",
-  "worker_threads",
-  "node:fs",
-  "node:child_process",
-  "node:cluster",
-  "node:worker_threads",
-];
-
-// Slot에서 직접 import를 피해야 하는 모듈
-const DISCOURAGED_SLOT_IMPORTS = ["zod"];
+const FORBIDDEN_IMPORTS = [
+  "fs",
+  "child_process",
+  "cluster",
+  "worker_threads",
+  "node:fs",
+  "node:child_process",
+  "node:cluster",
+  "node:worker_threads",
+];
+
+// Slot에서 직접 import를 피해야 하는 모듈
+const DISCOURAGED_SLOT_IMPORTS = ["zod"];
 
 // 필수 패턴들 (더 엄격한 검사)
 const REQUIRED_PATTERNS = {
@@ -147,9 +147,9 @@ export function validateSlotContent(content: string): SlotValidationResult {
   const codeWithoutComments = stripComments(content);
 
   // 1. 금지된 import 검사
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    for (const forbidden of FORBIDDEN_IMPORTS) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const forbidden of FORBIDDEN_IMPORTS) {
       // import 문에서 금지된 모듈 체크
       const importPattern = new RegExp(
         `import\\s+.*from\\s+['"]${forbidden.replace("/", "\\/")}['"]`
@@ -167,29 +167,29 @@ export function validateSlotContent(content: string): SlotValidationResult {
           suggestion: `'${forbidden}' 대신 Bun의 안전한 API 또는 adapter를 사용하세요`,
           autoFixable: true,
         });
-      }
-    }
-
-    for (const discouraged of DISCOURAGED_SLOT_IMPORTS) {
-      const importPattern = new RegExp(
-        `import\\s+.*from\\s+['"]${discouraged}['"]`
-      );
-      const requirePattern = new RegExp(
-        `require\\s*\\(\\s*['"]${discouraged}['"]\\s*\\)`
-      );
-
-      if (importPattern.test(line) || requirePattern.test(line)) {
-        issues.push({
-          code: "ZOD_DIRECT_IMPORT",
-          severity: "error",
-          message: `Slot에서 '${discouraged}' 직접 import 금지`,
-          line: i + 1,
-          suggestion: "계약은 spec/contracts/*.contract.ts에 정의하고 ctx.input()으로 검증하세요",
-          autoFixable: false,
-        });
-      }
-    }
-  }
+      }
+    }
+
+    for (const discouraged of DISCOURAGED_SLOT_IMPORTS) {
+      const importPattern = new RegExp(
+        `import\\s+.*from\\s+['"]${discouraged}['"]`
+      );
+      const requirePattern = new RegExp(
+        `require\\s*\\(\\s*['"]${discouraged}['"]\\s*\\)`
+      );
+
+      if (importPattern.test(line) || requirePattern.test(line)) {
+        issues.push({
+          code: "ZOD_DIRECT_IMPORT",
+          severity: "error",
+          message: `Slot에서 '${discouraged}' 직접 import 금지`,
+          line: i + 1,
+          suggestion: "계약은 spec/contracts/*.contract.ts에 정의하고 ctx.input()으로 검증하세요",
+          autoFixable: false,
+        });
+      }
+    }
+  }
 
   // 2. Mandu import 검사
   if (!REQUIRED_PATTERNS.manduImport.test(content)) {

package/src/spec/index.ts

@@ -1,3 +1,3 @@
-export * from "./schema";
-export * from "./load";
-export * from "./lock";
+export * from "./schema";
+export * from "./load";
+export * from "./lock";

package/src/spec/load.ts

@@ -1,76 +1,76 @@
-import { RoutesManifest, type RoutesManifest as RoutesManifestType } from "./schema";
-import { ZodError } from "zod";
-
-export interface LoadResult {
-  success: boolean;
-  data?: RoutesManifestType;
-  errors?: string[];
-}
-
-export function formatZodError(error: ZodError): string[] {
-  return error.errors.map((e) => {
-    const path = e.path.length > 0 ? `[${e.path.join(".")}] ` : "";
-    return `${path}${e.message}`;
-  });
-}
-
-export async function loadManifest(filePath: string): Promise<LoadResult> {
-  try {
-    const file = Bun.file(filePath);
-    const exists = await file.exists();
-
-    if (!exists) {
-      return {
-        success: false,
-        errors: [`파일을 찾을 수 없습니다: ${filePath}`],
-      };
-    }
-
-    const content = await file.text();
-    let json: unknown;
-
-    try {
-      json = JSON.parse(content);
-    } catch {
-      return {
-        success: false,
-        errors: ["JSON 파싱 실패: 올바른 JSON 형식이 아닙니다"],
-      };
-    }
-
-    const result = RoutesManifest.safeParse(json);
-
-    if (!result.success) {
-      return {
-        success: false,
-        errors: formatZodError(result.error),
-      };
-    }
-
-    return {
-      success: true,
-      data: result.data,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      errors: [`예상치 못한 오류: ${error instanceof Error ? error.message : String(error)}`],
-    };
-  }
-}
-
-export function validateManifest(data: unknown): LoadResult {
-  const result = RoutesManifest.safeParse(data);
-
-  if (!result.success) {
-    return {
-      success: false,
-      errors: formatZodError(result.error),
-    };
-  }
-
-  return {
-    success: true,
-    data: result.data,
-  };
-}
+import { RoutesManifest, type RoutesManifest as RoutesManifestType } from "./schema";
+import { ZodError } from "zod";
+
+export interface LoadResult {
+  success: boolean;
+  data?: RoutesManifestType;
+  errors?: string[];
+}
+
+export function formatZodError(error: ZodError): string[] {
+  return error.errors.map((e) => {
+    const path = e.path.length > 0 ? `[${e.path.join(".")}] ` : "";
+    return `${path}${e.message}`;
+  });
+}
+
+export async function loadManifest(filePath: string): Promise<LoadResult> {
+  try {
+    const file = Bun.file(filePath);
+    const exists = await file.exists();
+
+    if (!exists) {
+      return {
+        success: false,
+        errors: [`파일을 찾을 수 없습니다: ${filePath}`],
+      };
+    }
+
+    const content = await file.text();
+    let json: unknown;
+
+    try {
+      json = JSON.parse(content);
+    } catch {
+      return {
+        success: false,
+        errors: ["JSON 파싱 실패: 올바른 JSON 형식이 아닙니다"],
+      };
+    }
+
+    const result = RoutesManifest.safeParse(json);
+
+    if (!result.success) {
+      return {
+        success: false,
+        errors: formatZodError(result.error),
+      };
+    }
+
+    return {
+      success: true,
+      data: result.data,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [`예상치 못한 오류: ${error instanceof Error ? error.message : String(error)}`],
+    };
+  }
+}
+
+export function validateManifest(data: unknown): LoadResult {
+  const result = RoutesManifest.safeParse(data);
+
+  if (!result.success) {
+    return {
+      success: false,
+      errors: formatZodError(result.error),
+    };
+  }
+
+  return {
+    success: true,
+    data: result.data,
+  };
+}

package/src/spec/lock.ts

@@ -1,56 +1,56 @@
-import { createHash } from "crypto";
-import type { RoutesManifest } from "./schema";
-
-export interface SpecLock {
-  routesHash: string;
-  updatedAt: string;
-}
-
-export function computeHash(manifest: RoutesManifest): string {
-  const content = JSON.stringify(manifest, null, 2);
-  return createHash("sha256").update(content).digest("hex");
-}
-
-export async function readLock(lockPath: string): Promise<SpecLock | null> {
-  try {
-    const file = Bun.file(lockPath);
-    const exists = await file.exists();
-
-    if (!exists) {
-      return null;
-    }
-
-    const content = await file.text();
-    return JSON.parse(content) as SpecLock;
-  } catch {
-    return null;
-  }
-}
-
-export async function writeLock(lockPath: string, manifest: RoutesManifest): Promise<SpecLock> {
-  const lock: SpecLock = {
-    routesHash: computeHash(manifest),
-    updatedAt: new Date().toISOString(),
-  };
-
-  await Bun.write(lockPath, JSON.stringify(lock, null, 2));
-  return lock;
-}
-
-export async function verifyLock(
-  lockPath: string,
-  manifest: RoutesManifest
-): Promise<{ valid: boolean; currentHash: string; lockHash: string | null }> {
-  const currentHash = computeHash(manifest);
-  const lock = await readLock(lockPath);
-
-  if (!lock) {
-    return { valid: false, currentHash, lockHash: null };
-  }
-
-  return {
-    valid: lock.routesHash === currentHash,
-    currentHash,
-    lockHash: lock.routesHash,
-  };
-}
+import { createHash } from "crypto";
+import type { RoutesManifest } from "./schema";
+
+export interface SpecLock {
+  routesHash: string;
+  updatedAt: string;
+}
+
+export function computeHash(manifest: RoutesManifest): string {
+  const content = JSON.stringify(manifest, null, 2);
+  return createHash("sha256").update(content).digest("hex");
+}
+
+export async function readLock(lockPath: string): Promise<SpecLock | null> {
+  try {
+    const file = Bun.file(lockPath);
+    const exists = await file.exists();
+
+    if (!exists) {
+      return null;
+    }
+
+    const content = await file.text();
+    return JSON.parse(content) as SpecLock;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeLock(lockPath: string, manifest: RoutesManifest): Promise<SpecLock> {
+  const lock: SpecLock = {
+    routesHash: computeHash(manifest),
+    updatedAt: new Date().toISOString(),
+  };
+
+  await Bun.write(lockPath, JSON.stringify(lock, null, 2));
+  return lock;
+}
+
+export async function verifyLock(
+  lockPath: string,
+  manifest: RoutesManifest
+): Promise<{ valid: boolean; currentHash: string; lockHash: string | null }> {
+  const currentHash = computeHash(manifest);
+  const lock = await readLock(lockPath);
+
+  if (!lock) {
+    return { valid: false, currentHash, lockHash: null };
+  }
+
+  return {
+    valid: lock.routesHash === currentHash,
+    currentHash,
+    lockHash: lock.routesHash,
+  };
+}

package/src/utils/bun.ts

@@ -1,8 +1,8 @@
-export async function readJsonFile(filePath: string): Promise<unknown> {
-  try {
-    return await Bun.file(filePath).json();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse JSON in ${filePath}: ${message}`);
-  }
-}
+export async function readJsonFile(filePath: string): Promise<unknown> {
+  try {
+    return await Bun.file(filePath).json();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse JSON in ${filePath}: ${message}`);
+  }
+}

package/src/utils/lru-cache.ts

@@ -1,75 +1,75 @@
-/**
- * 간단한 LRU (Least Recently Used) 캐시 구현
- */
-export class LRUCache<K, V> {
-  private cache: Map<K, V>;
-  private readonly maxSize: number;
-  private _hits = 0;
-  private _misses = 0;
-
-  constructor(maxSize: number = 100) {
-    this.cache = new Map();
-    this.maxSize = maxSize;
-  }
-
-  get(key: K): V | undefined {
-    const value = this.cache.get(key);
-    if (value !== undefined) {
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-
-  getWithStats(key: K): V | undefined {
-    const value = this.get(key);
-    if (value !== undefined) {
-      this._hits++;
-    } else {
-      this._misses++;
-    }
-    return value;
-  }
-
-  set(key: K, value: V): void {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== undefined) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-
-  has(key: K): boolean {
-    return this.cache.has(key);
-  }
-
-  delete(key: K): boolean {
-    return this.cache.delete(key);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  get size(): number {
-    return this.cache.size;
-  }
-
-  getStats(): { hits: number; misses: number; hitRate: number } {
-    const total = this._hits + this._misses;
-    return {
-      hits: this._hits,
-      misses: this._misses,
-      hitRate: total > 0 ? this._hits / total : 0,
-    };
-  }
-
-  resetStats(): void {
-    this._hits = 0;
-    this._misses = 0;
-  }
-}
+/**
+ * 간단한 LRU (Least Recently Used) 캐시 구현
+ */
+export class LRUCache<K, V> {
+  private cache: Map<K, V>;
+  private readonly maxSize: number;
+  private _hits = 0;
+  private _misses = 0;
+
+  constructor(maxSize: number = 100) {
+    this.cache = new Map();
+    this.maxSize = maxSize;
+  }
+
+  get(key: K): V | undefined {
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+
+  getWithStats(key: K): V | undefined {
+    const value = this.get(key);
+    if (value !== undefined) {
+      this._hits++;
+    } else {
+      this._misses++;
+    }
+    return value;
+  }
+
+  set(key: K, value: V): void {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+
+  has(key: K): boolean {
+    return this.cache.has(key);
+  }
+
+  delete(key: K): boolean {
+    return this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  get size(): number {
+    return this.cache.size;
+  }
+
+  getStats(): { hits: number; misses: number; hitRate: number } {
+    const total = this._hits + this._misses;
+    return {
+      hits: this._hits,
+      misses: this._misses,
+      hitRate: total > 0 ? this._hits / total : 0,
+    };
+  }
+
+  resetStats(): void {
+    this._hits = 0;
+    this._misses = 0;
+  }
+}