@lark-apaas/devtool-kits 1.0.5-alpha.4 → 1.0.5-alpha.6

package/dist/index.cjs

@@ -28406,8 +28406,6 @@ __name(collapseExtraBlankLines, "collapseExtraBlankLines");
 // src/helpers/proxy-error/index.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
-var import_node_fs3 = require("fs");
-var import_node_readline = require("readline");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_https = __toESM(require("https"), 1);
 var errorHtmlTemplate = null;
@@ -28483,63 +28481,82 @@ function parseLogLine(line) {
   if (!trimmed) return null;
   const match = trimmed.match(/^\[\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\]\s+\[server\]\s+(.*)$/);
   if (match) {
-    return match[1];
+    const content = match[1].trim();
+    return content || null;
   }
-  return trimmed;
+  return null;
 }
 __name(parseLogLine, "parseLogLine");
 async function readRecentErrorLogs(logDir, maxLogs, fileName) {
   const logFilePath = import_node_path2.default.join(logDir, fileName);
+  let fileStats;
   try {
-    await import_node_fs2.default.promises.access(logFilePath);
+    fileStats = await import_node_fs2.default.promises.stat(logFilePath);
   } catch {
     return {
       logs: [],
       hasCompileError: false
     };
   }
-  const allLines = [];
-  const stream = (0, import_node_fs3.createReadStream)(logFilePath, {
-    encoding: "utf8"
-  });
-  const rl = (0, import_node_readline.createInterface)({
-    input: stream,
-    crlfDelay: Infinity
-  });
+  const fileSize = fileStats.size;
+  const maxReadSize = 1024 * 1024;
+  const readSize = Math.min(fileSize, maxReadSize);
+  const startPosition = Math.max(0, fileSize - readSize);
+  const buffer = Buffer.allocUnsafe(readSize);
+  let fileHandle;
   try {
-    for await (const line of rl) {
-      const parsed = parseLogLine(line);
-      if (parsed !== null) {
-        allLines.push(parsed);
-      }
-    }
+    fileHandle = await import_node_fs2.default.promises.open(logFilePath, "r");
+    await fileHandle.read(buffer, 0, readSize, startPosition);
+  } catch (error) {
+    console.error("[Proxy Error]: Failed to read log file:", error);
+    return {
+      logs: [],
+      hasCompileError: false
+    };
   } finally {
-    rl.close();
-    stream.destroy();
+    if (fileHandle) {
+      await fileHandle.close();
+    }
+  }
+  const content = buffer.toString("utf8");
+  const lines = content.split("\n");
+  if (startPosition > 0 && lines.length > 0) {
+    lines.shift();
+  }
+  const allLines = [];
+  for (const line of lines) {
+    const parsed = parseLogLine(line);
+    if (parsed !== null) {
+      allLines.push(parsed);
+    }
   }
   let startIndex = -1;
   for (let i = allLines.length - 1; i >= 0; i--) {
-    if (allLines[i].includes("dev:server")) {
+    const line = allLines[i];
+    if (line.includes("Starting compilation in watch mode") || line.includes("File change detected. Starting incremental compilation")) {
       startIndex = i;
       break;
     }
   }
   if (startIndex === -1) {
+    console.log("[Proxy Error]: No compilation start marker found, returning last logs");
+    const fallbackLogs = allLines.slice(-maxLogs);
+    const hasCompileError2 = checkForErrors(fallbackLogs);
     return {
-      logs: [],
-      hasCompileError: false
+      logs: fallbackLogs,
+      hasCompileError: hasCompileError2
     };
   }
   let endIndex = allLines.length;
-  let hasCompileError = false;
-  for (let i = startIndex; i < allLines.length; i++) {
-    if (/Found \d+ errors?\./.test(allLines[i])) {
-      endIndex = i + 1;
-      hasCompileError = true;
+  for (let i = startIndex + 1; i < allLines.length; i++) {
+    const line = allLines[i];
+    if (line.includes("Starting compilation in watch mode") || line.includes("File change detected. Starting incremental compilation")) {
+      endIndex = i;
       break;
     }
   }
   const errorSection = allLines.slice(startIndex, endIndex);
+  const hasCompileError = checkForErrors(errorSection);
   const logs = errorSection.length > maxLogs ? errorSection.slice(-maxLogs) : errorSection;
   return {
     logs,
@@ -28547,6 +28564,20 @@ async function readRecentErrorLogs(logDir, maxLogs, fileName) {
   };
 }
 __name(readRecentErrorLogs, "readRecentErrorLogs");
+function checkForErrors(logs) {
+  for (const line of logs) {
+    const compileErrorMatch = line.match(/Found (\d+) errors?\. Watching for file changes/);
+    if (compileErrorMatch) {
+      const errorCount = parseInt(compileErrorMatch[1], 10);
+      if (errorCount > 0) {
+        console.log(`[Proxy Error]: Found ${errorCount} compilation error(s)`);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(checkForErrors, "checkForErrors");
 function injectErrorData(template, errorLogs, clientBasePath) {
   let logsText = "";
   if (errorLogs.length > 0) {
@@ -28559,9 +28590,9 @@ function injectErrorData(template, errorLogs, clientBasePath) {
 }
 __name(injectErrorData, "injectErrorData");
 function handleDevProxyError(err, req, res, options) {
-  const { logDir = import_node_path2.default.join(process.cwd(), "logs"), maxErrorLogs = 100, logFileName = "server.log", retryTimeout = 5e3, retryInterval = 500, target, clientBasePath = process.env.CLIENT_BASE_PATH || "/" } = options || {};
+  const { logDir = import_node_path2.default.join(process.cwd(), "logs"), maxErrorLogs = 100, logFileName = "server.log", retryTimeout = 5e3, retryInterval = 500, target = `http://localhost:${process.env.SERVER_PORT || 3e3}`, clientBasePath = process.env.CLIENT_BASE_PATH || "/" } = options || {};
   const clientBasePathWithoutSlash = normalizeBasePath(clientBasePath);
-  console.error("[Proxy Error]:", err.message);
+  console.error("[Proxy Error]:", err.message, clientBasePathWithoutSlash);
   if (res.headersSent) {
     console.error("[Proxy Error]: Headers already sent, cannot send error page");
     return;
@@ -28570,7 +28601,7 @@ function handleDevProxyError(err, req, res, options) {
     try {
       const isConnError = isConnectionError(err);
       const { logs: errorLogs, hasCompileError } = await readRecentErrorLogs(logDir, maxErrorLogs, logFileName);
-      if (isConnError && !hasCompileError && target) {
+      if (isConnError && !hasCompileError) {
         console.log("[Proxy Error]: Connection error without compile errors, possibly server restarting...");
         try {
           new URL(target);
@@ -28726,17 +28757,17 @@ var import_promises = __toESM(require("fs/promises"), 1);
 var import_node_crypto = __toESM(require("crypto"), 1);
 
 // src/middlewares/openapi/services.ts
-var import_node_fs5 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path4 = __toESM(require("path"), 1);
 var import_typescript = __toESM(require("typescript"), 1);
 
 // src/middlewares/openapi/utils.ts
 var import_node_path3 = __toESM(require("path"), 1);
-var import_node_fs4 = require("fs");
+var import_node_fs3 = require("fs");
 async function findControllerFiles(dir) {
   const files = [];
   async function scan(currentDir) {
-    const entries = await import_node_fs4.promises.readdir(currentDir, {
+    const entries = await import_node_fs3.promises.readdir(currentDir, {
       withFileTypes: true
     });
     for (const entry of entries) {
@@ -28820,14 +28851,14 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
   if (options.openapiData) {
     openapi = JSON.parse(JSON.stringify(options.openapiData));
   } else {
-    const openapiContent = await import_node_fs5.promises.readFile(openapiPath, "utf-8");
+    const openapiContent = await import_node_fs4.promises.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 (writeFile) {
-    await import_node_fs5.promises.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
+    await import_node_fs4.promises.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
   }
   const duration = Date.now() - startTime;
   return {
@@ -28843,7 +28874,7 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
 __name(enhanceOpenApiWithSourceInfo, "enhanceOpenApiWithSourceInfo");
 async function processControllerFile(filePath) {
   const relativePath = import_node_path4.default.relative(process.cwd(), filePath);
-  const content = await import_node_fs5.promises.readFile(filePath, "utf-8");
+  const content = await import_node_fs4.promises.readFile(filePath, "utf-8");
   const sourceFile = import_typescript.default.createSourceFile(filePath, content, import_typescript.default.ScriptTarget.Latest, true);
   return extractControllerMetadata(sourceFile, relativePath);
 }
@@ -29003,7 +29034,7 @@ __name(createOpenapiMiddleware, "createOpenapiMiddleware");
 var import_express3 = __toESM(require_express2(), 1);
 
 // src/middlewares/dev-logs/utils.ts
-var import_node_fs6 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_path5 = require("path");
 
 // src/middlewares/dev-logs/helper/path-matcher.ts
@@ -29055,7 +29086,7 @@ function getRelativePath(filePath) {
 __name(getRelativePath, "getRelativePath");
 async function fileExists(filePath) {
   try {
-    await import_node_fs6.promises.access(filePath);
+    await import_node_fs5.promises.access(filePath);
     return true;
   } catch {
     return false;
@@ -29138,18 +29169,18 @@ __name(serializeError, "serializeError");
 var import_node_path6 = require("path");
 
 // src/middlewares/dev-logs/services.ts
-var import_node_fs7 = require("fs");
-var import_node_readline2 = require("readline");
+var import_node_fs6 = require("fs");
+var import_node_readline = require("readline");
 async function readLogEntriesByTrace(filePath, traceId, limit) {
   const exists = await fileExists(filePath);
   if (!exists) {
     return void 0;
   }
   const matches = [];
-  const stream = (0, import_node_fs7.createReadStream)(filePath, {
+  const stream = (0, import_node_fs6.createReadStream)(filePath, {
     encoding: "utf8"
   });
-  const rl = (0, import_node_readline2.createInterface)({
+  const rl = (0, import_node_readline.createInterface)({
     input: stream,
     crlfDelay: Infinity
   });
@@ -29238,7 +29269,7 @@ async function readRecentTraceCalls(filePath, page, pageSize, pathFilter, method
 }
 __name(readRecentTraceCalls, "readRecentTraceCalls");
 async function readFileReverse(filePath, chunkSize, processLine) {
-  const handle = await import_node_fs7.promises.open(filePath, "r");
+  const handle = await import_node_fs6.promises.open(filePath, "r");
   try {
     const stats = await handle.stat();
     let position = stats.size;
@@ -29300,10 +29331,10 @@ async function readLogFilePage(filePath, page, pageSize) {
   const capacity = page * pageSize;
   const buffer = [];
   let totalLines = 0;
-  const stream = (0, import_node_fs7.createReadStream)(filePath, {
+  const stream = (0, import_node_fs6.createReadStream)(filePath, {
     encoding: "utf8"
   });
-  const rl = (0, import_node_readline2.createInterface)({
+  const rl = (0, import_node_readline.createInterface)({
     input: stream,
     crlfDelay: Infinity
   });
@@ -29496,7 +29527,7 @@ var import_fs = __toESM(require("fs"), 1);
 
 // src/middlewares/collect-logs/utils.ts
 var import_node_path7 = require("path");
-var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
 function resolveLogDir2(provided) {
   if (!provided) {
     return (0, import_node_path7.join)(process.cwd(), "logs");
@@ -29505,8 +29536,8 @@ function resolveLogDir2(provided) {
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
-  if (!import_node_fs8.default.existsSync(dir)) {
-    import_node_fs8.default.mkdirSync(dir, {
+  if (!import_node_fs7.default.existsSync(dir)) {
+    import_node_fs7.default.mkdirSync(dir, {
       recursive: true
     });
   }