@lark-apaas/devtool-kits 1.2.17-alpha.3 → 1.2.17-alpha.30

package/dist/index.cjs

@@ -39,6 +39,7 @@ __export(index_exports, {
   handleDevProxyError: () => handleDevProxyError,
   normalizeBasePath: () => normalizeBasePath,
   parseAndGenerateNestResourceTemplate: () => parseAndGenerateNestResourceTemplate,
+  parseApiRoutes: () => parseApiRoutes,
   postprocessDrizzleSchema: () => postprocessDrizzleSchema,
   registerMiddlewares: () => registerMiddlewares,
   sendError: () => sendError,
@@ -1386,6 +1387,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 +1610,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) {
@@ -1940,8 +2056,10 @@ function parsePinoLog(line, source) {
         statusCode: pinoLog.status_code,
         durationMs: pinoLog.duration_ms,
         ip: pinoLog.ip,
+        pageRoute: pinoLog.page_route,
         requestBody: pinoLog.request_body,
-        responseBody: pinoLog.response_body
+        responseBody: pinoLog.response_body,
+        queryParams: pinoLog.query_params
       },
       tags: [
         source
@@ -2845,8 +2963,10 @@ function parsePinoLog2(line, source) {
         statusCode: pinoLog.status_code,
         durationMs: pinoLog.duration_ms,
         ip: pinoLog.ip,
+        pageRoute: pinoLog.page_route,
         requestBody: pinoLog.request_body,
-        responseBody: pinoLog.response_body
+        responseBody: pinoLog.response_body,
+        queryParams: pinoLog.query_params
       },
       tags: [
         source
@@ -3297,6 +3417,106 @@ function createSSEHandler(logDir, options = {}) {
 }
 __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);
+  let startIndex = 0;
+  if (segments[0] === "api") {
+    startIndex = 1;
+  }
+  if (segments[startIndex]?.match(/^v\d+$/)) {
+    startIndex++;
+  }
+  const moduleName = segments[startIndex];
+  if (!moduleName || moduleName.startsWith(":")) {
+    return "default";
+  }
+  return moduleName;
+}
+__name(extractModuleFromPath, "extractModuleFromPath");
+function generateRouteId(method, path7) {
+  const cleanPath = path7.replace(/[/:]/g, "_").replace(/^_+|_+$/g, "");
+  return `${method.toLowerCase()}_${cleanPath}`;
+}
+__name(generateRouteId, "generateRouteId");
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+__name(capitalize, "capitalize");
+function groupRoutesByModule(routes) {
+  const groupMap = /* @__PURE__ */ new Map();
+  routes.forEach((route) => {
+    const existing = groupMap.get(route.module) || [];
+    existing.push(route);
+    groupMap.set(route.module, existing);
+  });
+  const groups = [];
+  groupMap.forEach((apis, moduleName) => {
+    groups.push({
+      id: moduleName,
+      name: capitalize(moduleName),
+      apis: apis.sort((a, b) => a.path.localeCompare(b.path))
+    });
+  });
+  return groups.sort((a, b) => a.name.localeCompare(b.name));
+}
+__name(groupRoutesByModule, "groupRoutesByModule");
+async function fetchRoutesFromBackend(basePath) {
+  const normalizedBasePath = basePath.replace(/\/+$/, "");
+  const url = `http://localhost:${SERVER_PORT}${normalizedBasePath}/api/__framework__/debug`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Accept": "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch routes: ${response.status}`);
+  }
+  const data = await response.json();
+  const routeConfig = data["\u8DEF\u7531\u914D\u7F6E"];
+  if (!routeConfig || !routeConfig.routes || !Array.isArray(routeConfig.routes)) {
+    console.warn("[api-list] Invalid routes data:", routeConfig);
+    return [];
+  }
+  const debugRoutes = routeConfig.routes;
+  return debugRoutes.filter((route) => {
+    return route.path.includes("/api/") && !route.path.includes("__framework__") && !route.path.includes("__innerapi__") && !route.path.includes("/api/capability");
+  }).map((route) => {
+    const apiPathMatch = route.path.match(/\/api\/.*/);
+    const apiPath = apiPathMatch ? apiPathMatch[0] : route.path;
+    const method = route.method || "ALL";
+    return {
+      id: generateRouteId(method, apiPath),
+      path: apiPath,
+      method,
+      module: extractModuleFromPath(apiPath)
+    };
+  });
+}
+__name(fetchRoutesFromBackend, "fetchRoutesFromBackend");
+function createApiListHandler() {
+  return async (_req, res) => {
+    try {
+      const basePath = process.env.CLIENT_BASE_PATH || "";
+      const routes = await fetchRoutesFromBackend(basePath);
+      const groups = groupRoutesByModule(routes);
+      res.json({
+        groups,
+        total: routes.length
+      });
+    } catch (error) {
+      console.error("[api-list] Failed to fetch routes:", error);
+      res.status(500).json({
+        error: "Failed to fetch routes",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  };
+}
+__name(createApiListHandler, "createApiListHandler");
+
 // src/middlewares/dev-logs/router.ts
 function createDevLogRouter(options = {}) {
   const logDir = resolveLogDir(options.logDir);
@@ -3310,6 +3530,7 @@ function createDevLogRouter(options = {}) {
   router.get("/trace/trigger/:instanceID", createGetTriggerDetailHandler(logDir));
   router.get("/trace/capability/list", createGetCapabilityTraceListHandler(logDir));
   router.get("/health", createHealthCheckHandler());
+  router.get("/api-list", createApiListHandler());
   return router;
 }
 __name(createDevLogRouter, "createDevLogRouter");
@@ -3345,6 +3566,11 @@ var DEV_LOGS_ROUTES = [
     method: "GET",
     path: "/trace/trigger/:instanceID",
     description: "Get trigger detail (automation trigger) in trace.log by instanceID"
+  },
+  {
+    method: "GET",
+    path: "/api-list",
+    description: "Get all API routes grouped by module"
   }
 ];
 function createDevLogsMiddleware(options = {}) {
@@ -3461,11 +3687,21 @@ function handleError2(res, error, message = "Failed to collect logs") {
 __name(handleError2, "handleError");
 
 // src/middlewares/collect-logs/router.ts
+var DEFAULT_BODY_SIZE_LIMIT = "1mb";
+function getBodySizeLimit() {
+  return process.env.BODY_SIZE_LIMIT || DEFAULT_BODY_SIZE_LIMIT;
+}
+__name(getBodySizeLimit, "getBodySizeLimit");
 function createDevLogRouter2(options = {}) {
   const logDir = resolveLogDir2(options.logDir);
   const router = import_express3.default.Router();
-  router.post("/collect", import_express3.default.json(), collectLogsHandler(logDir, options.fileName || "client.log"));
-  router.post("/collect-batch", import_express3.default.json(), collectLogsBatchHandler(logDir, options.fileName || "client.log"));
+  const bodyLimit = getBodySizeLimit();
+  router.post("/collect", import_express3.default.json({
+    limit: bodyLimit
+  }), collectLogsHandler(logDir, options.fileName || "client.log"));
+  router.post("/collect-batch", import_express3.default.json({
+    limit: bodyLimit
+  }), collectLogsBatchHandler(logDir, options.fileName || "client.log"));
   return router;
 }
 __name(createDevLogRouter2, "createDevLogRouter");
@@ -3684,6 +3920,7 @@ __name(registerMiddlewares, "registerMiddlewares");
   handleDevProxyError,
   normalizeBasePath,
   parseAndGenerateNestResourceTemplate,
+  parseApiRoutes,
   postprocessDrizzleSchema,
   registerMiddlewares,
   sendError,