ortoni-report 4.0.2 → 4.0.3

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

@@ -1732,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,

package/dist/ortoni-report.mjs

@@ -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;

package/dist/utils/expressServer.js

@@ -0,0 +1,61 @@
+import express from "express";
+import path from "path";
+import { spawn } from "child_process";
+export function startReportServer(reportFolder, reportFilename, port = 2004, open) {
+    const app = express();
+    app.use(express.static(reportFolder, { index: false }));
+    app.get("/", (_req, res) => {
+        try {
+            res.sendFile(path.resolve(reportFolder, reportFilename));
+        }
+        catch (error) {
+            console.error("Ortoni Report: Error sending report file:", error);
+            res.status(500).send("Error loading report");
+        }
+    });
+    try {
+        const server = app.listen(port, () => {
+            console.log(`Server is running at http://localhost:${port} \nPress Ctrl+C to stop.`);
+            if (open === "always" || open === "on-failure") {
+                try {
+                    openBrowser(`http://localhost:${port}`);
+                }
+                catch (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...`);
+            }
+            else {
+                console.error("Ortoni Report: Server error:", error);
+            }
+        });
+    }
+    catch (error) {
+        console.error("Ortoni Report: Error starting the server:", error);
+    }
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+    try {
+        if (platform === "win32") {
+            command = "cmd";
+            spawn(command, ["/c", "start", url]);
+        }
+        else if (platform === "darwin") {
+            command = "open";
+            spawn(command, [url]);
+        }
+        else {
+            command = "xdg-open";
+            spawn(command, [url]);
+        }
+    }
+    catch (error) {
+        console.error("Ortoni Report: Error opening the browser:", error);
+    }
+}

package/dist/utils/groupProjects.d.ts

@@ -0,0 +1,3 @@
+import { OrtoniReportConfig } from "../types/reporterConfig";
+import { TestResultData } from "../types/testResults";
+export declare function groupResults(config: OrtoniReportConfig, results: TestResultData[]): any;

package/dist/utils/groupProjects.js

@@ -0,0 +1,30 @@
+export function groupResults(config, results) {
+    if (config.showProject) {
+        // Group by filePath, suite, and projectName
+        const groupedResults = results.reduce((acc, result, index) => {
+            const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+            const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
+            const { filePath, suite, projectName } = result;
+            acc[filePath] = acc[filePath] || {};
+            acc[filePath][suite] = acc[filePath][suite] || {};
+            acc[filePath][suite][projectName] =
+                acc[filePath][suite][projectName] || [];
+            acc[filePath][suite][projectName].push({ ...result, index, testId, key });
+            return acc;
+        }, {});
+        return groupedResults;
+    }
+    else {
+        // Group by filePath and suite, ignoring projectName
+        const groupedResults = results.reduce((acc, result, index) => {
+            const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+            const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
+            const { filePath, suite } = result;
+            acc[filePath] = acc[filePath] || {};
+            acc[filePath][suite] = acc[filePath][suite] || [];
+            acc[filePath][suite].push({ ...result, index, testId, key });
+            return acc;
+        }, {});
+        return groupedResults;
+    }
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,15 @@
+export declare function normalizeFilePath(filePath: string): string;
+export declare function formatDate(date: Date): string;
+export declare function safeStringify(obj: any, indent?: number): string;
+export declare function ensureHtmlExtension(filename: string): string;
+export declare function escapeHtml(unsafe: string): string;
+export declare function formatDateUTC(date: Date): string;
+export declare function formatDateLocal(dateInput: Date | string): string;
+export declare function formatDateNoTimezone(isoString: string): string;
+type SuiteAndTitle = {
+    hierarchy: string;
+    topLevelSuite: string;
+    parentSuite: string;
+};
+export declare function extractSuites(titlePath: string[]): SuiteAndTitle;
+export {};

package/dist/utils/utils.js

@@ -0,0 +1,84 @@
+import path from "path";
+export function normalizeFilePath(filePath) {
+    // Normalize the path to handle different separators
+    const normalizedPath = path.normalize(filePath);
+    // Get the base name of the file (removes any leading directories)
+    return path.basename(normalizedPath);
+}
+export function formatDate(date) {
+    const day = String(date.getDate()).padStart(2, "0");
+    const month = date.toLocaleString("default", { month: "short" });
+    const year = date.getFullYear();
+    const time = date.toLocaleTimeString();
+    return `${day}-${month}-${year} ${time}`;
+}
+export function safeStringify(obj, indent = 2) {
+    const cache = new Set();
+    const json = JSON.stringify(obj, (key, value) => {
+        if (typeof value === "object" && value !== null) {
+            if (cache.has(value)) {
+                return;
+            }
+            cache.add(value);
+        }
+        return value;
+    }, indent);
+    cache.clear();
+    return json;
+}
+export function ensureHtmlExtension(filename) {
+    const ext = path.extname(filename);
+    if (ext && ext.toLowerCase() === ".html") {
+        return filename;
+    }
+    return `${filename}.html`;
+}
+export 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;
+    });
+}
+export function formatDateUTC(date) {
+    return date.toISOString();
+}
+export 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(undefined, options).format(date);
+}
+export function formatDateNoTimezone(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleString("en-US", {
+        dateStyle: "medium",
+        timeStyle: "short",
+    });
+}
+export 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(" > "),
+        topLevelSuite: suiteParts[0] ?? "",
+        parentSuite: suiteParts[suiteParts.length - 1] ?? "", // last suite
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ortoni-report",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "Playwright Report By LetCode with Koushik",
   "scripts": {
     "tsc": "tsc",

package/readme.md

@@ -201,7 +201,7 @@ Developed and designed by [Koushik Chatterjee](https://letcode.in/contact)
 **Tech Stack**
 
 1. Report generated using Playwright custom report
-2. UI - React and Shadcn UI
+2. [UI - React and Shadcn UI](https://github.com/ortoniKC/ortoni-report-react)
 3. DB - sqlite
 4. Local host - express