@lark-apaas/devtool-kits 1.2.17-alpha.4 → 1.2.17-alpha.41

package/dist/index.js

@@ -1,5 +1,11 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import {
+  enhanceOpenApiWithSourceInfo,
+  parseApiRoutes,
+  transformOpenapiPaths
+} from "./chunk-LSHFHCDF.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
 
 // src/utils/index.ts
 function normalizeBasePath(basePath) {
@@ -1329,246 +1335,19 @@ function handleDevProxyError(err, req, res, options) {
 __name(handleDevProxyError, "handleDevProxyError");
 
 // src/middlewares/index.ts
-import path6 from "path";
+import path4 from "path";
 
 // src/middlewares/openapi/router.ts
 import express from "express";
 
 // src/middlewares/openapi/controller.ts
-import fs5 from "fs/promises";
+import fs3 from "fs/promises";
 import crypto from "crypto";
-
-// src/middlewares/openapi/services.ts
-import { promises as fs4 } from "fs";
-import path4 from "path";
-import ts from "typescript";
-
-// src/middlewares/openapi/utils.ts
-import path3 from "path";
-import { promises as fs3 } from "fs";
-async function findControllerFiles(dir) {
-  const files = [];
-  async function scan(currentDir) {
-    const entries = await fs3.readdir(currentDir, {
-      withFileTypes: true
-    });
-    for (const entry of entries) {
-      const fullPath = path3.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await scan(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith(".controller.ts")) {
-        files.push(fullPath);
-      }
-    }
-  }
-  __name(scan, "scan");
-  await scan(dir);
-  return files;
-}
-__name(findControllerFiles, "findControllerFiles");
-async function buildSourceMap(controllerFiles, processFile) {
-  const sourceMap = /* @__PURE__ */ new Map();
-  const concurrency = 10;
-  const results = [];
-  for (let i = 0; i < controllerFiles.length; i += concurrency) {
-    const batch = controllerFiles.slice(i, i + concurrency);
-    const batchResults = await Promise.all(batch.map((filePath) => processFile(filePath)));
-    results.push(...batchResults);
-  }
-  for (const metadata of results) {
-    for (const [operationId, info] of metadata.entries()) {
-      sourceMap.set(operationId, info);
-    }
-  }
-  return sourceMap;
-}
-__name(buildSourceMap, "buildSourceMap");
-function findSourceInfo(operationId, sourceMap) {
-  const directMatch = sourceMap.get(operationId);
-  if (directMatch) {
-    return directMatch;
-  }
-  for (const [key, value] of sourceMap.entries()) {
-    const [className, methodName] = key.split("_");
-    if (!className || !methodName) continue;
-    const camelCaseId = className.charAt(0).toLowerCase() + className.slice(1) + methodName.charAt(0).toUpperCase() + methodName.slice(1);
-    if (operationId === camelCaseId) {
-      return value;
-    }
-    if (operationId === methodName) {
-      return value;
-    }
-  }
-  return void 0;
-}
-__name(findSourceInfo, "findSourceInfo");
-function enhanceOpenApiPaths(openapi, sourceMap) {
-  let enhancedCount = 0;
-  if (!openapi.paths) {
-    return enhancedCount;
-  }
-  for (const pathItem of Object.values(openapi.paths)) {
-    if (!pathItem || typeof pathItem !== "object") continue;
-    for (const operation of Object.values(pathItem)) {
-      if (operation && typeof operation === "object" && "operationId" in operation) {
-        const sourceInfo = findSourceInfo(operation.operationId, sourceMap);
-        if (sourceInfo) {
-          operation["x-source"] = {
-            file: sourceInfo.file,
-            line: sourceInfo.line
-          };
-          enhancedCount++;
-        }
-      }
-    }
-  }
-  return enhancedCount;
-}
-__name(enhanceOpenApiPaths, "enhanceOpenApiPaths");
-function transformOpenapiPaths(openapi, basePath) {
-  if (basePath === "/" || !openapi.paths) {
-    return openapi;
-  }
-  const newPaths = {};
-  Object.keys(openapi.paths).forEach((key) => {
-    const staticApiKey = key.startsWith(basePath) ? key.slice(basePath.length) : key;
-    newPaths[staticApiKey] = openapi.paths[key];
-  });
-  return {
-    ...openapi,
-    paths: newPaths,
-    basePath
-  };
-}
-__name(transformOpenapiPaths, "transformOpenapiPaths");
-
-// src/middlewares/openapi/services.ts
-async function enhanceOpenApiWithSourceInfo(options = {}) {
-  const startTime = Date.now();
-  const openapiPath = options.openapiPath || path4.resolve(__dirname, "../client/src/api/gen/openapi.json");
-  const serverDir = options.serverDir || path4.resolve(__dirname, "../server");
-  const writeFile2 = options.writeFile !== false;
-  let openapi;
-  if (options.openapiData) {
-    openapi = JSON.parse(JSON.stringify(options.openapiData));
-  } else {
-    const openapiContent = await fs4.readFile(openapiPath, "utf-8");
-    openapi = JSON.parse(openapiContent);
-  }
-  const controllerFiles = await findControllerFiles(serverDir);
-  const sourceMap = await buildSourceMap(controllerFiles, processControllerFile);
-  const enhanced = enhanceOpenApiPaths(openapi, sourceMap);
-  if (writeFile2) {
-    await fs4.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
-  }
-  const duration = Date.now() - startTime;
-  return {
-    openapi,
-    stats: {
-      duration,
-      controllersFound: controllerFiles.length,
-      endpointsExtracted: sourceMap.size,
-      endpointsEnhanced: enhanced
-    }
-  };
-}
-__name(enhanceOpenApiWithSourceInfo, "enhanceOpenApiWithSourceInfo");
-async function processControllerFile(filePath) {
-  const relativePath = path4.relative(process.cwd(), filePath);
-  const content = await fs4.readFile(filePath, "utf-8");
-  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-  return extractControllerMetadata(sourceFile, relativePath);
-}
-__name(processControllerFile, "processControllerFile");
-function extractControllerMetadata(sourceFile, filePath) {
-  const metadata = /* @__PURE__ */ new Map();
-  let controllerPath = "";
-  let className = "";
-  function getDecorators(node) {
-    if ("modifiers" in node && Array.isArray(node.modifiers)) {
-      return node.modifiers.filter((mod) => mod.kind === ts.SyntaxKind.Decorator);
-    }
-    if ("decorators" in node && Array.isArray(node.decorators)) {
-      return node.decorators;
-    }
-    return [];
-  }
-  __name(getDecorators, "getDecorators");
-  function visit(node) {
-    if (ts.isClassDeclaration(node)) {
-      const decorators = getDecorators(node);
-      if (node.name) {
-        className = node.name.getText(sourceFile);
-      }
-      for (const decorator of decorators) {
-        if (ts.isCallExpression(decorator.expression)) {
-          const expression = decorator.expression;
-          const decoratorName = expression.expression.getText(sourceFile);
-          if (decoratorName === "Controller") {
-            if (expression.arguments.length > 0) {
-              const arg = expression.arguments[0];
-              if (ts.isStringLiteral(arg)) {
-                controllerPath = arg.text;
-              }
-            }
-          }
-        }
-      }
-    }
-    if (ts.isMethodDeclaration(node) && node.name) {
-      const methodName = node.name.getText(sourceFile);
-      let httpMethod = "";
-      let routePath = "";
-      const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-      const decorators = getDecorators(node);
-      for (const decorator of decorators) {
-        if (ts.isCallExpression(decorator.expression)) {
-          const decoratorName = decorator.expression.expression.getText(sourceFile);
-          if ([
-            "Get",
-            "Post",
-            "Put",
-            "Delete",
-            "Patch",
-            "Options",
-            "Head",
-            "All"
-          ].includes(decoratorName)) {
-            httpMethod = decoratorName.toLowerCase();
-            if (decorator.expression.arguments.length > 0) {
-              const arg = decorator.expression.arguments[0];
-              if (ts.isStringLiteral(arg)) {
-                routePath = arg.text;
-              }
-            }
-          }
-        }
-      }
-      if (httpMethod && methodName && className) {
-        const operationId = `${className}_${methodName}`;
-        metadata.set(operationId, {
-          file: filePath,
-          line: line + 1,
-          method: httpMethod,
-          controllerPath,
-          routePath
-        });
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  __name(visit, "visit");
-  visit(sourceFile);
-  return metadata;
-}
-__name(extractControllerMetadata, "extractControllerMetadata");
-
-// src/middlewares/openapi/controller.ts
 function createOpenapiHandler(openapiFilePath, enableEnhancement, serverDir) {
   let cache = null;
   return async (_req, res, context) => {
     try {
-      const fileBuffer = await fs5.readFile(openapiFilePath, "utf-8");
+      const fileBuffer = await fs3.readFile(openapiFilePath, "utf-8");
       const currentHash = crypto.createHash("md5").update(fileBuffer).digest("hex");
       if (cache && cache.fileHash === currentHash) {
         return res.json(cache.data);
@@ -1640,7 +1419,7 @@ __name(createOpenapiMiddleware, "createOpenapiMiddleware");
 import express2 from "express";
 
 // src/middlewares/dev-logs/utils.ts
-import { promises as fs6 } from "fs";
+import { promises as fs4 } from "fs";
 import { isAbsolute, join as join2, relative } from "path";
 
 // src/middlewares/dev-logs/helper/path-matcher.ts
@@ -1673,8 +1452,8 @@ function hasSpecialPatterns(pattern) {
   return /[{*]/.test(pattern);
 }
 __name(hasSpecialPatterns, "hasSpecialPatterns");
-function normalizePathForMatching(path7) {
-  return path7.replace(/\/+/g, "/").replace(/\/+$/, "");
+function normalizePathForMatching(path5) {
+  return path5.replace(/\/+/g, "/").replace(/\/+$/, "");
 }
 __name(normalizePathForMatching, "normalizePathForMatching");
 
@@ -1692,7 +1471,7 @@ function getRelativePath(filePath) {
 __name(getRelativePath, "getRelativePath");
 async function fileExists(filePath) {
   try {
-    await fs6.access(filePath);
+    await fs4.access(filePath);
     return true;
   } catch {
     return false;
@@ -1775,9 +1554,9 @@ __name(serializeError, "serializeError");
 import { join as join4 } from "path";
 
 // src/middlewares/dev-logs/services/file-reader.ts
-import { promises as fs7 } from "fs";
+import { promises as fs5 } from "fs";
 async function readFileReverse(filePath, chunkSize, processLine) {
-  const handle = await fs7.open(filePath, "r");
+  const handle = await fs5.open(filePath, "r");
   try {
     const stats = await handle.stat();
     let position = stats.size;
@@ -1894,8 +1673,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
@@ -2221,7 +2002,7 @@ __name(readLogsBySource, "readLogsBySource");
 // src/middlewares/dev-logs/services/trigger.service.ts
 import { createReadStream as createReadStream3 } from "fs";
 import { createInterface as createInterface3 } from "readline";
-async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
+async function readTriggerList(filePath, trigger, path5, limit, triggerID) {
   if (!await fileExists(filePath)) {
     return void 0;
   }
@@ -2247,7 +2028,7 @@ async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
     if (alreadyAdded) {
       return false;
     }
-    const isAutomationTrigger = builder.path?.endsWith(path7);
+    const isAutomationTrigger = builder.path?.endsWith(path5);
     if (!isAutomationTrigger) {
       return false;
     }
@@ -2330,7 +2111,7 @@ async function readTriggerList(filePath, trigger, path7, limit, triggerID) {
   };
 }
 __name(readTriggerList, "readTriggerList");
-async function readTriggerDetail(filePath, path7, instanceID) {
+async function readTriggerDetail(filePath, path5, instanceID) {
   const exists = await fileExists(filePath);
   if (!exists) {
     return void 0;
@@ -2346,7 +2127,7 @@ async function readTriggerDetail(filePath, path7, instanceID) {
   for await (const line of rl) {
     const entry = parseLogLine(line);
     if (!entry) continue;
-    const isAutomationTrigger = entry.path?.endsWith(path7);
+    const isAutomationTrigger = entry.path?.endsWith(path5);
     const hasInstanceID = entry.instance_id === instanceID && entry.trigger;
     if (!isAutomationTrigger || !hasInstanceID) continue;
     matches.push(entry);
@@ -2600,16 +2381,16 @@ function createGetTriggerListHandler(logDir) {
       });
     }
     const triggerID = typeof req.query.triggerID === "string" ? req.query.triggerID.trim() : void 0;
-    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path5 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     const limit = parseLimit(req.query.limit, 10, 200);
     try {
-      const result = await readTriggerList(traceLogPath, trigger, path7, limit, triggerID);
+      const result = await readTriggerList(traceLogPath, trigger, path5, limit, triggerID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
       res.json({
         file: getRelativePath(traceLogPath),
-        path: path7,
+        path: path5,
         ...result
       });
     } catch (error) {
@@ -2627,9 +2408,9 @@ function createGetTriggerDetailHandler(logDir) {
         message: "instanceID is required"
       });
     }
-    const path7 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
+    const path5 = typeof req.query.path === "string" ? req.query.path.trim() : "/__innerapi__/automation/invoke";
     try {
-      const result = await readTriggerDetail(traceLogPath, path7, instanceID);
+      const result = await readTriggerDetail(traceLogPath, path5, instanceID);
       if (!result) {
         return handleNotFound(res, traceLogPath);
       }
@@ -2737,8 +2518,8 @@ function createHealthCheckHandler(options = {}) {
 __name(createHealthCheckHandler, "createHealthCheckHandler");
 
 // src/middlewares/dev-logs/sse/log-watcher.ts
-import * as fs8 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path3 from "path";
 function mapPinoLevelToServerLogLevel2(pinoLevel) {
   if (typeof pinoLevel === "string") {
     const lower = pinoLevel.toLowerCase();
@@ -2799,8 +2580,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
@@ -2953,13 +2736,13 @@ var LogWatcher = class {
   * Watch a single log file
   */
   watchFile(config) {
-    const filePath = path5.join(this.logDir, config.fileName);
-    if (!fs8.existsSync(filePath)) {
+    const filePath = path3.join(this.logDir, config.fileName);
+    if (!fs6.existsSync(filePath)) {
       this.log(`File not found, skipping: ${config.fileName}`);
       return;
     }
     try {
-      const stats = fs8.statSync(filePath);
+      const stats = fs6.statSync(filePath);
       this.filePositions.set(config.fileName, stats.size);
       this.log(`Initialized position for ${config.fileName}: ${stats.size} bytes`);
     } catch (error) {
@@ -2967,7 +2750,7 @@ var LogWatcher = class {
       this.filePositions.set(config.fileName, 0);
     }
     try {
-      const watcher = fs8.watch(filePath, (eventType) => {
+      const watcher = fs6.watch(filePath, (eventType) => {
         if (eventType === "change") {
           this.handleFileChange(config);
         }
@@ -3002,10 +2785,10 @@ var LogWatcher = class {
   * Handle file change event - read new content
   */
   handleFileChange(config) {
-    const filePath = path5.join(this.logDir, config.fileName);
+    const filePath = path3.join(this.logDir, config.fileName);
     const lastPosition = this.filePositions.get(config.fileName) || 0;
     try {
-      const stats = fs8.statSync(filePath);
+      const stats = fs6.statSync(filePath);
       const currentSize = stats.size;
       if (currentSize < lastPosition) {
         this.log(`File ${config.fileName} was truncated, resetting position`);
@@ -3018,11 +2801,11 @@ var LogWatcher = class {
       }
       const readSize = currentSize - lastPosition;
       const buffer = Buffer.alloc(readSize);
-      const fd = fs8.openSync(filePath, "r");
+      const fd = fs6.openSync(filePath, "r");
       try {
-        fs8.readSync(fd, buffer, 0, readSize, lastPosition);
+        fs6.readSync(fd, buffer, 0, readSize, lastPosition);
       } finally {
-        fs8.closeSync(fd);
+        fs6.closeSync(fd);
       }
       this.filePositions.set(config.fileName, currentSize);
       const content = buffer.toString("utf8");
@@ -3251,6 +3034,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(path5) {
+  const segments = path5.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, path5) {
+  const cleanPath = path5.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 +3147,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 +3183,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 = {}) {
@@ -3322,11 +3211,11 @@ import express3 from "express";
 
 // src/middlewares/collect-logs/controller.ts
 import { join as join7 } from "path";
-import fs10 from "fs";
+import fs8 from "fs";
 
 // src/middlewares/collect-logs/utils.ts
 import { isAbsolute as isAbsolute2, join as join6 } from "path";
-import fs9 from "fs";
+import fs7 from "fs";
 function resolveLogDir2(provided) {
   if (!provided) {
     return join6(process.cwd(), "logs");
@@ -3335,8 +3224,8 @@ function resolveLogDir2(provided) {
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, {
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, {
       recursive: true
     });
   }
@@ -3368,7 +3257,7 @@ function collectLogsHandler(logDir, fileName) {
         ...logContent,
         server_time: (/* @__PURE__ */ new Date()).toISOString()
       }) + "\n";
-      await fs10.promises.appendFile(filePath, logLine);
+      await fs8.promises.appendFile(filePath, logLine);
       res.json({
         success: true
       });
@@ -3396,7 +3285,7 @@ function collectLogsBatchHandler(logDir, fileName) {
           server_time: (/* @__PURE__ */ new Date()).toISOString()
         }) + "\n");
       }
-      await fs10.promises.appendFile(filePath, logLines.join(""));
+      await fs8.promises.appendFile(filePath, logLines.join(""));
       res.json({
         success: true
       });
@@ -3415,11 +3304,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");
@@ -3552,7 +3451,7 @@ function isGlobalMiddleware(middleware) {
 }
 __name(isGlobalMiddleware, "isGlobalMiddleware");
 function computeMountPath(basePath, mountPath) {
-  const routePath = path6.posix.join(basePath, mountPath);
+  const routePath = path4.posix.join(basePath, mountPath);
   return routePath.startsWith("/") ? routePath : `/${routePath}`;
 }
 __name(computeMountPath, "computeMountPath");
@@ -3560,7 +3459,7 @@ function logMiddlewareRegistration(middleware, fullMountPath) {
   if (middleware.routes && middleware.routes.length > 0) {
     console.log(`[Middleware] Registered: ${middleware.name} at ${fullMountPath}`);
     middleware.routes.forEach((route) => {
-      const routePath = route.path === "/" ? fullMountPath : path6.posix.join(fullMountPath, route.path);
+      const routePath = route.path === "/" ? fullMountPath : path4.posix.join(fullMountPath, route.path);
       console.log(`  ${route.method} ${routePath} - ${route.description}`);
     });
   } else {
@@ -3637,6 +3536,7 @@ export {
   handleDevProxyError,
   normalizeBasePath,
   parseAndGenerateNestResourceTemplate,
+  parseApiRoutes,
   postprocessDrizzleSchema,
   registerMiddlewares,
   sendError,