@allurereport/ci 3.18.0 → 3.19.1

package/dist/detectors/gitlab.d.ts

@@ -1,2 +1,16 @@
 import { type CiDescriptor } from "@allurereport/core-api";
-export declare const gitlab: CiDescriptor;
+export type GitlabCiDescriptor = CiDescriptor & {
+    projectId: string;
+    projectPath: string;
+    projectDirectory: string;
+    pipelineSource: string;
+    ciJobName: string;
+    currentJobId: string;
+    currentJobUrl: string;
+    mergeRequestProjectId: string;
+    restApiUrl: string;
+    graphqlApiUrl: string;
+    ref: string;
+    jobArtifactsUrlBase: string;
+};
+export declare const gitlab: GitlabCiDescriptor;

package/dist/detectors/gitlab.js

@@ -1,15 +1,18 @@
 import { CiType, GitProvider } from "@allurereport/core-api";
 import { getEnv } from "../utils.js";
+const GITLAB_DEFAULT_SERVER_URL = "https://gitlab.com";
+const stripTrailingSlashes = (value) => value.replace(/\/+$/, "");
 const getMergeRequestProjectUrl = () => getEnv("CI_MERGE_REQUEST_PROJECT_URL") || getEnv("CI_PROJECT_URL");
-const isTagPipeline = () => Boolean(getEnv("CI_COMMIT_TAG"));
-const getSourceBranch = () => {
-    if (isTagPipeline()) {
-        return undefined;
+const getSourceRef = () => getEnv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME") || getEnv("CI_COMMIT_REF_NAME") || undefined;
+const getServerUrl = () => stripTrailingSlashes(getEnv("CI_SERVER_URL") || GITLAB_DEFAULT_SERVER_URL);
+const getRestApiUrl = () => stripTrailingSlashes(getEnv("CI_API_V4_URL") || `${getServerUrl()}/api/v4`);
+const getGraphqlApiUrl = () => {
+    const explicit = getEnv("CI_API_GRAPHQL_URL");
+    if (explicit) {
+        return stripTrailingSlashes(explicit);
     }
-    return (getEnv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME") ||
-        getEnv("CI_COMMIT_BRANCH") ||
-        getEnv("CI_COMMIT_REF_NAME") ||
-        undefined);
+    const restApiUrl = getRestApiUrl();
+    return restApiUrl.replace(/\/api\/v4$/, "/api/graphql");
 };
 export const gitlab = {
     type: CiType.Gitlab,
@@ -28,6 +31,9 @@ export const gitlab = {
     get jobName() {
         return getEnv("CI_PROJECT_NAME");
     },
+    get ciJobName() {
+        return getEnv("CI_JOB_NAME");
+    },
     get jobRunUid() {
         return getEnv("CI_PIPELINE_ID");
     },
@@ -38,14 +44,14 @@ export const gitlab = {
         return getEnv("CI_PIPELINE_ID");
     },
     get jobRunBranch() {
-        return getSourceBranch() || "";
+        return getSourceRef() || "";
     },
     get pullRequestUrl() {
         const mergeRequestIID = getEnv("CI_MERGE_REQUEST_IID");
         if (!mergeRequestIID) {
             return "";
         }
-        const projectUrl = getMergeRequestProjectUrl().replace(/\/+$/, "");
+        const projectUrl = stripTrailingSlashes(getMergeRequestProjectUrl());
         return projectUrl ? `${projectUrl}/-/merge_requests/${mergeRequestIID}` : "";
     },
     get pullRequestName() {
@@ -64,7 +70,7 @@ export const gitlab = {
             : undefined;
     },
     get sourceBranch() {
-        return getSourceBranch();
+        return getSourceRef();
     },
     get targetBranch() {
         return getEnv("CI_MERGE_REQUEST_TARGET_BRANCH_NAME") || undefined;
@@ -79,4 +85,38 @@ export const gitlab = {
             }
             : undefined;
     },
+    get projectId() {
+        return getEnv("CI_PROJECT_ID");
+    },
+    get projectPath() {
+        return getEnv("CI_PROJECT_PATH");
+    },
+    get projectDirectory() {
+        return getEnv("CI_PROJECT_DIR");
+    },
+    get pipelineSource() {
+        return getEnv("CI_PIPELINE_SOURCE");
+    },
+    get currentJobId() {
+        return getEnv("CI_JOB_ID");
+    },
+    get currentJobUrl() {
+        return getEnv("CI_JOB_URL");
+    },
+    get mergeRequestProjectId() {
+        return getEnv("CI_MERGE_REQUEST_PROJECT_ID");
+    },
+    get restApiUrl() {
+        return getRestApiUrl();
+    },
+    get graphqlApiUrl() {
+        return getGraphqlApiUrl();
+    },
+    get ref() {
+        return getSourceRef() || "";
+    },
+    get jobArtifactsUrlBase() {
+        return (`${new URL(getServerUrl()).protocol}//${getEnv("CI_PROJECT_ROOT_NAMESPACE_SLUG")}.${getEnv("CI_PAGES_DOMAIN") || "gitlab.io"}` +
+            `/-/${getEnv("CI_PROJECT_NAME")}/-/jobs/${this.currentJobId}/artifacts`);
+    },
 };

package/dist/helpers/gitlab/client.d.ts

@@ -0,0 +1,14 @@
+import { type AxiosResponse } from "axios";
+import { type GitlabCiDescriptor } from "../../detectors/gitlab.js";
+export type GitlabClient = {
+    ci: GitlabCiDescriptor;
+    query<T>(query: string, variables: Record<string, unknown>): Promise<T>;
+    requestJson<T>(method: "GET" | "POST" | "PUT", path: string, body?: unknown): Promise<{
+        data: T;
+        headers: AxiosResponse["headers"];
+    }>;
+    downloadArtifact(jobId: string, artifactPath: string): Promise<Uint8Array>;
+};
+export declare const createGitlabClient: (options?: {
+    token?: string;
+}) => GitlabClient;

package/dist/helpers/gitlab/client.js

@@ -0,0 +1,133 @@
+import axios from "axios";
+import { gitlab } from "../../detectors/gitlab.js";
+const REQUEST_TIMEOUT_MS = 10000;
+const isDecimalString = (value) => /^[0-9]+$/.test(value);
+const requireMetadata = (ci) => {
+    const missing = [];
+    if (!ci.detected) {
+        missing.push("GitLab CI");
+    }
+    if (!ci.projectId) {
+        missing.push("CI_PROJECT_ID");
+    }
+    if (!ci.projectPath) {
+        missing.push("CI_PROJECT_PATH");
+    }
+    if (!ci.projectDirectory) {
+        missing.push("CI_PROJECT_DIR");
+    }
+    if (!ci.jobRunUid) {
+        missing.push("CI_PIPELINE_ID");
+    }
+    if (!ci.pipelineSource) {
+        missing.push("CI_PIPELINE_SOURCE");
+    }
+    if (!ci.ciJobName) {
+        missing.push("CI_JOB_NAME");
+    }
+    if (!ci.ref) {
+        missing.push("CI_COMMIT_REF_NAME");
+    }
+    return missing;
+};
+const invalidNumericMetadata = (ci) => {
+    const invalid = [];
+    if (!isDecimalString(ci.projectId)) {
+        invalid.push("CI_PROJECT_ID");
+    }
+    if (!isDecimalString(ci.jobRunUid)) {
+        invalid.push("CI_PIPELINE_ID");
+    }
+    if (ci.currentJobId && !isDecimalString(ci.currentJobId)) {
+        invalid.push("CI_JOB_ID");
+    }
+    if (ci.mergeRequestProjectId && !isDecimalString(ci.mergeRequestProjectId)) {
+        invalid.push("CI_MERGE_REQUEST_PROJECT_ID");
+    }
+    return invalid;
+};
+const encodeArtifactPathSegment = (segment) => {
+    if (segment === ".") {
+        return "%2E";
+    }
+    if (segment === "..") {
+        return "%2E%2E";
+    }
+    return encodeURIComponent(segment);
+};
+const encodeArtifactPath = (artifactPath) => artifactPath.split("/").map(encodeArtifactPathSegment).join("/");
+const buildRestUrl = (restApiUrl, path) => new URL(path.replace(/^\/+/, ""), `${restApiUrl.href.replace(/\/+$/, "")}/`);
+const hasApiPathSuffix = (url, suffix) => url.pathname.replace(/\/+$/, "").endsWith(suffix);
+const assertTrustedApiUrl = (url, apiOrigin) => {
+    if (url.origin !== apiOrigin) {
+        throw new Error("GitLab API request left trusted origin");
+    }
+};
+export const createGitlabClient = (options) => {
+    const token = options?.token;
+    const ci = gitlab;
+    const missingMetadata = requireMetadata(ci);
+    if (missingMetadata.length > 0) {
+        throw new Error(`missing GitLab metadata: ${missingMetadata.join(", ")}`);
+    }
+    const invalidNumeric = invalidNumericMetadata(ci);
+    if (invalidNumeric.length > 0) {
+        throw new Error(`invalid numeric GitLab metadata: ${invalidNumeric.join(", ")}`);
+    }
+    const restApiUrl = new URL(ci.restApiUrl);
+    const graphqlApiUrl = new URL(ci.graphqlApiUrl);
+    if (!hasApiPathSuffix(restApiUrl, "/api/v4") || !hasApiPathSuffix(graphqlApiUrl, "/api/graphql")) {
+        throw new Error("invalid GitLab API endpoint paths");
+    }
+    if (restApiUrl.origin !== graphqlApiUrl.origin) {
+        throw new Error("GitLab API origins do not match");
+    }
+    const apiOrigin = restApiUrl.origin;
+    const requestOptions = {
+        headers: token ? { "private-token": token } : {},
+        sensitiveHeaders: ["private-token"],
+        timeout: REQUEST_TIMEOUT_MS,
+    };
+    return {
+        ci,
+        async query(query, variables) {
+            const { data: envelope } = await axios.request({
+                ...requestOptions,
+                url: graphqlApiUrl.href,
+                method: "POST",
+                data: { query, variables },
+            });
+            if (!envelope || typeof envelope !== "object") {
+                throw new Error("GitLab GraphQL response was invalid");
+            }
+            if (envelope.errors) {
+                throw new Error("GitLab GraphQL response contained errors");
+            }
+            if (!Object.hasOwn(envelope, "data")) {
+                throw new Error("GitLab GraphQL response omitted data");
+            }
+            return envelope.data;
+        },
+        async requestJson(method, path, body) {
+            const url = buildRestUrl(restApiUrl, path);
+            assertTrustedApiUrl(url, apiOrigin);
+            const { data, headers } = await axios.request({
+                ...requestOptions,
+                url: url.href,
+                method,
+                data: body,
+            });
+            return { data, headers };
+        },
+        async downloadArtifact(jobId, artifactPath) {
+            const url = buildRestUrl(restApiUrl, `/projects/${encodeURIComponent(ci.projectId)}/jobs/${encodeURIComponent(jobId)}/artifacts/${encodeArtifactPath(artifactPath)}`);
+            const { data } = await axios.request({
+                ...requestOptions,
+                url: url.href,
+                method: "GET",
+                responseType: "arraybuffer",
+            });
+            return data;
+        },
+    };
+};

package/dist/helpers/gitlab/comments.d.ts

@@ -0,0 +1,6 @@
+import type { ReportContext } from "../../reportContext.js";
+export declare const upsertGitlabJobNote: (options: {
+    token: string;
+    summary: ReportContext;
+    reportUrl: string;
+}) => Promise<void>;

package/dist/helpers/gitlab/comments.js

@@ -0,0 +1,128 @@
+import { gitlab } from "../../detectors/gitlab.js";
+import { createGitlabClient } from "./client.js";
+import { renderGitlabReportSummary } from "./summary.js";
+const MARKER_VERSION = "v1";
+const MAX_NOTE_SCAN_PAGES = 5;
+const NOTE_PAGE_SIZE = 100;
+const MAX_COMMENT_LENGTH = 60000;
+const isDecimalString = (value) => /^[0-9]+$/.test(value);
+const encodePathSegment = (value) => encodeURIComponent(value);
+const ownershipMarker = ({ jobName, pipelineId, jobId }) => `<!-- allure-gitlab-summary:${MARKER_VERSION}:${jobName}:${pipelineId}:${jobId} -->`;
+const parseNotes = (value) => {
+    if (!Array.isArray(value)) {
+        throw new Error("invalid notes response");
+    }
+    return value.map((note) => {
+        if (typeof note !== "object" || note === null) {
+            throw new Error("invalid notes response");
+        }
+        const { id, body } = note;
+        const textId = typeof id === "number" && Number.isInteger(id) ? String(id) : typeof id === "string" ? id : "";
+        if (!textId || typeof body !== "string") {
+            throw new Error("invalid notes response");
+        }
+        return { id: textId, body };
+    });
+};
+const markerPattern = new RegExp(`^<!-- allure-gitlab-summary:${MARKER_VERSION}:([A-Za-z0-9+/]+={0,2}):([0-9]+):([0-9]+) -->\\n`);
+const parseMarker = (body) => {
+    const match = body.match(markerPattern);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        jobName: match[1],
+        pipelineId: BigInt(match[2]),
+        jobId: BigInt(match[3]),
+    };
+};
+const compareLogicalRun = (left, right) => {
+    if (left.pipelineId > right.pipelineId) {
+        return 1;
+    }
+    if (left.pipelineId < right.pipelineId) {
+        return -1;
+    }
+    if (left.jobId > right.jobId) {
+        return 1;
+    }
+    if (left.jobId < right.jobId) {
+        return -1;
+    }
+    return 0;
+};
+const currentMarker = (client) => ({
+    jobName: Buffer.from(client.ci.ciJobName).toString("base64"),
+    pipelineId: BigInt(client.ci.jobRunUid),
+    jobId: BigInt(client.ci.currentJobId),
+});
+const notePath = (client, iid, page) => {
+    const base = `/projects/${encodePathSegment(client.ci.projectId)}/merge_requests/${encodePathSegment(iid)}/notes`;
+    return page === undefined ? base : `${base}?per_page=${NOTE_PAGE_SIZE}&page=${page}`;
+};
+const readOwnedNotes = async (client, iid, currentJobName) => {
+    const notes = [];
+    let page = 1;
+    for (let index = 0; index < MAX_NOTE_SCAN_PAGES; index += 1) {
+        const { data, headers } = await client.requestJson("GET", notePath(client, iid, page));
+        for (const note of parseNotes(data)) {
+            const marker = parseMarker(note.body);
+            if (marker?.jobName === currentJobName) {
+                notes.push({ note, marker });
+            }
+        }
+        const nextPageHeader = headers["x-next-page"];
+        if (typeof nextPageHeader !== "string") {
+            throw new Error("incomplete note scan");
+        }
+        const nextPage = nextPageHeader.trim();
+        if (!nextPage) {
+            return notes;
+        }
+        const expectedNextPage = String(page + 1);
+        if (!isDecimalString(nextPage) || nextPage !== expectedNextPage) {
+            throw new Error("incomplete note scan");
+        }
+        page += 1;
+    }
+    throw new Error("incomplete note scan");
+};
+const selectNewestOwnedNote = (notes) => notes.reduce((selected, candidate) => {
+    if (!selected || compareLogicalRun(candidate.marker, selected.marker) > 0) {
+        return candidate;
+    }
+    return selected;
+}, undefined);
+export const upsertGitlabJobNote = async (options) => {
+    const iid = gitlab.pullRequest?.id;
+    if (!iid || !isDecimalString(iid)) {
+        throw new Error("missing merge request");
+    }
+    if (gitlab.projectId && gitlab.mergeRequestProjectId && gitlab.mergeRequestProjectId !== gitlab.projectId) {
+        throw new Error("cross-project merge request");
+    }
+    const client = createGitlabClient(options);
+    if (!client.ci.currentJobId || !isDecimalString(client.ci.currentJobId)) {
+        throw new Error("missing current job");
+    }
+    const current = currentMarker(client);
+    const reportUrl = new URL(options.reportUrl);
+    if ((reportUrl.protocol !== "http:" && reportUrl.protocol !== "https:") || reportUrl.username || reportUrl.password) {
+        throw new Error("invalid report URL");
+    }
+    const body = `${ownershipMarker(current)}\n${renderGitlabReportSummary(options.summary, reportUrl)}`;
+    if (body.length > MAX_COMMENT_LENGTH) {
+        throw new Error("comment too large");
+    }
+    const ownedNotes = await readOwnedNotes(client, iid, current.jobName);
+    const selected = selectNewestOwnedNote(ownedNotes);
+    if (selected && compareLogicalRun(selected.marker, current) > 0) {
+        throw new Error("newer owned note exists");
+    }
+    if (selected) {
+        await client.requestJson("PUT", `${notePath(client, iid)}/${encodePathSegment(selected.note.id)}`, { body });
+    }
+    else {
+        await client.requestJson("POST", notePath(client, iid), { body });
+    }
+};

package/dist/helpers/gitlab/history.d.ts

@@ -0,0 +1,4 @@
+export declare const restoreGitlabHistory: (options: {
+    token?: string;
+    historyPath: string;
+}) => Promise<void>;

package/dist/helpers/gitlab/history.js

@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, relative, sep } from "node:path";
+import { createGitlabClient } from "./client.js";
+const previousGitlabJobQuery = `query PreviousGitlabJob($path: ID!, $ref: String!, $source: String!, $job: String!) {
+  project(fullPath: $path) {
+    pipelines(ref: $ref, source: $source, first: 100) {
+      nodes { id source job(name: $job) { id name status retried } }
+    }
+  }
+}`;
+const isRecord = (value) => typeof value === "object" && value !== null;
+const decodeGitlabId = (value, type) => {
+    if (typeof value !== "string") {
+        throw new Error("invalid id");
+    }
+    const typeName = type === "Pipeline" ? "Pipeline" : "Build";
+    const match = value.match(new RegExp(`^gid://gitlab/Ci::${typeName}/([0-9]+)$`));
+    if (!match) {
+        throw new Error("invalid id");
+    }
+    return { text: match[1], value: BigInt(match[1]) };
+};
+const parseJob = (value) => {
+    if (value === null) {
+        return null;
+    }
+    if (!isRecord(value)) {
+        throw new Error("invalid job");
+    }
+    const { id, name, status, retried } = value;
+    if (typeof id !== "string" || typeof name !== "string" || typeof status !== "string") {
+        throw new Error("invalid job");
+    }
+    if (retried !== true && retried !== false && retried !== null) {
+        throw new Error("invalid job");
+    }
+    return { id, name, status, retried };
+};
+const parsePipelines = (response) => {
+    if (!isRecord(response) || !isRecord(response.project)) {
+        throw new Error("invalid project");
+    }
+    const { pipelines } = response.project;
+    if (!isRecord(pipelines) || !Array.isArray(pipelines.nodes)) {
+        throw new Error("invalid pipelines");
+    }
+    return pipelines.nodes.map((node) => {
+        if (!isRecord(node) ||
+            typeof node.id !== "string" ||
+            typeof node.source !== "string" ||
+            !Object.hasOwn(node, "job")) {
+            throw new Error("invalid pipeline");
+        }
+        return {
+            id: node.id,
+            source: node.source,
+            job: parseJob(node.job),
+        };
+    });
+};
+const selectPreviousJobId = (client, nodes) => {
+    const currentPipelineId = BigInt(client.ci.jobRunUid);
+    let previousPipelineId;
+    let selectedJobId;
+    for (const node of nodes) {
+        const pipelineId = decodeGitlabId(node.id, "Pipeline");
+        if (previousPipelineId !== undefined && pipelineId.value >= previousPipelineId) {
+            throw new Error("invalid pipeline order");
+        }
+        previousPipelineId = pipelineId.value;
+        if (node.source !== client.ci.pipelineSource) {
+            throw new Error("invalid pipeline source");
+        }
+        const { job } = node;
+        const jobId = job ? decodeGitlabId(job.id, "Build") : undefined;
+        if (selectedJobId || pipelineId.value >= currentPipelineId || !job || !jobId) {
+            continue;
+        }
+        if (job.name !== client.ci.ciJobName) {
+            continue;
+        }
+        if (job.status !== "SUCCESS" && job.status !== "FAILED") {
+            continue;
+        }
+        if (job.retried === true) {
+            continue;
+        }
+        selectedJobId = jobId.text;
+    }
+    return selectedJobId;
+};
+const projectRelativePath = (projectDirectory, historyPath) => relative(projectDirectory, historyPath).split(sep).join("/");
+export const restoreGitlabHistory = async (options) => {
+    const client = createGitlabClient(options);
+    const response = await client.query(previousGitlabJobQuery, {
+        path: client.ci.projectPath,
+        ref: client.ci.ref,
+        source: client.ci.pipelineSource,
+        job: client.ci.ciJobName,
+    });
+    const selectedJobId = selectPreviousJobId(client, parsePipelines(response));
+    if (!selectedJobId) {
+        throw new Error("no matching prior job in returned pipeline window");
+    }
+    const bytes = await client.downloadArtifact(selectedJobId, projectRelativePath(client.ci.projectDirectory, options.historyPath));
+    if (bytes.byteLength === 0) {
+        throw new Error("empty history artifact");
+    }
+    await mkdir(dirname(options.historyPath), { recursive: true });
+    await writeFile(options.historyPath, bytes);
+};

package/dist/helpers/gitlab/index.d.ts

@@ -0,0 +1,4 @@
+export { createGitlabClient } from "./client.js";
+export { upsertGitlabJobNote } from "./comments.js";
+export { restoreGitlabHistory } from "./history.js";
+export type { GitlabClient } from "./client.js";

package/dist/helpers/gitlab/index.js

@@ -0,0 +1,3 @@
+export { createGitlabClient } from "./client.js";
+export { upsertGitlabJobNote } from "./comments.js";
+export { restoreGitlabHistory } from "./history.js";

package/dist/helpers/gitlab/summary.d.ts

@@ -0,0 +1,2 @@
+import type { ReportContext } from "../../reportContext.js";
+export declare const renderGitlabReportSummary: (summary: ReportContext, reportUrl: URL) => string;

package/dist/helpers/gitlab/summary.js

@@ -0,0 +1,19 @@
+import { renderReportSummaryMarkdown } from "../../reportMarkdown.js";
+const reportHref = (report, reportUrl) => {
+    const { href, reportPath } = report;
+    if (href && /^[A-Za-z][A-Za-z0-9+.-]*:/.test(href)) {
+        return href;
+    }
+    if (reportPath !== undefined) {
+        const path = reportPath.split("/").filter(Boolean).map(encodeURIComponent).join("/");
+        return new URL(`${path ? `${path}/` : ""}index.html`, reportUrl).href;
+    }
+    return href ? new URL(href, reportUrl).href : undefined;
+};
+export const renderGitlabReportSummary = (summary, reportUrl) => {
+    const context = {
+        ...summary,
+        reports: summary.reports.map((report) => ({ ...report, href: reportHref(report, reportUrl) })),
+    };
+    return renderReportSummaryMarkdown(context, { includeArtifacts: false });
+};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
+export * from "./reportContext.js";
+export * from "./reportMarkdown.js";
 export { applyAllureCiEnv } from "./ciEnv.js";
 export { detect } from "./detect.js";
 export { isLocalCiDescriptor } from "./detectors/local.js";
-export * from "./reportContext.js";
-export * from "./reportMarkdown.js";
+export { restoreGitlabHistory, upsertGitlabJobNote } from "./helpers/gitlab/index.js";
+export type { GitlabCiDescriptor } from "./detectors/gitlab.js";

package/dist/index.js

@@ -1,5 +1,6 @@
+export * from "./reportContext.js";
+export * from "./reportMarkdown.js";
 export { applyAllureCiEnv } from "./ciEnv.js";
 export { detect } from "./detect.js";
 export { isLocalCiDescriptor } from "./detectors/local.js";
-export * from "./reportContext.js";
-export * from "./reportMarkdown.js";
+export { restoreGitlabHistory, upsertGitlabJobNote } from "./helpers/gitlab/index.js";

package/dist/reportContext.js

@@ -27,6 +27,7 @@ const emptyResolutionStats = () => ({
 });
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isTestStatus = (value) => typeof value === "string" && TEST_STATUSES.includes(value);
+const getFiniteNumber = (value, fallback = 0) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
 const normalizePath = (filePath) => filePath.split(sep).join("/");
 const readOptionalJson = async (filePath, onError) => {
     if (!existsSync(filePath)) {
@@ -40,12 +41,43 @@ const readOptionalJson = async (filePath, onError) => {
         return undefined;
     }
 };
+const getReportName = (summary) => {
+    if (typeof summary.name === "string" && summary.name.trim()) {
+        return summary.name;
+    }
+    return "Allure Report";
+};
+const hasPluginSummarySignal = (value) => typeof value.name === "string" ||
+    typeof value.plugin === "string" ||
+    typeof value.href === "string" ||
+    typeof value.remoteHref === "string" ||
+    isRecord(value.stats);
 const isPluginSummary = (value) => {
-    if (!isRecord(value) || typeof value.name !== "string" || !isRecord(value.stats)) {
+    if (!isRecord(value) || !hasPluginSummarySignal(value)) {
         return false;
     }
-    return typeof value.duration === "number" && isTestStatus(value.status);
+    return true;
+};
+const normalizePluginSummaryStats = (summary) => {
+    const rawStats = isRecord(summary.stats) ? summary.stats : {};
+    const stats = {
+        ...rawStats,
+        failed: getFiniteNumber(rawStats.failed),
+        broken: getFiniteNumber(rawStats.broken),
+        passed: getFiniteNumber(rawStats.passed),
+        skipped: getFiniteNumber(rawStats.skipped),
+        unknown: getFiniteNumber(rawStats.unknown),
+    };
+    stats.total = getFiniteNumber(rawStats.total, TEST_STATUSES.reduce((acc, status) => acc + getFiniteNumber(stats[status]), 0));
+    return stats;
 };
+const normalizePluginSummary = (summary) => ({
+    ...summary,
+    name: getReportName(summary),
+    stats: normalizePluginSummaryStats(summary),
+    status: isTestStatus(summary.status) ? summary.status : "passed",
+    duration: getFiniteNumber(summary.duration),
+});
 const getReportPath = (reportDir, summaryFile) => normalizePath(relative(resolve(reportDir), dirname(resolve(summaryFile))));
 const readPluginSummary = async (reportDir, filePath, onError) => {
     const value = await readOptionalJson(filePath, onError);
@@ -57,7 +89,7 @@ const readPluginSummary = async (reportDir, filePath, onError) => {
         return undefined;
     }
     return {
-        ...value,
+        ...normalizePluginSummary(value),
         summaryFile: filePath,
         reportPath: getReportPath(reportDir, filePath),
     };
@@ -204,8 +236,10 @@ const createEnvironmentContext = (registry, summaries) => {
     });
     return [...environmentsByName.values()].toSorted((left, right) => left.name.localeCompare(right.name));
 };
-const createReport = (summary) => ({ ...summary });
-const sortReports = (reports) => reports.toSorted((left, right) => left.name.localeCompare(right.name));
+const createReport = (summary) => normalizePluginSummary(summary);
+const sortReports = (reports) => reports
+    .map((report) => normalizePluginSummary(report))
+    .toSorted((left, right) => left.name.localeCompare(right.name));
 const getResolutionStats = (summaries) => {
     const stats = emptyResolutionStats();
     summaries.forEach((summary) => {

package/dist/reportMarkdown.d.ts

@@ -1,6 +1,16 @@
-import type { ReportContext } from "./reportContext.js";
+import type { ReportContext, ReportContextFlagStats, ReportContextTestReport, ReportContextResolutionStats, ReportContextStatusStats } from "./reportContext.js";
+export type ReportSummaryMarkdownRow = {
+    kind: "total" | "environment" | "report";
+    name: string;
+    duration: number;
+    stats: ReportContextStatusStats;
+    flags: ReportContextFlagStats;
+    resolutions?: ReportContextResolutionStats;
+    report?: ReportContextTestReport;
+};
 export type RenderReportSummaryMarkdownOptions = {
     title?: string;
     includeArtifacts?: boolean;
+    getReportFilterHref?: (filter: keyof ReportContextFlagStats, row: ReportSummaryMarkdownRow) => string | undefined;
 };
 export declare const renderReportSummaryMarkdown: (context: ReportContext, options?: RenderReportSummaryMarkdownOptions) => string;

package/dist/reportMarkdown.js

@@ -10,6 +10,7 @@ const STATUS_ICON_BASE_URL = "https://allurecharts.qameta.workers.dev/dot";
 const STATUS_PIE_BASE_URL = "https://allurecharts.qameta.workers.dev/pie";
 const escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 const tableCell = (value) => escapeHtml(String(value)).replaceAll("|", "&#124;").replaceAll("\n", "<br>");
+const inlineCode = (value) => `<code>${escapeHtml(value)}</code>`;
 const isSafeHref = (href) => {
     try {
         const url = new URL(href);
@@ -82,11 +83,19 @@ const formatResolutions = (resolutions) => {
     return lines.join("<br>");
 };
 const hasResolutions = (resolutions) => resolutions.issues > 0 || resolutions.muted > 0 || resolutions.accepted > 0;
-const formatFlag = (value) => (value > 0 ? String(value) : "0");
-const renderTable = (rows, includeResolutions) => {
+const formatFlag = (flag, row, options) => {
+    const value = row.flags[flag];
+    if (value <= 0) {
+        return "0";
+    }
+    const label = String(value);
+    const href = options.getReportFilterHref?.(flag, row);
+    return href ? link(label, href) : label;
+};
+const renderTable = (rows, includeResolutions, options) => {
     const headers = [
         "&nbsp;&nbsp;&nbsp;&nbsp;",
-        "Scope",
+        "Environment",
         "Duration",
         "Stats",
         ...(includeResolutions ? ["Resolutions"] : []),
@@ -101,14 +110,31 @@ const renderTable = (rows, includeResolutions) => {
         tableCell(formatDuration(row.duration)),
         formatStats(row.stats),
         ...(includeResolutions ? [formatResolutions(row.resolutions)] : []),
-        tableCell(formatFlag(row.flags.new)),
-        tableCell(formatFlag(row.flags.flaky)),
-        tableCell(formatFlag(row.flags.retry)),
+        formatFlag("new", row, options),
+        formatFlag("flaky", row, options),
+        formatFlag("retry", row, options),
     ].join(" | "));
     return [`| ${headers.join(" | ")} |`, `| ${divider.join(" | ")} |`, ...body.map((row) => `| ${row} |`)].join("\n");
 };
 const reportHref = (report) => report.remoteHref ?? report.href;
 const reportLabel = (report) => report.plugin ?? report.name;
+const isAwesomeReport = (report) => report?.pluginId?.toLowerCase() === "awesome" || report?.plugin?.toLowerCase() === "awesome";
+const appendReportFilter = (href, filter) => {
+    const hashIndex = href.indexOf("#");
+    const base = hashIndex === -1 ? href : href.slice(0, hashIndex);
+    const hash = hashIndex === -1 ? "" : href.slice(hashIndex);
+    const separator = base.includes("?") ? "&" : "?";
+    const query = filter === "new" ? "transition=new" : `${filter}=true`;
+    return `${base}${separator}${query}${hash}`;
+};
+const createDefaultReportFilterHref = (reports) => {
+    const defaultReport = reports.find(isAwesomeReport);
+    return (filter, row) => {
+        const report = isAwesomeReport(row.report) ? row.report : defaultReport;
+        const href = report ? reportHref(report) : undefined;
+        return href ? appendReportFilter(href, filter) : undefined;
+    };
+};
 const reportLinkKind = (report) => report.plugin?.toLowerCase() === "testops" ? "testops" : "report";
 const toReportLink = (report) => {
     const href = reportHref(report);
@@ -151,43 +177,46 @@ const pluginSummaryToResolutions = (report) => ({
     muted: report.stats.resolutions?.muted ?? 0,
     accepted: report.stats.resolutions?.accepted ?? 0,
 });
-const renderFilteredReports = (reports) => {
+const renderFilteredReports = (reports, options) => {
     const rows = reports.map((report) => ({
+        kind: "report",
         name: report.name,
         duration: report.duration,
         stats: pluginSummaryToStatusStats(report),
         flags: pluginSummaryToFlags(report),
         resolutions: pluginSummaryToResolutions(report),
+        report,
     }));
     if (!rows.length) {
         return undefined;
     }
     const includeResolutions = rows.some(({ resolutions }) => resolutions && hasResolutions(resolutions));
     const links = renderReportLinks(reports);
-    return ["**Filtered Reports**", renderTable(rows, includeResolutions), ...links].join("\n\n");
+    return ["**Filtered Reports**", renderTable(rows, includeResolutions, options), ...links].join("\n\n");
 };
 const renderArtifacts = (artifacts) => {
     if (!artifacts.length) {
         return undefined;
     }
-    const rows = artifacts.map(({ name, path }) => `| ${tableCell(name)} | ${tableCell(path)} |`);
-    return [
-        `<details>`,
-        `<summary>Artifacts used (${artifacts.length})</summary>`,
-        "",
-        "| Name | Path |",
-        "| --- | --- |",
-        ...rows,
-        "",
-        "</details>",
-    ].join("\n");
+    const rows = artifacts.map(({ name, path }) => {
+        const normalizedPath = path.replaceAll("\\", "/");
+        const isDuplicateName = name === path || normalizedPath.endsWith(`/${name}`);
+        const label = isDuplicateName ? inlineCode(path) : `${inlineCode(name)} &mdash; ${inlineCode(path)}`;
+        return `- ${label}`;
+    });
+    return [`<details>`, `<summary>Artifacts used (${artifacts.length})</summary>`, "", ...rows, "", "</details>"].join("\n");
 };
 export const renderReportSummaryMarkdown = (context, options = {}) => {
     const { title = "Allure Report Summary", includeArtifacts = true } = options;
     const regularReports = context.reports.filter((report) => report.filtered !== true);
     const filteredReports = context.reports.filter((report) => report.filtered === true);
+    const renderOptions = {
+        ...options,
+        getReportFilterHref: options.getReportFilterHref ?? createDefaultReportFilterHref(regularReports),
+    };
     const aggregateRows = [
         {
+            kind: "total",
             name: "All tests",
             duration: context.totals.duration,
             stats: context.totals.stats,
@@ -195,6 +224,7 @@ export const renderReportSummaryMarkdown = (context, options = {}) => {
             resolutions: context.totals.resolutions,
         },
         ...context.environments.map((environment) => ({
+            kind: "environment",
             name: environment.name,
             duration: environment.duration,
             stats: environment.stats,
@@ -204,9 +234,9 @@ export const renderReportSummaryMarkdown = (context, options = {}) => {
     const includeResolutions = hasResolutions(context.totals.resolutions);
     const sections = [
         `# ${escapeHtml(title)}`,
-        renderTable(aggregateRows, includeResolutions),
+        renderTable(aggregateRows, includeResolutions, renderOptions),
         ...renderReportLinks(regularReports),
-        renderFilteredReports(filteredReports),
+        renderFilteredReports(filteredReports, renderOptions),
         includeArtifacts ? renderArtifacts(context.artifacts) : undefined,
     ].filter((section) => Boolean(section));
     return `${sections.join("\n\n")}\n`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/ci",
-  "version": "3.18.0",
+  "version": "3.19.1",
   "description": "Utilities set to get useful report data from different CI",
   "keywords": [
     "allure",
@@ -32,14 +32,15 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.18.0",
-    "@allurereport/plugin-api": "3.18.0",
+    "@allurereport/core-api": "3.19.1",
+    "@allurereport/plugin-api": "3.19.1",
+    "axios": "^1.20.0",
     "glob": "^13.0.6"
   },
   "devDependencies": {
     "@types/node": "^20",
     "@vitest/runner": "^2.1.8",
-    "@vitest/snapshot": "^2.1.8",
+    "@vitest/snapshot": "^5.0.1",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",
     "rimraf": "^6",