@spfn/core 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/scripts/index.js

@@ -1,971 +1,1143 @@
 import { drizzle } from 'drizzle-orm/postgres-js';
 import { migrate } from 'drizzle-orm/postgres-js/migrator';
 import postgres from 'postgres';
-import { config } from 'dotenv';
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
+import { config } from 'dotenv';
+import { existsSync, mkdirSync, createWriteStream, readFileSync } from 'fs';
+import pino from 'pino';
 import { mkdir, writeFile, readdir, stat } from 'fs/promises';
 import * as ts from 'typescript';
-import { existsSync, mkdirSync, createWriteStream, readFileSync } from 'fs';
 import { watch } from 'chokidar';
-import pino from 'pino';
 import chalk from 'chalk';
 
 // src/scripts/migrate.ts
-config({ path: ".env.local" });
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var projectRoot = join(__dirname, "../../..");
-var DATABASE_URL = process.env.DATABASE_URL;
-if (!DATABASE_URL) {
-  console.error("\u274C DATABASE_URL environment variable is required");
-  process.exit(1);
-}
-async function runMigrations() {
-  console.log("\u{1F504} Starting database migration...");
-  console.log(`\u{1F4C2} Migrations folder: ${join(projectRoot, "drizzle")}`);
-  const migrationConnection = postgres(DATABASE_URL, { max: 1 });
-  const db = drizzle(migrationConnection);
-  try {
-    console.log("\u23F3 Applying migrations...");
-    await migrate(db, {
-      migrationsFolder: join(projectRoot, "drizzle")
-    });
-    console.log("\u2705 Migration completed successfully");
-  } catch (error) {
-    console.error("\u274C Migration failed:", error);
-    throw error;
-  } finally {
-    await migrationConnection.end();
-    console.log("\u{1F50C} Database connection closed");
-  }
-}
-runMigrations().then(() => {
-  console.log("\u{1F389} All migrations applied");
-  process.exit(0);
-}).catch((error) => {
-  console.error("\u{1F4A5} Migration process failed:", error);
-  process.exit(1);
-});
-async function scanContracts(routesDir) {
-  const contractFiles = await scanContractFiles(routesDir);
-  const mappings = [];
-  for (let i = 0; i < contractFiles.length; i++) {
-    const filePath = contractFiles[i];
-    const exports = extractContractExports(filePath);
-    const basePath = getBasePathFromFile(filePath, routesDir);
-    for (let j = 0; j < exports.length; j++) {
-      const contractExport = exports[j];
-      const fullPath = combinePaths(basePath, contractExport.path);
-      mappings.push({
-        method: contractExport.method,
-        path: fullPath,
-        contractName: contractExport.name,
-        contractImportPath: getImportPathFromRoutes(filePath, routesDir),
-        routeFile: "",
-        // Not needed anymore
-        contractFile: filePath
+var PinoAdapter = class _PinoAdapter {
+  logger;
+  constructor(config) {
+    const isProduction = process.env.NODE_ENV === "production";
+    const isDevelopment = process.env.NODE_ENV === "development";
+    const fileLoggingEnabled = process.env.LOGGER_FILE_ENABLED === "true";
+    const targets = [];
+    if (!isProduction && isDevelopment) {
+      targets.push({
+        target: "pino-pretty",
+        level: "debug",
+        options: {
+          colorize: true,
+          translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
+          ignore: "pid,hostname"
+        }
       });
     }
-  }
-  return mappings;
-}
-async function scanContractFiles(dir, files = []) {
-  try {
-    const entries = await readdir(dir);
-    for (let i = 0; i < entries.length; i++) {
-      const entry = entries[i];
-      const fullPath = join(dir, entry);
-      const fileStat = await stat(fullPath);
-      if (fileStat.isDirectory()) {
-        await scanContractFiles(fullPath, files);
-      } else if (entry === "contract.ts") {
-        files.push(fullPath);
-      }
-    }
-  } catch (error) {
-  }
-  return files;
-}
-function extractContractExports(filePath) {
-  const sourceCode = readFileSync(filePath, "utf-8");
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    sourceCode,
-    ts.ScriptTarget.Latest,
-    true
-  );
-  const exports = [];
-  function visit(node) {
-    if (ts.isVariableStatement(node)) {
-      const hasExport = node.modifiers?.some(
-        (m) => m.kind === ts.SyntaxKind.ExportKeyword
-      );
-      if (hasExport && node.declarationList.declarations.length > 0) {
-        const declaration = node.declarationList.declarations[0];
-        if (ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) && declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
-          const name = declaration.name.text;
-          if (isContractName(name)) {
-            const contractData = extractContractData(declaration.initializer);
-            if (contractData.method && contractData.path) {
-              exports.push({
-                name,
-                method: contractData.method,
-                path: contractData.path
-              });
-            }
-          }
+    if (fileLoggingEnabled && isProduction) {
+      const logDir = process.env.LOG_DIR || "./logs";
+      const maxFileSize = process.env.LOG_MAX_FILE_SIZE || "10M";
+      const maxFiles = parseInt(process.env.LOG_MAX_FILES || "10", 10);
+      targets.push({
+        target: "pino-roll",
+        level: "info",
+        options: {
+          file: `${logDir}/app.log`,
+          frequency: "daily",
+          size: maxFileSize,
+          limit: { count: maxFiles },
+          mkdir: true
         }
-      }
+      });
     }
-    ts.forEachChild(node, visit);
+    this.logger = pino({
+      level: config.level,
+      // Transport 설정 (targets가 있으면 사용, 없으면 기본 stdout)
+      transport: targets.length > 0 ? { targets } : void 0,
+      // 기본 필드
+      base: config.module ? { module: config.module } : void 0
+    });
   }
-  visit(sourceFile);
-  return exports;
-}
-function extractContractData(objectLiteral) {
-  const result = {};
-  for (let i = 0; i < objectLiteral.properties.length; i++) {
-    const prop = objectLiteral.properties[i];
-    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-      const propName = prop.name.text;
-      if (propName === "method") {
-        let value;
-        if (ts.isStringLiteral(prop.initializer)) {
-          value = prop.initializer.text;
-        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
-          value = prop.initializer.expression.text;
-        }
-        if (value) result.method = value;
-      } else if (propName === "path") {
-        let value;
-        if (ts.isStringLiteral(prop.initializer)) {
-          value = prop.initializer.text;
-        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
-          value = prop.initializer.expression.text;
-        }
-        if (value) result.path = value;
-      }
-    }
+  child(module) {
+    const childLogger = new _PinoAdapter({ level: this.logger.level, module });
+    childLogger.logger = this.logger.child({ module });
+    return childLogger;
   }
-  return result;
-}
-function isContractName(name) {
-  return name.indexOf("Contract") !== -1 || name.indexOf("contract") !== -1 || name.endsWith("Schema") || name.endsWith("schema");
-}
-function getBasePathFromFile(filePath, routesDir) {
-  let relativePath = filePath.replace(routesDir, "");
-  if (relativePath.startsWith("/")) {
-    relativePath = relativePath.slice(1);
+  debug(message, context) {
+    this.logger.debug(context || {}, message);
   }
-  relativePath = relativePath.replace("/contract.ts", "");
-  if (relativePath === "index" || relativePath === "") {
-    return "/";
+  info(message, context) {
+    this.logger.info(context || {}, message);
   }
-  const segments = relativePath.split("/");
-  const transformed = [];
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    if (seg === "index") {
-      continue;
-    }
-    if (seg.startsWith("[") && seg.endsWith("]")) {
-      transformed.push(":" + seg.slice(1, -1));
+  warn(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.warn({ err: errorOrContext, ...context }, message);
     } else {
-      transformed.push(seg);
+      this.logger.warn(errorOrContext || {}, message);
     }
   }
-  if (transformed.length === 0) {
-    return "/";
-  }
-  return "/" + transformed.join("/");
-}
-function combinePaths(basePath, contractPath) {
-  basePath = basePath || "/";
-  contractPath = contractPath || "/";
-  if (basePath.endsWith("/") && basePath !== "/") {
-    basePath = basePath.slice(0, -1);
+  error(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.error({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.error(errorOrContext || {}, message);
+    }
   }
-  if (contractPath.startsWith("/") && contractPath !== "/") {
-    if (basePath === "/") {
-      return contractPath;
+  fatal(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.fatal({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.fatal(errorOrContext || {}, message);
     }
-    return basePath + contractPath;
   }
-  if (contractPath === "/") {
-    return basePath;
+  async close() {
   }
-  return basePath + "/" + contractPath;
-}
-function getImportPathFromRoutes(filePath, routesDir) {
-  let relativePath = filePath.replace(routesDir, "");
-  if (relativePath.startsWith("/")) {
-    relativePath = relativePath.slice(1);
+};
+
+// src/logger/logger.ts
+var Logger = class _Logger {
+  config;
+  module;
+  constructor(config) {
+    this.config = config;
+    this.module = config.module;
   }
-  if (relativePath.endsWith(".ts")) {
-    relativePath = relativePath.slice(0, -3);
+  /**
+   * Get current log level
+   */
+  get level() {
+    return this.config.level;
   }
-  return "@/server/routes/" + relativePath;
-}
-
-// src/codegen/route-scanner.ts
-function groupByResource(mappings) {
-  const grouped = {};
-  for (let i = 0; i < mappings.length; i++) {
-    const mapping = mappings[i];
-    const resource = extractResourceName(mapping.path);
-    if (!grouped[resource]) {
-      grouped[resource] = [];
+  /**
+   * Create child logger (per module)
+   */
+  child(module) {
+    return new _Logger({
+      ...this.config,
+      module
+    });
+  }
+  /**
+   * Debug log
+   */
+  debug(message, context) {
+    this.log("debug", message, void 0, context);
+  }
+  /**
+   * Info log
+   */
+  info(message, context) {
+    this.log("info", message, void 0, context);
+  }
+  warn(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.log("warn", message, errorOrContext, context);
+    } else {
+      this.log("warn", message, void 0, errorOrContext);
     }
-    grouped[resource].push(mapping);
   }
-  return grouped;
-}
-function extractResourceName(path) {
-  const segments = path.slice(1).split("/").filter((s) => s && s !== "*");
-  const staticSegments = [];
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    if (!seg.startsWith(":")) {
-      staticSegments.push(seg);
+  error(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.log("error", message, errorOrContext, context);
+    } else {
+      this.log("error", message, void 0, errorOrContext);
     }
   }
-  if (staticSegments.length === 0) {
-    return "root";
+  fatal(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.log("fatal", message, errorOrContext, context);
+    } else {
+      this.log("fatal", message, void 0, errorOrContext);
+    }
   }
-  if (staticSegments.length === 1) {
-    return staticSegments[0];
+  /**
+   * Log processing (internal)
+   */
+  log(level, message, error, context) {
+    const metadata = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      message,
+      module: this.module,
+      error,
+      context
+    };
+    this.processTransports(metadata);
   }
-  const result = [staticSegments[0]];
-  for (let i = 1; i < staticSegments.length; i++) {
-    const seg = staticSegments[i];
-    result.push(seg.charAt(0).toUpperCase() + seg.slice(1));
+  /**
+   * Process Transports
+   */
+  processTransports(metadata) {
+    const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
+    Promise.all(promises).catch((error) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[Logger] Transport error: ${errorMessage}
+`);
+    });
   }
-  return result.join("");
-}
-async function generateClient(mappings, options) {
-  const startTime = Date.now();
-  const grouped = groupByResource(mappings);
-  const resourceNames = Object.keys(grouped);
-  const code = generateClientCode(mappings, grouped, options);
-  await mkdir(dirname(options.outputPath), { recursive: true });
-  await writeFile(options.outputPath, code, "utf-8");
-  const stats = {
-    routesScanned: mappings.length,
-    contractsFound: mappings.length,
-    contractFiles: countUniqueContractFiles(mappings),
-    resourcesGenerated: resourceNames.length,
-    methodsGenerated: mappings.length,
-    duration: Date.now() - startTime
-  };
-  return stats;
+  /**
+   * Transport log (error-safe)
+   */
+  async safeTransportLog(transport, metadata) {
+    try {
+      await transport.log(metadata);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
+`);
+    }
+  }
+  /**
+   * Close all Transports
+   */
+  async close() {
+    const closePromises = this.config.transports.filter((transport) => transport.close).map((transport) => transport.close());
+    await Promise.all(closePromises);
+  }
+};
+
+// src/logger/types.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4
+};
+
+// src/logger/formatters.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  // 로그 레벨 컬러
+  debug: "\x1B[36m",
+  // cyan
+  info: "\x1B[32m",
+  // green
+  warn: "\x1B[33m",
+  // yellow
+  error: "\x1B[31m",
+  // red
+  fatal: "\x1B[35m",
+  // magenta
+  // 추가 컬러
+  gray: "\x1B[90m"
+};
+function colorizeLevel(level) {
+  const color = COLORS[level];
+  const levelStr = level.toUpperCase().padEnd(5);
+  return `${color}${levelStr}${COLORS.reset}`;
 }
-function generateClientCode(mappings, grouped, options) {
-  let code = "";
-  code += generateHeader();
-  code += generateImports(mappings, options);
-  code += generateApiObject(grouped, options);
-  code += generateFooter();
-  return code;
+function formatTimestamp(date) {
+  return date.toISOString();
 }
-function generateHeader() {
-  return `/**
- * Auto-generated API Client
- *
- * Generated by @spfn/core codegen
- * DO NOT EDIT MANUALLY
- *
- * @generated ${(/* @__PURE__ */ new Date()).toISOString()}
- */
-
-`;
+function formatTimestampHuman(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
 }
-function generateImports(mappings, options) {
-  let code = "";
-  code += `import { client } from '@spfn/core/client';
-`;
-  if (options.includeTypes !== false) {
-    code += `import type { InferContract } from '@spfn/core';
-`;
+function formatError(error) {
+  const lines = [];
+  lines.push(`${error.name}: ${error.message}`);
+  if (error.stack) {
+    const stackLines = error.stack.split("\n").slice(1);
+    lines.push(...stackLines);
   }
-  code += `
-`;
-  const importGroups = groupContractsByImportPath(mappings);
-  const importPaths = Object.keys(importGroups);
-  for (let i = 0; i < importPaths.length; i++) {
-    const importPath = importPaths[i];
-    const contracts = importGroups[importPath];
-    code += `import { ${contracts.join(", ")} } from '${importPath}';
-`;
+  return lines.join("\n");
+}
+function formatContext(context) {
+  try {
+    return JSON.stringify(context, null, 2);
+  } catch (error) {
+    return "[Context serialization failed]";
   }
-  code += `
-`;
-  return code;
 }
-function groupContractsByImportPath(mappings) {
-  const groups = {};
-  for (let i = 0; i < mappings.length; i++) {
-    const mapping = mappings[i];
-    const path = mapping.contractImportPath;
-    if (!groups[path]) {
-      groups[path] = /* @__PURE__ */ new Set();
+function formatConsole(metadata, colorize = true) {
+  const parts = [];
+  const timestamp = formatTimestampHuman(metadata.timestamp);
+  if (colorize) {
+    parts.push(`${COLORS.gray}${timestamp}${COLORS.reset}`);
+  } else {
+    parts.push(timestamp);
+  }
+  if (colorize) {
+    parts.push(colorizeLevel(metadata.level));
+  } else {
+    parts.push(metadata.level.toUpperCase().padEnd(5));
+  }
+  if (metadata.module) {
+    if (colorize) {
+      parts.push(`${COLORS.dim}[${metadata.module}]${COLORS.reset}`);
+    } else {
+      parts.push(`[${metadata.module}]`);
     }
-    groups[path].add(mapping.contractName);
   }
-  const result = {};
-  const keys = Object.keys(groups);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    result[key] = Array.from(groups[key]);
+  parts.push(metadata.message);
+  let output = parts.join(" ");
+  if (metadata.context && Object.keys(metadata.context).length > 0) {
+    output += "\n" + formatContext(metadata.context);
   }
-  return result;
+  if (metadata.error) {
+    output += "\n" + formatError(metadata.error);
+  }
+  return output;
 }
-function generateApiObject(grouped, options) {
-  let code = "";
-  code += `/**
- * Type-safe API client
- */
-export const api = {
-`;
-  const resourceNames = Object.keys(grouped);
-  for (let i = 0; i < resourceNames.length; i++) {
-    const resourceName = resourceNames[i];
-    const routes = grouped[resourceName];
-    code += `    ${resourceName}: {
-`;
-    for (let j = 0; j < routes.length; j++) {
-      const route = routes[j];
-      code += generateMethodCode(route, options);
+function formatJSON(metadata) {
+  const obj = {
+    timestamp: formatTimestamp(metadata.timestamp),
+    level: metadata.level,
+    message: metadata.message
+  };
+  if (metadata.module) {
+    obj.module = metadata.module;
+  }
+  if (metadata.context) {
+    obj.context = metadata.context;
+  }
+  if (metadata.error) {
+    obj.error = {
+      name: metadata.error.name,
+      message: metadata.error.message,
+      stack: metadata.error.stack
+    };
+  }
+  return JSON.stringify(obj);
+}
+
+// src/logger/transports/console.ts
+var ConsoleTransport = class {
+  name = "console";
+  level;
+  enabled;
+  colorize;
+  constructor(config) {
+    this.level = config.level;
+    this.enabled = config.enabled;
+    this.colorize = config.colorize ?? true;
+  }
+  async log(metadata) {
+    if (!this.enabled) {
+      return;
     }
-    code += `    }`;
-    if (i < resourceNames.length - 1) {
-      code += `,`;
+    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
+      return;
+    }
+    const message = formatConsole(metadata, this.colorize);
+    if (metadata.level === "warn" || metadata.level === "error" || metadata.level === "fatal") {
+      console.error(message);
+    } else {
+      console.log(message);
     }
-    code += `
-`;
   }
-  code += `} as const;
-
-`;
-  return code;
-}
-function generateMethodCode(mapping, options) {
-  const methodName = generateMethodName(mapping);
-  const contractType = `typeof ${mapping.contractName}`;
-  const hasParams = mapping.path.includes(":");
-  const hasBody = ["POST", "PUT", "PATCH"].indexOf(mapping.method) !== -1;
-  let code = "";
-  if (options.includeJsDoc !== false) {
-    code += `        /**
-`;
-    code += `         * ${mapping.method} ${mapping.path}
-`;
-    code += `         */
-`;
+};
+var FileTransport = class {
+  name = "file";
+  level;
+  enabled;
+  logDir;
+  currentStream = null;
+  currentFilename = null;
+  constructor(config) {
+    this.level = config.level;
+    this.enabled = config.enabled;
+    this.logDir = config.logDir;
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  async log(metadata) {
+    if (!this.enabled) {
+      return;
+    }
+    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
+      return;
+    }
+    const message = formatJSON(metadata);
+    const filename = this.getLogFilename(metadata.timestamp);
+    if (this.currentFilename !== filename) {
+      await this.rotateStream(filename);
+    }
+    if (this.currentStream) {
+      return new Promise((resolve2, reject) => {
+        this.currentStream.write(message + "\n", "utf-8", (error) => {
+          if (error) {
+            process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
+`);
+            reject(error);
+          } else {
+            resolve2();
+          }
+        });
+      });
+    }
   }
-  code += `        ${methodName}: (`;
-  const params = [];
-  if (hasParams) {
-    params.push(`params: InferContract<${contractType}>['params']`);
+  /**
+   * 스트림 교체 (날짜 변경 시)
+   */
+  async rotateStream(filename) {
+    if (this.currentStream) {
+      await this.closeStream();
+    }
+    const filepath = join(this.logDir, filename);
+    this.currentStream = createWriteStream(filepath, {
+      flags: "a",
+      // append mode
+      encoding: "utf-8"
+    });
+    this.currentFilename = filename;
+    this.currentStream.on("error", (error) => {
+      process.stderr.write(`[FileTransport] Stream error: ${error.message}
+`);
+      this.currentStream = null;
+      this.currentFilename = null;
+    });
   }
-  if (hasBody) {
-    params.push(`body: InferContract<${contractType}>['body']`);
+  /**
+   * 현재 스트림 닫기
+   */
+  async closeStream() {
+    if (!this.currentStream) {
+      return;
+    }
+    return new Promise((resolve2, reject) => {
+      this.currentStream.end((error) => {
+        if (error) {
+          reject(error);
+        } else {
+          this.currentStream = null;
+          this.currentFilename = null;
+          resolve2();
+        }
+      });
+    });
   }
-  if (params.length > 0) {
-    code += `options: { ${params.join(", ")} }`;
+  /**
+   * 날짜별 로그 파일명 생성
+   */
+  getLogFilename(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}.log`;
   }
-  code += `) => `;
-  code += `client.call('${mapping.path}', ${mapping.contractName}, `;
-  if (params.length > 0) {
-    code += `options`;
-  } else {
-    code += `{}`;
+  async close() {
+    await this.closeStream();
   }
-  code += `),
-`;
-  return code;
-}
-function generateMethodName(mapping) {
-  const method = mapping.method.toLowerCase();
-  if (mapping.path === "/" || mapping.path.match(/^\/[\w-]+$/)) {
-    if (method === "get") {
-      return "list";
-    }
-    if (method === "post") {
-      return "create";
-    }
+};
+
+// src/logger/config.ts
+function getDefaultLogLevel() {
+  const isProduction = process.env.NODE_ENV === "production";
+  const isDevelopment = process.env.NODE_ENV === "development";
+  if (isDevelopment) {
+    return "debug";
   }
-  if (mapping.path.includes(":")) {
-    if (method === "get") {
-      return "getById";
-    }
-    if (method === "put" || method === "patch") {
-      return "update";
-    }
-    if (method === "delete") {
-      return "delete";
-    }
+  if (isProduction) {
+    return "info";
   }
-  return method;
+  return "warn";
 }
-function generateFooter() {
-  return `/**
- * Export client instance for advanced usage
- *
- * Use this to add interceptors or customize the client:
- *
- * @example
- * \`\`\`ts
- * import { client } from './api';
- * import { createAuthInterceptor } from '@spfn/auth/nextjs';
- * import { NextJSCookieProvider } from '@spfn/auth/nextjs';
- *
- * client.use(createAuthInterceptor({
- *   cookieProvider: new NextJSCookieProvider(),
- *   encryptionKey: process.env.ENCRYPTION_KEY!
- * }));
- * \`\`\`
- */
-export { client };
-`;
+function getConsoleConfig() {
+  const isProduction = process.env.NODE_ENV === "production";
+  return {
+    level: "debug",
+    enabled: true,
+    colorize: !isProduction
+    // Dev: colored output, Production: plain text
+  };
 }
-function countUniqueContractFiles(mappings) {
-  const files = /* @__PURE__ */ new Set();
-  for (let i = 0; i < mappings.length; i++) {
-    if (mappings[i].contractFile) {
-      files.add(mappings[i].contractFile);
-    }
+function getFileConfig() {
+  const isProduction = process.env.NODE_ENV === "production";
+  return {
+    level: "info",
+    enabled: isProduction,
+    // File logging in production only
+    logDir: process.env.LOG_DIR || "./logs",
+    maxFileSize: 10 * 1024 * 1024,
+    // 10MB
+    maxFiles: 10
+  };
+}
+
+// src/logger/adapters/custom.ts
+function initializeTransports() {
+  const transports = [];
+  const consoleConfig = getConsoleConfig();
+  transports.push(new ConsoleTransport(consoleConfig));
+  const fileConfig = getFileConfig();
+  if (fileConfig.enabled) {
+    transports.push(new FileTransport(fileConfig));
   }
-  return files.size;
+  return transports;
 }
-var PinoAdapter = class _PinoAdapter {
+var CustomAdapter = class _CustomAdapter {
   logger;
-  constructor(config2) {
-    const isProduction = process.env.NODE_ENV === "production";
-    const isDevelopment = process.env.NODE_ENV === "development";
-    const fileLoggingEnabled = process.env.LOGGER_FILE_ENABLED === "true";
-    const targets = [];
-    if (!isProduction && isDevelopment) {
-      targets.push({
-        target: "pino-pretty",
-        level: "debug",
-        options: {
-          colorize: true,
-          translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
-          ignore: "pid,hostname"
-        }
-      });
-    }
-    if (fileLoggingEnabled && isProduction) {
-      const logDir = process.env.LOG_DIR || "./logs";
-      const maxFileSize = process.env.LOG_MAX_FILE_SIZE || "10M";
-      const maxFiles = parseInt(process.env.LOG_MAX_FILES || "10", 10);
-      targets.push({
-        target: "pino-roll",
-        level: "info",
-        options: {
-          file: `${logDir}/app.log`,
-          frequency: "daily",
-          size: maxFileSize,
-          limit: { count: maxFiles },
-          mkdir: true
-        }
-      });
-    }
-    this.logger = pino({
-      level: config2.level,
-      // Transport 설정 (targets가 있으면 사용, 없으면 기본 stdout)
-      transport: targets.length > 0 ? { targets } : void 0,
-      // 기본 필드
-      base: config2.module ? { module: config2.module } : void 0
+  constructor(config) {
+    this.logger = new Logger({
+      level: config.level,
+      module: config.module,
+      transports: initializeTransports()
     });
   }
   child(module) {
-    const childLogger = new _PinoAdapter({ level: this.logger.level, module });
-    childLogger.logger = this.logger.child({ module });
-    return childLogger;
+    const adapter = new _CustomAdapter({ level: this.logger.level, module });
+    adapter.logger = this.logger.child(module);
+    return adapter;
   }
   debug(message, context) {
-    this.logger.debug(context || {}, message);
+    this.logger.debug(message, context);
   }
   info(message, context) {
-    this.logger.info(context || {}, message);
+    this.logger.info(message, context);
   }
   warn(message, errorOrContext, context) {
     if (errorOrContext instanceof Error) {
-      this.logger.warn({ err: errorOrContext, ...context }, message);
+      this.logger.warn(message, errorOrContext, context);
     } else {
-      this.logger.warn(errorOrContext || {}, message);
+      this.logger.warn(message, errorOrContext);
     }
   }
   error(message, errorOrContext, context) {
     if (errorOrContext instanceof Error) {
-      this.logger.error({ err: errorOrContext, ...context }, message);
+      this.logger.error(message, errorOrContext, context);
     } else {
-      this.logger.error(errorOrContext || {}, message);
+      this.logger.error(message, errorOrContext);
     }
   }
   fatal(message, errorOrContext, context) {
     if (errorOrContext instanceof Error) {
-      this.logger.fatal({ err: errorOrContext, ...context }, message);
+      this.logger.fatal(message, errorOrContext, context);
     } else {
-      this.logger.fatal(errorOrContext || {}, message);
+      this.logger.fatal(message, errorOrContext);
     }
   }
   async close() {
+    await this.logger.close();
   }
 };
 
-// src/logger/logger.ts
-var Logger = class _Logger {
-  config;
-  module;
-  constructor(config2) {
-    this.config = config2;
-    this.module = config2.module;
+// src/logger/adapter-factory.ts
+function createAdapter(type) {
+  const level = getDefaultLogLevel();
+  switch (type) {
+    case "pino":
+      return new PinoAdapter({ level });
+    case "custom":
+      return new CustomAdapter({ level });
+    default:
+      return new PinoAdapter({ level });
   }
-  /**
-   * Get current log level
-   */
-  get level() {
-    return this.config.level;
+}
+function getAdapterType() {
+  const adapterEnv = process.env.LOGGER_ADAPTER;
+  if (adapterEnv === "custom" || adapterEnv === "pino") {
+    return adapterEnv;
+  }
+  return "pino";
+}
+var logger = createAdapter(getAdapterType());
+
+// src/env/config.ts
+var ENV_FILE_PRIORITY = [
+  ".env",
+  // Base configuration (lowest priority)
+  ".env.{NODE_ENV}",
+  // Environment-specific
+  ".env.local",
+  // Local overrides
+  ".env.{NODE_ENV}.local"
+  // Local environment-specific (highest priority)
+];
+var TEST_ONLY_FILES = [
+  ".env.test",
+  ".env.test.local"
+];
+
+// src/env/loader.ts
+var envLogger = logger.child("environment");
+var environmentLoaded = false;
+var cachedLoadResult;
+function buildFileList(basePath, nodeEnv) {
+  const files = [];
+  for (const pattern of ENV_FILE_PRIORITY) {
+    const fileName = pattern.replace("{NODE_ENV}", nodeEnv);
+    if (nodeEnv !== "test" && TEST_ONLY_FILES.includes(fileName)) {
+      continue;
+    }
+    files.push(join(basePath, fileName));
+  }
+  return files;
+}
+function loadSingleFile(filePath, debug) {
+  if (!existsSync(filePath)) {
+    if (debug) {
+      envLogger.debug("Environment file not found (optional)", {
+        path: filePath
+      });
+    }
+    return { success: false, parsed: {}, error: "File not found" };
   }
-  /**
-   * Create child logger (per module)
-   */
-  child(module) {
-    return new _Logger({
-      ...this.config,
-      module
+  try {
+    const result = config({ path: filePath });
+    if (result.error) {
+      envLogger.warn("Failed to parse environment file", {
+        path: filePath,
+        error: result.error.message
+      });
+      return {
+        success: false,
+        parsed: {},
+        error: result.error.message
+      };
+    }
+    const parsed = result.parsed || {};
+    if (debug) {
+      envLogger.debug("Environment file loaded successfully", {
+        path: filePath,
+        variables: Object.keys(parsed),
+        count: Object.keys(parsed).length
+      });
+    }
+    return { success: true, parsed };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    envLogger.error("Error loading environment file", {
+      path: filePath,
+      error: message
     });
+    return { success: false, parsed: {}, error: message };
   }
-  /**
-   * Debug log
-   */
-  debug(message, context) {
-    this.log("debug", message, void 0, context);
+}
+function validateRequiredVars(required, debug) {
+  const missing = [];
+  for (const varName of required) {
+    if (!process.env[varName]) {
+      missing.push(varName);
+    }
   }
-  /**
-   * Info log
-   */
-  info(message, context) {
-    this.log("info", message, void 0, context);
+  if (missing.length > 0) {
+    const error = `Required environment variables missing: ${missing.join(", ")}`;
+    envLogger.error("Environment validation failed", {
+      missing,
+      required
+    });
+    throw new Error(error);
   }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("warn", message, errorOrContext, context);
-    } else {
-      this.log("warn", message, void 0, errorOrContext);
-    }
+  if (debug) {
+    envLogger.debug("Required environment variables validated", {
+      required,
+      allPresent: true
+    });
   }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("error", message, errorOrContext, context);
-    } else {
-      this.log("error", message, void 0, errorOrContext);
+}
+function loadEnvironment(options = {}) {
+  const {
+    basePath = process.cwd(),
+    customPaths = [],
+    debug = false,
+    nodeEnv = process.env.NODE_ENV || "development",
+    required = [],
+    useCache = true
+  } = options;
+  if (useCache && environmentLoaded && cachedLoadResult) {
+    if (debug) {
+      envLogger.debug("Returning cached environment", {
+        loaded: cachedLoadResult.loaded.length,
+        variables: Object.keys(cachedLoadResult.parsed).length
+      });
     }
+    return cachedLoadResult;
+  }
+  if (debug) {
+    envLogger.debug("Loading environment variables", {
+      basePath,
+      nodeEnv,
+      customPaths,
+      required
+    });
   }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("fatal", message, errorOrContext, context);
-    } else {
-      this.log("fatal", message, void 0, errorOrContext);
-    }
+  const result = {
+    success: true,
+    loaded: [],
+    failed: [],
+    parsed: {},
+    warnings: []
+  };
+  const standardFiles = buildFileList(basePath, nodeEnv);
+  const allFiles = [...standardFiles, ...customPaths];
+  if (debug) {
+    envLogger.debug("Environment files to load", {
+      standardFiles,
+      customPaths,
+      total: allFiles.length
+    });
   }
-  /**
-   * Log processing (internal)
-   */
-  log(level, message, error, context) {
-    const metadata = {
-      timestamp: /* @__PURE__ */ new Date(),
-      level,
-      message,
-      module: this.module,
-      error,
-      context
-    };
-    this.processTransports(metadata);
+  const reversedFiles = [...allFiles].reverse();
+  for (const filePath of reversedFiles) {
+    const fileResult = loadSingleFile(filePath, debug);
+    if (fileResult.success) {
+      result.loaded.push(filePath);
+      Object.assign(result.parsed, fileResult.parsed);
+    } else if (fileResult.error) {
+      result.failed.push({
+        path: filePath,
+        reason: fileResult.error
+      });
+    }
   }
-  /**
-   * Process Transports
-   */
-  processTransports(metadata) {
-    const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
-    Promise.all(promises).catch((error) => {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[Logger] Transport error: ${errorMessage}
-`);
+  if (debug || result.loaded.length > 0) {
+    envLogger.info("Environment loading complete", {
+      loaded: result.loaded.length,
+      failed: result.failed.length,
+      variables: Object.keys(result.parsed).length,
+      files: result.loaded
     });
   }
-  /**
-   * Transport log (error-safe)
-   */
-  async safeTransportLog(transport, metadata) {
+  if (required.length > 0) {
     try {
-      await transport.log(metadata);
+      validateRequiredVars(required, debug);
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
-`);
+      result.success = false;
+      result.errors = [
+        error instanceof Error ? error.message : "Validation failed"
+      ];
+      throw error;
     }
   }
-  /**
-   * Close all Transports
-   */
-  async close() {
-    const closePromises = this.config.transports.filter((transport) => transport.close).map((transport) => transport.close());
-    await Promise.all(closePromises);
-  }
-};
-
-// src/logger/types.ts
-var LOG_LEVEL_PRIORITY = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  fatal: 4
-};
+  environmentLoaded = true;
+  cachedLoadResult = result;
+  return result;
+}
 
-// src/logger/formatters.ts
-var COLORS = {
-  reset: "\x1B[0m",
-  bright: "\x1B[1m",
-  dim: "\x1B[2m",
-  // 로그 레벨 컬러
-  debug: "\x1B[36m",
-  // cyan
-  info: "\x1B[32m",
-  // green
-  warn: "\x1B[33m",
-  // yellow
-  error: "\x1B[31m",
-  // red
-  fatal: "\x1B[35m",
-  // magenta
-  // 추가 컬러
-  gray: "\x1B[90m"
-};
-function colorizeLevel(level) {
-  const color = COLORS[level];
-  const levelStr = level.toUpperCase().padEnd(5);
-  return `${color}${levelStr}${COLORS.reset}`;
+// src/scripts/migrate.ts
+loadEnvironment({ debug: true });
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var projectRoot = join(__dirname, "../../..");
+var DATABASE_URL = process.env.DATABASE_URL;
+if (!DATABASE_URL) {
+  console.error("\u274C DATABASE_URL environment variable is required");
+  process.exit(1);
 }
-function formatTimestamp(date) {
-  return date.toISOString();
+async function runMigrations() {
+  console.log("\u{1F504} Starting database migration...");
+  console.log(`\u{1F4C2} Migrations folder: ${join(projectRoot, "drizzle")}`);
+  const migrationConnection = postgres(DATABASE_URL, { max: 1 });
+  const db = drizzle(migrationConnection);
+  try {
+    console.log("\u23F3 Applying migrations...");
+    await migrate(db, {
+      migrationsFolder: join(projectRoot, "drizzle")
+    });
+    console.log("\u2705 Migration completed successfully");
+  } catch (error) {
+    console.error("\u274C Migration failed:", error);
+    throw error;
+  } finally {
+    await migrationConnection.end();
+    console.log("\u{1F50C} Database connection closed");
+  }
 }
-function formatTimestampHuman(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  const ms = String(date.getMilliseconds()).padStart(3, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+runMigrations().then(() => {
+  console.log("\u{1F389} All migrations applied");
+  process.exit(0);
+}).catch((error) => {
+  console.error("\u{1F4A5} Migration process failed:", error);
+  process.exit(1);
+});
+async function scanContracts(routesDir) {
+  const contractFiles = await scanContractFiles(routesDir);
+  const mappings = [];
+  for (let i = 0; i < contractFiles.length; i++) {
+    const filePath = contractFiles[i];
+    const exports = extractContractExports(filePath);
+    const basePath = getBasePathFromFile(filePath, routesDir);
+    for (let j = 0; j < exports.length; j++) {
+      const contractExport = exports[j];
+      const fullPath = combinePaths(basePath, contractExport.path);
+      mappings.push({
+        method: contractExport.method,
+        path: fullPath,
+        contractName: contractExport.name,
+        contractImportPath: getImportPathFromRoutes(filePath, routesDir),
+        routeFile: "",
+        // Not needed anymore
+        contractFile: filePath
+      });
+    }
+  }
+  return mappings;
 }
-function formatError(error) {
-  const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
-    lines.push(...stackLines);
+async function scanContractFiles(dir, files = []) {
+  try {
+    const entries = await readdir(dir);
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const fullPath = join(dir, entry);
+      const fileStat = await stat(fullPath);
+      if (fileStat.isDirectory()) {
+        await scanContractFiles(fullPath, files);
+      } else if (entry === "contract.ts") {
+        files.push(fullPath);
+      }
+    }
+  } catch (error) {
+  }
+  return files;
+}
+function extractContractExports(filePath) {
+  const sourceCode = readFileSync(filePath, "utf-8");
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const exports = [];
+  function visit(node) {
+    if (ts.isVariableStatement(node)) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.ExportKeyword
+      );
+      if (hasExport && node.declarationList.declarations.length > 0) {
+        const declaration = node.declarationList.declarations[0];
+        if (ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) && declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
+          const name = declaration.name.text;
+          if (isContractName(name)) {
+            const contractData = extractContractData(declaration.initializer);
+            if (contractData.method && contractData.path) {
+              exports.push({
+                name,
+                method: contractData.method,
+                path: contractData.path
+              });
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return exports;
+}
+function extractContractData(objectLiteral) {
+  const result = {};
+  for (let i = 0; i < objectLiteral.properties.length; i++) {
+    const prop = objectLiteral.properties[i];
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      const propName = prop.name.text;
+      if (propName === "method") {
+        let value;
+        if (ts.isStringLiteral(prop.initializer)) {
+          value = prop.initializer.text;
+        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
+          value = prop.initializer.expression.text;
+        }
+        if (value) result.method = value;
+      } else if (propName === "path") {
+        let value;
+        if (ts.isStringLiteral(prop.initializer)) {
+          value = prop.initializer.text;
+        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
+          value = prop.initializer.expression.text;
+        }
+        if (value) result.path = value;
+      }
+    }
   }
-  return lines.join("\n");
+  return result;
 }
-function formatContext(context) {
-  try {
-    return JSON.stringify(context, null, 2);
-  } catch (error) {
-    return "[Context serialization failed]";
-  }
+function isContractName(name) {
+  return name.indexOf("Contract") !== -1 || name.indexOf("contract") !== -1 || name.endsWith("Schema") || name.endsWith("schema");
 }
-function formatConsole(metadata, colorize = true) {
-  const parts = [];
-  const timestamp = formatTimestampHuman(metadata.timestamp);
-  if (colorize) {
-    parts.push(`${COLORS.gray}${timestamp}${COLORS.reset}`);
-  } else {
-    parts.push(timestamp);
+function getBasePathFromFile(filePath, routesDir) {
+  let relativePath = filePath.replace(routesDir, "");
+  if (relativePath.startsWith("/")) {
+    relativePath = relativePath.slice(1);
   }
-  if (colorize) {
-    parts.push(colorizeLevel(metadata.level));
-  } else {
-    parts.push(metadata.level.toUpperCase().padEnd(5));
+  relativePath = relativePath.replace("/contract.ts", "");
+  if (relativePath === "index" || relativePath === "") {
+    return "/";
   }
-  if (metadata.module) {
-    if (colorize) {
-      parts.push(`${COLORS.dim}[${metadata.module}]${COLORS.reset}`);
+  const segments = relativePath.split("/");
+  const transformed = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg === "index") {
+      continue;
+    }
+    if (seg.startsWith("[") && seg.endsWith("]")) {
+      transformed.push(":" + seg.slice(1, -1));
     } else {
-      parts.push(`[${metadata.module}]`);
+      transformed.push(seg);
     }
   }
-  parts.push(metadata.message);
-  let output = parts.join(" ");
-  if (metadata.context && Object.keys(metadata.context).length > 0) {
-    output += "\n" + formatContext(metadata.context);
-  }
-  if (metadata.error) {
-    output += "\n" + formatError(metadata.error);
+  if (transformed.length === 0) {
+    return "/";
   }
-  return output;
+  return "/" + transformed.join("/");
 }
-function formatJSON(metadata) {
-  const obj = {
-    timestamp: formatTimestamp(metadata.timestamp),
-    level: metadata.level,
-    message: metadata.message
-  };
-  if (metadata.module) {
-    obj.module = metadata.module;
+function combinePaths(basePath, contractPath) {
+  basePath = basePath || "/";
+  contractPath = contractPath || "/";
+  if (basePath.endsWith("/") && basePath !== "/") {
+    basePath = basePath.slice(0, -1);
   }
-  if (metadata.context) {
-    obj.context = metadata.context;
+  if (contractPath.startsWith("/") && contractPath !== "/") {
+    if (basePath === "/") {
+      return contractPath;
+    }
+    return basePath + contractPath;
   }
-  if (metadata.error) {
-    obj.error = {
-      name: metadata.error.name,
-      message: metadata.error.message,
-      stack: metadata.error.stack
-    };
+  if (contractPath === "/") {
+    return basePath;
   }
-  return JSON.stringify(obj);
+  return basePath + "/" + contractPath;
 }
-
-// src/logger/transports/console.ts
-var ConsoleTransport = class {
-  name = "console";
-  level;
-  enabled;
-  colorize;
-  constructor(config2) {
-    this.level = config2.level;
-    this.enabled = config2.enabled;
-    this.colorize = config2.colorize ?? true;
+function getImportPathFromRoutes(filePath, routesDir) {
+  let relativePath = filePath.replace(routesDir, "");
+  if (relativePath.startsWith("/")) {
+    relativePath = relativePath.slice(1);
   }
-  async log(metadata) {
-    if (!this.enabled) {
-      return;
-    }
-    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-      return;
-    }
-    const message = formatConsole(metadata, this.colorize);
-    if (metadata.level === "warn" || metadata.level === "error" || metadata.level === "fatal") {
-      console.error(message);
-    } else {
-      console.log(message);
-    }
+  if (relativePath.endsWith(".ts")) {
+    relativePath = relativePath.slice(0, -3);
   }
-};
-var FileTransport = class {
-  name = "file";
-  level;
-  enabled;
-  logDir;
-  currentStream = null;
-  currentFilename = null;
-  constructor(config2) {
-    this.level = config2.level;
-    this.enabled = config2.enabled;
-    this.logDir = config2.logDir;
-    if (!existsSync(this.logDir)) {
-      mkdirSync(this.logDir, { recursive: true });
+  return "@/server/routes/" + relativePath;
+}
+
+// src/codegen/route-scanner.ts
+function groupByResource(mappings) {
+  const grouped = {};
+  for (let i = 0; i < mappings.length; i++) {
+    const mapping = mappings[i];
+    const resource = extractResourceName(mapping.path);
+    if (!grouped[resource]) {
+      grouped[resource] = [];
     }
+    grouped[resource].push(mapping);
   }
-  async log(metadata) {
-    if (!this.enabled) {
-      return;
-    }
-    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-      return;
-    }
-    const message = formatJSON(metadata);
-    const filename = this.getLogFilename(metadata.timestamp);
-    if (this.currentFilename !== filename) {
-      await this.rotateStream(filename);
-    }
-    if (this.currentStream) {
-      return new Promise((resolve2, reject) => {
-        this.currentStream.write(message + "\n", "utf-8", (error) => {
-          if (error) {
-            process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
-`);
-            reject(error);
-          } else {
-            resolve2();
-          }
-        });
-      });
+  return grouped;
+}
+function extractResourceName(path) {
+  const segments = path.slice(1).split("/").filter((s) => s && s !== "*");
+  const staticSegments = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (!seg.startsWith(":")) {
+      staticSegments.push(seg);
     }
   }
-  /**
-   * 스트림 교체 (날짜 변경 시)
-   */
-  async rotateStream(filename) {
-    if (this.currentStream) {
-      await this.closeStream();
-    }
-    const filepath = join(this.logDir, filename);
-    this.currentStream = createWriteStream(filepath, {
-      flags: "a",
-      // append mode
-      encoding: "utf-8"
-    });
-    this.currentFilename = filename;
-    this.currentStream.on("error", (error) => {
-      process.stderr.write(`[FileTransport] Stream error: ${error.message}
-`);
-      this.currentStream = null;
-      this.currentFilename = null;
-    });
+  if (staticSegments.length === 0) {
+    return "root";
+  }
+  if (staticSegments.length === 1) {
+    return staticSegments[0];
+  }
+  const result = [staticSegments[0]];
+  for (let i = 1; i < staticSegments.length; i++) {
+    const seg = staticSegments[i];
+    result.push(seg.charAt(0).toUpperCase() + seg.slice(1));
+  }
+  return result.join("");
+}
+async function generateClient(mappings, options) {
+  const startTime = Date.now();
+  const grouped = groupByResource(mappings);
+  const resourceNames = Object.keys(grouped);
+  const code = generateClientCode(mappings, grouped, options);
+  await mkdir(dirname(options.outputPath), { recursive: true });
+  await writeFile(options.outputPath, code, "utf-8");
+  const stats = {
+    routesScanned: mappings.length,
+    contractsFound: mappings.length,
+    contractFiles: countUniqueContractFiles(mappings),
+    resourcesGenerated: resourceNames.length,
+    methodsGenerated: mappings.length,
+    duration: Date.now() - startTime
+  };
+  return stats;
+}
+function generateClientCode(mappings, grouped, options) {
+  let code = "";
+  code += generateHeader();
+  code += generateImports(mappings, options);
+  code += generateApiObject(grouped, options);
+  code += generateFooter();
+  return code;
+}
+function generateHeader() {
+  return `/**
+ * Auto-generated API Client
+ *
+ * Generated by @spfn/core codegen
+ * DO NOT EDIT MANUALLY
+ *
+ * @generated ${(/* @__PURE__ */ new Date()).toISOString()}
+ */
+
+`;
+}
+function generateImports(mappings, options) {
+  let code = "";
+  code += `import { client } from '@spfn/core/client';
+`;
+  if (options.includeTypes !== false) {
+    code += `import type { InferContract } from '@spfn/core';
+`;
   }
-  /**
-   * 현재 스트림 닫기
-   */
-  async closeStream() {
-    if (!this.currentStream) {
-      return;
+  code += `
+`;
+  const importGroups = groupContractsByImportPath(mappings);
+  const importPaths = Object.keys(importGroups);
+  for (let i = 0; i < importPaths.length; i++) {
+    const importPath = importPaths[i];
+    const contracts = importGroups[importPath];
+    code += `import { ${contracts.join(", ")} } from '${importPath}';
+`;
+  }
+  code += `
+`;
+  return code;
+}
+function groupContractsByImportPath(mappings) {
+  const groups = {};
+  for (let i = 0; i < mappings.length; i++) {
+    const mapping = mappings[i];
+    const path = mapping.contractImportPath;
+    if (!groups[path]) {
+      groups[path] = /* @__PURE__ */ new Set();
     }
-    return new Promise((resolve2, reject) => {
-      this.currentStream.end((error) => {
-        if (error) {
-          reject(error);
-        } else {
-          this.currentStream = null;
-          this.currentFilename = null;
-          resolve2();
-        }
-      });
-    });
+    groups[path].add(mapping.contractName);
   }
-  /**
-   * 날짜별 로그 파일명 생성
-   */
-  getLogFilename(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    return `${year}-${month}-${day}.log`;
+  const result = {};
+  const keys = Object.keys(groups);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    result[key] = Array.from(groups[key]);
   }
-  async close() {
-    await this.closeStream();
+  return result;
+}
+function generateApiObject(grouped, options) {
+  let code = "";
+  code += `/**
+ * Type-safe API client
+ */
+export const api = {
+`;
+  const resourceNames = Object.keys(grouped);
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
+    code += `    ${resourceName}: {
+`;
+    for (let j = 0; j < routes.length; j++) {
+      const route = routes[j];
+      code += generateMethodCode(route, options);
+    }
+    code += `    }`;
+    if (i < resourceNames.length - 1) {
+      code += `,`;
+    }
+    code += `
+`;
   }
-};
+  code += `} as const;
 
-// src/logger/config.ts
-function getDefaultLogLevel() {
-  const isProduction = process.env.NODE_ENV === "production";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    return "debug";
-  }
-  if (isProduction) {
-    return "info";
-  }
-  return "warn";
-}
-function getConsoleConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "debug",
-    enabled: true,
-    colorize: !isProduction
-    // Dev: colored output, Production: plain text
-  };
-}
-function getFileConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "info",
-    enabled: isProduction,
-    // File logging in production only
-    logDir: process.env.LOG_DIR || "./logs",
-    maxFileSize: 10 * 1024 * 1024,
-    // 10MB
-    maxFiles: 10
-  };
+`;
+  return code;
 }
-
-// src/logger/adapters/custom.ts
-function initializeTransports() {
-  const transports = [];
-  const consoleConfig = getConsoleConfig();
-  transports.push(new ConsoleTransport(consoleConfig));
-  const fileConfig = getFileConfig();
-  if (fileConfig.enabled) {
-    transports.push(new FileTransport(fileConfig));
+function generateMethodCode(mapping, options) {
+  const methodName = generateMethodName(mapping);
+  const contractType = `typeof ${mapping.contractName}`;
+  const hasParams = mapping.path.includes(":");
+  const hasBody = ["POST", "PUT", "PATCH"].indexOf(mapping.method) !== -1;
+  let code = "";
+  if (options.includeJsDoc !== false) {
+    code += `        /**
+`;
+    code += `         * ${mapping.method} ${mapping.path}
+`;
+    code += `         */
+`;
   }
-  return transports;
-}
-var CustomAdapter = class _CustomAdapter {
-  logger;
-  constructor(config2) {
-    this.logger = new Logger({
-      level: config2.level,
-      module: config2.module,
-      transports: initializeTransports()
-    });
+  code += `        ${methodName}: (`;
+  const params = [];
+  if (hasParams) {
+    params.push(`params: InferContract<${contractType}>['params']`);
   }
-  child(module) {
-    const adapter = new _CustomAdapter({ level: this.logger.level, module });
-    adapter.logger = this.logger.child(module);
-    return adapter;
+  if (hasBody) {
+    params.push(`body: InferContract<${contractType}>['body']`);
   }
-  debug(message, context) {
-    this.logger.debug(message, context);
+  if (params.length > 0) {
+    code += `options: { ${params.join(", ")} }`;
   }
-  info(message, context) {
-    this.logger.info(message, context);
+  code += `) => `;
+  code += `client.call('${mapping.path}', ${mapping.contractName}, `;
+  if (params.length > 0) {
+    code += `options`;
+  } else {
+    code += `{}`;
   }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.warn(message, errorOrContext, context);
-    } else {
-      this.logger.warn(message, errorOrContext);
+  code += `),
+`;
+  return code;
+}
+function generateMethodName(mapping) {
+  const method = mapping.method.toLowerCase();
+  if (mapping.path === "/" || mapping.path.match(/^\/[\w-]+$/)) {
+    if (method === "get") {
+      return "list";
     }
-  }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.error(message, errorOrContext, context);
-    } else {
-      this.logger.error(message, errorOrContext);
+    if (method === "post") {
+      return "create";
     }
   }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.fatal(message, errorOrContext, context);
-    } else {
-      this.logger.fatal(message, errorOrContext);
+  if (mapping.path.includes(":")) {
+    if (method === "get") {
+      return "getById";
+    }
+    if (method === "put" || method === "patch") {
+      return "update";
+    }
+    if (method === "delete") {
+      return "delete";
     }
   }
-  async close() {
-    await this.logger.close();
-  }
-};
-
-// src/logger/adapter-factory.ts
-function createAdapter(type) {
-  const level = getDefaultLogLevel();
-  switch (type) {
-    case "pino":
-      return new PinoAdapter({ level });
-    case "custom":
-      return new CustomAdapter({ level });
-    default:
-      return new PinoAdapter({ level });
-  }
+  return method;
 }
-function getAdapterType() {
-  const adapterEnv = process.env.LOGGER_ADAPTER;
-  if (adapterEnv === "custom" || adapterEnv === "pino") {
-    return adapterEnv;
+function generateFooter() {
+  return `/**
+ * Export client instance for advanced usage
+ *
+ * Use this to add interceptors or customize the client:
+ *
+ * @example
+ * \`\`\`ts
+ * import { client } from './api';
+ * import { createAuthInterceptor } from '@spfn/auth/nextjs';
+ * import { NextJSCookieProvider } from '@spfn/auth/nextjs';
+ *
+ * client.use(createAuthInterceptor({
+ *   cookieProvider: new NextJSCookieProvider(),
+ *   encryptionKey: process.env.ENCRYPTION_KEY!
+ * }));
+ * \`\`\`
+ */
+export { client };
+`;
+}
+function countUniqueContractFiles(mappings) {
+  const files = /* @__PURE__ */ new Set();
+  for (let i = 0; i < mappings.length; i++) {
+    if (mappings[i].contractFile) {
+      files.add(mappings[i].contractFile);
+    }
   }
-  return "pino";
+  return files.size;
 }
-var logger = createAdapter(getAdapterType());
-
-// src/codegen/watch-generate.ts
 var codegenLogger = logger.child("codegen");
 async function generateOnce(options) {
   const cwd = process.cwd();