ortoni-report 4.0.2-beta.1 → 4.0.3

package/dist/ortoni-report.js

@@ -1,4 +1,3 @@
-"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -38,69 +37,131 @@ __export(ortoni_report_exports, {
 module.exports = __toCommonJS(ortoni_report_exports);
 
 // src/helpers/fileManager.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+
+// src/helpers/templateLoader.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
+var import_meta = {};
+async function readBundledTemplate(pkgName = "ortoni-report") {
+  const packagedRel = "dist/index.html";
+  try {
+    if (typeof require === "function") {
+      const resolved = require.resolve(`${pkgName}/${packagedRel}`);
+      if (import_fs.default.existsSync(resolved)) {
+        return import_fs.default.readFileSync(resolved, "utf-8");
+      }
+    }
+  } catch {
+  }
+  try {
+    const moduleNS = await import("module");
+    if (moduleNS && typeof moduleNS.createRequire === "function") {
+      const createRequire = moduleNS.createRequire;
+      const req = createRequire(
+        // @ts-ignore
+        typeof __filename !== "undefined" ? __filename : import_meta.url
+      );
+      const resolved = req.resolve(`${pkgName}/${packagedRel}`);
+      if (import_fs.default.existsSync(resolved)) {
+        return import_fs.default.readFileSync(resolved, "utf-8");
+      }
+    }
+  } catch {
+  }
+  try {
+    const here = import_path.default.resolve(__dirname, "../dist/index.html");
+    if (import_fs.default.existsSync(here)) return import_fs.default.readFileSync(here, "utf-8");
+  } catch {
+  }
+  try {
+    const nm = import_path.default.join(process.cwd(), "node_modules", pkgName, packagedRel);
+    if (import_fs.default.existsSync(nm)) return import_fs.default.readFileSync(nm, "utf-8");
+  } catch {
+  }
+  try {
+    const alt = import_path.default.join(process.cwd(), "dist", "index.html");
+    if (import_fs.default.existsSync(alt)) return import_fs.default.readFileSync(alt, "utf-8");
+  } catch {
+  }
+  throw new Error(
+    `ortoni-report template not found (tried:
+  - require.resolve('${pkgName}/${packagedRel}')
+  - import('module').createRequire(...).resolve('${pkgName}/${packagedRel}')
+  - relative ../dist/index.html
+  - ${import_path.default.join(
+      process.cwd(),
+      "node_modules",
+      pkgName,
+      packagedRel
+    )}
+  - ${import_path.default.join(process.cwd(), "dist", "index.html")}
+Ensure 'dist/index.html' is present in the published package and package.json 'files' includes 'dist/'.`
+  );
+}
+
+// src/helpers/fileManager.ts
 var FileManager = class {
   constructor(folderPath) {
     this.folderPath = folderPath;
   }
   ensureReportDirectory() {
-    const ortoniDataFolder = import_path.default.join(this.folderPath, "ortoni-data");
-    if (!import_fs.default.existsSync(this.folderPath)) {
-      import_fs.default.mkdirSync(this.folderPath, { recursive: true });
+    const ortoniDataFolder = import_path2.default.join(this.folderPath, "ortoni-data");
+    if (!import_fs2.default.existsSync(this.folderPath)) {
+      import_fs2.default.mkdirSync(this.folderPath, { recursive: true });
     } else {
-      if (import_fs.default.existsSync(ortoniDataFolder)) {
-        import_fs.default.rmSync(ortoniDataFolder, { recursive: true, force: true });
+      if (import_fs2.default.existsSync(ortoniDataFolder)) {
+        import_fs2.default.rmSync(ortoniDataFolder, { recursive: true, force: true });
       }
     }
   }
-  writeReportFile(filename, data) {
-    const templatePath = import_path.default.join(__dirname, "..", "index.html");
-    console.log("temp path - " + templatePath);
-    let html = import_fs.default.readFileSync(templatePath, "utf-8");
+  async writeReportFile(filename, data) {
+    let html = await readBundledTemplate();
     const reportJSON = JSON.stringify({
       data
     });
     html = html.replace("__ORTONI_TEST_REPORTDATA__", reportJSON);
-    import_fs.default.writeFileSync(filename, html);
-    return filename;
+    const outputPath = import_path2.default.join(process.cwd(), this.folderPath, filename);
+    import_fs2.default.writeFileSync(outputPath, html);
+    return outputPath;
   }
   writeRawFile(filename, data) {
-    const outputPath = import_path.default.join(process.cwd(), this.folderPath, filename);
-    import_fs.default.mkdirSync(import_path.default.dirname(outputPath), { recursive: true });
+    const outputPath = import_path2.default.join(process.cwd(), this.folderPath, filename);
+    import_fs2.default.mkdirSync(import_path2.default.dirname(outputPath), { recursive: true });
     const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
-    import_fs.default.writeFileSync(outputPath, content, "utf-8");
+    import_fs2.default.writeFileSync(outputPath, content, "utf-8");
     return outputPath;
   }
   copyTraceViewerAssets(skip) {
     if (skip) return;
-    const traceViewerFolder = import_path.default.join(
+    const traceViewerFolder = import_path2.default.join(
       require.resolve("playwright-core"),
       "..",
       "lib",
       "vite",
       "traceViewer"
     );
-    const traceViewerTargetFolder = import_path.default.join(this.folderPath, "trace");
-    const traceViewerAssetsTargetFolder = import_path.default.join(
+    const traceViewerTargetFolder = import_path2.default.join(this.folderPath, "trace");
+    const traceViewerAssetsTargetFolder = import_path2.default.join(
       traceViewerTargetFolder,
       "assets"
     );
-    import_fs.default.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
-    for (const file of import_fs.default.readdirSync(traceViewerFolder)) {
+    import_fs2.default.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
+    for (const file of import_fs2.default.readdirSync(traceViewerFolder)) {
       if (file.endsWith(".map") || file.includes("watch") || file.includes("assets"))
         continue;
-      import_fs.default.copyFileSync(
-        import_path.default.join(traceViewerFolder, file),
-        import_path.default.join(traceViewerTargetFolder, file)
+      import_fs2.default.copyFileSync(
+        import_path2.default.join(traceViewerFolder, file),
+        import_path2.default.join(traceViewerTargetFolder, file)
       );
     }
-    const assetsFolder = import_path.default.join(traceViewerFolder, "assets");
-    for (const file of import_fs.default.readdirSync(assetsFolder)) {
+    const assetsFolder = import_path2.default.join(traceViewerFolder, "assets");
+    for (const file of import_fs2.default.readdirSync(assetsFolder)) {
       if (file.endsWith(".map") || file.includes("xtermModule")) continue;
-      import_fs.default.copyFileSync(
-        import_path.default.join(assetsFolder, file),
-        import_path.default.join(traceViewerAssetsTargetFolder, file)
+      import_fs2.default.copyFileSync(
+        import_path2.default.join(assetsFolder, file),
+        import_path2.default.join(traceViewerAssetsTargetFolder, file)
       );
     }
   }
@@ -149,13 +210,46 @@ var HTMLGenerator = class {
     );
     return data;
   }
+  /**
+   * Return safe analytics/report data.
+   * If no dbManager is provided, return empty defaults and a note explaining why.
+   */
   async getReportData() {
-    return {
-      summary: await this.dbManager.getSummaryData(),
-      trends: await this.dbManager.getTrends(),
-      flakyTests: await this.dbManager.getFlakyTests(),
-      slowTests: await this.dbManager.getSlowTests()
-    };
+    if (!this.dbManager) {
+      return {
+        summary: {},
+        trends: {},
+        flakyTests: [],
+        slowTests: [],
+        note: "Test history/trends are unavailable (saveHistory disabled or DB not initialized)."
+      };
+    }
+    try {
+      const [summary, trends, flakyTests, slowTests] = await Promise.all([
+        this.dbManager.getSummaryData ? this.dbManager.getSummaryData() : Promise.resolve({}),
+        this.dbManager.getTrends ? this.dbManager.getTrends() : Promise.resolve({}),
+        this.dbManager.getFlakyTests ? this.dbManager.getFlakyTests() : Promise.resolve([]),
+        this.dbManager.getSlowTests ? this.dbManager.getSlowTests() : Promise.resolve([])
+      ]);
+      return {
+        summary: summary ?? {},
+        trends: trends ?? {},
+        flakyTests: flakyTests ?? [],
+        slowTests: slowTests ?? []
+      };
+    } catch (err) {
+      console.warn(
+        "HTMLGenerator: failed to read analytics from DB, continuing without history.",
+        err
+      );
+      return {
+        summary: {},
+        trends: {},
+        flakyTests: [],
+        slowTests: [],
+        note: "Test history/trends could not be loaded due to a DB error."
+      };
+    }
   }
   async prepareReportData(filteredResults, totalDuration, results, projectSet) {
     const totalTests = filteredResults.length;
@@ -164,10 +258,10 @@ var HTMLGenerator = class {
     const failed = filteredResults.filter(
       (r) => r.status === "failed" || r.status === "timedOut"
     ).length;
-    const successRate = ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
+    const successRate = totalTests === 0 ? "0.00" : ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
     const allTags = /* @__PURE__ */ new Set();
     results.forEach(
-      (result) => result.testTags.forEach((tag) => allTags.add(tag))
+      (result) => (result.testTags || []).forEach((tag) => allTags.add(tag))
     );
     const projectResults = this.calculateProjectResults(
       filteredResults,
@@ -178,13 +272,31 @@ var HTMLGenerator = class {
     const testHistories = await Promise.all(
       results.map(async (result) => {
         const testId = `${result.filePath}:${result.projectName}:${result.title}`;
-        const history = await this.dbManager.getTestHistory(testId);
-        return {
-          testId,
-          history
-        };
+        if (!this.dbManager || !this.dbManager.getTestHistory) {
+          return {
+            testId,
+            history: []
+          };
+        }
+        try {
+          const history = await this.dbManager.getTestHistory(testId);
+          return {
+            testId,
+            history: history ?? []
+          };
+        } catch (err) {
+          console.warn(
+            `HTMLGenerator: failed to read history for ${testId}`,
+            err
+          );
+          return {
+            testId,
+            history: []
+          };
+        }
       })
     );
+    const reportData = await this.getReportData();
     return {
       summary: {
         overAllResult: {
@@ -220,7 +332,7 @@ var HTMLGenerator = class {
         showProject: this.ortoniConfig.showProject || false
       },
       analytics: {
-        reportData: await this.getReportData()
+        reportData
       }
     };
   }
@@ -258,16 +370,16 @@ var HTMLGenerator = class {
   }
 };
 
-// src/helpers/resultProcessor .ts
+// src/helpers/resultProcessor.ts
 var import_ansi_to_html = __toESM(require("ansi-to-html"));
-var import_path4 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 
 // src/utils/attachFiles.ts
-var import_path2 = __toESM(require("path"));
-var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs"));
 
 // src/helpers/markdownConverter.ts
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 
 // node_modules/marked/lib/marked.esm.js
 function M() {
@@ -1393,27 +1505,27 @@ var Qt = b.lex;
 
 // src/helpers/markdownConverter.ts
 function convertMarkdownToHtml(markdownPath, htmlOutputPath) {
-  const hasMarkdown = import_fs2.default.existsSync(markdownPath);
-  const markdownContent = hasMarkdown ? import_fs2.default.readFileSync(markdownPath, "utf-8") : "";
+  const hasMarkdown = import_fs3.default.existsSync(markdownPath);
+  const markdownContent = hasMarkdown ? import_fs3.default.readFileSync(markdownPath, "utf-8") : "";
   const markdownHtml = hasMarkdown ? k(markdownContent) : "";
   const drawerHtml = `${markdownHtml || ""}`;
-  import_fs2.default.writeFileSync(htmlOutputPath, drawerHtml.trim(), "utf-8");
+  import_fs3.default.writeFileSync(htmlOutputPath, drawerHtml.trim(), "utf-8");
   if (hasMarkdown) {
-    import_fs2.default.unlinkSync(markdownPath);
+    import_fs3.default.unlinkSync(markdownPath);
   }
 }
 
 // src/utils/attachFiles.ts
 function attachFiles(subFolder, result, testResult, config, steps, errors) {
   const folderPath = config.folderPath || "ortoni-report";
-  const attachmentsFolder = import_path2.default.join(
+  const attachmentsFolder = import_path3.default.join(
     folderPath,
     "ortoni-data",
     "attachments",
     subFolder
   );
-  if (!import_fs3.default.existsSync(attachmentsFolder)) {
-    import_fs3.default.mkdirSync(attachmentsFolder, { recursive: true });
+  if (!import_fs4.default.existsSync(attachmentsFolder)) {
+    import_fs4.default.mkdirSync(attachmentsFolder, { recursive: true });
   }
   if (!result.attachments) return;
   const { base64Image } = config;
@@ -1422,14 +1534,14 @@ function attachFiles(subFolder, result, testResult, config, steps, errors) {
   result.attachments.forEach((attachment) => {
     const { contentType, name, path: attachmentPath, body } = attachment;
     if (!attachmentPath && !body) return;
-    const fileName = attachmentPath ? import_path2.default.basename(attachmentPath) : `${name}.${getFileExtension(contentType)}`;
-    const relativePath = import_path2.default.join(
+    const fileName = attachmentPath ? import_path3.default.basename(attachmentPath) : `${name}.${getFileExtension(contentType)}`;
+    const relativePath = import_path3.default.join(
       "ortoni-data",
       "attachments",
       subFolder,
       fileName
     );
-    const fullPath = import_path2.default.join(attachmentsFolder, fileName);
+    const fullPath = import_path3.default.join(attachmentsFolder, fileName);
     if (contentType === "image/png") {
       handleImage(
         attachmentPath,
@@ -1472,13 +1584,13 @@ function handleImage(attachmentPath, body, base64Image, fullPath, relativePath,
   let screenshotPath = "";
   if (attachmentPath) {
     try {
-      const screenshotContent = import_fs3.default.readFileSync(
+      const screenshotContent = import_fs4.default.readFileSync(
         attachmentPath,
         base64Image ? "base64" : void 0
       );
       screenshotPath = base64Image ? `data:image/png;base64,${screenshotContent}` : relativePath;
       if (!base64Image) {
-        import_fs3.default.copyFileSync(attachmentPath, fullPath);
+        import_fs4.default.copyFileSync(attachmentPath, fullPath);
       }
     } catch (error) {
       console.error(
@@ -1495,7 +1607,7 @@ function handleImage(attachmentPath, body, base64Image, fullPath, relativePath,
 }
 function handleAttachment(attachmentPath, fullPath, relativePath, resultKey, testResult, steps, errors) {
   if (attachmentPath) {
-    import_fs3.default.copyFileSync(attachmentPath, fullPath);
+    import_fs4.default.copyFileSync(attachmentPath, fullPath);
     if (resultKey === "videoPath") {
       testResult[resultKey]?.push(relativePath);
     } else if (resultKey === "tracePath") {
@@ -1521,13 +1633,13 @@ function getFileExtension(contentType) {
 }
 
 // src/utils/utils.ts
-var import_path3 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 function normalizeFilePath(filePath) {
-  const normalizedPath = import_path3.default.normalize(filePath);
-  return import_path3.default.basename(normalizedPath);
+  const normalizedPath = import_path4.default.normalize(filePath);
+  return import_path4.default.basename(normalizedPath);
 }
 function ensureHtmlExtension(filename) {
-  const ext = import_path3.default.extname(filename);
+  const ext = import_path4.default.extname(filename);
   if (ext && ext.toLowerCase() === ".html") {
     return filename;
   }
@@ -1575,7 +1687,7 @@ function extractSuites(titlePath) {
   };
 }
 
-// src/helpers/resultProcessor .ts
+// src/helpers/resultProcessor.ts
 var TestResultProcessor = class {
   constructor(projectRoot) {
     this.ansiToHtml = new import_ansi_to_html.default({ fg: "var(--snippet-color)" });
@@ -1620,7 +1732,7 @@ var TestResultProcessor = class {
       testId: `${filePath}:${projectName}:${title}`
     };
     attachFiles(
-      test.id,
+      import_path5.default.join(test.id, `retry-${result.retry}`),
       result,
       testResult,
       ortoniConfig,
@@ -1631,7 +1743,7 @@ var TestResultProcessor = class {
   }
   processSteps(steps) {
     return steps.map((step) => {
-      const stepLocation = step.location ? `${import_path4.default.relative(this.projectRoot, step.location.file)}:${step.location.line}:${step.location.column}` : "";
+      const stepLocation = step.location ? `${import_path5.default.relative(this.projectRoot, step.location.file)}:${step.location.line}:${step.location.column}` : "";
       return {
         snippet: this.ansiToHtml.toHtml(escapeHtml(step.error?.snippet || "")),
         title: step.title,
@@ -1643,16 +1755,16 @@ var TestResultProcessor = class {
 
 // src/utils/expressServer.ts
 var import_express = __toESM(require("express"));
-var import_path5 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 var import_child_process = require("child_process");
 function startReportServer(reportFolder, reportFilename, port = 2004, open2) {
   const app = (0, import_express.default)();
-  app.use(import_express.default.static(reportFolder));
+  app.use(import_express.default.static(reportFolder, { index: false }));
   app.get("/", (_req, res) => {
     try {
-      res.sendFile(import_path5.default.resolve(reportFolder, reportFilename));
+      res.sendFile(import_path6.default.resolve(reportFolder, reportFilename));
     } catch (error) {
-      console.error("Ortoni-Report: Error sending report file:", error);
+      console.error("Ortoni Report: Error sending report file:", error);
       res.status(500).send("Error loading report");
     }
   });
@@ -1666,21 +1778,21 @@ Press Ctrl+C to stop.`
         try {
           openBrowser(`http://localhost:${port}`);
         } catch (error) {
-          console.error("Ortoni-Report: Error opening browser:", error);
+          console.error("Ortoni Report: Error opening browser:", error);
         }
       }
     });
     server.on("error", (error) => {
       if (error.code === "EADDRINUSE") {
         console.error(
-          `Ortoni-Report: Port ${port} is already in use. Trying a different port...`
+          `Ortoni Report: Port ${port} is already in use. Trying a different port...`
         );
       } else {
-        console.error("Ortoni-Report: Server error:", error);
+        console.error("Ortoni Report: Server error:", error);
       }
     });
   } catch (error) {
-    console.error("Ortoni-Report: Error starting the server:", error);
+    console.error("Ortoni Report: Error starting the server:", error);
   }
 }
 function openBrowser(url) {
@@ -1698,7 +1810,7 @@ function openBrowser(url) {
       (0, import_child_process.spawn)(command, [url]);
     }
   } catch (error) {
-    console.error("Ortoni-Report: Error opening the browser:", error);
+    console.error("Ortoni Report: Error opening the browser:", error);
   }
 }
 
@@ -1707,7 +1819,7 @@ var ServerManager = class {
   constructor(ortoniConfig) {
     this.ortoniConfig = ortoniConfig;
   }
-  startServer(folderPath, outputFilename, overAllStatus) {
+  async startServer(folderPath, outputFilename, overAllStatus) {
     const openOption = this.ortoniConfig.open || "never";
     const hasFailures = overAllStatus === "failed";
     if (openOption === "always" || openOption === "on-failure" && hasFailures) {
@@ -1717,6 +1829,8 @@ var ServerManager = class {
         this.ortoniConfig.port,
         openOption
       );
+      await new Promise((_resolve) => {
+      });
     }
   }
 };
@@ -1996,7 +2110,7 @@ var DatabaseManager = class {
 };
 
 // src/ortoni-report.ts
-var import_path6 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 var OrtoniReport = class {
   constructor(ortoniConfig = {}) {
     this.ortoniConfig = ortoniConfig;
@@ -2027,9 +2141,9 @@ var OrtoniReport = class {
     this.testResultProcessor = new TestResultProcessor(config.rootDir);
     this.fileManager.ensureReportDirectory();
     await this.dbManager.initialize(
-      import_path6.default.join(this.folderPath, "ortoni-data-history.sqlite")
+      import_path7.default.join(this.folderPath, "ortoni-data-history.sqlite")
     );
-    this.config = config?.shard;
+    this.shardConfig = config?.shard;
   }
   onStdOut(chunk, _test, _result) {
     if (this.reportsCount == 1 && this.showConsoleLogs) {
@@ -2046,7 +2160,7 @@ var OrtoniReport = class {
       );
       this.results.push(testResult);
     } catch (error) {
-      console.error("OrtoniReport: Error processing test end:", error);
+      console.error("Ortoni Report: Error processing test end:", error);
     }
   }
   printsToStdio() {
@@ -2065,12 +2179,12 @@ var OrtoniReport = class {
           (r) => r.status !== "skipped"
         );
         const totalDuration = result.duration;
-        if (this.config && this.config.total > 1) {
-          const shard = this.config;
+        if (this.shardConfig && this.shardConfig.total > 1) {
+          const shard = this.shardConfig;
           const shardFile = `ortoni-shard-${shard.current}-of-${shard.total}.json`;
           const shardData = {
-            status: result.status,
-            duration: totalDuration,
+            // status: result.status,
+            totalDuration,
             results: this.results,
             projectSet: Array.from(this.projectSet),
             userConfig: {
@@ -2083,8 +2197,11 @@ var OrtoniReport = class {
               meta: this.ortoniConfig.meta
             }
           };
-          this.fileManager.writeRawFile(shardFile, shardData);
-          console.log(`\u{1F4E6} OrtoniReport wrote shard file: ${shardFile}`);
+          const shardFilePath = this.fileManager.writeRawFile(
+            shardFile,
+            shardData
+          );
+          console.info(`Ortoni Report: Shard data written to ${shardFilePath}`);
           this.shouldGenerateReport = false;
           return;
         }
@@ -2097,21 +2214,21 @@ var OrtoniReport = class {
             this.results,
             this.projectSet
           );
-          this.outputPath = this.fileManager.writeReportFile(
+          this.outputPath = await this.fileManager.writeReportFile(
             this.outputFilename,
             finalReportData
           );
         } else {
-          console.error("OrtoniReport: Error saving test run to database");
+          console.error("Ortoni Report: Error saving test run to database");
         }
       } else {
         console.error(
-          "OrtoniReport: Report generation skipped due to error in Playwright worker!"
+          "Ortoni Report: Report generation skipped due to error in Playwright worker!"
         );
       }
     } catch (error) {
       this.shouldGenerateReport = false;
-      console.error("OrtoniReport: Error generating report:", error);
+      console.error("Ortoni Report: Error generating report:", error);
     }
   }
   async onExit() {
@@ -2119,17 +2236,15 @@ var OrtoniReport = class {
       await this.dbManager.close();
       if (this.shouldGenerateReport) {
         this.fileManager.copyTraceViewerAssets(this.skipTraceViewer);
-        console.info(`Ortoni HTML report generated at ${this.outputPath}`);
-        this.serverManager.startServer(
+        console.info(`Ortoni Report generated at ${this.outputPath}`);
+        await this.serverManager.startServer(
           this.folderPath,
           this.outputFilename,
           this.overAllStatus
         );
-        await new Promise((_resolve) => {
-        });
       }
     } catch (error) {
-      console.error("OrtoniReport: Error in onExit:", error);
+      console.error("Ortoni Report: Error in onExit:", error);
     }
   }
 };