@lark-apaas/devtool-kits 1.2.17 → 1.2.19

package/dist/index.js

@@ -1894,8 +1894,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
@@ -2799,8 +2801,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
@@ -3251,6 +3255,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);
@@ -3264,6 +3368,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");
@@ -3299,6 +3404,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 = {}) {
@@ -3415,11 +3525,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 = express3.Router();
-  router.post("/collect", express3.json(), collectLogsHandler(logDir, options.fileName || "client.log"));
-  router.post("/collect-batch", express3.json(), collectLogsBatchHandler(logDir, options.fileName || "client.log"));
+  const bodyLimit = getBodySizeLimit();
+  router.post("/collect", express3.json({
+    limit: bodyLimit
+  }), collectLogsHandler(logDir, options.fileName || "client.log"));
+  router.post("/collect-batch", express3.json({
+    limit: bodyLimit
+  }), collectLogsBatchHandler(logDir, options.fileName || "client.log"));
   return router;
 }
 __name(createDevLogRouter2, "createDevLogRouter");