@mindbase/express-common 1.0.6 → 1.0.8

package/dist/index.mjs

@@ -1,2468 +0,0 @@
-// core/state.ts
-import express from "express";
-function createState(options = {}) {
-  return {
-    options: {
-      host: options.host || "127.0.0.1",
-      port: options.port || 3e3,
-      logging: options.logging !== false,
-      staticPath: options.staticPath,
-      userAgent: options.userAgent !== false,
-      ip: options.ip !== false,
-      cors: options.cors !== false,
-      apiPrefix: options.apiPrefix,
-      logLevel: options.logLevel || "info",
-      authWhitelist: [],
-      database: {
-        path: options.database?.path || "./data/app.db"
-      }
-    },
-    express: express(),
-    schemas: {}
-  };
-}
-
-// feature/scanner/FileScanner.ts
-import { glob } from "glob";
-import path from "path";
-import fs from "fs";
-import { pathToFileURL } from "url";
-
-// utils/Dayjs.ts
-import dayjs from "dayjs";
-import "dayjs/locale/zh-cn";
-import duration from "dayjs/plugin/duration";
-import relativeTime from "dayjs/plugin/relativeTime";
-import utc from "dayjs/plugin/utc";
-dayjs.locale("zh-cn");
-dayjs.extend(utc);
-dayjs.extend(duration);
-dayjs.extend(relativeTime);
-var Dayjs_default = dayjs;
-
-// utils/Logger.ts
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  silent: 4
-};
-var currentLogLevel = "info";
-var COLORS = {
-  debug: "\x1B[36m",
-  info: "\x1B[32m",
-  warn: "\x1B[33m",
-  error: "\x1B[31m",
-  reset: "\x1B[0m"
-};
-function getVisualWidth(str) {
-  let width = 0;
-  const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-  for (const { segment } of segmenter.segment(str)) {
-    const charCode = segment.charCodeAt(0);
-    if (charCode <= 255) {
-      width += 1;
-      continue;
-    }
-    const isCJK = charCode >= 19968 && charCode <= 40959 || // CJK Unified Ideographs
-    charCode >= 12288 && charCode <= 12351 || // CJK Symbols and Punctuation
-    charCode >= 65280 && charCode <= 65519;
-    const isMultiByte = segment.length > 1;
-    if (isCJK || isMultiByte) {
-      width += 2;
-    } else {
-      width += 1;
-    }
-  }
-  return width;
-}
-function truncateToWidth(str, maxWidth) {
-  const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-  const segments = Array.from(segmenter.segment(str)).map((s) => s.segment);
-  if (getVisualWidth(str) <= maxWidth) return str;
-  let currentWidth = 3;
-  let result = "";
-  for (let i = segments.length - 1; i >= 0; i--) {
-    const segment = segments[i];
-    const segmentWidth = getVisualWidth(segment);
-    if (currentWidth + segmentWidth > maxWidth) break;
-    result = segment + result;
-    currentWidth += segmentWidth;
-  }
-  return "..." + result;
-}
-function formatMessage(level, message) {
-  const timestamp = Dayjs_default().format("YYYY-MM-DD HH:mm:ss");
-  const terminalWidth = process.stdout.columns || 80;
-  const timeStr = ` ${timestamp}`;
-  const timeWidth = getVisualWidth(timeStr);
-  const maxMessageWidth = terminalWidth - timeWidth - 2;
-  let displayMessage = message;
-  const messageWidth = getVisualWidth(displayMessage);
-  if (messageWidth > maxMessageWidth) {
-    displayMessage = truncateToWidth(displayMessage, maxMessageWidth);
-  }
-  const currentMsgWidth = getVisualWidth(displayMessage);
-  const paddingCount = Math.max(0, terminalWidth - currentMsgWidth - timeWidth);
-  const padding = " ".repeat(paddingCount);
-  return `${COLORS[level]}${displayMessage}${padding}${timeStr}${COLORS.reset}`;
-}
-var startupTime = Date.now();
-function padTag(tag, targetWidth = 8) {
-  const currentWidth = getVisualWidth(tag);
-  const padding = Math.max(0, targetWidth - currentWidth);
-  if (padding === 0) return tag;
-  const chars = [...tag];
-  const gapCount = chars.length + 1;
-  const baseSpaces = Math.floor(padding / gapCount);
-  const extraSpaces = padding % gapCount;
-  let result = "";
-  for (let i = 0; i < chars.length; i++) {
-    const spaces = baseSpaces + (i < extraSpaces ? 1 : 0);
-    result += " ".repeat(spaces) + chars[i];
-  }
-  result += " ".repeat(baseSpaces + (chars.length < extraSpaces ? 1 : 0));
-  return result;
-}
-function startupMessage(message, tag) {
-  const diff = Date.now() - startupTime;
-  const timeStr = diff.toString().padStart(6, "0");
-  const tagStr = tag ? `\u3010${padTag(tag)}\u3011` : "";
-  return `${COLORS["warn"]}[${timeStr}] ${tagStr}${message}${COLORS["reset"]}`;
-}
-function shouldLog(level) {
-  return LOG_LEVELS[level] >= LOG_LEVELS[currentLogLevel];
-}
-function formatArgs(args) {
-  return args.map((arg) => {
-    if (arg instanceof Error) {
-      return arg.message;
-    }
-    if (typeof arg === "object") {
-      return JSON.stringify(arg, null, 2);
-    }
-    return String(arg);
-  }).join(" ");
-}
-var logger = {
-  debug(...args) {
-    if (shouldLog("debug")) {
-      console.log(formatMessage("debug", formatArgs(args)));
-    }
-  },
-  info(...args) {
-    if (shouldLog("info")) {
-      console.log(formatMessage("info", formatArgs(args)));
-    }
-  },
-  warn(...args) {
-    if (shouldLog("warn")) {
-      console.warn(formatMessage("warn", formatArgs(args)));
-    }
-  },
-  error(...args) {
-    if (shouldLog("error")) {
-      console.error(formatMessage("error", formatArgs(args)));
-      const errorArg = args.find((arg) => arg instanceof Error);
-      if (errorArg) {
-        console.error(errorArg);
-      }
-    }
-  },
-  startup(tagOrMessage, ...args) {
-    if (args.length > 0) {
-      console.log(startupMessage(formatArgs(args), tagOrMessage));
-    } else {
-      console.log(startupMessage(tagOrMessage));
-    }
-  },
-  setLevel(level) {
-    currentLogLevel = level;
-  },
-  getLevel() {
-    return currentLogLevel;
-  }
-};
-var Logger_default = logger;
-
-// feature/scanner/FileScanner.ts
-var CACHE_VERSION = "2.0";
-var CACHE_DIR = path.join(process.cwd(), "node_modules/.cache/mindbase");
-var CACHE_FILE = path.join(CACHE_DIR, "startup-cache.json");
-var cacheData = null;
-var state = {
-  scanPaths: [],
-  baseDir: ""
-};
-function setBaseDir(baseDir) {
-  state.baseDir = baseDir;
-}
-function addScanPath(dirPath) {
-  if (!path.isAbsolute(dirPath)) {
-    throw new Error(`\u8DEF\u5F84\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84: ${dirPath}`);
-  }
-  if (!fs.existsSync(dirPath)) {
-    throw new Error(`\u76EE\u5F55\u4E0D\u5B58\u5728: ${dirPath}`);
-  }
-  if (!fs.statSync(dirPath).isDirectory()) {
-    throw new Error(`\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${dirPath}`);
-  }
-  if (state.scanPaths.includes(dirPath)) {
-    return;
-  }
-  if (state.baseDir && dirPath.startsWith(state.baseDir)) {
-    return;
-  }
-  for (const existingPath of state.scanPaths) {
-    if (dirPath.startsWith(existingPath)) {
-      return;
-    }
-  }
-  state.scanPaths.push(dirPath);
-}
-function isValidDirectory(dirPath) {
-  try {
-    return fs.statSync(dirPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function extractFileName(filePath) {
-  const fileName = path.basename(filePath);
-  return fileName.replace(/\.(route|middleware|schema)\.ts$/, "");
-}
-async function loadCache() {
-  try {
-    if (!fs.existsSync(CACHE_FILE)) {
-      cacheData = { version: CACHE_VERSION, entries: /* @__PURE__ */ new Map() };
-      return;
-    }
-    const json = fs.readFileSync(CACHE_FILE, "utf-8");
-    const data = JSON.parse(json);
-    if (data.version !== CACHE_VERSION) {
-      Logger_default.debug(`\u7F13\u5B58\u7248\u672C\u4E0D\u5339\u914D (${data.version} vs ${CACHE_VERSION})\uFF0C\u5C06\u91CD\u65B0\u6784\u5EFA`);
-      cacheData = { version: CACHE_VERSION, entries: /* @__PURE__ */ new Map() };
-      return;
-    }
-    cacheData = {
-      version: data.version,
-      entries: new Map(Object.entries(data.entries).map(([k, v]) => [k, v]))
-    };
-    Logger_default.debug(`\u5DF2\u52A0\u8F7D\u7F13\u5B58\uFF0C\u5305\u542B ${cacheData.entries.size} \u4E2A\u6587\u4EF6\u6761\u76EE`);
-  } catch (error) {
-    Logger_default.warn(`\u52A0\u8F7D\u7F13\u5B58\u5931\u8D25\uFF0C\u5C06\u91CD\u65B0\u6784\u5EFA: ${error}`);
-    cacheData = { version: CACHE_VERSION, entries: /* @__PURE__ */ new Map() };
-  }
-}
-async function saveCache() {
-  try {
-    if (!cacheData) return;
-    if (!fs.existsSync(CACHE_DIR)) {
-      fs.mkdirSync(CACHE_DIR, { recursive: true });
-    }
-    const data = {
-      version: cacheData.version,
-      entries: Object.fromEntries(cacheData.entries)
-    };
-    fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2), "utf-8");
-    Logger_default.debug(`\u7F13\u5B58\u5DF2\u4FDD\u5B58\uFF0C\u5305\u542B ${cacheData.entries.size} \u4E2A\u6587\u4EF6\u6761\u76EE`);
-  } catch (error) {
-    Logger_default.warn(`\u4FDD\u5B58\u7F13\u5B58\u5931\u8D25: ${error}`);
-  }
-}
-async function scan(onlyPaths = false) {
-  await loadCache();
-  const results = [];
-  const allScanPaths = [...state.scanPaths];
-  const processedFiles = /* @__PURE__ */ new Set();
-  if (state.baseDir) {
-    allScanPaths.push(state.baseDir);
-  }
-  for (const dirPath of allScanPaths) {
-    if (!isValidDirectory(dirPath)) {
-      Logger_default.warn(`\u8DF3\u8FC7\u65E0\u6548\u76EE\u5F55: ${dirPath}`);
-      continue;
-    }
-    const patterns = [
-      { type: "middleware", pattern: "**/*.middleware.ts" },
-      { type: "route", pattern: "**/*.route.ts" },
-      { type: "schema", pattern: "**/*.schema.ts" }
-    ];
-    for (const { type, pattern } of patterns) {
-      const globPattern = path.join(dirPath, pattern).replace(/\\/g, "/");
-      try {
-        const files = await glob(globPattern, { absolute: true });
-        for (const file of files) {
-          if (processedFiles.has(file)) {
-            continue;
-          }
-          processedFiles.add(file);
-          try {
-            const fileName = extractFileName(file);
-            if (onlyPaths) {
-              results.push({
-                fileName,
-                type,
-                filePath: file,
-                defaultExport: null,
-                allExports: null
-              });
-              continue;
-            }
-            const stats = await fs.promises.stat(file);
-            const mtime = stats.mtimeMs;
-            const cached = cacheData?.entries.get(file);
-            const cacheHit = cached && cached.mtime === mtime;
-            if (cacheHit) {
-              Logger_default.debug(`\u7F13\u5B58\u547D\u4E2D: ${file}`);
-            }
-            const module = await import(pathToFileURL(file).href);
-            const scanResult = {
-              fileName,
-              defaultExport: module.default,
-              allExports: module,
-              type,
-              filePath: file,
-              cacheHit
-            };
-            results.push(scanResult);
-            if (cacheData) {
-              cacheData.entries.set(file, { filePath: file, mtime });
-            }
-          } catch (error) {
-            Logger_default.warn(`\u5904\u7406\u6587\u4EF6\u5931\u8D25: ${file}`, error);
-          }
-        }
-      } catch (error) {
-        Logger_default.warn(`\u626B\u63CF\u76EE\u5F55\u5931\u8D25: ${dirPath} (Pattern: ${pattern})`, error);
-      }
-    }
-  }
-  await saveCache();
-  return results;
-}
-
-// utils/InitExpress.ts
-import express2 from "express";
-import fs2 from "fs";
-import cookieParser from "cookie-parser";
-
-// middleware/Cors.ts
-function Cors_default(req, res, next) {
-  res.header("Access-Control-Allow-Origin", "*");
-  res.header("Access-Control-Allow-Credentials", "true");
-  res.header("Access-Control-Allow-Methods", "POST,GET,OPTIONS");
-  res.header("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With");
-  if (req.method == "OPTIONS") {
-    res.sendStatus(200);
-  } else {
-    next();
-  }
-}
-
-// middleware/IpParser.ts
-import ipdb from "ipip-ipdb";
-import { join } from "path";
-var dbPath = join(process.cwd(), "ipipfree.ipdb");
-var cityInstance;
-try {
-  cityInstance = new ipdb.City(dbPath);
-} catch (error) {
-  Logger_default.error(`[IpParser] Failed to load IP database at: ${dbPath}`);
-}
-function IpParser_default(req, res, next) {
-  const ip = req.headers["real-ip"] || req.headers["x-real-ip"] || req.ip;
-  const info = {
-    address: ip,
-    location: "\u672A\u77E5",
-    country: "",
-    province: "",
-    city: "",
-    isp: "",
-    latitude: "",
-    longitude: "",
-    isLocal: false
-  };
-  const localIdentifiers = ["127.0.0.1", "::1", "::ffff:127.0.0.1", "localhost"];
-  if (localIdentifiers.includes(ip)) {
-    info.location = "\u672C\u673A";
-    info.isLocal = true;
-    res.locals.ip = info;
-    return next();
-  }
-  if (cityInstance) {
-    try {
-      const data = cityInstance.findMap(ip, "CN");
-      if (data) {
-        info.country = data.country_name || "";
-        info.province = data.region_name || "";
-        info.city = data.city_name || "";
-        info.isp = data.isp_domain || "";
-        info.latitude = data.latitude || "";
-        info.longitude = data.longitude || "";
-        const parts = [info.country, info.province, info.city].filter(Boolean);
-        info.location = parts.join(" ") || "\u672A\u77E5\u4F4D\u7F6E";
-      }
-    } catch (err) {
-    }
-  }
-  res.locals.ip = info;
-  next();
-}
-
-// middleware/UaParser.ts
-import { UAParser } from "ua-parser-js";
-function UaParser_default(req, res, next) {
-  const parser = new UAParser(req.headers["user-agent"]);
-  const result = parser.getResult();
-  const ua = {
-    ua: result.ua,
-    browser: result.browser,
-    engine: result.engine,
-    os: result.os,
-    device: result.device,
-    cpu: result.cpu,
-    isMobile: result.device.type === "mobile"
-  };
-  res.locals.UA = ua;
-  next();
-}
-
-// utils/InitExpress.ts
-function initExpress(mindBaseState) {
-  const app = mindBaseState.express;
-  const options = mindBaseState.options;
-  app.getDB = () => mindBaseState.db;
-  app.configs = mindBaseState.options;
-  app.disable("x-powered-by");
-  app.use(express2.urlencoded({ extended: false, limit: "10mb" }));
-  app.use(express2.json({ limit: "10mb" }));
-  app.use(cookieParser());
-  if (options.staticPath) {
-    if (!fs2.existsSync(options.staticPath)) {
-      fs2.mkdirSync(options.staticPath, { recursive: true });
-    }
-    app.use(express2.static(options.staticPath));
-    Logger_default.startup("\u8BBE\u7F6E", `\u9759\u6001\u76EE\u5F55: ${options.staticPath}`);
-  }
-  if (options.cors) {
-    app.use(Cors_default);
-    Logger_default.startup("\u8BBE\u7F6E", "\u8DE8\u57DF\u8BF7\u6C42\u5934");
-  }
-  if (options.ip) {
-    Logger_default.startup("\u8BBE\u7F6E", "IP\u5730\u5740\u89E3\u6790");
-    app.use(IpParser_default);
-  }
-  if (options.userAgent) {
-    Logger_default.startup("\u8BBE\u7F6E", "\u7528\u6237\u4EE3\u7406\u89E3\u6790");
-    app.use(UaParser_default);
-  }
-}
-
-// utils/InitDatabase.ts
-import path2 from "path";
-import fs3 from "fs";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-import Database from "better-sqlite3";
-function setupDatabase(state2, scannedResults) {
-  try {
-    if (!state2) {
-      throw new Error("\u5E94\u7528\u72B6\u6001\u5BF9\u8C61\u4E0D\u80FD\u4E3A\u7A7A");
-    }
-    if (!Array.isArray(scannedResults)) {
-      throw new Error("\u626B\u63CF\u7ED3\u679C\u5FC5\u987B\u662F\u4E00\u4E2A\u6570\u7EC4");
-    }
-    const schemas = {};
-    for (const item of scannedResults) {
-      if (item.type === "schema" && item.allExports) {
-        try {
-          Object.assign(schemas, item.allExports);
-        } catch (e) {
-          Logger_default.warn(`\u5904\u7406 Schema \u6587\u4EF6\u5931\u8D25: ${item.filePath}`, e);
-        }
-      }
-    }
-    state2.schemas = schemas;
-    Logger_default.startup("\u626B\u63CF", `\u63D0\u53D6\u5230 ${Object.keys(schemas).length} \u4E2A Schema \u5B9A\u4E49`);
-    return initDatabase({
-      schemas,
-      state: state2
-    });
-  } catch (error) {
-    Logger_default.error("\u6570\u636E\u5E93\u8BBE\u7F6E\u5931\u8D25\uFF1A", error);
-    throw new Error(`\u6570\u636E\u5E93\u8BBE\u7F6E\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function initDatabase(options) {
-  if (!options) {
-    throw new Error("\u521D\u59CB\u5316\u9009\u9879\u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  try {
-    const currentDir = process.cwd();
-    const dbPath2 = options.dbPath || options.state?.options?.database?.path || "./data/app.db";
-    const absoluteDbPath = path2.resolve(currentDir, dbPath2);
-    const dbDir = path2.dirname(absoluteDbPath);
-    Logger_default.startup("\u6570\u636E\u5E93", `\u521D\u59CB\u5316\uFF1A\u8DEF\u5F84=${absoluteDbPath}`);
-    try {
-      if (!fs3.existsSync(dbDir)) {
-        Logger_default.startup("\u6570\u636E\u5E93", `\u521B\u5EFA\u76EE\u5F55\uFF1A${dbDir}`);
-        fs3.mkdirSync(dbDir, { recursive: true });
-      }
-    } catch (e) {
-      throw new Error(`\u521B\u5EFA\u6570\u636E\u5E93\u76EE\u5F55\u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}`);
-    }
-    let sqlite;
-    try {
-      sqlite = new Database(absoluteDbPath);
-    } catch (e) {
-      throw new Error(`\u8FDE\u63A5\u6570\u636E\u5E93\u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}`);
-    }
-    try {
-      sqlite.pragma("journal_mode = WAL");
-      sqlite.pragma("synchronous = NORMAL");
-      sqlite.pragma("cache_size = -1048576");
-      sqlite.pragma("temp_store = MEMORY");
-      sqlite.pragma("page_size = 4096");
-      sqlite.pragma("wal_autocheckpoint = 10000");
-      sqlite.pragma("busy_timeout = 5000");
-    } catch (e) {
-      Logger_default.warn("\u8BBE\u7F6E SQLite \u6027\u80FD\u53C2\u6570\u5931\u8D25\uFF1A", e);
-    }
-    let db;
-    try {
-      db = drizzle(sqlite, { schema: options.schemas || {} });
-    } catch (e) {
-      try {
-        sqlite.close();
-      } catch (closeError) {
-        Logger_default.warn("\u5173\u95ED\u6570\u636E\u5E93\u8FDE\u63A5\u5931\u8D25\uFF1A", closeError);
-      }
-      throw new Error(`\u521D\u59CB\u5316 Drizzle ORM \u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}`);
-    }
-    if (options.state) {
-      options.state.db = db;
-    }
-    return db;
-  } catch (error) {
-    Logger_default.error("\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25\uFF1A", error);
-    throw new Error(`\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-// utils/MiddlewareRegistry.ts
-async function registerMiddleware(app, config2) {
-  const { fileName = "anonymous", defaultExport: handler } = config2;
-  try {
-    app.use(handler);
-    Logger_default.startup("\u4E2D\u95F4\u4EF6", `\u6CE8\u518C: ${fileName}`);
-  } catch (error) {
-    Logger_default.error(`\u6CE8\u518C\u4E2D\u95F4\u4EF6\u5931\u8D25 ${fileName}:`, error);
-  }
-}
-
-// utils/RouteParser.ts
-import {
-  Project,
-  SyntaxKind as SyntaxKind3,
-  ModuleKind,
-  ScriptTarget
-} from "ts-morph";
-import * as path3 from "path";
-
-// utils/ZodSchemaParser.ts
-import {
-  Node
-} from "ts-morph";
-var ZodSchemaParser = class {
-  /**
-   * 解析 schema 变量，返回字段结构
-   */
-  parseSchemaVariable(sourceFile, schemaName) {
-    try {
-      const variableDecl = this.findVariableDeclaration(sourceFile, schemaName);
-      if (!variableDecl) {
-        Logger_default.warn(`\u672A\u627E\u5230 schema \u53D8\u91CF: ${schemaName}`);
-        return null;
-      }
-      const initializer = variableDecl.getInitializer();
-      if (!initializer) {
-        Logger_default.warn(`schema \u53D8\u91CF ${schemaName} \u6CA1\u6709\u521D\u59CB\u5316\u8868\u8FBE\u5F0F`);
-        return null;
-      }
-      return this.parseZodObject(initializer);
-    } catch (error) {
-      Logger_default.error(`\u89E3\u6790 schema \u53D8\u91CF\u5931\u8D25: ${schemaName}`, error);
-      return null;
-    }
-  }
-  /**
-   * 查找变量声明
-   */
-  findVariableDeclaration(sourceFile, name) {
-    for (const decl of sourceFile.getVariableDeclarations()) {
-      if (decl.getName() === name) {
-        return decl;
-      }
-    }
-    return null;
-  }
-  /**
-   * 解析 z.object({...}) 调用
-   */
-  parseZodObject(node) {
-    let targetNode = node;
-    if (Node.isAsExpression(node)) {
-      targetNode = node.getExpression();
-    }
-    if (Node.isCallExpression(targetNode)) {
-      const expr = targetNode.getExpression();
-      if (Node.isPropertyAccessExpression(expr)) {
-        const propText = expr.getText();
-        if (propText === "z.object") {
-          const args = targetNode.getArguments();
-          if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-            return this.parseObjectLiteral(args[0]);
-          }
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * 解析对象字面量中的字段定义
-   */
-  parseObjectLiteral(objLit) {
-    const fields = {};
-    for (const prop of objLit.getProperties()) {
-      if (Node.isPropertyAssignment(prop)) {
-        const fieldName = prop.getName();
-        const initializer = prop.getInitializer();
-        if (initializer) {
-          fields[fieldName] = this.parseZodField(initializer);
-        }
-      }
-    }
-    return fields;
-  }
-  /**
-   * 解析单个 Zod 字段定义
-   */
-  parseZodField(node) {
-    const field = {
-      type: "any",
-      required: true
-    };
-    let targetNode = node;
-    if (Node.isAsExpression(node)) {
-      targetNode = node.getExpression();
-    }
-    const callChain = this.collectCallChain(targetNode);
-    for (const call of callChain) {
-      this.applyZodMethod(field, call);
-    }
-    return field;
-  }
-  /**
-   * 收集方法调用链
-   * 例如: z.string().min(1).optional() -> [{method: "z.string", args: []}, {method: "min", args: [...]}, {method: "optional", args: []}]
-   */
-  collectCallChain(node) {
-    const chain = [];
-    let current = node;
-    while (current && Node.isCallExpression(current)) {
-      const expr = current.getExpression();
-      const args = current.getArguments();
-      if (Node.isPropertyAccessExpression(expr)) {
-        const methodName = expr.getName();
-        chain.unshift({ method: methodName, args: [...args] });
-        current = expr.getExpression();
-      } else if (Node.isIdentifier(expr)) {
-        chain.unshift({ method: expr.getText(), args: [] });
-        break;
-      } else if (Node.isPropertyAccessExpression(expr)) {
-        chain.unshift({
-          method: expr.getName(),
-          args: []
-        });
-        current = expr.getExpression();
-      } else {
-        break;
-      }
-    }
-    return chain;
-  }
-  /**
-   * 应用 Zod 方法到字段定义
-   */
-  applyZodMethod(field, call) {
-    const { method, args } = call;
-    switch (method) {
-      // 类型定义
-      case "z.string":
-      case "string":
-        field.type = "string";
-        break;
-      case "z.number":
-      case "number":
-        field.type = "number";
-        break;
-      case "z.boolean":
-      case "boolean":
-        field.type = "boolean";
-        break;
-      case "z.array":
-      case "array":
-        field.type = "array";
-        if (args.length > 0) {
-          field.items = this.parseZodField(args[0]);
-        }
-        break;
-      case "z.object":
-      case "object":
-        field.type = "object";
-        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-          field.properties = this.parseObjectLiteral(args[0]);
-        }
-        break;
-      case "z.date":
-      case "date":
-        field.type = "date";
-        break;
-      case "z.any":
-      case "any":
-        field.type = "any";
-        break;
-      case "z.unknown":
-      case "unknown":
-        field.type = "any";
-        break;
-      case "z.undefined":
-      case "undefined":
-        field.required = false;
-        field.optional = true;
-        break;
-      case "z.null":
-      case "null":
-        field.nullable = true;
-        break;
-      case "z.void":
-      case "void":
-        field.type = "any";
-        break;
-      case "z.nativeEnum":
-      case "nativeEnum":
-      case "z.enum":
-      case "enum":
-        field.type = "string";
-        break;
-      case "coerce":
-        break;
-      // 可选性
-      case "optional":
-        field.required = false;
-        field.optional = true;
-        break;
-      case "nullable":
-        field.nullable = true;
-        break;
-      case "nullish":
-        field.required = false;
-        field.optional = true;
-        field.nullable = true;
-        break;
-      // 默认值
-      case "default":
-        if (args.length > 0) {
-          field.defaultValue = this.parseArgumentValue(args[0]);
-          field.required = false;
-        }
-        break;
-      // 约束 - 通用
-      case "min":
-        if (args.length > 0) {
-          const minVal = this.parseArgumentValue(args[0]);
-          field.constraints = field.constraints || {};
-          if (field.type === "string") {
-            field.constraints.minLength = minVal;
-          } else if (field.type === "number") {
-            field.constraints.min = minVal;
-          }
-          if (args.length > 1) {
-            const msg = this.parseArgumentValue(args[1]);
-            if (typeof msg === "string") {
-              field.constraints.custom = field.constraints.custom || [];
-              field.constraints.custom.push(msg);
-            }
-          }
-        }
-        break;
-      case "max":
-        if (args.length > 0) {
-          const maxVal = this.parseArgumentValue(args[0]);
-          field.constraints = field.constraints || {};
-          if (field.type === "string") {
-            field.constraints.maxLength = maxVal;
-          } else if (field.type === "number") {
-            field.constraints.max = maxVal;
-          }
-        }
-        break;
-      case "length":
-        if (args.length > 0) {
-          const lenVal = this.parseArgumentValue(args[0]);
-          field.constraints = field.constraints || {};
-          field.constraints.minLength = lenVal;
-          field.constraints.maxLength = lenVal;
-        }
-        break;
-      // 约束 - 字符串
-      case "email":
-        field.constraints = field.constraints || {};
-        field.constraints.email = true;
-        break;
-      case "url":
-        field.constraints = field.constraints || {};
-        field.constraints.url = true;
-        break;
-      case "uuid":
-        field.constraints = field.constraints || {};
-        field.constraints.uuid = true;
-        break;
-      case "regex":
-      case "pattern":
-        if (args.length > 0) {
-          field.constraints = field.constraints || {};
-          field.constraints.pattern = args[0].getText();
-        }
-        break;
-      case "startsWith":
-      case "endsWith":
-      case "includes":
-      case "trim":
-      case "toLowerCase":
-      case "toUpperCase":
-        break;
-      // 约束 - 数字
-      case "int":
-        field.constraints = field.constraints || {};
-        field.constraints.int = true;
-        break;
-      case "positive":
-        field.constraints = field.constraints || {};
-        field.constraints.positive = true;
-        break;
-      case "nonnegative":
-        field.constraints = field.constraints || {};
-        field.constraints.nonnegative = true;
-        break;
-      case "negative":
-        field.constraints = field.constraints || {};
-        field.constraints.max = -1;
-        break;
-      case "nonpositive":
-        field.constraints = field.constraints || {};
-        field.constraints.max = 0;
-        break;
-      case "finite":
-      case "safe":
-        break;
-      // 约束 - 数组
-      case "nonempty":
-        field.constraints = field.constraints || {};
-        field.constraints.minLength = 1;
-        break;
-      // 其他方法
-      case "refine":
-      case "superRefine":
-      case "transform":
-      case "pipe":
-      case " preprocess":
-      case "omit":
-      case "pick":
-      case "partial":
-      case "required":
-      case "strict":
-      case "passthrough":
-      case "extend":
-      case "merge":
-      case "keyof":
-        break;
-    }
-  }
-  /**
-   * 解析参数值
-   */
-  parseArgumentValue(node) {
-    if (Node.isStringLiteral(node)) {
-      return node.getLiteralValue();
-    } else if (Node.isNumericLiteral(node)) {
-      return node.getLiteralValue();
-    } else if (Node.isTrueLiteral(node)) {
-      return true;
-    } else if (Node.isFalseLiteral(node)) {
-      return false;
-    } else if (Node.isIdentifier(node)) {
-      return node.getText();
-    } else if (Node.isObjectLiteralExpression(node)) {
-      return node.getText();
-    } else if (Node.isArrayLiteralExpression(node)) {
-      return node.getText();
-    }
-    return node.getText();
-  }
-};
-var zodSchemaParser = new ZodSchemaParser();
-
-// utils/TSTypeParser.ts
-import {
-  Node as Node2,
-  SyntaxKind as SyntaxKind2
-} from "ts-morph";
-var TSTypeParser = class {
-  /**
-   * 解析类型引用字符串
-   * 例如: "ApiResponse<User[]>" -> { typeName: "ApiResponse", typeArgs: ["User[]"] }
-   */
-  parseTypeRef(typeString) {
-    typeString = typeString.trim();
-    const genericMatch = typeString.match(/^(\w+)<(.+)>$/);
-    if (genericMatch) {
-      const typeName = genericMatch[1];
-      const argsStr = genericMatch[2];
-      const typeArgs = argsStr.split(",").map((s) => s.trim());
-      return { typeName, typeArgs };
-    }
-    if (/^\w+$/.test(typeString)) {
-      return { typeName: typeString, typeArgs: [] };
-    }
-    const arrayMatch = typeString.match(/^(\w+)\[\]$/);
-    if (arrayMatch) {
-      return { typeName: "Array", typeArgs: [arrayMatch[1]] };
-    }
-    return null;
-  }
-  /**
-   * 解析响应类型
-   * @param sourceFile 源文件
-   * @param typeString 类型字符串如 "ApiResponse<User[]>"
-   * @param imports 导入映射 (类型名 -> 文件路径)
-   */
-  parseResponseType(sourceFile, typeString, imports) {
-    const typeRef = this.parseTypeRef(typeString);
-    if (!typeRef) {
-      Logger_default.debug(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B\u5F15\u7528: ${typeString}`);
-      return null;
-    }
-    if (typeRef.typeName === "ApiResponse") {
-      return this.parseApiResponse(sourceFile, typeRef.typeArgs, imports);
-    }
-    const typeDecl = this.findTypeDeclaration(sourceFile, typeRef.typeName, imports);
-    if (!typeDecl) {
-      Logger_default.debug(`\u672A\u627E\u5230\u7C7B\u578B\u5B9A\u4E49: ${typeRef.typeName}`);
-      return null;
-    }
-    const fields = this.extractFieldsFromType(typeDecl, typeRef.typeArgs, imports);
-    return { fields };
-  }
-  /**
-   * 解析 ApiResponse<T> 类型
-   * ApiResponse 是标准的 API 响应包装器，包含 code, data, msg 字段
-   */
-  parseApiResponse(sourceFile, typeArgs, imports) {
-    const fields = {
-      code: { type: "number", required: true },
-      msg: { type: "string", required: true }
-    };
-    if (typeArgs.length > 0) {
-      const dataType = typeArgs[0];
-      const dataField = this.parseDataType(sourceFile, dataType, imports);
-      fields.data = dataField;
-    } else {
-      fields.data = { type: "any", required: true };
-    }
-    return { fields };
-  }
-  /**
-   * 解析 data 字段的类型
-   */
-  parseDataType(sourceFile, typeString, imports) {
-    if (typeString === "string") {
-      return { type: "string", required: true };
-    } else if (typeString === "number") {
-      return { type: "number", required: true };
-    } else if (typeString === "boolean") {
-      return { type: "boolean", required: true };
-    } else if (typeString === "any") {
-      return { type: "any", required: true };
-    }
-    const arrayMatch = typeString.match(/^(\w+)\[\]$/);
-    if (arrayMatch) {
-      const elementType = arrayMatch[1];
-      const elementField = this.parseDataType(sourceFile, elementType, imports);
-      return {
-        type: "array",
-        required: true,
-        items: elementField
-      };
-    }
-    const typeDecl = this.findTypeDeclaration(sourceFile, typeString, imports);
-    if (typeDecl) {
-      const fields = this.extractFieldsFromType(typeDecl, [], imports);
-      return {
-        type: "object",
-        required: true,
-        properties: fields
-      };
-    }
-    return { type: "any", required: true };
-  }
-  /**
-   * 查找类型声明
-   */
-  findTypeDeclaration(sourceFile, typeName, imports) {
-    const interfaceDecl = sourceFile.getInterface(typeName);
-    if (interfaceDecl) return interfaceDecl;
-    const typeAlias = sourceFile.getTypeAlias(typeName);
-    if (typeAlias) return typeAlias;
-    const importPath = imports.get(typeName);
-    if (importPath) {
-      try {
-        const importedFile = sourceFile.getProject().addSourceFileAtPath(importPath);
-        const importedInterface = importedFile.getInterface(typeName);
-        if (importedInterface) return importedInterface;
-        const importedTypeAlias = importedFile.getTypeAlias(typeName);
-        if (importedTypeAlias) return importedTypeAlias;
-      } catch (error) {
-        Logger_default.warn(`\u65E0\u6CD5\u52A0\u8F7D\u5BFC\u5165\u6587\u4EF6: ${importPath}`);
-      }
-    }
-    return null;
-  }
-  /**
-   * 从类型声明中提取字段
-   */
-  extractFieldsFromType(typeDecl, typeArgs, imports) {
-    const fields = {};
-    let typeNode;
-    if (Node2.isInterfaceDeclaration(typeDecl)) {
-      for (const prop of typeDecl.getProperties()) {
-        const fieldName = prop.getName();
-        const fieldType = prop.getType();
-        fields[fieldName] = this.parsePropertyType(prop, typeArgs, imports);
-      }
-      return fields;
-    } else if (Node2.isTypeAliasDeclaration(typeDecl)) {
-      typeNode = typeDecl.getTypeNode();
-    }
-    if (!typeNode) return fields;
-    if (typeNode.getKind() === SyntaxKind2.TypeReference) {
-      return this.extractFieldsFromTypeReference(typeNode, typeArgs, imports);
-    } else if (typeNode.getKind() === SyntaxKind2.IntersectionType) {
-      for (const child of typeNode.getTypeNodes()) {
-        const childFields = this.extractFieldsFromTypeNode(child, typeArgs, imports);
-        Object.assign(fields, childFields);
-      }
-    } else if (typeNode.getKind() === SyntaxKind2.UnionType) {
-      const firstType = typeNode.getTypeNodes()[0];
-      if (firstType) {
-        return this.extractFieldsFromTypeNode(firstType, typeArgs, imports);
-      }
-    } else {
-      return this.extractFieldsFromTypeNode(typeNode, typeArgs, imports);
-    }
-    return fields;
-  }
-  /**
-   * 从类型节点提取字段
-   */
-  extractFieldsFromTypeNode(typeNode, typeArgs, imports) {
-    const fields = {};
-    if (typeNode.getKind() === SyntaxKind2.TypeReference) {
-      return this.extractFieldsFromTypeReference(typeNode, typeArgs, imports);
-    } else if (typeNode.getKind() === SyntaxKind2.IntersectionType) {
-      for (const child of typeNode.getTypeNodes()) {
-        const childFields = this.extractFieldsFromTypeNode(child, typeArgs, imports);
-        Object.assign(fields, childFields);
-      }
-    }
-    return fields;
-  }
-  /**
-   * 从类型引用提取字段
-   */
-  extractFieldsFromTypeReference(typeRefNode, typeArgs, imports) {
-    const fields = {};
-    const typeName = typeRefNode.getTypeName().getText();
-    if (typeName === "Array" || typeName === "ReadonlyArray") {
-      const typeArgsNodes = typeRefNode.getTypeArguments();
-      if (typeArgsNodes.length > 0) {
-        const elementType = typeArgsNodes[0];
-        fields["[]"] = {
-          type: "array",
-          required: true,
-          items: this.parseTypeNodeToFieldValidation(elementType, typeArgs, imports)
-        };
-      }
-      return fields;
-    }
-    if (typeName === "Promise") {
-      const typeArgsNodes = typeRefNode.getTypeArguments();
-      if (typeArgsNodes.length > 0) {
-        return this.extractFieldsFromTypeNode(typeArgsNodes[0], typeArgs, imports);
-      }
-    }
-    if (typeArgs.includes(typeName) && typeArgs.length > 0) {
-      const actualType = typeArgs[0];
-    }
-    const sourceFile = typeRefNode.getSourceFile();
-    const typeDecl = this.findTypeDeclarationInFile(sourceFile, typeName);
-    if (typeDecl) {
-      return this.extractFieldsFromType(typeDecl, typeArgs, imports);
-    }
-    return fields;
-  }
-  /**
-   * 在文件中查找类型声明
-   */
-  findTypeDeclarationInFile(sourceFile, typeName) {
-    const interfaceDecl = sourceFile.getInterface(typeName);
-    if (interfaceDecl) return interfaceDecl;
-    const typeAlias = sourceFile.getTypeAlias(typeName);
-    if (typeAlias) return typeAlias;
-    return null;
-  }
-  /**
-   * 解析属性类型
-   */
-  parsePropertyType(prop, typeArgs, imports) {
-    const type = prop.getType();
-    const isOptional = prop.hasQuestionToken();
-    const typeText = type.getText();
-    if (type.isString()) {
-      return { type: "string", required: !isOptional };
-    } else if (type.isNumber()) {
-      return { type: "number", required: !isOptional };
-    } else if (type.isBoolean()) {
-      return { type: "boolean", required: !isOptional };
-    } else if (type.isArray()) {
-      const elementType = type.getArrayElementType();
-      let items;
-      if (elementType) {
-        items = {
-          type: this.mapTypeToString(elementType),
-          required: !elementType.isUndefined() && !elementType.isNull()
-        };
-      }
-      return { type: "array", required: !isOptional, items };
-    } else if (type.isObject()) {
-      const properties = type.getProperties();
-      if (properties.length > 0) {
-        const props = {};
-        for (const prop2 of properties) {
-          const propName = prop2.getName();
-          const propType = prop2.getTypeAtLocation(prop2.getValueDeclaration() || prop2.getDeclarations()[0]);
-          props[propName] = {
-            type: this.mapTypeToString(propType),
-            required: !prop2.isOptional()
-          };
-        }
-        return { type: "object", required: !isOptional, properties: props };
-      }
-      return { type: "object", required: !isOptional };
-    } else if (type.isNull()) {
-      return { type: "any", required: false, nullable: true };
-    } else if (type.isUndefined()) {
-      return { type: "any", required: false, optional: true };
-    } else if (type.isAny()) {
-      return { type: "any", required: !isOptional };
-    }
-    return { type: "any", required: !isOptional };
-  }
-  /**
-   * 将类型映射为字符串
-   */
-  mapTypeToString(type) {
-    if (type.isString()) return "string";
-    if (type.isNumber()) return "number";
-    if (type.isBoolean()) return "boolean";
-    if (type.isArray()) return "array";
-    if (type.isObject()) return "object";
-    if (type.isDate()) return "date";
-    return "any";
-  }
-  /**
-   * 从类型节点创建 FieldValidation
-   */
-  parseTypeNodeToFieldValidation(typeNode, typeArgs, imports) {
-    if (Node2.isStringKeyword(typeNode)) {
-      return { type: "string", required: true };
-    } else if (Node2.isNumberKeyword(typeNode)) {
-      return { type: "number", required: true };
-    } else if (Node2.isBooleanKeyword(typeNode)) {
-      return { type: "boolean", required: true };
-    } else if (Node2.isArrayTypeNode(typeNode)) {
-      const elementType = typeNode.getElementTypeNode();
-      return {
-        type: "array",
-        required: true,
-        items: this.parseTypeNodeToFieldValidation(elementType, typeArgs, imports)
-      };
-    } else if (typeNode.getKind() === SyntaxKind2.TypeReference) {
-      const refNode = typeNode;
-      const typeName = refNode.getTypeName().getText();
-      const sourceFile = refNode.getSourceFile();
-      const typeDecl = this.findTypeDeclarationInFile(sourceFile, typeName);
-      if (typeDecl) {
-        const fields = this.extractFieldsFromType(typeDecl, typeArgs, imports);
-        return { type: "object", required: true, properties: fields };
-      }
-      return { type: "any", required: true };
-    }
-    return { type: "any", required: true };
-  }
-};
-var tsTypeParser = new TSTypeParser();
-
-// utils/RouteParser.ts
-var RouteParser = class {
-  project;
-  schemaParser;
-  tsTypeParser;
-  constructor() {
-    this.project = new Project({
-      compilerOptions: {
-        module: ModuleKind.CommonJS,
-        target: ScriptTarget.ES2018,
-        allowJs: true
-      }
-    });
-    this.schemaParser = new ZodSchemaParser();
-    this.tsTypeParser = new TSTypeParser();
-  }
-  /**
-   * 解析单个路由文件
-   * @param filePath 路由文件路径
-   * @returns 路由信息数组
-   */
-  parseRouteFile(filePath) {
-    try {
-      const sourceFile = this.project.addSourceFileAtPath(filePath);
-      const routes = [];
-      const schemaFiles = this.getImportedSchemaFiles(sourceFile, filePath);
-      const typeImports = this.getTypeImports(sourceFile, filePath);
-      sourceFile.forEachDescendant((node) => {
-        const callExpr = node;
-        if (callExpr.isKind && callExpr.isKind(SyntaxKind3.CallExpression) && callExpr.getExpression && callExpr.getExpression().isKind(SyntaxKind3.PropertyAccessExpression)) {
-          const propAccess = callExpr.getExpression();
-          const object = propAccess.getExpression && propAccess.getExpression().getText();
-          const method = propAccess.getName && propAccess.getName();
-          if (object === "router" && ["get", "post", "put", "delete", "patch"].includes(method)) {
-            const args = callExpr.getArguments && callExpr.getArguments();
-            if (args && args.length > 0) {
-              const pathArg = args[0];
-              if (pathArg.isKind && pathArg.isKind(SyntaxKind3.StringLiteral)) {
-                const routePath = pathArg.getText && pathArg.getText().replace(/['"]/g, "");
-                const jsDoc = callExpr.getPreviousSiblingIfKind && callExpr.getPreviousSiblingIfKind(SyntaxKind3.JSDocComment);
-                let summary = "";
-                let description = "";
-                let requestSchema;
-                let responseSchema;
-                if (jsDoc) {
-                  const commentText = jsDoc.getCommentText && jsDoc.getCommentText();
-                  if (commentText) {
-                    const lines = commentText.split("\n").map((line) => line.trim());
-                    summary = lines[0] || "";
-                    description = lines.slice(1).join("\n").trim() || summary;
-                  }
-                  try {
-                    const fullCommentText = jsDoc.getFullText?.() || commentText || "";
-                    const apiDocTags = this.parseApiDocTags(fullCommentText);
-                    if (apiDocTags.params.length > 0) {
-                      requestSchema = this.buildRequestSchemaFromTags(apiDocTags.params);
-                    }
-                    if (apiDocTags.success.length > 0) {
-                      responseSchema = this.buildResponseSchemaFromTags(apiDocTags.success);
-                    }
-                  } catch (error) {
-                    Logger_default.warn(`\u89E3\u6790 apidoc \u6CE8\u91CA\u5931\u8D25: ${filePath}:${routePath}`, error);
-                  }
-                  if (!responseSchema) {
-                    responseSchema = this.extractResponseSchema(jsDoc, sourceFile, typeImports);
-                  }
-                }
-                const middlewares = [];
-                for (let i = 1; i < args.length - 1; i++) {
-                  const arg = args[i];
-                  if (arg.isKind(SyntaxKind3.CallExpression)) {
-                    const mwCallExpr = arg;
-                    const expr = mwCallExpr.getExpression();
-                    if (expr.isKind(SyntaxKind3.Identifier)) {
-                      middlewares.push(expr.getText());
-                    } else if (expr.isKind(SyntaxKind3.PropertyAccessExpression)) {
-                      middlewares.push(expr.getText());
-                    }
-                  }
-                }
-                if (!requestSchema) {
-                  requestSchema = this.extractRequestSchema(args, schemaFiles);
-                }
-                const routeInfo = {
-                  module: path3.basename(path3.dirname(filePath)).toLowerCase(),
-                  method: method.toUpperCase(),
-                  path: routePath,
-                  fullPath: "",
-                  // 完整路径会在注册时填充
-                  summary,
-                  description,
-                  requestSchema,
-                  responseSchema,
-                  middlewares,
-                  filePath
-                };
-                routes.push(routeInfo);
-              }
-            }
-          }
-        }
-      });
-      return routes;
-    } catch (error) {
-      Logger_default.error(`\u89E3\u6790\u8DEF\u7531\u6587\u4EF6\u5931\u8D25: ${filePath}`, error);
-      return [];
-    }
-  }
-  /**
-   * 获取导入的 schema 文件映射
-   * @returns Map<变量名, 文件绝对路径>
-   */
-  getImportedSchemaFiles(sourceFile, currentFilePath) {
-    const schemaFiles = /* @__PURE__ */ new Map();
-    for (const importDecl of sourceFile.getImportDeclarations()) {
-      const source = importDecl.getModuleSpecifierValue();
-      if (source.includes(".schema") || source.includes("/zod/") || source.includes("\\zod\\")) {
-        const absolutePath = this.resolveImportPath(
-          currentFilePath,
-          source
-        );
-        if (absolutePath) {
-          for (const specifier of importDecl.getNamedImports()) {
-            Logger_default.debug(`\u53D1\u73B0 schema \u5BFC\u5165: ${specifier.getName()} -> ${absolutePath}`);
-            schemaFiles.set(specifier.getName(), absolutePath);
-          }
-        } else {
-          Logger_default.debug(`\u65E0\u6CD5\u89E3\u6790 schema \u5BFC\u5165\u8DEF\u5F84: ${source}`);
-        }
-      }
-    }
-    return schemaFiles;
-  }
-  /**
-   * 获取所有类型导入映射（用于响应类型解析）
-   * @returns Map<类型名, 文件绝对路径>
-   */
-  getTypeImports(sourceFile, currentFilePath) {
-    const typeImports = /* @__PURE__ */ new Map();
-    for (const importDecl of sourceFile.getImportDeclarations()) {
-      const source = importDecl.getModuleSpecifierValue();
-      const absolutePath = this.resolveImportPath(currentFilePath, source);
-      if (absolutePath) {
-        for (const specifier of importDecl.getNamedImports()) {
-          typeImports.set(specifier.getName(), absolutePath);
-        }
-      }
-    }
-    return typeImports;
-  }
-  /**
-   * 从 JSDoc 中提取响应 Schema
-   */
-  extractResponseSchema(jsDoc, sourceFile, typeImports) {
-    const tags = jsDoc.getTags();
-    for (const tag of tags) {
-      const tagName = tag.getTagName();
-      if (tagName === "returns" || tagName === "return") {
-        const tagText = tag.getText?.() || "";
-        Logger_default.debug(`@returns \u6807\u7B7E\u6587\u672C: ${tagText}`);
-        const typeMatch = tagText.match(/@\s*returns?\s*\{([^}]+)\}/i);
-        if (typeMatch) {
-          const typeString = typeMatch[1].trim();
-          Logger_default.debug(`\u4ECE\u6807\u7B7E\u6587\u672C\u63D0\u53D6\u7C7B\u578B: ${typeString}`);
-          const responseSchema = this.tsTypeParser.parseResponseType(
-            sourceFile,
-            typeString,
-            typeImports
-          );
-          if (responseSchema) {
-            return responseSchema;
-          }
-        }
-        const comment = tag.getCommentText?.();
-        if (comment) {
-          const commentMatch = comment.match(/^\{([^}]+)\}/);
-          if (commentMatch) {
-            const typeString = commentMatch[1].trim();
-            Logger_default.debug(`\u4ECE\u6CE8\u91CA\u63D0\u53D6\u7C7B\u578B: ${typeString}`);
-            const responseSchema = this.tsTypeParser.parseResponseType(
-              sourceFile,
-              typeString,
-              typeImports
-            );
-            if (responseSchema) {
-              return responseSchema;
-            }
-          }
-        }
-        const typeExpression = tag.getTypeExpression?.();
-        if (typeExpression) {
-          const typeNode = typeExpression.getType?.();
-          if (typeNode) {
-            const typeString = typeNode.getText();
-            Logger_default.debug(`\u4ECE\u7C7B\u578B\u8868\u8FBE\u5F0F\u63D0\u53D6\u7C7B\u578B: ${typeString}`);
-            if (typeString && typeString !== "any") {
-              const responseSchema = this.tsTypeParser.parseResponseType(
-                sourceFile,
-                typeString,
-                typeImports
-              );
-              if (responseSchema) {
-                return responseSchema;
-              }
-            }
-          }
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * 解析导入路径为绝对路径
-   */
-  resolveImportPath(currentFilePath, importPath) {
-    try {
-      if (importPath.startsWith(".")) {
-        const currentDir = path3.dirname(currentFilePath);
-        const absolutePath = path3.resolve(currentDir, importPath);
-        const tsPath = absolutePath.endsWith(".ts") ? absolutePath : `${absolutePath}.ts`;
-        return tsPath;
-      }
-      return null;
-    } catch (error) {
-      Logger_default.warn(`\u89E3\u6790\u5BFC\u5165\u8DEF\u5F84\u5931\u8D25: ${importPath}`);
-      return null;
-    }
-  }
-  /**
-   * 提取请求 Schema
-   */
-  extractRequestSchema(args, schemaFiles) {
-    for (const arg of args) {
-      let targetArg = arg;
-      if (arg.isKind && arg.isKind(SyntaxKind3.AsExpression)) {
-        targetArg = arg.getExpression();
-      }
-      if (targetArg.isKind && targetArg.isKind(SyntaxKind3.CallExpression) && targetArg.getExpression && targetArg.getExpression().isKind && targetArg.getExpression().isKind(SyntaxKind3.Identifier) && targetArg.getExpression().getText() === "validate") {
-        const validateArgs = targetArg.getArguments();
-        if (validateArgs.length === 0) continue;
-        const schemaArg = validateArgs[0];
-        let schemaName;
-        if (schemaArg.isKind && schemaArg.isKind(SyntaxKind3.AsExpression)) {
-          schemaName = schemaArg.getExpression().getText();
-        } else {
-          schemaName = schemaArg.getText();
-        }
-        let target = "body";
-        if (validateArgs.length > 1) {
-          const targetArgParam = validateArgs[1];
-          if (targetArgParam.isKind && targetArgParam.isKind(SyntaxKind3.StringLiteral)) {
-            target = targetArgParam.getLiteralValue();
-          }
-        }
-        const schemaFilePath = schemaFiles.get(schemaName);
-        if (schemaFilePath) {
-          try {
-            const schemaSourceFile = this.project.addSourceFileAtPath(schemaFilePath);
-            const fields = this.schemaParser.parseSchemaVariable(
-              schemaSourceFile,
-              schemaName
-            );
-            if (fields) {
-              return { target, fields };
-            }
-          } catch (error) {
-            Logger_default.warn(`\u89E3\u6790 schema \u6587\u4EF6\u5931\u8D25: ${schemaFilePath}`, error);
-          }
-        } else {
-          Logger_default.debug(`\u672A\u627E\u5230 schema \u6587\u4EF6\u6620\u5C04: ${schemaName}`);
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * 解析多个路由文件
-   * @param filePaths 路由文件路径数组
-   * @returns 路由信息数组
-   */
-  parseRouteFiles(filePaths) {
-    const allRoutes = [];
-    for (const filePath of filePaths) {
-      const routes = this.parseRouteFile(filePath);
-      allRoutes.push(...routes);
-    }
-    return allRoutes;
-  }
-  /**
-   * 解析 apidoc 格式的注释标签
-   * @param commentText JSDoc 注释文本
-   * @returns 解析出的标签信息
-   */
-  parseApiDocTags(commentText) {
-    const tags = { params: [], success: [] };
-    const paramRegex = /@apiParam\s+\{([^}]+)\}\s*(?:\[([^\]]+)\]|(\S+))\s*(.*)/g;
-    let match;
-    while ((match = paramRegex.exec(commentText)) !== null) {
-      const [, typeStr, optionalName, requiredName, description] = match;
-      const name = optionalName || requiredName;
-      const required = !optionalName;
-      const typeInfo = this.parseParamType(typeStr);
-      tags.params.push({
-        name,
-        type: typeInfo.type,
-        description: description.trim(),
-        required,
-        enumValues: typeInfo.enumValues
-      });
-    }
-    const successRegex = /@apiSuccess\s+\{([^}]+)\}\s+([^\s]+)\s*(.*)/g;
-    while ((match = successRegex.exec(commentText)) !== null) {
-      const [, typeStr, fieldPath, description] = match;
-      const parts = fieldPath.split(".");
-      const name = parts[parts.length - 1];
-      const parent = parts.length > 1 ? parts.slice(0, -1).join(".") : void 0;
-      const typeInfo = this.parseParamType(typeStr);
-      tags.success.push({
-        name,
-        type: typeInfo.type,
-        description: description.trim(),
-        parent
-      });
-    }
-    return tags;
-  }
-  /**
-   * 解析 apidoc 类型字符串
-   * @param typeStr 类型字符串，如 "string", "string=", "number[]", {string="a","b"}
-   * @returns 解析后的类型信息
-   */
-  parseParamType(typeStr) {
-    typeStr = typeStr.trim();
-    const enumMatch = typeStr.match(/^(\w+)=(.+)$/);
-    if (enumMatch) {
-      const baseType = enumMatch[1];
-      const enumValues = enumMatch[2].split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
-      return {
-        type: this.mapTypeName(baseType),
-        enumValues
-      };
-    }
-    if (typeStr.endsWith("[]")) {
-      const baseType = typeStr.slice(0, -2);
-      return {
-        type: this.mapTypeName(baseType),
-        array: true
-      };
-    }
-    if (typeStr.endsWith("?")) {
-      const baseType = typeStr.slice(0, -1);
-      return {
-        type: this.mapTypeName(baseType)
-      };
-    }
-    return {
-      type: this.mapTypeName(typeStr)
-    };
-  }
-  /**
-   * 映射类型名称到 FieldValidation 类型
-   */
-  mapTypeName(typeName) {
-    const typeMap = {
-      string: "string",
-      number: "number",
-      integer: "number",
-      boolean: "boolean",
-      array: "array",
-      object: "object",
-      file: "file",
-      date: "date"
-    };
-    return typeMap[typeName.toLowerCase()] || "any";
-  }
-  /**
-   * 从 @apiParam 标签构建请求 Schema
-   */
-  buildRequestSchemaFromTags(params) {
-    const fields = {};
-    for (const param of params) {
-      fields[param.name] = {
-        type: param.type,
-        required: param.required,
-        constraints: param.enumValues ? { custom: [`\u53EF\u9009\u503C: ${param.enumValues.join(", ")}`] } : void 0
-      };
-    }
-    return { target: "body", fields };
-  }
-  /**
-   * 从 @apiSuccess 标签构建响应 Schema
-   */
-  buildResponseSchemaFromTags(success) {
-    const fields = {};
-    for (const field of success) {
-      if (!field.parent && !fields[field.name]) {
-        if (field.type === "object") {
-          fields[field.name] = {
-            type: "object",
-            required: true,
-            properties: {}
-          };
-        } else {
-          fields[field.name] = {
-            type: field.type,
-            required: true
-          };
-        }
-      }
-    }
-    for (const field of success) {
-      if (field.parent) {
-        const parts = field.parent.split(".");
-        let current = fields;
-        for (let i = 0; i < parts.length; i++) {
-          const part = parts[i];
-          if (!current[part]) {
-            current[part] = {
-              type: "object",
-              required: true,
-              properties: {}
-            };
-          } else if (!current[part].properties) {
-            current[part].properties = {};
-          }
-          current = current[part].properties;
-        }
-        current[field.name] = {
-          type: field.type,
-          required: true
-        };
-      }
-    }
-    return { fields };
-  }
-};
-var routeParser = new RouteParser();
-
-// utils/DocManager.ts
-import Database2 from "better-sqlite3";
-import * as path4 from "path";
-import * as fs4 from "fs";
-var DocManager = class {
-  db = null;
-  config;
-  constructor(config2) {
-    this.config = config2;
-    this.init();
-  }
-  /**
-   * 初始化数据库
-   */
-  init() {
-    try {
-      const dbDir = path4.dirname(this.config.path);
-      if (!fs4.existsSync(dbDir)) {
-        fs4.mkdirSync(dbDir, { recursive: true });
-      }
-      this.db = new Database2(this.config.path);
-      this.createTables();
-    } catch (error) {
-      Logger_default.error("\u6587\u6863\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25:", error);
-      this.db = null;
-    }
-  }
-  /**
-   * 创建表结构
-   */
-  createTables() {
-    if (!this.db) return;
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS doc_routes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        module TEXT NOT NULL,
-        method TEXT NOT NULL,
-        path TEXT NOT NULL,
-        full_path TEXT NOT NULL,
-        summary TEXT,
-        description TEXT,
-        request_schema TEXT,
-        response_schema TEXT,
-        middlewares TEXT,
-        file_path TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        UNIQUE(module, method, path)
-      );
-    `);
-    this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_doc_routes_module ON doc_routes(module);
-      CREATE INDEX IF NOT EXISTS idx_doc_routes_full_path ON doc_routes(full_path);
-    `);
-  }
-  /**
-   * 保存路由信息
-   * @param routeInfo 路由信息
-   * @param apiPrefix API 前缀
-   * @param moduleName 模块名称
-   */
-  saveRoute(routeInfo, apiPrefix = "/api", moduleName) {
-    if (!this.db) return;
-    try {
-      const fullPath = `${apiPrefix}/${moduleName}${routeInfo.path}`.replace(/\/+/g, "/");
-      const now = Date.now();
-      const data = {
-        module: moduleName,
-        method: routeInfo.method,
-        path: routeInfo.path,
-        full_path: fullPath,
-        summary: routeInfo.summary,
-        description: routeInfo.description,
-        request_schema: routeInfo.requestSchema ? JSON.stringify(routeInfo.requestSchema) : null,
-        response_schema: routeInfo.responseSchema ? JSON.stringify(routeInfo.responseSchema) : null,
-        middlewares: routeInfo.middlewares ? JSON.stringify(routeInfo.middlewares) : null,
-        file_path: routeInfo.filePath,
-        created_at: now,
-        updated_at: now
-      };
-      const stmt = this.db.prepare(`
-        INSERT INTO doc_routes (
-          module, method, path, full_path, summary, description,
-          request_schema, response_schema, middlewares, file_path, created_at, updated_at
-        ) VALUES (
-          @module, @method, @path, @full_path, @summary, @description,
-          @request_schema, @response_schema, @middlewares, @file_path, @created_at, @updated_at
-        ) ON CONFLICT(module, method, path) DO UPDATE SET
-          full_path = @full_path,
-          summary = @summary,
-          description = @description,
-          request_schema = @request_schema,
-          response_schema = @response_schema,
-          middlewares = @middlewares,
-          file_path = @file_path,
-          updated_at = @updated_at
-      `);
-      stmt.run(data);
-    } catch (error) {
-      Logger_default.error("\u4FDD\u5B58\u8DEF\u7531\u4FE1\u606F\u5931\u8D25:", error);
-    }
-  }
-  /**
-   * 获取模块列表
-   * @returns 模块列表
-   */
-  getModules() {
-    if (!this.db) return [];
-    try {
-      const stmt = this.db.prepare(`
-        SELECT module, COUNT(*) as count 
-        FROM doc_routes 
-        GROUP BY module 
-        ORDER BY module
-      `);
-      return stmt.all();
-    } catch (error) {
-      Logger_default.error("\u83B7\u53D6\u6A21\u5757\u5217\u8868\u5931\u8D25:", error);
-      return [];
-    }
-  }
-  /**
-   * 获取路由列表
-   * @param module 模块名称（可选）
-   * @returns 路由列表
-   */
-  getRoutes(module) {
-    if (!this.db) return [];
-    try {
-      let query = `
-        SELECT id, module, method, path, full_path, summary, description,
-               request_schema, response_schema, middlewares, file_path, created_at, updated_at
-        FROM doc_routes
-      `;
-      const params = {};
-      if (module) {
-        query += " WHERE module = @module";
-        params.module = module;
-      }
-      query += " ORDER BY module, method, path";
-      const stmt = this.db.prepare(query);
-      const rows = stmt.all(params);
-      return rows.map((row) => ({
-        id: row.id,
-        module: row.module,
-        method: row.method,
-        path: row.path,
-        fullPath: row.full_path,
-        summary: row.summary,
-        description: row.description,
-        requestSchema: row.request_schema ? JSON.parse(row.request_schema) : void 0,
-        responseSchema: row.response_schema ? JSON.parse(row.response_schema) : void 0,
-        middlewares: row.middlewares ? JSON.parse(row.middlewares) : void 0,
-        filePath: row.file_path,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      }));
-    } catch (error) {
-      Logger_default.error("\u83B7\u53D6\u8DEF\u7531\u5217\u8868\u5931\u8D25:", error);
-      return [];
-    }
-  }
-  /**
-   * 获取路由详情
-   * @param id 路由 ID
-   * @returns 路由详情
-   */
-  getRouteById(id) {
-    if (!this.db) return null;
-    try {
-      const stmt = this.db.prepare(`
-        SELECT id, module, method, path, full_path, summary, description,
-               request_schema, response_schema, middlewares, file_path, created_at, updated_at
-        FROM doc_routes
-        WHERE id = @id
-      `);
-      const row = stmt.get({ id });
-      if (!row) return null;
-      return {
-        id: row.id,
-        module: row.module,
-        method: row.method,
-        path: row.path,
-        fullPath: row.full_path,
-        summary: row.summary,
-        description: row.description,
-        requestSchema: row.request_schema ? JSON.parse(row.request_schema) : void 0,
-        responseSchema: row.response_schema ? JSON.parse(row.response_schema) : void 0,
-        middlewares: row.middlewares ? JSON.parse(row.middlewares) : void 0,
-        filePath: row.file_path,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      };
-    } catch (error) {
-      Logger_default.error("\u83B7\u53D6\u8DEF\u7531\u8BE6\u60C5\u5931\u8D25:", error);
-      return null;
-    }
-  }
-  /**
-   * 清空所有路由数据
-   */
-  clearAllRoutes() {
-    if (!this.db) return;
-    try {
-      this.db.exec("DELETE FROM doc_routes");
-    } catch (error) {
-      Logger_default.error("\u6E05\u7A7A\u8DEF\u7531\u6570\u636E\u5931\u8D25:", error);
-    }
-  }
-  /**
-   * 关闭数据库连接
-   */
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      Logger_default.info("\u6587\u6863\u6570\u636E\u5E93\u8FDE\u63A5\u5DF2\u5173\u95ED");
-    }
-  }
-};
-var docManager;
-function initDocManager(config2) {
-  docManager = new DocManager(config2);
-  return docManager;
-}
-
-// utils/RouteRegistry.ts
-import path5 from "path";
-function getRoutes(router2, prefix = "") {
-  const routes = [];
-  if (router2 && router2.stack) {
-    router2.stack.forEach((layer) => {
-      if (layer.route) {
-        const path9 = (prefix + layer.route.path).replace(/\/+/g, "/");
-        const methods = Object.keys(layer.route.methods).map((m) => m.toUpperCase());
-        methods.forEach((method) => {
-          routes.push({ path: path9, method });
-        });
-      } else if (layer.name === "router" && layer.handle && layer.handle.stack) {
-        const newPrefix = (prefix + (layer.regexp.source.replace("^\\/", "").replace("\\/?(?=\\/|$)", "") || "")).replace(/\/+/g, "/");
-        routes.push(...getRoutes(layer.handle, newPrefix));
-      }
-    });
-  }
-  return routes;
-}
-async function registerRoute(app, config2, apiPrefix = "/api") {
-  const { fileName, defaultExport: handler, filePath, cacheHit } = config2;
-  try {
-    const lowercaseModuleName = fileName.toLowerCase();
-    if (!cacheHit) {
-      const routes = routeParser.parseRouteFile(filePath);
-      routes.forEach((route) => {
-        docManager.saveRoute(route, apiPrefix, lowercaseModuleName);
-      });
-    }
-    const filePathParts = filePath.split(path5.sep);
-    const routesIndex = filePathParts.lastIndexOf("routes");
-    if (routesIndex === -1) {
-      throw new Error(`\u8DEF\u7531\u6587\u4EF6\u5FC5\u987B\u5728 routes \u76EE\u5F55\u4E0B: ${filePath}`);
-    }
-    const routesDir = filePathParts.slice(0, routesIndex + 1).join(path5.sep);
-    const fileDir = path5.dirname(filePath);
-    const relativePath = path5.relative(routesDir, fileDir);
-    let pathParts = [];
-    if (relativePath && relativePath !== ".") {
-      pathParts = relativePath.split(path5.sep).map((p) => p.toLowerCase());
-    }
-    pathParts.push(lowercaseModuleName);
-    const baseRoutePath = `${apiPrefix}/${pathParts.join("/")}`.replace(/\/+/g, "/");
-    app.use(baseRoutePath, handler);
-    const subRoutes = getRoutes(handler);
-    if (subRoutes.length > 0) {
-      Logger_default.startup("\u8DEF\u7531", `${baseRoutePath} (${subRoutes.length} \u4E2A\u7AEF\u70B9)`);
-      subRoutes.forEach((route) => {
-        const fullPath = `${baseRoutePath}${route.path}`.replace(/\/+/g, "/");
-        const method = route.method.padEnd(6, " ");
-        Logger_default.startup(`  \u2514\u2500 ${method} ${fullPath}`);
-      });
-    } else {
-      Logger_default.startup("\u8DEF\u7531", `${baseRoutePath} (\u65E0\u7AEF\u70B9)`);
-    }
-  } catch (error) {
-    Logger_default.error(`\u6CE8\u518C\u8DEF\u7531\u5931\u8D25[${fileName.toLowerCase()}]: ${error}`);
-  }
-}
-
-// utils/ComponentRegistry.ts
-async function registerComponents(state2, scannedResults) {
-  for (const item of scannedResults) {
-    if (item.type === "middleware") {
-      registerMiddleware(state2.express, item);
-    }
-  }
-  for (const item of scannedResults) {
-    if (item.type === "route") {
-      registerRoute(state2.express, item, state2.options.apiPrefix);
-    }
-  }
-  const syncAppRoutes = state2.express.get("syncAppRoutes");
-  if (syncAppRoutes && typeof syncAppRoutes === "function") {
-    try {
-      await syncAppRoutes();
-    } catch (error) {
-      Logger_default.error("[ComponentRegistry] \u8DEF\u7531\u8D44\u6E90\u540C\u6B65\u5931\u8D25:", error);
-    }
-  }
-}
-
-// utils/InitErrorHandler.ts
-import { ZodError } from "zod";
-function isSQLError(err) {
-  if (!err) return false;
-  const msg = err.message || err.toString() || "";
-  return /no such table|table.*does not exist|column.*does not exist|database schema has changed/i.test(msg);
-}
-function setupErrorHandlers(app, logging) {
-  app.use((req, res) => {
-    res.status(404).json({
-      code: 404,
-      data: null,
-      msg: "\u8D44\u6E90\u4E0D\u5B58\u5728",
-      error: "Not Found",
-      fields: {}
-    });
-  });
-  app.use((err, req, res, next) => {
-    if (err.isAppError || err.statusCode && err.statusCode >= 400 && err.statusCode < 500) {
-      return res.status(err.statusCode).json({
-        code: err.statusCode,
-        data: null,
-        msg: err.message,
-        error: "BusinessError",
-        fields: {}
-      });
-    }
-    if (err instanceof ZodError) {
-      const fields = {};
-      err.errors.forEach((e) => {
-        const path9 = e.path.join(".");
-        fields[path9] = e.message;
-      });
-      return res.status(400).json({
-        code: 400,
-        data: null,
-        msg: "\u53C2\u6570\u6821\u9A8C\u5931\u8D25",
-        error: "ZodValidationError",
-        fields
-      });
-    }
-    if (isSQLError(err)) {
-      Logger_default.error("");
-      Logger_default.error("\u274C \u6570\u636E\u5E93\u7ED3\u6784\u53EF\u80FD\u5DF2\u53D8\u5316\uFF0C\u8BF7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u540C\u6B65\uFF1A");
-      Logger_default.error("");
-      Logger_default.error("   npm run db:migrate");
-      Logger_default.error("");
-    }
-    const statusCode = err.status || err.statusCode || 500;
-    if (!isSQLError(err)) {
-      Logger_default.error("\u7CFB\u7EDF\u9519\u8BEF:", err);
-    }
-    res.status(statusCode).json({
-      code: statusCode,
-      data: null,
-      msg: err.message || "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF",
-      error: logging ? err.stack : "InternalServerError",
-      fields: {}
-    });
-  });
-}
-
-// utils/HttpServer.ts
-async function startServer(app, port) {
-  if (!app) {
-    throw new Error("Express \u5B9E\u4F8B\u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  if (!port || typeof port !== "number" || port <= 0 || port > 65535) {
-    throw new Error(`\u65E0\u6548\u7684\u7AEF\u53E3\u53F7: ${port}`);
-  }
-  return new Promise((resolve3, reject) => {
-    try {
-      const server = app.listen(port, () => {
-        resolve3();
-      });
-      server.on("error", (error) => {
-        Logger_default.error("\u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25\uFF1A", error);
-        reject(new Error(`\u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`));
-      });
-      server.on("close", () => {
-        Logger_default.info("\u670D\u52A1\u5668\u5DF2\u5173\u95ED");
-      });
-    } catch (error) {
-      Logger_default.error("\u670D\u52A1\u5668\u542F\u52A8\u5F02\u5E38\uFF1A", error);
-      reject(new Error(`\u670D\u52A1\u5668\u542F\u52A8\u5F02\u5E38\uFF1A${error instanceof Error ? error.message : String(error)}`));
-    }
-  });
-}
-
-// routes/Doc.route.ts
-import { Router } from "express";
-
-// utils/Validate.ts
-var validate = (schema, target = "body") => {
-  return async (req, res, next) => {
-    try {
-      await schema.parseAsync(req[target]);
-      next();
-    } catch (error) {
-      next(error);
-    }
-  };
-};
-
-// zod/Doc.schema.ts
-import { z } from "zod";
-var routeIdParamsSchema = z.object({
-  id: z.coerce.number().int().positive("\u65E0\u6548\u7684\u8DEF\u7531ID")
-});
-
-// routes/Doc.route.ts
-var router = Router();
-router.get("/modules", (req, res) => {
-  try {
-    const modules = docManager.getModules();
-    const response = {
-      code: 200,
-      data: modules,
-      msg: "success"
-    };
-    res.json(response);
-  } catch (error) {
-    const response = {
-      code: 500,
-      data: null,
-      msg: "\u83B7\u53D6\u6A21\u5757\u5217\u8868\u5931\u8D25"
-    };
-    res.json(response);
-  }
-});
-router.get("/routes", (req, res) => {
-  try {
-    const module = req.query.module;
-    const routes = docManager.getRoutes(module);
-    const response = {
-      code: 200,
-      data: routes,
-      msg: "success"
-    };
-    res.json(response);
-  } catch (error) {
-    const response = {
-      code: 500,
-      data: null,
-      msg: "\u83B7\u53D6\u8DEF\u7531\u5217\u8868\u5931\u8D25"
-    };
-    res.json(response);
-  }
-});
-router.get("/routes/:id", validate(routeIdParamsSchema, "params"), (req, res) => {
-  try {
-    const { id } = req.params;
-    const route = docManager.getRouteById(id);
-    if (!route) {
-      const response2 = {
-        code: 404,
-        data: null,
-        msg: "\u8DEF\u7531\u4E0D\u5B58\u5728"
-      };
-      return res.json(response2);
-    }
-    const response = {
-      code: 200,
-      data: route,
-      msg: "success"
-    };
-    res.json(response);
-  } catch (error) {
-    const response = {
-      code: 500,
-      data: null,
-      msg: "\u83B7\u53D6\u8DEF\u7531\u8BE6\u60C5\u5931\u8D25"
-    };
-    res.json(response);
-  }
-});
-router.post("/sync", (req, res) => {
-  try {
-    const response = {
-      code: 200,
-      data: true,
-      msg: "\u540C\u6B65\u6210\u529F"
-    };
-    res.json(response);
-  } catch (error) {
-    const response = {
-      code: 500,
-      data: null,
-      msg: "\u540C\u6B65\u5931\u8D25"
-    };
-    res.json(response);
-  }
-});
-var Doc_route_default = router;
-
-// core/app.ts
-function createApp(options = {}) {
-  Logger_default.startup("\u521D\u59CB\u5316", "\u5E94\u7528\u521D\u59CB\u5316\u2026\u2026");
-  const stateInstance = createState(options);
-  const plugins = [];
-  if (stateInstance.options.logLevel) {
-    Logger_default.setLevel(stateInstance.options.logLevel);
-  }
-  const app = {
-    use: async (plugin) => {
-      if (typeof plugin.install === "function") {
-        plugins.push(plugin);
-      }
-      if (typeof plugin.__modulePath === "string") {
-        Logger_default.startup("\u6A21\u5757", `\u6CE8\u518C\uFF1A${plugin.__modulePath}`);
-        addScanPath(plugin.__modulePath);
-      }
-    },
-    startup: async () => {
-      initExpress(stateInstance);
-      await prepareScanEnvironment();
-      const scannedResults = await scanComponents();
-      await initializeDataStorage(scannedResults);
-      await installPlugins();
-      registerComponents(stateInstance, scannedResults);
-      registerDocRoutes();
-      setupErrorHandlers(stateInstance.express, stateInstance.options.logging);
-      await startHttpServer();
-      Logger_default.startup("\u521D\u59CB\u5316", "\u2705 \u5E94\u7528\u542F\u52A8\u5B8C\u6210");
-    },
-    getApp: () => stateInstance.express,
-    getDB: () => stateInstance.db,
-    getOptions: () => stateInstance.options
-  };
-  async function prepareScanEnvironment() {
-    setBaseDir(process.cwd());
-    Logger_default.startup("\u626B\u63CF", `\u57FA\u51C6\u76EE\u5F55: ${process.cwd()}`);
-  }
-  async function scanComponents() {
-    const scannedResults = await scan();
-    const routeFiles = scannedResults.filter((r) => r.type === "route");
-    const cacheHits = routeFiles.filter((r) => r.cacheHit).length;
-    const total = routeFiles.length;
-    if (cacheHits > 0) {
-      Logger_default.startup("\u626B\u63CF", `\u53D1\u73B0 ${scannedResults.length} \u4E2A\u7EC4\u4EF6\u6587\u4EF6 (\u7F13\u5B58\u547D\u4E2D: ${cacheHits}/${total})`);
-    } else {
-      Logger_default.startup("\u626B\u63CF", `\u53D1\u73B0 ${scannedResults.length} \u4E2A\u7EC4\u4EF6\u6587\u4EF6`);
-    }
-    return scannedResults;
-  }
-  async function initializeDataStorage(scannedResults) {
-    setupDatabase(stateInstance, scannedResults);
-    stateInstance.express.set("db", stateInstance.db);
-    if (stateInstance.db) {
-      const dbPath2 = stateInstance.options.database?.path || "./data/app.db";
-      Logger_default.startup("\u6570\u636E\u5E93", `\u5DF2\u8FDE\u63A5: SQLite (${dbPath2})`);
-    }
-    const docDbPath = stateInstance.options.database?.path ? stateInstance.options.database.path.replace(/app\.db$/, "doc.db") : "./data/doc.db";
-    initDocManager({ path: docDbPath });
-    Logger_default.startup("\u6570\u636E\u5E93", `\u6587\u6863\u5E93\u5DF2\u521D\u59CB\u5316: ${docDbPath}`);
-  }
-  async function installPlugins() {
-    for (const plugin of plugins) {
-      await plugin.install(app);
-    }
-  }
-  async function startHttpServer() {
-    const listenPort = stateInstance.options.port || 3e3;
-    await startServer(stateInstance.express, listenPort);
-    const serverUrl = `http://${stateInstance.options.host}:${listenPort}`;
-    Logger_default.startup("\u670D\u52A1", `\u8BBF\u95EE\u5730\u5740: ${serverUrl}`);
-  }
-  function registerDocRoutes() {
-    const apiPrefix = stateInstance.options.apiPrefix || "/api";
-    const docRoutePath = `${apiPrefix}/doc`.replace(/\/+/g, "/");
-    stateInstance.express.use(docRoutePath, Doc_route_default);
-    stateInstance.options.authWhitelist.push(`${docRoutePath}/modules`);
-    Logger_default.startup("\u8DEF\u7531", `${docRoutePath}/modules (GET)`);
-    stateInstance.options.authWhitelist.push(`${docRoutePath}/routes`);
-    Logger_default.startup("\u8DEF\u7531", `${docRoutePath}/routes (GET)`);
-    stateInstance.options.authWhitelist.push(new RegExp(`^${docRoutePath}/routes/[^/]+$`));
-    Logger_default.startup("\u8DEF\u7531", `${docRoutePath}/routes/:id (GET)`);
-    stateInstance.options.authWhitelist.push(`${docRoutePath}/sync`);
-    Logger_default.startup("\u8DEF\u7531", `${docRoutePath}/sync (POST)`);
-  }
-  return app;
-}
-
-// commands/prepare.ts
-import fs5 from "fs";
-import path6 from "path";
-async function prepare(cwd = process.cwd()) {
-  console.log("\u{1F680} MindBase \u73AF\u5883\u51C6\u5907\u5DE5\u5177");
-  console.log(`\u5DE5\u4F5C\u76EE\u5F55: ${cwd}
-`);
-  setBaseDir(cwd);
-  try {
-    console.log("\u{1F4C2} \u626B\u63CF\u7EC4\u4EF6\u6587\u4EF6...");
-    const results = await scan();
-    const routeFiles = results.filter((r) => r.type === "route");
-    const middlewareFiles = results.filter((r) => r.type === "middleware");
-    const schemaFiles = results.filter((r) => r.type === "schema");
-    console.log(`  \u53D1\u73B0 ${results.length} \u4E2A\u7EC4\u4EF6\u6587\u4EF6`);
-    console.log(`    - \u8DEF\u7531: ${routeFiles.length}`);
-    console.log(`    - \u4E2D\u95F4\u4EF6: ${middlewareFiles.length}`);
-    console.log(`    - Schema: ${schemaFiles.length}`);
-    if (schemaFiles.length > 0) {
-      const schemaJsonPath = path6.join(cwd, ".drizzle-schemas.json");
-      const relativeSchemaPaths = schemaFiles.map(
-        (f) => path6.relative(cwd, f.filePath).replace(/\\/g, "/")
-      );
-      fs5.writeFileSync(schemaJsonPath, JSON.stringify(relativeSchemaPaths, null, 2));
-      console.log(`  \u5DF2\u751F\u6210 schema \u6E05\u5355: .drizzle-schemas.json
-`);
-    } else {
-      console.log("  \u8B66\u544A: \u672A\u627E\u5230 schema \u6587\u4EF6\n");
-    }
-    const schemas = {};
-    for (const item of results) {
-      if (item.type === "schema" && item.allExports) {
-        try {
-          Object.assign(schemas, item.allExports);
-        } catch (e) {
-          Logger_default.warn(`\u5904\u7406 Schema \u6587\u4EF6\u5931\u8D25: ${item.filePath}`, e);
-        }
-      }
-    }
-    console.log("\u{1F4BE} \u521D\u59CB\u5316\u6570\u636E\u5E93...");
-    const db = initDatabase({
-      dbPath: process.env.DB_PATH || "./data/app.db",
-      schemas
-    });
-    console.log(`  \u6570\u636E\u5E93\u5DF2\u521D\u59CB\u5316
-`);
-    const cacheFile = path6.join(cwd, "node_modules/.cache/mindbase/startup-cache.json");
-    console.log("\u2705 \u73AF\u5883\u51C6\u5907\u5B8C\u6210\uFF01");
-    console.log(`
-\u{1F4E6} \u7F13\u5B58\u6587\u4EF6: ${cacheFile}`);
-    console.log(`\u{1F4BE} \u6570\u636E\u5E93: ${process.env.DB_PATH || "./data/app.db"}`);
-    console.log("\n\u{1F4A1} \u63D0\u793A: \u73B0\u5728\u53EF\u4EE5\u8FD0\u884C db push\u3001init-admin \u7B49\u547D\u4EE4\u4E86");
-  } catch (error) {
-    console.error("\n\u274C \u51C6\u5907\u5931\u8D25:", error);
-    process.exit(1);
-  }
-}
-async function precache(cwd) {
-  return prepare(cwd);
-}
-
-// feature/cron/CronManager.ts
-import { CronJob } from "cron";
-import { randomUUID } from "crypto";
-var jobs = {};
-var config = {
-  timezone: "Asia/Shanghai"
-};
-function addCron(pattern, handler, customId) {
-  const id = customId || generateId();
-  if (jobs[id]) {
-    jobs[id].stop();
-  }
-  const job = new CronJob(pattern, handler, null, true, config.timezone);
-  jobs[id] = job;
-  return id;
-}
-function stopCron(id) {
-  const job = jobs[id];
-  if (job) {
-    job.stop();
-    delete jobs[id];
-    return true;
-  }
-  return false;
-}
-function stopAllCron() {
-  Object.values(jobs).forEach((job) => {
-    job.stop();
-  });
-  jobs = {};
-}
-function generateId() {
-  return randomUUID();
-}
-
-// core/module/FindPackageRoot.ts
-import path7 from "path";
-import fs6 from "fs";
-function findPackageRoot(startPath) {
-  if (!startPath || typeof startPath !== "string") {
-    throw new Error("\u65E0\u6548\u7684\u8D77\u59CB\u8DEF\u5F84\uFF1A\u8DEF\u5F84\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
-  }
-  let currentPath;
-  try {
-    currentPath = path7.isAbsolute(startPath) ? startPath : path7.resolve(startPath);
-  } catch (e) {
-    throw new Error(`\u65E0\u6CD5\u89E3\u6790\u8DEF\u5F84\uFF1A${startPath}`);
-  }
-  try {
-    if (!fs6.existsSync(currentPath)) {
-      throw new Error(`\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${currentPath}`);
-    }
-    const stat = fs6.statSync(currentPath);
-    if (stat.isFile()) {
-      currentPath = path7.dirname(currentPath);
-    }
-  } catch (e) {
-    throw new Error(`\u8DEF\u5F84\u9A8C\u8BC1\u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}`);
-  }
-  while (currentPath !== path7.parse(currentPath).root) {
-    try {
-      const pkgJsonPath = path7.join(currentPath, "package.json");
-      if (fs6.existsSync(pkgJsonPath)) {
-        const pkgStat = fs6.statSync(pkgJsonPath);
-        if (pkgStat.isFile()) {
-          return currentPath;
-        }
-      }
-    } catch (e) {
-    }
-    currentPath = path7.dirname(currentPath);
-  }
-  return path7.dirname(startPath);
-}
-
-// core/module/GetModulePath.ts
-import * as path8 from "path";
-function getModulePath() {
-  try {
-    const error = new Error();
-    if (error.stack) {
-      console.log("DEBUG STACK:", error.stack);
-      const stackLines = error.stack.split("\n");
-      for (const line of stackLines) {
-        if (!line.includes("at") || line.includes("getModulePath") || line.includes("createModule") || line.includes("CreateModule.ts") || line.includes("ts-node") || line.includes("node:internal")) {
-          continue;
-        }
-        const match = line.match(/\(([^:]+\.ts)/) || line.match(/at\s+([^:]+\.ts)/);
-        if (match && match[1]) {
-          const filePath = match[1];
-          console.log("\u63D0\u53D6\u5230\u7684\u8DEF\u5F84:", filePath);
-          return path8.resolve(filePath);
-        }
-      }
-    }
-  } catch (e) {
-  }
-  throw new Error("\u65E0\u6CD5\u786E\u5B9A\u6A21\u5757\u8DEF\u5F84\uFF1A\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 __filename \u4E14\u65E0\u6CD5\u4ECE\u8C03\u7528\u6808\u4E2D\u63D0\u53D6\u8DEF\u5F84");
-}
-
-// core/module/CreateModule.ts
-function createModule(install, callerPath) {
-  if (typeof install !== "function") {
-    throw new Error("\u6A21\u5757\u5B89\u88C5\u51FD\u6570\u5FC5\u987B\u662F\u4E00\u4E2A\u51FD\u6570");
-  }
-  try {
-    const modulePath = callerPath || getModulePath();
-    const packageRoot = findPackageRoot(modulePath);
-    Logger_default.debug(`\u521B\u5EFA\u6A21\u5757\uFF1A\u8DEF\u5F84=${modulePath}\uFF0C\u5305\u6839\u76EE\u5F55=${packageRoot}`);
-    return {
-      install,
-      __modulePath: packageRoot
-    };
-  } catch (error) {
-    Logger_default.error("\u6A21\u5757\u521B\u5EFA\u5931\u8D25\uFF1A", error);
-    throw new Error(`\u6A21\u5757\u521B\u5EFA\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-// utils/AppError.ts
-function createAppError(code, msg) {
-  const err = new Error(msg);
-  err.statusCode = code;
-  err.isAppError = true;
-  return err;
-}
-var Errors = {
-  badRequest: (msg) => createAppError(400, msg),
-  unauthorized: (msg) => createAppError(401, msg),
-  forbidden: (msg) => createAppError(403, msg),
-  notFound: (msg) => createAppError(404, msg)
-};
-export {
-  DocManager,
-  Errors,
-  addCron,
-  createApp,
-  createAppError,
-  createModule,
-  dayjs,
-  docManager,
-  initDatabase,
-  initDocManager,
-  logger,
-  precache,
-  prepare,
-  stopAllCron,
-  stopCron,
-  validate
-};
-//# sourceMappingURL=index.mjs.map