@mandujs/core 0.9.2 → 0.9.4

package/src/runtime/trace.ts

@@ -1,144 +1,144 @@
-/**
- * Mandu Trace 🧭
- * Lifecycle 단계별 추적 (옵션)
- */
-
-import type { ManduContext } from "../filling/context";
-
-export type TraceEvent =
-  | "request"
-  | "parse"
-  | "transform"
-  | "beforeHandle"
-  | "handle"
-  | "afterHandle"
-  | "mapResponse"
-  | "afterResponse"
-  | "error";
-
-export type TracePhase = "begin" | "end" | "error";
-
-export interface TraceEntry {
-  event: TraceEvent;
-  phase: TracePhase;
-  time: number;
-  name?: string;
-  error?: string;
-}
-
-export interface TraceCollector {
-  records: TraceEntry[];
-}
-
-export interface TraceReportEntry {
-  event: TraceEvent;
-  name?: string;
-  start: number;
-  end: number;
-  duration: number;
-}
-
-export interface TraceReport {
-  entries: TraceReportEntry[];
-  errors: TraceEntry[];
-}
-
-export const TRACE_KEY = "__mandu_trace";
-
-const now = (): number => {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-};
-
-export function enableTrace(ctx: ManduContext): TraceCollector {
-  const existing = ctx.get<TraceCollector>(TRACE_KEY);
-  if (existing) return existing;
-  const collector: TraceCollector = { records: [] };
-  ctx.set(TRACE_KEY, collector);
-  return collector;
-}
-
-export function getTrace(ctx: ManduContext): TraceCollector | undefined {
-  return ctx.get<TraceCollector>(TRACE_KEY);
-}
-
-/**
- * Build a normalized trace report with durations
- */
-export function buildTraceReport(collector: TraceCollector): TraceReport {
-  const entries: TraceReportEntry[] = [];
-  const errors: TraceEntry[] = [];
-  const stacks = new Map<string, TraceEntry[]>();
-
-  for (const record of collector.records) {
-    if (record.phase === "error") {
-      errors.push(record);
-      continue;
-    }
-
-    const key = `${record.event}:${record.name ?? ""}`;
-    if (record.phase === "begin") {
-      const stack = stacks.get(key) ?? [];
-      stack.push(record);
-      stacks.set(key, stack);
-      continue;
-    }
-
-    if (record.phase === "end") {
-      const stack = stacks.get(key);
-      const begin = stack?.pop();
-      if (!begin) continue;
-      entries.push({
-        event: record.event,
-        name: record.name,
-        start: begin.time,
-        end: record.time,
-        duration: record.time - begin.time,
-      });
-    }
-  }
-
-  return { entries, errors };
-}
-
-/**
- * Convert trace report to JSON string
- */
-export function formatTraceReport(report: TraceReport): string {
-  return JSON.stringify(report, null, 2);
-}
-
-export interface Tracer {
-  enabled: boolean;
-  begin: (event: TraceEvent, name?: string) => () => void;
-  error: (event: TraceEvent, err: unknown, name?: string) => void;
-}
-
-const NOOP_TRACER: Tracer = {
-  enabled: false,
-  begin: () => () => {},
-  error: () => {},
-};
-
-export function createTracer(ctx: ManduContext, enabled?: boolean): Tracer {
-  const shouldEnable = Boolean(enabled) || ctx.has(TRACE_KEY);
-  if (!shouldEnable) return NOOP_TRACER;
-
-  const collector = enableTrace(ctx);
-
-  return {
-    enabled: true,
-    begin: (event, name) => {
-      collector.records.push({ event, phase: "begin", time: now(), name });
-      return () => {
-        collector.records.push({ event, phase: "end", time: now(), name });
-      };
-    },
-    error: (event, err, name) => {
-      const message = err instanceof Error ? err.message : String(err);
-      collector.records.push({ event, phase: "error", time: now(), name, error: message });
-    },
-  };
-}
+/**
+ * Mandu Trace 🧭
+ * Lifecycle 단계별 추적 (옵션)
+ */
+
+import type { ManduContext } from "../filling/context";
+
+export type TraceEvent =
+  | "request"
+  | "parse"
+  | "transform"
+  | "beforeHandle"
+  | "handle"
+  | "afterHandle"
+  | "mapResponse"
+  | "afterResponse"
+  | "error";
+
+export type TracePhase = "begin" | "end" | "error";
+
+export interface TraceEntry {
+  event: TraceEvent;
+  phase: TracePhase;
+  time: number;
+  name?: string;
+  error?: string;
+}
+
+export interface TraceCollector {
+  records: TraceEntry[];
+}
+
+export interface TraceReportEntry {
+  event: TraceEvent;
+  name?: string;
+  start: number;
+  end: number;
+  duration: number;
+}
+
+export interface TraceReport {
+  entries: TraceReportEntry[];
+  errors: TraceEntry[];
+}
+
+export const TRACE_KEY = "__mandu_trace";
+
+const now = (): number => {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+};
+
+export function enableTrace(ctx: ManduContext): TraceCollector {
+  const existing = ctx.get<TraceCollector>(TRACE_KEY);
+  if (existing) return existing;
+  const collector: TraceCollector = { records: [] };
+  ctx.set(TRACE_KEY, collector);
+  return collector;
+}
+
+export function getTrace(ctx: ManduContext): TraceCollector | undefined {
+  return ctx.get<TraceCollector>(TRACE_KEY);
+}
+
+/**
+ * Build a normalized trace report with durations
+ */
+export function buildTraceReport(collector: TraceCollector): TraceReport {
+  const entries: TraceReportEntry[] = [];
+  const errors: TraceEntry[] = [];
+  const stacks = new Map<string, TraceEntry[]>();
+
+  for (const record of collector.records) {
+    if (record.phase === "error") {
+      errors.push(record);
+      continue;
+    }
+
+    const key = `${record.event}:${record.name ?? ""}`;
+    if (record.phase === "begin") {
+      const stack = stacks.get(key) ?? [];
+      stack.push(record);
+      stacks.set(key, stack);
+      continue;
+    }
+
+    if (record.phase === "end") {
+      const stack = stacks.get(key);
+      const begin = stack?.pop();
+      if (!begin) continue;
+      entries.push({
+        event: record.event,
+        name: record.name,
+        start: begin.time,
+        end: record.time,
+        duration: record.time - begin.time,
+      });
+    }
+  }
+
+  return { entries, errors };
+}
+
+/**
+ * Convert trace report to JSON string
+ */
+export function formatTraceReport(report: TraceReport): string {
+  return JSON.stringify(report, null, 2);
+}
+
+export interface Tracer {
+  enabled: boolean;
+  begin: (event: TraceEvent, name?: string) => () => void;
+  error: (event: TraceEvent, err: unknown, name?: string) => void;
+}
+
+const NOOP_TRACER: Tracer = {
+  enabled: false,
+  begin: () => () => {},
+  error: () => {},
+};
+
+export function createTracer(ctx: ManduContext, enabled?: boolean): Tracer {
+  const shouldEnable = Boolean(enabled) || ctx.has(TRACE_KEY);
+  if (!shouldEnable) return NOOP_TRACER;
+
+  const collector = enableTrace(ctx);
+
+  return {
+    enabled: true,
+    begin: (event, name) => {
+      collector.records.push({ event, phase: "begin", time: now(), name });
+      return () => {
+        collector.records.push({ event, phase: "end", time: now(), name });
+      };
+    },
+    error: (event, err, name) => {
+      const message = err instanceof Error ? err.message : String(err);
+      collector.records.push({ event, phase: "error", time: now(), name, error: message });
+    },
+  };
+}

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,
+  };
+}