@lark-apaas/devtool-kits 1.2.20 → 1.2.21

package/dist/index.cjs

@@ -1769,12 +1769,135 @@ function createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir) {
 }
 __name(createOpenapiHandler, "createOpenapiHandler");
 
+// src/middlewares/openapi/spec-controller.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_crypto2 = __toESM(require("crypto"), 1);
+var MAX_REF_DEPTH = 5;
+function createOpenapiSpecHandler(openapiSpecFilePath) {
+  let cache = null;
+  return async (_req, res, context) => {
+    try {
+      const fileBuffer = await import_promises3.default.readFile(openapiSpecFilePath, "utf-8");
+      const currentHash = import_node_crypto2.default.createHash("md5").update(fileBuffer).digest("hex");
+      if (cache && cache.fileHash === currentHash) {
+        return res.json(cache.data);
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(fileBuffer);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Invalid JSON";
+        return res.status(500).json({
+          error: "Failed to load OpenAPI spec",
+          message: `${openapiSpecFilePath} invalid: ${message}`
+        });
+      }
+      if (!parsed || typeof parsed !== "object" || !parsed.paths || typeof parsed.paths !== "object") {
+        return res.status(500).json({
+          error: "Failed to load OpenAPI spec",
+          message: `${openapiSpecFilePath} missing "paths"`
+        });
+      }
+      const result = buildFilteredSpec(parsed, context.basePath ?? "");
+      cache = {
+        data: result,
+        fileHash: currentHash
+      };
+      res.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      res.status(500).json({
+        error: "Failed to load OpenAPI spec",
+        message
+      });
+    }
+  };
+}
+__name(createOpenapiSpecHandler, "createOpenapiSpecHandler");
+function buildFilteredSpec(spec, globalPrefix) {
+  const schemas = spec.components?.schemas ?? {};
+  const paths = spec.paths ?? {};
+  const filteredPaths = {};
+  const cleanPrefix = globalPrefix.replace(/\/+$/, "");
+  for (const [pathKey, methods] of Object.entries(paths)) {
+    const cleanPath = stripPrefix(pathKey, cleanPrefix);
+    if (!cleanPath.startsWith("/openapi")) continue;
+    filteredPaths[cleanPath] = {};
+    for (const [method, operation] of Object.entries(methods)) {
+      if ([
+        "parameters",
+        "summary",
+        "description",
+        "servers"
+      ].includes(method)) continue;
+      filteredPaths[cleanPath][method] = resolveRefsDeep(structuredClone(operation), schemas);
+    }
+  }
+  return {
+    openapi: spec.openapi ?? "3.0.0",
+    paths: filteredPaths,
+    components: {
+      schemas: resolveAllSchemaRefs(structuredClone(schemas))
+    }
+  };
+}
+__name(buildFilteredSpec, "buildFilteredSpec");
+function stripPrefix(pathStr, prefix) {
+  if (prefix && pathStr.startsWith(prefix)) {
+    return pathStr.slice(prefix.length);
+  }
+  return pathStr;
+}
+__name(stripPrefix, "stripPrefix");
+function resolveRefsDeep(obj, schemas, depth = 0) {
+  if (depth > MAX_REF_DEPTH || obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolveRefsDeep(item, schemas, depth));
+  }
+  const record = obj;
+  if (typeof record["$ref"] === "string") {
+    const resolved = resolveRef(record["$ref"], schemas);
+    if (resolved !== void 0) {
+      return resolveRefsDeep(structuredClone(resolved), schemas, depth + 1);
+    }
+    return record;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    result[key] = resolveRefsDeep(value, schemas, depth);
+  }
+  return result;
+}
+__name(resolveRefsDeep, "resolveRefsDeep");
+function resolveRef(ref, schemas) {
+  const prefix = "#/components/schemas/";
+  if (ref.startsWith(prefix)) {
+    const name = ref.slice(prefix.length);
+    return schemas[name];
+  }
+  return void 0;
+}
+__name(resolveRef, "resolveRef");
+function resolveAllSchemaRefs(schemas) {
+  const result = {};
+  for (const [name, schema] of Object.entries(schemas)) {
+    result[name] = resolveRefsDeep(schema, schemas);
+  }
+  return result;
+}
+__name(resolveAllSchemaRefs, "resolveAllSchemaRefs");
+
 // src/middlewares/openapi/router.ts
 function createOpenapiRouter(options, context) {
-  const { openapiFilePath, enableEnhancement, serverDir } = options;
+  const { openapiFilePath, openapiSpecFilePath, 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));
+  if (openapiSpecFilePath) {
+    const specHandler = createOpenapiSpecHandler(openapiSpecFilePath);
+    router.get("/openapi/spec", (req, res) => specHandler(req, res, context));
+  }
   return router;
 }
 __name(createOpenapiRouter, "createOpenapiRouter");
@@ -1785,18 +1908,25 @@ var OPENAPI_ROUTES = [
     method: "GET",
     path: "/openapi.json",
     description: "Serve enhanced OpenAPI specification with source code references"
+  },
+  {
+    method: "GET",
+    path: "/openapi/spec",
+    description: "Serve OpenAPI specification for /openapi/*"
   }
 ];
 function createOpenapiMiddleware(options) {
-  const { openapiFilePath, enableEnhancement = true, serverDir } = options;
+  const { openapiFilePath, openapiSpecFilePath, enableEnhancement = true, serverDir } = options;
+  const routes = openapiSpecFilePath ? OPENAPI_ROUTES : OPENAPI_ROUTES.filter((route) => route.path !== "/openapi/spec");
   return {
     name: "openapi",
     mountPath: "/dev",
-    routes: OPENAPI_ROUTES,
+    routes,
     enabled: /* @__PURE__ */ __name((context) => context.isDev, "enabled"),
     createRouter: /* @__PURE__ */ __name((context) => {
       return createOpenapiRouter({
         openapiFilePath,
+        openapiSpecFilePath,
         enableEnhancement,
         serverDir
       }, context);
@@ -2191,8 +2321,8 @@ async function readRecentTraceCalls(filePath, page, pageSize, pathFilter, method
   const handleRequestCompleted = /* @__PURE__ */ __name((builder, entry, message) => {
     builder.hasCompleted = true;
     builder.endTime = entry.time;
-    builder.statusCode = extractNumber(message, /status_code:\s*(\d+)/);
-    builder.durationMs = extractNumber(message, /duration_ms:\s*(\d+)/);
+    builder.statusCode = typeof entry.status_code === "number" ? entry.status_code : extractNumber(message, /status_code:\s*(\d+)/);
+    builder.durationMs = typeof entry.duration_ms === "number" ? entry.duration_ms : extractNumber(message, /duration_ms:\s*(\d+)/);
     if (!builder.path && entry.path) {
       builder.path = String(entry.path);
     }
@@ -2908,7 +3038,7 @@ function createHealthCheckHandler(options = {}) {
 __name(createHealthCheckHandler, "createHealthCheckHandler");
 
 // src/middlewares/dev-logs/sse/log-watcher.ts
-var fs8 = __toESM(require("fs"), 1);
+var fs9 = __toESM(require("fs"), 1);
 var path5 = __toESM(require("path"), 1);
 function mapPinoLevelToServerLogLevel2(pinoLevel) {
   if (typeof pinoLevel === "string") {
@@ -3127,12 +3257,12 @@ var LogWatcher = class {
   */
   watchFile(config) {
     const filePath = path5.join(this.logDir, config.fileName);
-    if (!fs8.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       this.log(`File not found, skipping: ${config.fileName}`);
       return;
     }
     try {
-      const stats = fs8.statSync(filePath);
+      const stats = fs9.statSync(filePath);
       this.filePositions.set(config.fileName, stats.size);
       this.log(`Initialized position for ${config.fileName}: ${stats.size} bytes`);
     } catch (error) {
@@ -3140,7 +3270,7 @@ var LogWatcher = class {
       this.filePositions.set(config.fileName, 0);
     }
     try {
-      const watcher = fs8.watch(filePath, (eventType) => {
+      const watcher = fs9.watch(filePath, (eventType) => {
         if (eventType === "change") {
           this.handleFileChange(config);
         }
@@ -3178,7 +3308,7 @@ var LogWatcher = class {
     const filePath = path5.join(this.logDir, config.fileName);
     const lastPosition = this.filePositions.get(config.fileName) || 0;
     try {
-      const stats = fs8.statSync(filePath);
+      const stats = fs9.statSync(filePath);
       const currentSize = stats.size;
       if (currentSize < lastPosition) {
         this.log(`File ${config.fileName} was truncated, resetting position`);
@@ -3191,11 +3321,11 @@ var LogWatcher = class {
       }
       const readSize = currentSize - lastPosition;
       const buffer = Buffer.alloc(readSize);
-      const fd = fs8.openSync(filePath, "r");
+      const fd = fs9.openSync(filePath, "r");
       try {
-        fs8.readSync(fd, buffer, 0, readSize, lastPosition);
+        fs9.readSync(fd, buffer, 0, readSize, lastPosition);
       } finally {
-        fs8.closeSync(fd);
+        fs9.closeSync(fd);
       }
       this.filePositions.set(config.fileName, currentSize);
       const content = buffer.toString("utf8");
@@ -3919,9 +4049,9 @@ async function registerMiddlewares(server, middlewares, options) {
 __name(registerMiddlewares, "registerMiddlewares");
 
 // src/route-parser.ts
-var fs11 = __toESM(require("fs"), 1);
+var fs12 = __toESM(require("fs"), 1);
 var path7 = __toESM(require("path"), 1);
-var crypto2 = __toESM(require("crypto"), 1);
+var crypto3 = __toESM(require("crypto"), 1);
 var import_parser = require("@babel/parser");
 var import_traverse = __toESM(require("@babel/traverse"), 1);
 var t = __toESM(require("@babel/types"), 1);
@@ -3946,8 +4076,8 @@ function routeParserLog(level, message, ...args) {
 __name(routeParserLog, "routeParserLog");
 function calculateFileHash(filePath) {
   try {
-    const content = fs11.readFileSync(filePath, "utf-8");
-    return crypto2.createHash("md5").update(content).digest("hex");
+    const content = fs12.readFileSync(filePath, "utf-8");
+    return crypto3.createHash("md5").update(content).digest("hex");
   } catch (error) {
     routeParserLog("warn", "Failed to calculate file hash:", error.message);
     return null;
@@ -4031,10 +4161,10 @@ function parseRoutesFromFile(appPath, basePath, options = {}) {
   const defaultPath = applyBasePath && basePath ? `${basePath}/` : "/";
   try {
     const appFilePath = path7.resolve(process.cwd(), appPath);
-    if (!fs11.existsSync(appFilePath)) {
+    if (!fs12.existsSync(appFilePath)) {
       throw new Error(`App file does not exist: ${appFilePath}`);
     }
-    const sourceCode = fs11.readFileSync(appFilePath, "utf-8");
+    const sourceCode = fs12.readFileSync(appFilePath, "utf-8");
     const ast = (0, import_parser.parse)(sourceCode, {
       sourceType: "module",
       plugins: [