@lark-apaas/devtool-kits 1.2.17-alpha.22 → 1.2.17-alpha.23

package/dist/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  createApiRoutesMiddleware: () => createApiRoutesMiddleware,
   createCollectLogsMiddleware: () => createCollectLogsMiddleware,
   createDevLogsMiddleware: () => createDevLogsMiddleware,
   createOpenapiMiddleware: () => createOpenapiMiddleware,
@@ -1651,7 +1652,7 @@ function createOpenapiRouter(options, context) {
   const { openapiFilePath, 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));
+  router.get("/", (req, res) => handler(req, res, context));
   return router;
 }
 __name(createOpenapiRouter, "createOpenapiRouter");
@@ -1660,7 +1661,7 @@ __name(createOpenapiRouter, "createOpenapiRouter");
 var OPENAPI_ROUTES = [
   {
     method: "GET",
-    path: "/openapi.json",
+    path: "/",
     description: "Serve enhanced OpenAPI specification with source code references"
   }
 ];
@@ -1668,7 +1669,7 @@ function createOpenapiMiddleware(options) {
   const { openapiFilePath, enableEnhancement = true, serverDir } = options;
   return {
     name: "openapi",
-    mountPath: "/dev",
+    mountPath: "/dev/openapi.json",
     routes: OPENAPI_ROUTES,
     enabled: /* @__PURE__ */ __name((context) => context.isDev, "enabled"),
     createRouter: /* @__PURE__ */ __name((context) => {
@@ -1940,8 +1941,10 @@ function parsePinoLog(line, source) {
         statusCode: pinoLog.status_code,
         durationMs: pinoLog.duration_ms,
         ip: pinoLog.ip,
+        referer: pinoLog.referer,
         requestBody: pinoLog.request_body,
-        responseBody: pinoLog.response_body
+        responseBody: pinoLog.response_body,
+        queryParams: pinoLog.query_params
       },
       tags: [
         source
@@ -2846,7 +2849,8 @@ function parsePinoLog2(line, source) {
         durationMs: pinoLog.duration_ms,
         ip: pinoLog.ip,
         requestBody: pinoLog.request_body,
-        responseBody: pinoLog.response_body
+        responseBody: pinoLog.response_body,
+        queryParams: pinoLog.query_params
       },
       tags: [
         source
@@ -3297,6 +3301,109 @@ 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) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type, Accept");
+    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 +3417,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 +3453,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 = {}) {
@@ -3464,12 +3577,8 @@ __name(handleError2, "handleError");
 function createDevLogRouter2(options = {}) {
   const logDir = resolveLogDir2(options.logDir);
   const router = import_express3.default.Router();
-  router.post("/collect", import_express3.default.json({
-    limit: "50mb"
-  }), collectLogsHandler(logDir, options.fileName || "client.log"));
-  router.post("/collect-batch", import_express3.default.json({
-    limit: "50mb"
-  }), collectLogsBatchHandler(logDir, options.fileName || "client.log"));
+  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"));
   return router;
 }
 __name(createDevLogRouter2, "createDevLogRouter");
@@ -3557,6 +3666,147 @@ function serializeError3(error) {
 }
 __name(serializeError3, "serializeError");
 
+// src/middlewares/api-routes/router.ts
+var import_express4 = __toESM(require("express"), 1);
+function extractModuleFromPath2(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(extractModuleFromPath2, "extractModuleFromPath");
+function generateRouteId2(method, path7) {
+  const cleanPath = path7.replace(/[/:]/g, "_").replace(/^_+|_+$/g, "");
+  return `${method.toLowerCase()}_${cleanPath}`;
+}
+__name(generateRouteId2, "generateRouteId");
+function capitalize2(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+__name(capitalize2, "capitalize");
+function extractRoutes(app) {
+  const router = app._router;
+  if (!router?.stack) {
+    return [];
+  }
+  const routes = [];
+  const seenRoutes = /* @__PURE__ */ new Set();
+  const processLayer = /* @__PURE__ */ __name((layer, basePath = "") => {
+    if (layer.route) {
+      const path7 = basePath + layer.route.path;
+      if (!path7.includes("/api/") || path7.includes("__framework__") || path7.includes("__innerapi__")) {
+        return;
+      }
+      const methods = Object.keys(layer.route.methods).filter((m) => layer.route.methods[m]);
+      methods.forEach((method) => {
+        const upperMethod = method.toUpperCase();
+        const routeKey = `${upperMethod}:${path7}`;
+        if (seenRoutes.has(routeKey)) {
+          return;
+        }
+        seenRoutes.add(routeKey);
+        const apiPathMatch = path7.match(/\/api\/.*/);
+        const apiPath = apiPathMatch ? apiPathMatch[0] : path7;
+        routes.push({
+          id: generateRouteId2(upperMethod, apiPath),
+          path: apiPath,
+          method: upperMethod,
+          module: extractModuleFromPath2(apiPath)
+        });
+      });
+    }
+    if (layer.name === "router" && layer.handle?.stack) {
+      let prefix = basePath;
+      if (layer.regexp) {
+        const pattern = new RegExp("^\\^\\\\?(.*?)(?:\\\\/\\?|$)");
+        const match = layer.regexp.source.match(pattern);
+        if (match) {
+          prefix = basePath + match[1].replace(/\\\//g, "/");
+        }
+      }
+      layer.handle.stack.forEach((subLayer) => processLayer(subLayer, prefix));
+    }
+  }, "processLayer");
+  router.stack.forEach((layer) => processLayer(layer));
+  return routes;
+}
+__name(extractRoutes, "extractRoutes");
+function groupRoutesByModule2(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: capitalize2(moduleName),
+      apis: apis.sort((a, b) => a.path.localeCompare(b.path))
+    });
+  });
+  return groups.sort((a, b) => a.name.localeCompare(b.name));
+}
+__name(groupRoutesByModule2, "groupRoutesByModule");
+function createApiRoutesRouter() {
+  console.log("[api-routes] createApiRoutesRouter called");
+  const router = import_express4.default.Router();
+  console.log("[api-routes] router created, adding /api-list route");
+  router.get("/api-list", (req, res) => {
+    console.log("[api-routes] /api-list handler called");
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type, Accept");
+    try {
+      const routes = extractRoutes(req.app);
+      const groups = groupRoutesByModule2(routes);
+      res.json({
+        groups,
+        total: routes.length
+      });
+    } catch (error) {
+      console.error("[api-routes] Failed to extract routes:", error);
+      res.status(500).json({
+        error: "Failed to extract routes",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  return router;
+}
+__name(createApiRoutesRouter, "createApiRoutesRouter");
+
+// src/middlewares/api-routes/index.ts
+var API_ROUTES_ROUTES = [
+  {
+    method: "GET",
+    path: "/api-list",
+    description: "Get all API routes grouped by module"
+  }
+];
+function createApiRoutesMiddleware() {
+  return {
+    name: "api-routes",
+    mountPath: "/dev/api",
+    routes: API_ROUTES_ROUTES,
+    enabled: /* @__PURE__ */ __name((context) => context.isDev, "enabled"),
+    createRouter: /* @__PURE__ */ __name((_context) => {
+      return createApiRoutesRouter();
+    }, "createRouter")
+  };
+}
+__name(createApiRoutesMiddleware, "createApiRoutesMiddleware");
+
 // src/middlewares/index.ts
 function enhanceForCompat(req, res) {
   if (!res.status) {
@@ -3680,6 +3930,7 @@ async function registerMiddlewares(server, middlewares, options) {
 __name(registerMiddlewares, "registerMiddlewares");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createApiRoutesMiddleware,
   createCollectLogsMiddleware,
   createDevLogsMiddleware,
   createOpenapiMiddleware,