@lark-apaas/devtool-kits 1.2.17-alpha.8 → 1.2.17

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);
 
@@ -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
@@ -3494,151 +3495,100 @@ function createCollectLogsMiddleware(options = {}) {
 }
 __name(createCollectLogsMiddleware, "createCollectLogsMiddleware");
 
-// src/middlewares/api-routes/router.ts
-var import_express4 = __toESM(require("express"), 1);
-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 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: generateRouteId(upperMethod, apiPath),
-          path: apiPath,
-          method: upperMethod,
-          module: extractModuleFromPath(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 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");
-function createApiRoutesRouter() {
-  const router = import_express4.default.Router();
-  router.use((_req, res, next) => {
-    res.header("Access-Control-Allow-Origin", "*");
-    res.header("Access-Control-Allow-Methods", "GET, OPTIONS");
-    res.header("Access-Control-Allow-Headers", "Content-Type, Accept");
-    next();
-  });
-  router.options("/", (_req, res) => {
-    res.status(204).end();
-  });
-  router.get("/", (req, res) => {
-    try {
-      const routes = extractRoutes(req.app);
-      const groups = groupRoutesByModule(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: "/",
-    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",
-    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;
 }
@@ -3691,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
   ];
@@ -3719,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