@lark-apaas/devtool-kits 1.2.17-alpha.17 → 1.2.17-alpha.18

package/README.md

@@ -92,6 +92,17 @@ import {
 } from '@apaas/fullstack-toolkits';
 ```
 
+### 兼容工具函数 (Compat)
+```typescript
+import {
+  sendJson,         // 发送 JSON 响应（兼容 Express/Connect）
+  sendError,        // 发送错误响应
+  sendSuccess,      // 发送成功响应
+  getQuery,         // 获取所有查询参数
+  getQueryParam,    // 获取单个查询参数
+} from '@apaas/fullstack-toolkits';
+```
+
 ### 类型定义 (Types)
 ```typescript
 import type {
@@ -171,6 +182,38 @@ export default {
 - 全局中间件应放在路由中间件之前
 - 路由中间件仅处理匹配其挂载路径的请求
 
+### Vite/Connect 兼容性
+
+本工具包原生支持 Vite 开发服务器。`registerMiddlewares` 会自动检测 Vite/Connect 环境，并添加必要的 Express API 兼容层：
+
+- `res.status()` - 设置响应状态码
+- `res.json()` - 发送 JSON 响应
+- `res.send()` - 发送响应
+- `req.query` - 解析后的查询参数
+
+这意味着您可以直接在 Vite 中使用本工具包，无需额外配置。
+
+**兼容工具函数（可选）：**
+
+如果您正在编写自定义中间件并希望同时支持 Express 和 Vite，可以使用导出的兼容工具函数：
+
+```typescript
+import { sendJson, sendError, sendSuccess, getQuery, getQueryParam } from '@lark-apaas/devtool-kits';
+
+// 发送 JSON 响应（自动检测 Express/Connect）
+sendJson(res, { data: 'value' }, 200);
+
+// 发送错误响应
+sendError(res, 'Not found', error, 404);
+
+// 发送成功响应
+sendSuccess(res, { id: 123 });
+
+// 获取查询参数（自动解析 URL 或使用 req.query）
+const query = getQuery(req);
+const page = getQueryParam(req, 'page');
+```
+
 ## 中间件详细说明
 ### Dev Logs 中间件
 

package/dist/index.cjs

@@ -31,15 +31,19 @@ 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,
+  getQuery: () => getQuery,
+  getQueryParam: () => getQueryParam,
   handleDevProxyError: () => handleDevProxyError,
   normalizeBasePath: () => normalizeBasePath,
   parseAndGenerateNestResourceTemplate: () => parseAndGenerateNestResourceTemplate,
   postprocessDrizzleSchema: () => postprocessDrizzleSchema,
-  registerMiddlewares: () => registerMiddlewares
+  registerMiddlewares: () => registerMiddlewares,
+  sendError: () => sendError,
+  sendJson: () => sendJson,
+  sendSuccess: () => sendSuccess
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1647,7 +1651,7 @@ function createOpenapiRouter(options, context) {
   const { openapiFilePath, enableEnhancement, serverDir } = options;
   const router = import_express.default.Router();
   const handler = createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir);
-  router.get("/", (req, res) => handler(req, res, context));
+  router.get("/openapi.json", (req, res) => handler(req, res, context));
   return router;
 }
 __name(createOpenapiRouter, "createOpenapiRouter");
@@ -1656,7 +1660,7 @@ __name(createOpenapiRouter, "createOpenapiRouter");
 var OPENAPI_ROUTES = [
   {
     method: "GET",
-    path: "/",
+    path: "/openapi.json",
     description: "Serve enhanced OpenAPI specification with source code references"
   }
 ];
@@ -1664,7 +1668,7 @@ function createOpenapiMiddleware(options) {
   const { openapiFilePath, enableEnhancement = true, serverDir } = options;
   return {
     name: "openapi",
-    mountPath: "/dev/openapi.json",
+    mountPath: "/dev",
     routes: OPENAPI_ROUTES,
     enabled: /* @__PURE__ */ __name((context) => context.isDev, "enabled"),
     createRouter: /* @__PURE__ */ __name((context) => {
@@ -1936,10 +1940,8 @@ 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,
-        queryParams: pinoLog.query_params
+        responseBody: pinoLog.response_body
       },
       tags: [
         source
@@ -2844,8 +2846,7 @@ function parsePinoLog2(line, source) {
         durationMs: pinoLog.duration_ms,
         ip: pinoLog.ip,
         requestBody: pinoLog.request_body,
-        responseBody: pinoLog.response_body,
-        queryParams: pinoLog.query_params
+        responseBody: pinoLog.response_body
       },
       tags: [
         source
@@ -3296,108 +3297,6 @@ 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) {
-    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);
@@ -3411,7 +3310,6 @@ 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");
@@ -3447,11 +3345,6 @@ 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 = {}) {
@@ -3602,148 +3495,100 @@ function createCollectLogsMiddleware(options = {}) {
 }
 __name(createCollectLogsMiddleware, "createCollectLogsMiddleware");
 
-// 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 [];
+// src/middlewares/compat.ts
+function sendJson(res, data, statusCode = 200) {
+  const statusFn = res.status;
+  const jsonFn = res.json;
+  if (typeof statusFn === "function" && typeof jsonFn === "function") {
+    statusFn.call(res, statusCode);
+    jsonFn.call(res, data);
+  } else {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(data));
   }
-  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"
+__name(sendJson, "sendJson");
+function sendError(res, message, error, statusCode = 500) {
+  const errorData = {
+    message,
+    ...error ? {
+      error: serializeError3(error)
+    } : {}
+  };
+  sendJson(res, errorData, statusCode);
+}
+__name(sendError, "sendError");
+function sendSuccess(res, data) {
+  sendJson(res, {
+    success: true,
+    ...data
+  }, 200);
+}
+__name(sendSuccess, "sendSuccess");
+function getQuery(req) {
+  if (req.query) {
+    return req.query;
+  }
+  const url = new URL(req.url || "", `http://${req.headers.host}`);
+  return Object.fromEntries(url.searchParams.entries());
+}
+__name(getQuery, "getQuery");
+function getQueryParam(req, key) {
+  const query = getQuery(req);
+  return query[key];
+}
+__name(getQueryParam, "getQueryParam");
+function serializeError3(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
   }
-];
-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")
+    message: String(error)
   };
 }
-__name(createApiRoutesMiddleware, "createApiRoutesMiddleware");
+__name(serializeError3, "serializeError");
 
 // src/middlewares/index.ts
+function enhanceForCompat(req, res) {
+  if (!res.status) {
+    res.status = function(code) {
+      res.statusCode = code;
+      return res;
+    };
+  }
+  if (!res.json) {
+    res.json = function(data) {
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify(data));
+      return res;
+    };
+  }
+  if (!res.send) {
+    res.send = function(data) {
+      if (typeof data === "object" && data !== null) {
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify(data));
+      } else {
+        res.end(String(data));
+      }
+      return res;
+    };
+  }
+  if (!req.query) {
+    const url = new URL(req.url || "", `http://${req.headers.host || "localhost"}`);
+    req.query = Object.fromEntries(url.searchParams.entries());
+  }
+}
+__name(enhanceForCompat, "enhanceForCompat");
+function isConnectServer(server) {
+  return typeof server === "function" && !("set" in server) && !("engine" in server);
+}
+__name(isConnectServer, "isConnectServer");
 function isRouteMiddleware(middleware) {
   return "createRouter" in middleware && middleware.createRouter !== void 0;
 }
@@ -3796,6 +3641,13 @@ async function registerMiddlewares(server, middlewares, options) {
     rootDir: process.cwd(),
     ...options
   };
+  if (isConnectServer(server)) {
+    server.use((req, res, next) => {
+      enhanceForCompat(req, res);
+      next();
+    });
+    console.log("[Middleware] Registered Express compatibility layer for Connect/Vite");
+  }
   const allMiddlewares = [
     ...middlewares
   ];
@@ -3824,14 +3676,18 @@ 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,
+  getQuery,
+  getQueryParam,
   handleDevProxyError,
   normalizeBasePath,
   parseAndGenerateNestResourceTemplate,
   postprocessDrizzleSchema,
-  registerMiddlewares
+  registerMiddlewares,
+  sendError,
+  sendJson,
+  sendSuccess
 });
 //# sourceMappingURL=index.cjs.map