@allurereport/plugin-api 3.8.1 → 3.9.0

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import type { CategoriesConfig, DefaultLabelsConfig, EnvironmentsConfig, ReportVariables } from "@allurereport/core-api";
+import type { AllureServiceConfig, CategoriesConfig, DefaultLabelsConfig, EnvironmentsConfig, ReportVariables } from "@allurereport/core-api";
 import type { PluginDescriptor } from "./plugin.js";
 import type { QualityGateConfig } from "./qualityGate.js";
 export interface Config {
@@ -19,10 +19,7 @@ export interface Config {
     plugins?: Record<string, PluginDescriptor>;
     appendHistory?: boolean;
     qualityGate?: QualityGateConfig;
-    allureService?: {
-        accessToken?: string;
-        legacy?: boolean;
-    };
+    allureService?: AllureServiceConfig;
     categories?: CategoriesConfig;
     globalAttachments?: string[];
 }

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { AllureHistory, AttachmentLink, CategoryDefinition, CiDescriptor, Statistic, TestError, TestResult, TestStatus } from "@allurereport/core-api";
+import type { AllureHistory, AttachmentLink, CategoryDefinition, CiDescriptor, HistoryDataPoint, Statistic, TestError, TestResult, TestStatus } from "@allurereport/core-api";
 import type { QualityGateValidationResult } from "./qualityGate.js";
 import type { ResultFile } from "./resultFile.js";
 import type { AllureStore } from "./store.js";
@@ -25,6 +25,7 @@ export interface PluginContext {
     hideLabels?: (string | RegExp)[];
     reportFiles: ReportFiles;
     reportUrl?: string;
+    realTime?: boolean;
     output: string;
     ci?: CiDescriptor;
     categories?: CategoryDefinition[];
@@ -48,6 +49,26 @@ export interface PluginSummary {
     createdAt?: number;
     meta?: Record<string, any>;
 }
+export interface PluginReportFile {
+    pluginId: string;
+    publish: boolean;
+    files: Record<string, string>;
+}
+export interface PluginPublishContext {
+    reportUuid: string;
+    reportName: string;
+    ci?: CiDescriptor;
+    historyPoint?: HistoryDataPoint;
+    reports: PluginReportFile[];
+    summary?: {
+        filepath: string;
+        summaries?: PluginSummary[];
+    };
+}
+export interface PluginPublishResult {
+    linksByPluginId: Record<string, string>;
+    remoteHref?: string;
+}
 export interface ExitCode {
     actual?: number;
     original: number;

package/dist/store.d.ts

@@ -3,10 +3,16 @@ import type { ExitCode, PluginGlobalAttachment, PluginGlobalError } from "./plug
 import type { QualityGateValidationResult } from "./qualityGate.js";
 import type { ResultFile } from "./resultFile.js";
 export type TestResultFilter = (testResult: TestResult) => boolean;
+export interface TestResultRelatedData {
+    attachmentsByTrId: Map<string, AttachmentLink[]>;
+    fixturesByTrId: Map<string, TestFixtureResult[]>;
+    historyByTrId: Map<string, HistoryTestResult[] | undefined>;
+    retriesByTrId: Map<string, TestResult[]>;
+}
 export interface AllureStore {
     allTestCases: () => Promise<TestCase[]>;
     allTestResults: (options?: {
-        includeHidden?: boolean;
+        includeRetries?: boolean;
         filter?: TestResultFilter;
     }) => Promise<TestResult[]>;
     allAttachments: () => Promise<AttachmentLink[]>;
@@ -39,6 +45,7 @@ export interface AllureStore {
     retriesByTrId: (trId: string) => Promise<TestResult[]>;
     historyByTrId: (trId: string) => Promise<HistoryTestResult[] | undefined>;
     fixturesByTrId: (trId: string) => Promise<TestFixtureResult[]>;
+    relatedByTestResultIds: (trIds: readonly string[]) => Promise<TestResultRelatedData>;
     failedTestResults: () => Promise<TestResult[]>;
     unknownFailedTestResults: () => Promise<TestResult[]>;
     testResultsByLabel: (labelName: string) => Promise<{
@@ -49,10 +56,10 @@ export interface AllureStore {
     allEnvironments: () => Promise<string[]>;
     allEnvironmentIdentities: () => Promise<EnvironmentIdentity[]>;
     testResultsByEnvironment: (env: string, options?: {
-        includeHidden?: boolean;
+        includeRetries?: boolean;
     }) => Promise<TestResult[]>;
     testResultsByEnvironmentId: (envId: string, options?: {
-        includeHidden?: boolean;
+        includeRetries?: boolean;
     }) => Promise<TestResult[]>;
     allTestEnvGroups: () => Promise<TestEnvGroup[]>;
     allVariables: () => Promise<Record<string, any>>;
@@ -73,10 +80,10 @@ export interface AllureStoreDump {
     indexAttachmentByTestResult: Record<string, string[]>;
     indexTestResultByHistoryId: Record<string, string[]>;
     indexTestResultByTestCase: Record<string, string[]>;
-    indexLatestEnvTestResultByHistoryId: Record<string, string> | Record<string, Record<string, string>>;
     indexAttachmentByFixture: Record<string, string[]>;
     indexFixturesByTestResult: Record<string, string[]>;
     indexKnownByHistoryId: Record<string, KnownTestFailure[]>;
+    testResultIdsIngestOrder: string[];
 }
 export declare enum AllureStoreDumpFiles {
     TestResults = "test-results.json",
@@ -91,9 +98,9 @@ export declare enum AllureStoreDumpFiles {
     IndexAttachmentsByTestResults = "index-attachments-by-test-results.json",
     IndexTestResultsByHistoryId = "index-test-results-by-history-id.json",
     IndexTestResultsByTestCase = "index-test-results-by-test-case.json",
-    IndexLatestEnvTestResultsByHistoryId = "index-latest-env-test-results-by-history-id.json",
     IndexAttachmentsByFixture = "index-attachments-by-fixture.json",
     IndexFixturesByTestResult = "index-fixtures-by-test-result.json",
     IndexKnownByHistoryId = "index-known-by-history-id.json",
-    QualityGateResults = "quality-gate-results.json"
+    QualityGateResults = "quality-gate-results.json",
+    TestResultIngestOrder = "test-result-ingest-order.json"
 }

package/dist/store.js

@@ -12,9 +12,9 @@ export var AllureStoreDumpFiles;
     AllureStoreDumpFiles["IndexAttachmentsByTestResults"] = "index-attachments-by-test-results.json";
     AllureStoreDumpFiles["IndexTestResultsByHistoryId"] = "index-test-results-by-history-id.json";
     AllureStoreDumpFiles["IndexTestResultsByTestCase"] = "index-test-results-by-test-case.json";
-    AllureStoreDumpFiles["IndexLatestEnvTestResultsByHistoryId"] = "index-latest-env-test-results-by-history-id.json";
     AllureStoreDumpFiles["IndexAttachmentsByFixture"] = "index-attachments-by-fixture.json";
     AllureStoreDumpFiles["IndexFixturesByTestResult"] = "index-fixtures-by-test-result.json";
     AllureStoreDumpFiles["IndexKnownByHistoryId"] = "index-known-by-history-id.json";
     AllureStoreDumpFiles["QualityGateResults"] = "quality-gate-results.json";
+    AllureStoreDumpFiles["TestResultIngestOrder"] = "test-result-ingest-order.json";
 })(AllureStoreDumpFiles || (AllureStoreDumpFiles = {}));

package/dist/utils/tree.d.ts

@@ -5,6 +5,11 @@ export declare const createTreeByLabels: <T = TestResult, L = DefaultTreeLeaf, G
 export declare const createTreeByCategories: <T = TestResult, L = DefaultTreeLeaf, G = DefaultTreeGroup>(data: T[], leafFactory?: (item: T) => TreeLeaf<L>, groupFactory?: (parentGroup: string | undefined, groupClassifier: string) => TreeGroup<G>, addLeafToGroup?: (group: TreeGroup<G>, leaf: TreeLeaf<L>) => void) => TreeData<L, G>;
 export declare const byCategories: (item: TestResult) => string[][];
 export declare const preciseTreeLabels: <T = TestResult>(labelNames: string[], trs: T[], labelNamesAccessor?: (tr: T) => string[]) => string[];
+export declare const processTree: <L, G>(tree: TreeData<L, G>, options: {
+    filter?: (leaf: TreeLeaf<L>) => boolean;
+    sort?: Comparator<TreeLeaf<L>>;
+    transform?: (leaf: TreeLeaf<L>, idx: number) => TreeLeaf<L>;
+}) => TreeData<L, G>;
 export declare const filterTree: <L, G>(tree: TreeData<L, G>, predicate: (leaf: TreeLeaf<L>) => boolean) => TreeData<L, G>;
 export declare const sortTree: <L, G>(tree: TreeData<L, G>, comparator: Comparator<TreeLeaf<L>>) => TreeData<L, G>;
 export declare const transformTree: <L, G>(tree: TreeData<L, G>, transformer: (leaf: TreeLeaf<L>, idx: number) => TreeLeaf<L>) => TreeData<L, G>;

package/dist/utils/tree.js

@@ -1,28 +1,41 @@
-import { createDictionary, findByLabelName, } from "@allurereport/core-api";
 import { emptyStatistic } from "@allurereport/core-api";
 import { md5 } from "./misc.js";
-const addLeaf = (node, nodeId) => {
+const addLeaf = (childLeaves, node, nodeId) => {
     if (node.leaves === undefined) {
         node.leaves = [];
     }
-    if (node.leaves.find((value) => value === nodeId)) {
+    let leaves = childLeaves.get(node);
+    if (!leaves) {
+        leaves = new Set(node.leaves);
+        childLeaves.set(node, leaves);
+    }
+    if (leaves.has(nodeId)) {
         return;
     }
+    leaves.add(nodeId);
     node.leaves.push(nodeId);
 };
-const addGroup = (node, nodeId) => {
+const addGroup = (childGroups, node, nodeId) => {
     if (node.groups === undefined) {
         node.groups = [];
     }
-    if (node.groups.find((value) => value === nodeId)) {
+    let groups = childGroups.get(node);
+    if (!groups) {
+        groups = new Set(node.groups);
+        childGroups.set(node, groups);
+    }
+    if (groups.has(nodeId)) {
         return;
     }
+    groups.add(nodeId);
     node.groups.push(nodeId);
 };
 const createTree = (data, classifier, leafFactory, groupFactory, addLeafToGroup = () => { }) => {
-    const groupsByClassifier = createDictionary();
+    const groupsByClassifier = new Map();
     const leavesById = {};
     const groupsById = {};
+    const childLeaves = new WeakMap();
+    const childGroups = new WeakMap();
     const root = { groups: [], leaves: [] };
     for (const item of data) {
         const leaf = leafFactory(item);
@@ -33,32 +46,40 @@ const createTree = (data, classifier, leafFactory, groupFactory, addLeafToGroup
             if (layer.length === 0) {
                 break;
             }
-            parentGroups = layer.flatMap((group) => {
-                return parentGroups.flatMap((parentGroup) => {
+            const nextParentGroups = [];
+            const nextParentGroupIds = new Set();
+            for (const group of layer) {
+                for (const parentGroup of parentGroups) {
                     const parentId = "nodeId" in parentGroup ? parentGroup.nodeId : "";
-                    if (groupsByClassifier[parentId] === undefined) {
-                        groupsByClassifier[parentId] = createDictionary();
+                    let groupsByParent = groupsByClassifier.get(parentId);
+                    if (groupsByParent === undefined) {
+                        groupsByParent = new Map();
+                        groupsByClassifier.set(parentId, groupsByParent);
                     }
-                    if (groupsByClassifier[parentId][group] === undefined) {
+                    if (groupsByParent.get(group) === undefined) {
                         const newGroup = groupFactory(parentId, group);
                         if (!newGroup || typeof newGroup !== "object" || typeof newGroup.nodeId !== "string") {
-                            return [];
+                            continue;
                         }
-                        groupsByClassifier[parentId][group] = newGroup;
+                        groupsByParent.set(group, newGroup);
                         groupsById[newGroup.nodeId] = newGroup;
                     }
-                    const currentGroup = groupsByClassifier[parentId][group];
+                    const currentGroup = groupsByParent.get(group);
                     if (!currentGroup || typeof currentGroup !== "object") {
-                        return [];
+                        continue;
                     }
-                    addGroup(parentGroup, currentGroup.nodeId);
+                    addGroup(childGroups, parentGroup, currentGroup.nodeId);
                     addLeafToGroup(currentGroup, leaf);
-                    return [currentGroup];
-                });
-            });
+                    if (!nextParentGroupIds.has(currentGroup.nodeId)) {
+                        nextParentGroupIds.add(currentGroup.nodeId);
+                        nextParentGroups.push(currentGroup);
+                    }
+                }
+            }
+            parentGroups = nextParentGroups;
         }
         parentGroups.forEach((parentGroup) => {
-            addLeaf(parentGroup, leaf.nodeId);
+            addLeaf(childLeaves, parentGroup, leaf.nodeId);
         });
     }
     return {
@@ -67,16 +88,30 @@ const createTree = (data, classifier, leafFactory, groupFactory, addLeafToGroup
         leavesById,
     };
 };
-export const byLabels = (item, labelNames) => {
-    return labelNames
-        .map((labelName) => item.labels.filter((label) => labelName === label.name).map((label) => label.value ?? "__unknown") ?? [])
-        .filter((layer) => layer.length > 0);
+const byLabelsWithFallback = (item, labelNames, fallbackValue) => {
+    const labelsByName = new Map();
+    for (const label of item.labels) {
+        const values = labelsByName.get(label.name) ?? [];
+        values.push(label.value ?? fallbackValue);
+        labelsByName.set(label.name, values);
+    }
+    return labelNames.map((labelName) => labelsByName.get(labelName) ?? []).filter((layer) => layer.length > 0);
 };
+export const byLabels = (item, labelNames) => byLabelsWithFallback(item, labelNames, "__unknown");
 export const filterTreeLabels = (data, labelNames) => {
-    return [...labelNames]
-        .reverse()
-        .filter((labelName) => data.find((item) => findByLabelName(item.labels, labelName)))
-        .reverse();
+    const requested = new Set(labelNames);
+    const found = new Set();
+    for (const item of data) {
+        for (const label of item.labels) {
+            if (requested.has(label.name)) {
+                found.add(label.name);
+            }
+        }
+        if (found.size === requested.size) {
+            break;
+        }
+    }
+    return labelNames.filter((labelName) => found.has(labelName));
 };
 export const createTreeByLabels = (data, labelNames, leafFactory, groupFactory, addLeafToGroup = () => { }) => {
     const leafFactoryFn = leafFactory ??
@@ -128,92 +163,71 @@ export const byCategories = (item) => {
     return result;
 };
 export const preciseTreeLabels = (labelNames, trs, labelNamesAccessor = (tr) => tr.labels.map(({ name }) => name)) => {
-    const result = new Set();
-    for (const labelName of labelNames) {
-        if (trs.some((tr) => labelNamesAccessor(tr).includes(labelName))) {
-            result.add(labelName);
+    const requested = new Set(labelNames);
+    const found = new Set();
+    for (const tr of trs) {
+        for (const labelName of labelNamesAccessor(tr)) {
+            if (requested.has(labelName)) {
+                found.add(labelName);
+            }
+        }
+        if (found.size === requested.size) {
+            break;
         }
     }
-    return Array.from(result);
+    const emitted = new Set();
+    return labelNames.filter((labelName) => {
+        if (!found.has(labelName) || emitted.has(labelName)) {
+            return false;
+        }
+        emitted.add(labelName);
+        return true;
+    });
 };
-export const filterTree = (tree, predicate) => {
+export const processTree = (tree, options) => {
     const visitedGroups = new Set();
     const { root, leavesById, groupsById } = tree;
-    const filterGroupLeaves = (group) => {
-        if (!predicate) {
-            return group;
-        }
+    const processGroup = (group) => {
         if (group.groups?.length) {
             group.groups.forEach((groupId) => {
                 const subGroup = groupsById[groupId];
                 if (!subGroup || visitedGroups.has(groupId)) {
                     return;
                 }
-                filterGroupLeaves(subGroup);
+                processGroup(subGroup);
                 visitedGroups.add(groupId);
             });
         }
         if (group.leaves?.length) {
-            group.leaves = group.leaves.filter((leaveId) => predicate(leavesById[leaveId]));
+            if (options.filter) {
+                group.leaves = group.leaves.filter((leaveId) => options.filter(leavesById[leaveId]));
+            }
+            if (options.sort) {
+                group.leaves = group.leaves.sort((a, b) => {
+                    const leafA = leavesById[a];
+                    const leafB = leavesById[b];
+                    return options.sort(leafA, leafB);
+                });
+            }
+            if (options.transform) {
+                group.leaves.forEach((leafId, i) => {
+                    leavesById[leafId] = options.transform(leavesById[leafId], i);
+                });
+            }
         }
         return group;
     };
-    filterGroupLeaves(root);
+    processGroup(root);
     return tree;
 };
+export const filterTree = (tree, predicate) => {
+    return processTree(tree, { filter: predicate });
+};
 export const sortTree = (tree, comparator) => {
-    const visitedGroups = new Set();
-    const { root, leavesById, groupsById } = tree;
-    const sortGroupLeaves = (group) => {
-        if (!comparator) {
-            return group;
-        }
-        if (group.groups?.length) {
-            group.groups.forEach((groupId) => {
-                if (visitedGroups.has(groupId)) {
-                    return;
-                }
-                sortGroupLeaves(groupsById[groupId]);
-                visitedGroups.add(groupId);
-            });
-        }
-        if (group.leaves?.length) {
-            group.leaves = group.leaves.sort((a, b) => {
-                const leafA = leavesById[a];
-                const leafB = leavesById[b];
-                return comparator(leafA, leafB);
-            });
-        }
-        return group;
-    };
-    sortGroupLeaves(root);
-    return tree;
+    return processTree(tree, { sort: comparator });
 };
 export const transformTree = (tree, transformer) => {
-    const visitedGroups = new Set();
-    const { root, leavesById, groupsById } = tree;
-    const transformGroupLeaves = (group) => {
-        if (!transformer) {
-            return group;
-        }
-        if (group.groups?.length) {
-            group.groups.forEach((groupId) => {
-                if (visitedGroups.has(groupId)) {
-                    return;
-                }
-                transformGroupLeaves(groupsById[groupId]);
-                visitedGroups.add(groupId);
-            });
-        }
-        if (group.leaves?.length) {
-            group.leaves.forEach((leaf, i) => {
-                leavesById[leaf] = transformer(leavesById[leaf], i);
-            });
-        }
-        return group;
-    };
-    transformGroupLeaves(root);
-    return tree;
+    return processTree(tree, { transform: transformer });
 };
 export const createTreeByTitlePath = (data, leafFactory, groupFactory, addLeafToGroup = () => { }) => {
     const leafFactoryFn = leafFactory ??
@@ -235,14 +249,7 @@ export const createTreeByTitlePath = (data, leafFactory, groupFactory, addLeafTo
     return createTree(data, (item) => (item.titlePath ?? []).map((segment) => [segment]), leafFactoryFn, groupFactoryFn, addLeafToGroup);
 };
 const byLabelsAndTitlePath = (item, labelNames) => {
-    const leaves = [];
-    for (const labelName of labelNames) {
-        const values = item.labels.filter((label) => label.name === labelName).map((label) => label.value ?? "");
-        if (!values.length) {
-            continue;
-        }
-        leaves.push(values);
-    }
+    const leaves = byLabelsWithFallback(item, labelNames, "");
     const titlePath = item.titlePath;
     if (Array.isArray(titlePath) && titlePath.length > 0) {
         for (const segment of titlePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-api",
-  "version": "3.8.1",
+  "version": "3.9.0",
   "description": "Allure Plugin API",
   "keywords": [
     "allure"
@@ -26,12 +26,13 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.8.1"
+    "@allurereport/core-api": "3.9.0"
   },
   "devDependencies": {
     "@types/node": "^20.17.9",
     "@vitest/runner": "^2.1.9",
     "@vitest/snapshot": "^2.1.9",
+    "allure-js-commons": "^3.3.3",
     "allure-vitest": "^3.3.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",