@lark-apaas/devtool-kits 1.2.19 → 1.2.21

package/dist/index.cjs

@@ -31,16 +31,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  buildFullPath: () => buildFullPath,
+  calculateFileHash: () => calculateFileHash,
   createCollectLogsMiddleware: () => createCollectLogsMiddleware,
   createDevLogsMiddleware: () => createDevLogsMiddleware,
   createOpenapiMiddleware: () => createOpenapiMiddleware,
+  evaluateTemplateLiteral: () => evaluateTemplateLiteral,
+  extractPageRouteInfo: () => extractPageRouteInfo,
   getQuery: () => getQuery,
   getQueryParam: () => getQueryParam,
   handleDevProxyError: () => handleDevProxyError,
+  isRouteComponent: () => isRouteComponent,
   normalizeBasePath: () => normalizeBasePath,
   parseAndGenerateNestResourceTemplate: () => parseAndGenerateNestResourceTemplate,
+  parseApiRoutes: () => parseApiRoutes,
+  parseRoutesFromFile: () => parseRoutesFromFile,
   postprocessDrizzleSchema: () => postprocessDrizzleSchema,
   registerMiddlewares: () => registerMiddlewares,
+  routeParserLog: () => routeParserLog,
   sendError: () => sendError,
   sendJson: () => sendJson,
   sendSuccess: () => sendSuccess
@@ -1281,7 +1289,7 @@ function isConnectionError(err) {
 }
 __name(isConnectionError, "isConnectionError");
 function checkServiceAvailable(targetUrl, timeout = 2e3) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     try {
       const url = new URL(targetUrl);
       const isHttps = url.protocol === "https:";
@@ -1293,18 +1301,18 @@ function checkServiceAvailable(targetUrl, timeout = 2e3) {
         method: "HEAD",
         timeout
       }, (res) => {
-        resolve(res.statusCode !== 502);
+        resolve2(res.statusCode !== 502);
       });
       req.on("timeout", () => {
         req.destroy();
-        resolve(false);
+        resolve2(false);
       });
       req.on("error", () => {
-        resolve(false);
+        resolve2(false);
       });
       req.end();
     } catch {
-      resolve(false);
+      resolve2(false);
     }
   });
 }
@@ -1316,7 +1324,7 @@ async function waitForServiceRecovery(targetUrl, timeout, interval) {
     if (isAvailable) {
       return true;
     }
-    await new Promise((resolve) => setTimeout(resolve, interval));
+    await new Promise((resolve2) => setTimeout(resolve2, interval));
   }
   return false;
 }
@@ -1386,6 +1394,7 @@ var import_node_crypto = __toESM(require("crypto"), 1);
 
 // src/middlewares/openapi/services.ts
 var import_node_fs4 = require("fs");
+var fsSync = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
 var import_typescript = __toESM(require("typescript"), 1);
 
@@ -1608,6 +1617,120 @@ function extractControllerMetadata(sourceFile, filePath) {
   return metadata;
 }
 __name(extractControllerMetadata, "extractControllerMetadata");
+var HTTP_DECORATOR_NAMES = [
+  "Get",
+  "Post",
+  "Put",
+  "Delete",
+  "Patch",
+  "Options",
+  "Head",
+  "All"
+];
+function findControllerFilesSync(dir) {
+  const files = [];
+  function scan(currentDir) {
+    let entries;
+    try {
+      entries = fsSync.readdirSync(currentDir, {
+        withFileTypes: true
+      });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = import_node_path4.default.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        scan(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".controller.ts")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  __name(scan, "scan");
+  scan(dir);
+  return files;
+}
+__name(findControllerFilesSync, "findControllerFilesSync");
+function normalizeApiPath(controllerPath, routePath) {
+  const combined = routePath ? `${controllerPath}/${routePath}` : controllerPath;
+  let normalized = combined.replace(/\/+/g, "/");
+  if (!normalized.startsWith("/")) normalized = `/${normalized}`;
+  if (normalized.length > 1 && normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  return normalized;
+}
+__name(normalizeApiPath, "normalizeApiPath");
+function parseControllerRoutes(filePath) {
+  let content;
+  try {
+    content = fsSync.readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const sourceFile = import_typescript.default.createSourceFile(filePath, content, import_typescript.default.ScriptTarget.Latest, true);
+  const routes = [];
+  function getDecoratorsCompat(node) {
+    if ("modifiers" in node && Array.isArray(node.modifiers)) {
+      return node.modifiers.filter((mod) => mod.kind === import_typescript.default.SyntaxKind.Decorator);
+    }
+    if ("decorators" in node && Array.isArray(node.decorators)) {
+      return node.decorators;
+    }
+    return [];
+  }
+  __name(getDecoratorsCompat, "getDecoratorsCompat");
+  function getStringArg(expr) {
+    if (expr.arguments.length > 0 && import_typescript.default.isStringLiteral(expr.arguments[0])) {
+      return expr.arguments[0].text;
+    }
+    return "";
+  }
+  __name(getStringArg, "getStringArg");
+  function visit(node) {
+    if (import_typescript.default.isClassDeclaration(node)) {
+      let controllerPath = "";
+      for (const dec of getDecoratorsCompat(node)) {
+        if (import_typescript.default.isCallExpression(dec.expression)) {
+          const name = dec.expression.expression.getText(sourceFile);
+          if (name === "Controller") {
+            controllerPath = getStringArg(dec.expression);
+            break;
+          }
+        }
+      }
+      for (const member of node.members) {
+        if (!import_typescript.default.isMethodDeclaration(member)) continue;
+        for (const dec of getDecoratorsCompat(member)) {
+          if (!import_typescript.default.isCallExpression(dec.expression)) continue;
+          const decoratorName = dec.expression.expression.getText(sourceFile);
+          if (!HTTP_DECORATOR_NAMES.includes(decoratorName)) continue;
+          const routePath = getStringArg(dec.expression);
+          const fullPath = normalizeApiPath(controllerPath, routePath);
+          const method = decoratorName === "All" ? "*" : decoratorName.toUpperCase();
+          routes.push({
+            method,
+            path: fullPath
+          });
+        }
+      }
+    }
+    import_typescript.default.forEachChild(node, visit);
+  }
+  __name(visit, "visit");
+  visit(sourceFile);
+  return routes;
+}
+__name(parseControllerRoutes, "parseControllerRoutes");
+function parseApiRoutes(serverDir) {
+  const resolvedDir = import_node_path4.default.resolve(serverDir);
+  const controllerFiles = findControllerFilesSync(resolvedDir);
+  const routes = [];
+  for (const filePath of controllerFiles) {
+    routes.push(...parseControllerRoutes(filePath));
+  }
+  return routes;
+}
+__name(parseApiRoutes, "parseApiRoutes");
 
 // src/middlewares/openapi/controller.ts
 function createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir) {
@@ -1646,12 +1769,135 @@ function createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir) {
 }
 __name(createOpenapiHandler, "createOpenapiHandler");
 
+// src/middlewares/openapi/spec-controller.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_crypto2 = __toESM(require("crypto"), 1);
+var MAX_REF_DEPTH = 5;
+function createOpenapiSpecHandler(openapiSpecFilePath) {
+  let cache = null;
+  return async (_req, res, context) => {
+    try {
+      const fileBuffer = await import_promises3.default.readFile(openapiSpecFilePath, "utf-8");
+      const currentHash = import_node_crypto2.default.createHash("md5").update(fileBuffer).digest("hex");
+      if (cache && cache.fileHash === currentHash) {
+        return res.json(cache.data);
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(fileBuffer);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Invalid JSON";
+        return res.status(500).json({
+          error: "Failed to load OpenAPI spec",
+          message: `${openapiSpecFilePath} invalid: ${message}`
+        });
+      }
+      if (!parsed || typeof parsed !== "object" || !parsed.paths || typeof parsed.paths !== "object") {
+        return res.status(500).json({
+          error: "Failed to load OpenAPI spec",
+          message: `${openapiSpecFilePath} missing "paths"`
+        });
+      }
+      const result = buildFilteredSpec(parsed, context.basePath ?? "");
+      cache = {
+        data: result,
+        fileHash: currentHash
+      };
+      res.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      res.status(500).json({
+        error: "Failed to load OpenAPI spec",
+        message
+      });
+    }
+  };
+}
+__name(createOpenapiSpecHandler, "createOpenapiSpecHandler");
+function buildFilteredSpec(spec, globalPrefix) {
+  const schemas = spec.components?.schemas ?? {};
+  const paths = spec.paths ?? {};
+  const filteredPaths = {};
+  const cleanPrefix = globalPrefix.replace(/\/+$/, "");
+  for (const [pathKey, methods] of Object.entries(paths)) {
+    const cleanPath = stripPrefix(pathKey, cleanPrefix);
+    if (!cleanPath.startsWith("/openapi")) continue;
+    filteredPaths[cleanPath] = {};
+    for (const [method, operation] of Object.entries(methods)) {
+      if ([
+        "parameters",
+        "summary",
+        "description",
+        "servers"
+      ].includes(method)) continue;
+      filteredPaths[cleanPath][method] = resolveRefsDeep(structuredClone(operation), schemas);
+    }
+  }
+  return {
+    openapi: spec.openapi ?? "3.0.0",
+    paths: filteredPaths,
+    components: {
+      schemas: resolveAllSchemaRefs(structuredClone(schemas))
+    }
+  };
+}
+__name(buildFilteredSpec, "buildFilteredSpec");
+function stripPrefix(pathStr, prefix) {
+  if (prefix && pathStr.startsWith(prefix)) {
+    return pathStr.slice(prefix.length);
+  }
+  return pathStr;
+}
+__name(stripPrefix, "stripPrefix");
+function resolveRefsDeep(obj, schemas, depth = 0) {
+  if (depth > MAX_REF_DEPTH || obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolveRefsDeep(item, schemas, depth));
+  }
+  const record = obj;
+  if (typeof record["$ref"] === "string") {
+    const resolved = resolveRef(record["$ref"], schemas);
+    if (resolved !== void 0) {
+      return resolveRefsDeep(structuredClone(resolved), schemas, depth + 1);
+    }
+    return record;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    result[key] = resolveRefsDeep(value, schemas, depth);
+  }
+  return result;
+}
+__name(resolveRefsDeep, "resolveRefsDeep");
+function resolveRef(ref, schemas) {
+  const prefix = "#/components/schemas/";
+  if (ref.startsWith(prefix)) {
+    const name = ref.slice(prefix.length);
+    return schemas[name];
+  }
+  return void 0;
+}
+__name(resolveRef, "resolveRef");
+function resolveAllSchemaRefs(schemas) {
+  const result = {};
+  for (const [name, schema] of Object.entries(schemas)) {
+    result[name] = resolveRefsDeep(schema, schemas);
+  }
+  return result;
+}
+__name(resolveAllSchemaRefs, "resolveAllSchemaRefs");
+
 // src/middlewares/openapi/router.ts
 function createOpenapiRouter(options, context) {
-  const { openapiFilePath, enableEnhancement, serverDir } = options;
+  const { openapiFilePath, openapiSpecFilePath, enableEnhancement, serverDir } = options;
   const router = import_express.default.Router();
   const handler = createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir);
   router.get("/openapi.json", (req, res) => handler(req, res, context));
+  if (openapiSpecFilePath) {
+    const specHandler = createOpenapiSpecHandler(openapiSpecFilePath);
+    router.get("/openapi/spec", (req, res) => specHandler(req, res, context));
+  }
   return router;
 }
 __name(createOpenapiRouter, "createOpenapiRouter");
@@ -1662,18 +1908,25 @@ var OPENAPI_ROUTES = [
     method: "GET",
     path: "/openapi.json",
     description: "Serve enhanced OpenAPI specification with source code references"
+  },
+  {
+    method: "GET",
+    path: "/openapi/spec",
+    description: "Serve OpenAPI specification for /openapi/*"
   }
 ];
 function createOpenapiMiddleware(options) {
-  const { openapiFilePath, enableEnhancement = true, serverDir } = options;
+  const { openapiFilePath, openapiSpecFilePath, enableEnhancement = true, serverDir } = options;
+  const routes = openapiSpecFilePath ? OPENAPI_ROUTES : OPENAPI_ROUTES.filter((route) => route.path !== "/openapi/spec");
   return {
     name: "openapi",
     mountPath: "/dev",
-    routes: OPENAPI_ROUTES,
+    routes,
     enabled: /* @__PURE__ */ __name((context) => context.isDev, "enabled"),
     createRouter: /* @__PURE__ */ __name((context) => {
       return createOpenapiRouter({
         openapiFilePath,
+        openapiSpecFilePath,
         enableEnhancement,
         serverDir
       }, context);
@@ -1719,8 +1972,8 @@ function hasSpecialPatterns(pattern) {
   return /[{*]/.test(pattern);
 }
 __name(hasSpecialPatterns, "hasSpecialPatterns");
-function normalizePathForMatching(path7) {
-  return path7.replace(/\/+/g, "/").replace(/\/+$/, "");
+function normalizePathForMatching(path8) {
+  return path8.replace(/\/+/g, "/").replace(/\/+$/, "");
 }
 __name(normalizePathForMatching, "normalizePathForMatching");
 
@@ -2068,8 +2321,8 @@ async function readRecentTraceCalls(filePath, page, pageSize, pathFilter, method
   const handleRequestCompleted = /* @__PURE__ */ __name((builder, entry, message) => {
     builder.hasCompleted = true;
     builder.endTime = entry.time;
-    builder.statusCode = extractNumber(message, /status_code:\s*(\d+)/);
-    builder.durationMs = extractNumber(message, /duration_ms:\s*(\d+)/);
+    builder.statusCode = typeof entry.status_code === "number" ? entry.status_code : extractNumber(message, /status_code:\s*(\d+)/);
+    builder.durationMs = typeof entry.duration_ms === "number" ? entry.duration_ms : extractNumber(message, /duration_ms:\s*(\d+)/);
     if (!builder.path && entry.path) {
       builder.path = String(entry.path);
     }
@@ -2269,7 +2522,7 @@ __name(readLogsBySource, "readLogsBySource");
 // src/middlewares/dev-logs/services/trigger.service.ts
 var import_node_fs9 = require("fs");
 var import_node_readline3 = require("readline");
-async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
+async function readTriggerList(filePath, trigger, path8, limit, triggerID) {
   if (!await fileExists(filePath)) {
     return void 0;
   }
@@ -2295,7 +2548,7 @@ async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
     if (alreadyAdded) {
       return false;
     }
-    const isAutomationTrigger = builder.path?.endsWith(path7);
+    const isAutomationTrigger = builder.path?.endsWith(path8);
     if (!isAutomationTrigger) {
       return false;
     }
@@ -2378,7 +2631,7 @@ async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
   };
 }
 __name(readTriggerList, "readTriggerList");
-async function readTriggerDetail(filePath, path7, instanceID) {
+async function readTriggerDetail(filePath, path8, instanceID) {
   const exists = await fileExists(filePath);
   if (!exists) {
     return void 0;
@@ -2394,7 +2647,7 @@ async function readTriggerDetail(filePath, path7, instanceID) {
   for await (const line of rl) {
     const entry = parseLogLine(line);
     if (!entry) continue;
-    const isAutomationTrigger = entry.path?.endsWith(path7);
+    const isAutomationTrigger = entry.path?.endsWith(path8);
     const hasInstanceID = entry.instance_id === instanceID && entry.trigger;
     if (!isAutomationTrigger || !hasInstanceID) continue;
     matches.push(entry);
@@ -2648,16 +2901,16 @@ function createGetTriggerListHandler(logDir) {
       });
     }
     const triggerID = typeof req.query.triggerID === "string" ? req.query.triggerID.trim() : void 0;
-    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path8 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     const limit = parseLimit(req.query.limit, 10, 200);
     try {
-      const result = await readTriggerList(traceLogPath, trigger, path7, limit, triggerID);
+      const result = await readTriggerList(traceLogPath, trigger, path8, limit, triggerID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
       res.json({
         file: getRelativePath(traceLogPath),
-        path: path7,
+        path: path8,
         ...result
       });
     } catch (error) {
@@ -2675,9 +2928,9 @@ function createGetTriggerDetailHandler(logDir) {
         message: "instanceID is required"
       });
     }
-    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path8 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     try {
-      const result = await readTriggerDetail(traceLogPath, path7, instanceID);
+      const result = await readTriggerDetail(traceLogPath, path8, instanceID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
@@ -2720,7 +2973,7 @@ __name(createGetCapabilityTraceListHandler, "createGetCapabilityTraceListHandler
 // src/middlewares/dev-logs/health.controller.ts
 var import_node_http = __toESM(require("http"), 1);
 function checkServiceHealth(host, port, timeout) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const startTime = Date.now();
     const req = import_node_http.default.request({
       hostname: host,
@@ -2730,20 +2983,20 @@ function checkServiceHealth(host, port, timeout) {
       timeout
     }, (_res) => {
       const responseTime = Date.now() - startTime;
-      resolve({
+      resolve2({
         available: true,
         responseTime
       });
     });
     req.on("timeout", () => {
       req.destroy();
-      resolve({
+      resolve2({
         available: false,
         error: "Request timeout"
       });
     });
     req.on("error", (err) => {
-      resolve({
+      resolve2({
         available: false,
         error: err.message
       });
@@ -2785,7 +3038,7 @@ function createHealthCheckHandler(options = {}) {
 __name(createHealthCheckHandler, "createHealthCheckHandler");
 
 // src/middlewares/dev-logs/sse/log-watcher.ts
-var fs8 = __toESM(require("fs"), 1);
+var fs9 = __toESM(require("fs"), 1);
 var path5 = __toESM(require("path"), 1);
 function mapPinoLevelToServerLogLevel2(pinoLevel) {
   if (typeof pinoLevel === "string") {
@@ -3004,12 +3257,12 @@ var LogWatcher = class {
   */
   watchFile(config) {
     const filePath = path5.join(this.logDir, config.fileName);
-    if (!fs8.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       this.log(`File not found, skipping: ${config.fileName}`);
       return;
     }
     try {
-      const stats = fs8.statSync(filePath);
+      const stats = fs9.statSync(filePath);
       this.filePositions.set(config.fileName, stats.size);
       this.log(`Initialized position for ${config.fileName}: ${stats.size} bytes`);
     } catch (error) {
@@ -3017,7 +3270,7 @@ var LogWatcher = class {
       this.filePositions.set(config.fileName, 0);
     }
     try {
-      const watcher = fs8.watch(filePath, (eventType) => {
+      const watcher = fs9.watch(filePath, (eventType) => {
         if (eventType === "change") {
           this.handleFileChange(config);
         }
@@ -3055,7 +3308,7 @@ var LogWatcher = class {
     const filePath = path5.join(this.logDir, config.fileName);
     const lastPosition = this.filePositions.get(config.fileName) || 0;
     try {
-      const stats = fs8.statSync(filePath);
+      const stats = fs9.statSync(filePath);
       const currentSize = stats.size;
       if (currentSize < lastPosition) {
         this.log(`File ${config.fileName} was truncated, resetting position`);
@@ -3068,11 +3321,11 @@ var LogWatcher = class {
       }
       const readSize = currentSize - lastPosition;
       const buffer = Buffer.alloc(readSize);
-      const fd = fs8.openSync(filePath, "r");
+      const fd = fs9.openSync(filePath, "r");
       try {
-        fs8.readSync(fd, buffer, 0, readSize, lastPosition);
+        fs9.readSync(fd, buffer, 0, readSize, lastPosition);
       } finally {
-        fs8.closeSync(fd);
+        fs9.closeSync(fd);
       }
       this.filePositions.set(config.fileName, currentSize);
       const content = buffer.toString("utf8");
@@ -3303,8 +3556,8 @@ __name(createSSEHandler, "createSSEHandler");
 
 // src/middlewares/dev-logs/api-list-handler.ts
 var SERVER_PORT = process.env.SERVER_PORT || "3000";
-function extractModuleFromPath(path7) {
-  const segments = path7.split("/").filter(Boolean);
+function extractModuleFromPath(path8) {
+  const segments = path8.split("/").filter(Boolean);
   let startIndex = 0;
   if (segments[0] === "api") {
     startIndex = 1;
@@ -3319,8 +3572,8 @@ function extractModuleFromPath(path7) {
   return moduleName;
 }
 __name(extractModuleFromPath, "extractModuleFromPath");
-function generateRouteId(method, path7) {
-  const cleanPath = path7.replace(/[/:]/g, "_").replace(/^_+|_+$/g, "");
+function generateRouteId(method, path8) {
+  const cleanPath = path8.replace(/[/:]/g, "_").replace(/^_+|_+$/g, "");
   return `${method.toLowerCase()}_${cleanPath}`;
 }
 __name(generateRouteId, "generateRouteId");
@@ -3571,7 +3824,7 @@ function handleError2(res, error, message = "Failed to collect logs") {
 __name(handleError2, "handleError");
 
 // src/middlewares/collect-logs/router.ts
-var DEFAULT_BODY_SIZE_LIMIT = "1mb";
+var DEFAULT_BODY_SIZE_LIMIT = "20mb";
 function getBodySizeLimit() {
   return process.env.BODY_SIZE_LIMIT || DEFAULT_BODY_SIZE_LIMIT;
 }
@@ -3794,18 +4047,201 @@ async function registerMiddlewares(server, middlewares, options) {
   }
 }
 __name(registerMiddlewares, "registerMiddlewares");
+
+// src/route-parser.ts
+var fs12 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+var crypto3 = __toESM(require("crypto"), 1);
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var t = __toESM(require("@babel/types"), 1);
+var traverse = typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.default;
+function routeParserLog(level, message, ...args) {
+  const prefix = "[route-parser]";
+  const logMessage = `${prefix} ${message}`;
+  switch (level) {
+    case "warn":
+      console.warn(logMessage, ...args);
+      break;
+    case "error":
+      console.error(logMessage, ...args);
+      break;
+    case "info":
+      console.info(logMessage, ...args);
+      break;
+    default:
+      console.log(logMessage, ...args);
+  }
+}
+__name(routeParserLog, "routeParserLog");
+function calculateFileHash(filePath) {
+  try {
+    const content = fs12.readFileSync(filePath, "utf-8");
+    return crypto3.createHash("md5").update(content).digest("hex");
+  } catch (error) {
+    routeParserLog("warn", "Failed to calculate file hash:", error.message);
+    return null;
+  }
+}
+__name(calculateFileHash, "calculateFileHash");
+function isRouteComponent(openingElement) {
+  return t.isJSXIdentifier(openingElement.name) && openingElement.name.name === "Route";
+}
+__name(isRouteComponent, "isRouteComponent");
+function evaluateTemplateLiteral(templateLiteral) {
+  const quasis = templateLiteral.quasis;
+  const expressions = templateLiteral.expressions;
+  if (quasis.length === 1 && expressions.length === 0) {
+    return quasis[0].value.raw;
+  }
+  return quasis.map((q) => q.value.raw).join("");
+}
+__name(evaluateTemplateLiteral, "evaluateTemplateLiteral");
+function extractPageRouteInfo(openingElement) {
+  const routeInfo = {};
+  openingElement.attributes.forEach((attr) => {
+    if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+      const name = attr.name.name;
+      let value;
+      if (attr.value) {
+        if (t.isStringLiteral(attr.value)) {
+          value = attr.value.value;
+        } else if (t.isJSXExpressionContainer(attr.value)) {
+          const expression = attr.value.expression;
+          if (t.isStringLiteral(expression)) {
+            value = expression.value;
+          } else if (t.isTemplateLiteral(expression)) {
+            value = evaluateTemplateLiteral(expression);
+          } else {
+            value = true;
+          }
+        }
+      } else {
+        value = true;
+      }
+      routeInfo[name] = value;
+    }
+  });
+  return routeInfo;
+}
+__name(extractPageRouteInfo, "extractPageRouteInfo");
+function buildFullPath(routeStack, currentRoute) {
+  let fullPath = "";
+  for (let i = 0; i < routeStack.length; i++) {
+    if (routeStack[i].path) {
+      let parentPath = routeStack[i].path;
+      if (!parentPath.startsWith("/")) parentPath = `/${parentPath}`;
+      if (parentPath.endsWith("/") && parentPath !== "/") {
+        parentPath = parentPath.slice(0, -1);
+      }
+      fullPath += parentPath === "/" ? "" : parentPath;
+    }
+  }
+  if (currentRoute.index) {
+    return fullPath || "/";
+  } else if (currentRoute.path) {
+    const routePath = currentRoute.path;
+    if (routePath === "*") {
+      return null;
+    }
+    if (!routePath.startsWith("/")) {
+      fullPath = `${fullPath}/${routePath}`;
+    } else {
+      fullPath = routePath;
+    }
+    if (fullPath === "") fullPath = "/";
+    if (!fullPath.startsWith("/")) fullPath = `/${fullPath}`;
+    return fullPath;
+  }
+  return null;
+}
+__name(buildFullPath, "buildFullPath");
+function parseRoutesFromFile(appPath, basePath, options = {}) {
+  const { applyBasePath = true } = options;
+  const defaultPath = applyBasePath && basePath ? `${basePath}/` : "/";
+  try {
+    const appFilePath = path7.resolve(process.cwd(), appPath);
+    if (!fs12.existsSync(appFilePath)) {
+      throw new Error(`App file does not exist: ${appFilePath}`);
+    }
+    const sourceCode = fs12.readFileSync(appFilePath, "utf-8");
+    const ast = (0, import_parser.parse)(sourceCode, {
+      sourceType: "module",
+      plugins: [
+        "jsx",
+        "typescript",
+        "decorators-legacy",
+        "classProperties",
+        "objectRestSpread",
+        "functionBind",
+        "exportDefaultFrom",
+        "exportNamespaceFrom",
+        "dynamicImport",
+        "nullishCoalescingOperator",
+        "optionalChaining"
+      ]
+    });
+    const routeSet = /* @__PURE__ */ new Set();
+    const routeStack = [];
+    traverse(ast, {
+      JSXElement: {
+        enter(nodePath) {
+          const { openingElement } = nodePath.node;
+          if (isRouteComponent(openingElement)) {
+            routeStack.push(extractPageRouteInfo(openingElement));
+          }
+        },
+        exit(nodePath) {
+          const { openingElement } = nodePath.node;
+          if (isRouteComponent(openingElement)) {
+            const currentRoute = routeStack.pop();
+            if (currentRoute && currentRoute.path === "*") return;
+            if (currentRoute && (currentRoute.path || currentRoute.index)) {
+              const fullPath = buildFullPath(routeStack, currentRoute);
+              if (fullPath) routeSet.add(fullPath);
+            }
+          }
+        }
+      }
+    });
+    const routes = Array.from(routeSet).map((routePath) => ({
+      path: applyBasePath && basePath ? `${basePath}${routePath}` : routePath
+    }));
+    return routes.length > 0 ? routes : [
+      {
+        path: defaultPath
+      }
+    ];
+  } catch (error) {
+    routeParserLog("warn", "Route parsing failed, using default routes:", error.message);
+    return [
+      {
+        path: defaultPath
+      }
+    ];
+  }
+}
+__name(parseRoutesFromFile, "parseRoutesFromFile");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildFullPath,
+  calculateFileHash,
   createCollectLogsMiddleware,
   createDevLogsMiddleware,
   createOpenapiMiddleware,
+  evaluateTemplateLiteral,
+  extractPageRouteInfo,
   getQuery,
   getQueryParam,
   handleDevProxyError,
+  isRouteComponent,
   normalizeBasePath,
   parseAndGenerateNestResourceTemplate,
+  parseApiRoutes,
+  parseRoutesFromFile,
   postprocessDrizzleSchema,
   registerMiddlewares,
+  routeParserLog,
   sendError,
   sendJson,
   sendSuccess