ortoni-report 4.0.2 → 4.0.4

package/dist/mergeData.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Merge shard JSON files into a single report while keeping ALL test results.
+ *
+ * options:
+ *  - dir?: folder where shard files exist (default: "ortoni-report")
+ *  - file?: output file name for final HTML (default: "ortoni-report.html")
+ *  - saveHistory?: boolean | undefined -> if provided, overrides shard/userConfig
+ */
+export declare function mergeAllData(options?: {
+    dir?: string;
+    file?: string;
+    saveHistory?: boolean;
+}): Promise<void>;

package/dist/mergeData.js

@@ -0,0 +1,182 @@
+// src/mergeAllData.ts
+import * as fs from "fs";
+import * as path from "path";
+import { DatabaseManager } from "./helpers/databaseManager";
+import { HTMLGenerator } from "./helpers/HTMLGenerator";
+import { FileManager } from "./helpers/fileManager";
+/**
+ * Merge shard JSON files into a single report while keeping ALL test results.
+ *
+ * options:
+ *  - dir?: folder where shard files exist (default: "ortoni-report")
+ *  - file?: output file name for final HTML (default: "ortoni-report.html")
+ *  - saveHistory?: boolean | undefined -> if provided, overrides shard/userConfig
+ */
+export async function mergeAllData(options = {}) {
+    const folderPath = options.dir || "ortoni-report";
+    console.info(`Ortoni Report: Merging shard files in folder: ${folderPath}`);
+    if (!fs.existsSync(folderPath)) {
+        console.error(`Ortoni Report: folder "${folderPath}" does not exist.`);
+        process.exitCode = 1;
+        return;
+    }
+    const filenames = fs
+        .readdirSync(folderPath)
+        .filter((f) => f.startsWith("ortoni-shard-") && f.endsWith(".json"));
+    if (filenames.length === 0) {
+        console.error("Ortoni Report: ❌ No shard files found to merge.");
+        process.exitCode = 1;
+        return;
+    }
+    // deterministic sort by numeric shard index if available (ortoni-shard-<current>-of-<total>.json)
+    const shardFileIndex = (name) => {
+        const m = name.match(/ortoni-shard-(\d+)-of-(\d+)\.json$/);
+        return m ? parseInt(m[1], 10) : null;
+    };
+    const sortedFiles = filenames
+        .map((f) => ({ f, idx: shardFileIndex(f) }))
+        .sort((a, b) => {
+        if (a.idx === null && b.idx === null)
+            return a.f.localeCompare(b.f);
+        if (a.idx === null)
+            return 1;
+        if (b.idx === null)
+            return -1;
+        return a.idx - b.idx;
+    })
+        .map((x) => x.f);
+    // Merge state
+    const allResults = []; // keep every test entry from every shard
+    const projectSet = new Set();
+    let totalDurationSum = 0; // sum of shard durations (ms)
+    let mergedUserConfig = null;
+    let mergedUserMeta = null;
+    const badShards = [];
+    const shardCounts = {};
+    const shardDurMap = {}; // used duration per shard (ms)
+    for (const file of sortedFiles) {
+        const fullPath = path.join(folderPath, file);
+        try {
+            const shardRaw = fs.readFileSync(fullPath, "utf-8");
+            const shardData = JSON.parse(shardRaw);
+            // Validate results array
+            if (!Array.isArray(shardData.results)) {
+                console.warn(`Ortoni Report: Shard ${file} missing results array — skipping.`);
+                badShards.push(file);
+                continue;
+            }
+            // Append all results (keep duplicates)
+            shardData.results.forEach((r) => allResults.push(r));
+            shardCounts[file] = shardData.results.length;
+            // Merge project sets
+            if (Array.isArray(shardData.projectSet)) {
+                shardData.projectSet.forEach((p) => projectSet.add(p));
+            }
+            // Duration handling:
+            // Accept shardData.totalDuration when it is a number (including 0).
+            // Fallback: if shardData.totalDuration is missing or not a number, sum per-test durations inside the shard.
+            const rawShardDur = shardData.totalDuration;
+            let durToAdd = 0;
+            let perTestSum = 0;
+            if (typeof rawShardDur === "number") {
+                // Accept numeric durations (including 0)
+                durToAdd = rawShardDur;
+            }
+            else {
+                // fallback: sum per-test durations (coerce to Number)
+                perTestSum = Array.isArray(shardData.results)
+                    ? shardData.results.reduce((acc, t) => acc + (Number(t?.duration) || 0), 0)
+                    : 0;
+                durToAdd = perTestSum;
+            }
+            // accumulate
+            totalDurationSum += durToAdd;
+            shardDurMap[file] = durToAdd;
+            // Merge userConfig/userMeta conservatively (prefer first non-empty value)
+            if (shardData.userConfig) {
+                if (!mergedUserConfig)
+                    mergedUserConfig = { ...shardData.userConfig };
+                else {
+                    Object.keys(shardData.userConfig).forEach((k) => {
+                        if (mergedUserConfig[k] === undefined ||
+                            mergedUserConfig[k] === null ||
+                            mergedUserConfig[k] === "") {
+                            mergedUserConfig[k] = shardData.userConfig[k];
+                        }
+                        else if (shardData.userConfig[k] !== mergedUserConfig[k]) {
+                            console.warn(`Ortoni Report: userConfig mismatch for key "${k}" between shards. Using first value "${mergedUserConfig[k]}".`);
+                        }
+                    });
+                }
+            }
+            if (shardData.userMeta) {
+                if (!mergedUserMeta)
+                    mergedUserMeta = { ...shardData.userMeta };
+                else {
+                    mergedUserMeta.meta = {
+                        ...(mergedUserMeta.meta || {}),
+                        ...(shardData.userMeta.meta || {}),
+                    };
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Ortoni Report: Failed to parse shard ${file}:`, err);
+            badShards.push(file);
+            continue;
+        }
+    } // end for each shard
+    if (badShards.length > 0) {
+        console.warn(`Ortoni Report: Completed merge with ${badShards.length} bad shard(s) skipped:`, badShards);
+    }
+    // final results preserved with duplicates
+    const totalDuration = totalDurationSum; // in ms
+    // Determine whether to persist history:
+    // Priority: explicit options.saveHistory -> mergedUserConfig.saveHistory -> default true
+    const saveHistoryFromOptions = typeof options.saveHistory === "boolean" ? options.saveHistory : undefined;
+    const saveHistoryFromShard = mergedUserConfig && typeof mergedUserConfig.saveHistory === "boolean"
+        ? mergedUserConfig.saveHistory
+        : undefined;
+    const saveHistory = saveHistoryFromOptions ?? saveHistoryFromShard ?? true;
+    let dbManager;
+    let runId;
+    if (saveHistory) {
+        try {
+            dbManager = new DatabaseManager();
+            const dbPath = path.join(folderPath, "ortoni-data-history.sqlite");
+            await dbManager.initialize(dbPath);
+            runId = await dbManager.saveTestRun();
+            if (typeof runId === "number") {
+                // Save all results (your saveTestResults may batch internally)
+                await dbManager.saveTestResults(runId, allResults);
+                console.info(`Ortoni Report: Saved ${allResults.length} results to DB (runId=${runId}).`);
+            }
+            else {
+                console.warn("Ortoni Report: Failed to create test run in DB; proceeding without saving results.");
+            }
+        }
+        catch (err) {
+            console.error("Ortoni Report: Error while saving history to DB. Proceeding without DB:", err);
+            dbManager = undefined;
+            runId = undefined;
+        }
+    }
+    else {
+        console.info("Ortoni Report: Skipping history save (saveHistory=false). (Typical for CI runs)");
+    }
+    // Generate final report
+    const htmlGenerator = new HTMLGenerator({ ...(mergedUserConfig || {}), meta: mergedUserMeta?.meta }, dbManager);
+    const finalReportData = await htmlGenerator.generateFinalReport(
+    // filteredResults: typically filter out skipped for display (keeps existing behavior)
+    allResults.filter((r) => r.status !== "skipped"), totalDuration, allResults, projectSet // pass Set<string> as original generateFinalReport expects
+    );
+    // Write final HTML file
+    const fileManager = new FileManager(folderPath);
+    const outputFileName = options.file || "ortoni-report.html";
+    const outputPath = fileManager.writeReportFile(outputFileName, finalReportData);
+    // Logs & debugging summary
+    console.log(`✅ Final merged report generated at ${await outputPath}`);
+    console.log(`✅ Shards merged: ${sortedFiles.length}`);
+    console.log(`✅ Tests per shard:`, shardCounts);
+    console.log(`✅ Total tests merged ${allResults.length}`);
+}

package/dist/ortoni-report.js

@@ -195,6 +195,67 @@ function groupResults(config, results) {
   }
 }
 
+// src/utils/utils.ts
+var import_path3 = __toESM(require("path"));
+function normalizeFilePath(filePath) {
+  const normalizedPath = import_path3.default.normalize(filePath);
+  return import_path3.default.basename(normalizedPath);
+}
+function ensureHtmlExtension(filename) {
+  const ext = import_path3.default.extname(filename);
+  if (ext && ext.toLowerCase() === ".html") {
+    return filename;
+  }
+  return `${filename}.html`;
+}
+function escapeHtml(unsafe) {
+  if (typeof unsafe !== "string") {
+    return String(unsafe);
+  }
+  return unsafe.replace(/[&<"']/g, function(match) {
+    const escapeMap = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#039;"
+    };
+    return escapeMap[match] || match;
+  });
+}
+function formatDateLocal(dateInput) {
+  if (!dateInput) return "N/A";
+  try {
+    const date = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
+    if (isNaN(date.getTime())) {
+      return "N/A";
+    }
+    const options = {
+      year: "numeric",
+      month: "short",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: true
+    };
+    return new Intl.DateTimeFormat("en-US", options).format(date);
+  } catch (e) {
+    return "N/A";
+  }
+}
+function extractSuites(titlePath) {
+  const tagPattern = /@[\w]+/g;
+  const suiteParts = titlePath.slice(3, titlePath.length - 1).map((p) => p.replace(tagPattern, "").trim());
+  return {
+    hierarchy: suiteParts.join(" > "),
+    // full hierarchy
+    topLevelSuite: suiteParts[0] ?? "",
+    // first suite
+    parentSuite: suiteParts[suiteParts.length - 1] ?? ""
+    // last suite
+  };
+}
+
 // src/helpers/HTMLGenerator.ts
 var HTMLGenerator = class {
   constructor(ortoniConfig, dbManager) {
@@ -268,7 +329,7 @@ var HTMLGenerator = class {
       results,
       projectSet
     );
-    const lastRunDate = (/* @__PURE__ */ new Date()).toLocaleString();
+    const lastRunDate = formatDateLocal(/* @__PURE__ */ new Date());
     const testHistories = await Promise.all(
       results.map(async (result) => {
         const testId = `${result.filePath}:${result.projectName}:${result.title}`;
@@ -375,7 +436,7 @@ var import_ansi_to_html = __toESM(require("ansi-to-html"));
 var import_path5 = __toESM(require("path"));
 
 // src/utils/attachFiles.ts
-var import_path3 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 var import_fs4 = __toESM(require("fs"));
 
 // src/helpers/markdownConverter.ts
@@ -1518,7 +1579,7 @@ function convertMarkdownToHtml(markdownPath, htmlOutputPath) {
 // src/utils/attachFiles.ts
 function attachFiles(subFolder, result, testResult, config, steps, errors) {
   const folderPath = config.folderPath || "ortoni-report";
-  const attachmentsFolder = import_path3.default.join(
+  const attachmentsFolder = import_path4.default.join(
     folderPath,
     "ortoni-data",
     "attachments",
@@ -1534,14 +1595,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_path3.default.basename(attachmentPath) : `${name}.${getFileExtension(contentType)}`;
-    const relativePath = import_path3.default.join(
+    const fileName = attachmentPath ? import_path4.default.basename(attachmentPath) : `${name}.${getFileExtension(contentType)}`;
+    const relativePath = import_path4.default.join(
       "ortoni-data",
       "attachments",
       subFolder,
       fileName
     );
-    const fullPath = import_path3.default.join(attachmentsFolder, fileName);
+    const fullPath = import_path4.default.join(attachmentsFolder, fileName);
     if (contentType === "image/png") {
       handleImage(
         attachmentPath,
@@ -1632,61 +1693,6 @@ function getFileExtension(contentType) {
   return extensions[contentType] || "unknown";
 }
 
-// src/utils/utils.ts
-var import_path4 = __toESM(require("path"));
-function normalizeFilePath(filePath) {
-  const normalizedPath = import_path4.default.normalize(filePath);
-  return import_path4.default.basename(normalizedPath);
-}
-function ensureHtmlExtension(filename) {
-  const ext = import_path4.default.extname(filename);
-  if (ext && ext.toLowerCase() === ".html") {
-    return filename;
-  }
-  return `${filename}.html`;
-}
-function escapeHtml(unsafe) {
-  if (typeof unsafe !== "string") {
-    return String(unsafe);
-  }
-  return unsafe.replace(/[&<"']/g, function(match) {
-    const escapeMap = {
-      "&": "&amp;",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#039;"
-    };
-    return escapeMap[match] || match;
-  });
-}
-function formatDateLocal(dateInput) {
-  const date = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
-  const options = {
-    year: "numeric",
-    month: "short",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: true,
-    timeZoneName: "short"
-    // or "Asia/Kolkata"
-  };
-  return new Intl.DateTimeFormat(void 0, options).format(date);
-}
-function extractSuites(titlePath) {
-  const tagPattern = /@[\w]+/g;
-  const suiteParts = titlePath.slice(3, titlePath.length - 1).map((p) => p.replace(tagPattern, "").trim());
-  return {
-    hierarchy: suiteParts.join(" > "),
-    // full hierarchy
-    topLevelSuite: suiteParts[0] ?? "",
-    // first suite
-    parentSuite: suiteParts[suiteParts.length - 1] ?? ""
-    // last suite
-  };
-}
-
 // src/helpers/resultProcessor.ts
 var TestResultProcessor = class {
   constructor(projectRoot) {
@@ -1732,7 +1738,7 @@ var TestResultProcessor = class {
       testId: `${filePath}:${projectName}:${title}`
     };
     attachFiles(
-      test.id,
+      import_path5.default.join(test.id, `retry-${result.retry}`),
       result,
       testResult,
       ortoniConfig,
@@ -1961,7 +1967,8 @@ var DatabaseManager = class {
       );
       return results.map((result) => ({
         ...result,
-        run_date: formatDateLocal(result.run_date)
+        run_date: result.run_date
+        // Return raw ISO string to avoid parsing issues in browser
       }));
     } catch (error) {
       console.error("OrtoniReport: Error getting test history:", error);
@@ -2044,7 +2051,8 @@ var DatabaseManager = class {
       );
       return rows.reverse().map((row) => ({
         ...row,
-        run_date: formatDateLocal(row.run_date),
+        run_date: row.run_date,
+        // Return raw ISO string for chart compatibility
         avg_duration: Math.round(row.avg_duration || 0)
         // raw ms avg
       }));

package/dist/ortoni-report.mjs

@@ -8,7 +8,7 @@ import {
   extractSuites,
   normalizeFilePath,
   startReportServer
-} from "./chunk-4RZ5C7KY.mjs";
+} from "./chunk-L6VOLEP2.mjs";
 
 // src/helpers/resultProcessor.ts
 import AnsiToHtml from "ansi-to-html";
@@ -1317,7 +1317,7 @@ var TestResultProcessor = class {
       testId: `${filePath}:${projectName}:${title}`
     };
     attachFiles(
-      test.id,
+      path2.join(test.id, `retry-${result.retry}`),
       result,
       testResult,
       ortoniConfig,

package/dist/types/reporterConfig.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Configuration options for OrtoniReport.
+ */
+export interface OrtoniReportConfig {
+    /**
+     * Open the report in local host (Trace viewer is accessible only in localhost)
+     * @example "always"| "never"| "on-failure";
+     * @default "never"
+     */
+    open?: "always" | "never" | "on-failure";
+    /**
+     * The title of the HTML report.
+     * @example "Ortoni Playwright Test Report"
+     */
+    title?: string;
+    /**
+     * Add project on the list of the tests? (Filtering projects still works if hidden)
+     * @example true to display, false to hide.
+     * @default false
+     */
+    showProject?: boolean;
+    /**
+     * The name of the project.
+     * @example "Ortoni Project"
+     */
+    projectName?: string;
+    /**
+     * The name of the author.
+     * @example "Koushik Chatterjee"
+     */
+    authorName?: string;
+    /**
+     * The type of tests being run.
+     * @example "Regression"
+     */
+    testType?: string;
+    /**
+     * If true, images will be encoded in base64.
+     * Not recommended to use if many screenshots are present.
+     * @default false
+     * @example true
+     */
+    base64Image?: boolean;
+    /**
+     * The local relative of the logo image.
+     * Recommended to keep within the report genrated folder.
+     * @default "ortoni-report/logo.png"
+     * @example "logo.png"
+     */
+    logo?: string;
+    /**
+     * The filename to the html report.
+     * @example "index.html"
+     * @default "ortoni-report.html"
+     */
+    filename?: string;
+    /**
+     * The folder name.
+     * @example "report"
+     * @default "ortoni-report"
+     */
+    folderPath?: string;
+    /**
+     * Port to connect
+     * @example 3600
+     */
+    port?: number;
+    /**
+     * Display console logs?
+     * @example boolean
+     * @default true
+     */
+    stdIO?: boolean;
+    /**
+     * Metadata for the report. ['Test Cycle': 'Cycle 1', 'Test Environment':'QA', etc]
+     * @example { "key": "value" } as string
+     */
+    meta?: Record<string, string>;
+    /**
+     * Save the history of the reports in a SQL file to be used in future reports.
+     * The history file will be saved in the report folder.
+     * @default true
+     * @example false (to disable)
+     */
+    saveHistory?: boolean;
+}

package/dist/types/reporterConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/types/testResults.d.ts

@@ -0,0 +1,31 @@
+export interface Steps {
+    snippet: string | undefined;
+    title: string;
+    location: string;
+}
+export interface TestResultData {
+    suiteHierarchy: string;
+    key: string;
+    annotations: any[];
+    testTags: string[];
+    location: string;
+    retryAttemptCount: number;
+    projectName: any;
+    suite: any;
+    title: string;
+    status: "passed" | "failed" | "timedOut" | "skipped" | "interrupted" | "expected" | "unexpected" | "flaky";
+    flaky: string;
+    duration: number;
+    errors: any[];
+    steps: Steps[];
+    logs: string;
+    screenshotPath?: string | null | undefined;
+    screenshots?: string[];
+    filePath: string;
+    filters: Set<string>;
+    tracePath?: string;
+    videoPath?: string[];
+    markdownPath?: string;
+    base64Image: boolean | undefined;
+    testId: string;
+}

package/dist/types/testResults.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/attachFiles.d.ts

@@ -0,0 +1,4 @@
+import { TestResult } from "@playwright/test/reporter";
+import { Steps, TestResultData } from "../types/testResults";
+import { OrtoniReportConfig } from "../types/reporterConfig";
+export declare function attachFiles(subFolder: string, result: TestResult, testResult: TestResultData, config: OrtoniReportConfig, steps?: Steps[], errors?: string[]): void;

package/dist/utils/attachFiles.js

@@ -0,0 +1,87 @@
+import path from "path";
+import fs from "fs";
+import { convertMarkdownToHtml } from "../helpers/markdownConverter";
+export function attachFiles(subFolder, result, testResult, config, steps, errors) {
+    const folderPath = config.folderPath || "ortoni-report";
+    const attachmentsFolder = path.join(folderPath, "ortoni-data", "attachments", subFolder);
+    if (!fs.existsSync(attachmentsFolder)) {
+        fs.mkdirSync(attachmentsFolder, { recursive: true });
+    }
+    if (!result.attachments)
+        return;
+    const { base64Image } = config;
+    testResult.screenshots = [];
+    testResult.videoPath = [];
+    result.attachments.forEach((attachment) => {
+        const { contentType, name, path: attachmentPath, body } = attachment;
+        if (!attachmentPath && !body)
+            return;
+        const fileName = attachmentPath
+            ? path.basename(attachmentPath)
+            : `${name}.${getFileExtension(contentType)}`;
+        const relativePath = path.join("ortoni-data", "attachments", subFolder, fileName);
+        const fullPath = path.join(attachmentsFolder, fileName);
+        if (contentType === "image/png") {
+            handleImage(attachmentPath, body, base64Image, fullPath, relativePath, testResult);
+        }
+        else if (name === "video") {
+            handleAttachment(attachmentPath, fullPath, relativePath, "videoPath", testResult);
+        }
+        else if (name === "trace") {
+            handleAttachment(attachmentPath, fullPath, relativePath, "tracePath", testResult);
+        }
+        else if (name === "error-context") {
+            handleAttachment(attachmentPath, fullPath, relativePath, "markdownPath", testResult, steps, errors);
+        }
+    });
+}
+function handleImage(attachmentPath, body, base64Image, fullPath, relativePath, testResult) {
+    let screenshotPath = "";
+    if (attachmentPath) {
+        try {
+            const screenshotContent = fs.readFileSync(attachmentPath, base64Image ? "base64" : undefined);
+            screenshotPath = base64Image
+                ? `data:image/png;base64,${screenshotContent}`
+                : relativePath;
+            if (!base64Image) {
+                fs.copyFileSync(attachmentPath, fullPath);
+            }
+        }
+        catch (error) {
+            console.error(`OrtoniReport: Failed to read screenshot file: ${attachmentPath}`, error);
+        }
+    }
+    else if (body) {
+        screenshotPath = `data:image/png;base64,${body.toString("base64")}`;
+    }
+    if (screenshotPath) {
+        testResult.screenshots?.push(screenshotPath);
+    }
+}
+function handleAttachment(attachmentPath, fullPath, relativePath, resultKey, testResult, steps, errors) {
+    if (attachmentPath) {
+        fs.copyFileSync(attachmentPath, fullPath);
+        if (resultKey === "videoPath") {
+            testResult[resultKey]?.push(relativePath);
+        }
+        else if (resultKey === "tracePath") {
+            testResult[resultKey] = relativePath;
+        }
+    }
+    if (resultKey === "markdownPath" && errors) {
+        const htmlPath = fullPath.replace(/\.md$/, ".html");
+        const htmlRelativePath = relativePath.replace(/\.md$/, ".html");
+        convertMarkdownToHtml(fullPath, htmlPath);
+        testResult[resultKey] = htmlRelativePath;
+        return;
+    }
+}
+function getFileExtension(contentType) {
+    const extensions = {
+        "image/png": "png",
+        "video/webm": "webm",
+        "application/zip": "zip",
+        "text/markdown": "md",
+    };
+    return extensions[contentType] || "unknown";
+}

package/dist/utils/expressServer.d.ts

@@ -0,0 +1 @@
+export declare function startReportServer(reportFolder: string, reportFilename: string, port: number, open: string | undefined): void;