@allurereport/core 3.3.1 → 3.4.1

package/dist/api.d.ts

@@ -12,6 +12,7 @@ export interface FullConfig {
     output: string;
     open: boolean;
     port: string | undefined;
+    hideLabels?: (string | RegExp)[];
     historyPath?: string;
     historyLimit?: number;
     knownIssuesPath: string;

package/dist/config.d.ts

@@ -5,11 +5,13 @@ export interface ConfigOverride {
     output?: Config["output"];
     open?: Config["open"];
     port?: Config["port"];
+    hideLabels?: Config["hideLabels"];
     historyPath?: Config["historyPath"];
     historyLimit?: Config["historyLimit"];
     knownIssuesPath?: Config["knownIssuesPath"];
     plugins?: Config["plugins"];
 }
+export declare const assertValidPluginId: (id: string) => void;
 export declare const getPluginId: (key: string) => string;
 export declare const findConfig: (cwd: string, configPath?: string) => Promise<string | undefined>;
 export declare const validateConfig: (config: Config) => {

package/dist/config.js

@@ -2,11 +2,14 @@ import * as console from "node:console";
 import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import * as process from "node:process";
+import { validateEnvironmentName } from "@allurereport/core-api";
 import { parse } from "yaml";
 import { readKnownIssues } from "./known.js";
 import { FileSystemReportFiles } from "./plugin.js";
+import { environmentIdentityById, environmentIdentityByName, normalizeEnvironmentDescriptorMap, } from "./utils/environment.js";
 import { importWrapper } from "./utils/module.js";
 import { normalizeImportPath } from "./utils/path.js";
+import { assertValidPluginIdForWindows, isWindows } from "./utils/windows.js";
 const CONFIG_FILENAMES = [
     "allurerc.js",
     "allurerc.mjs",
@@ -16,8 +19,31 @@ const CONFIG_FILENAMES = [
     "allurerc.yml",
 ];
 const DEFAULT_CONFIG = {};
+export const assertValidPluginId = (id) => {
+    if (id.length === 0) {
+        throw new Error("Invalid plugin id: must not be empty");
+    }
+    if (id === "." || id === "..") {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: must not be "." or ".."`);
+    }
+    if (id.includes("..")) {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: must not contain ".."`);
+    }
+    if (/[/\\]/.test(id)) {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: must not contain path separators`);
+    }
+    if (isWindows()) {
+        assertValidPluginIdForWindows(id);
+    }
+};
 export const getPluginId = (key) => {
-    return key.replace(/^@.*\//, "").replace(/[/\\]/g, "-");
+    const trimmed = key.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`Invalid plugin key ${JSON.stringify(key)}: must not be empty or whitespace-only`);
+    }
+    const id = trimmed.replace(/^@.*\//, "").replace(/[/\\]/g, "-");
+    assertValidPluginId(id);
+    return id;
 };
 export const findConfig = async (cwd, configPath) => {
     if (configPath) {
@@ -51,12 +77,14 @@ export const validateConfig = (config) => {
         "output",
         "open",
         "port",
+        "hideLabels",
         "historyPath",
         "historyLimit",
         "knownIssuesPath",
         "plugins",
         "defaultLabels",
         "variables",
+        "environment",
         "environments",
         "appendHistory",
         "qualityGate",
@@ -98,14 +126,42 @@ export const loadJsonConfig = async (configPath) => {
 export const loadJsConfig = async (configPath) => {
     return (await import(normalizeImportPath(configPath))).default;
 };
+const resolveConfigEnvironments = (config) => {
+    const errors = [];
+    const { normalized: environments, errors: environmentErrors } = normalizeEnvironmentDescriptorMap(config.environments ?? {}, "config.environments");
+    let environment;
+    errors.push(...environmentErrors);
+    if (config.environment !== undefined) {
+        const environmentResult = validateEnvironmentName(config.environment);
+        if (!environmentResult.valid) {
+            errors.push(`environment ${environmentResult.reason}`);
+        }
+        else {
+            const normalizedEnvironment = environmentResult.normalized;
+            environment =
+                environmentIdentityById(environments, normalizedEnvironment)?.id ??
+                    environmentIdentityByName(environments, normalizedEnvironment)?.id ??
+                    normalizedEnvironment;
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`The provided Allure config contains invalid environments: ${errors.join("; ")}`);
+    }
+    return {
+        environments,
+        environment,
+    };
+};
 export const resolveConfig = async (config, override = {}) => {
     const validationResult = validateConfig(config);
     if (!validationResult.valid) {
         throw new Error(`The provided Allure config contains unsupported fields: ${validationResult.fields.join(", ")}`);
     }
+    const { environments, environment } = resolveConfigEnvironments(config);
     const name = override.name ?? config.name ?? "Allure Report";
     const open = override.open ?? config.open ?? false;
     const port = override.port ?? config.port ?? undefined;
+    const hideLabels = override.hideLabels ?? config.hideLabels;
     const historyPath = override.historyPath ?? config.historyPath;
     const historyLimit = override.historyLimit ?? config.historyLimit;
     const appendHistory = config.appendHistory ?? true;
@@ -113,22 +169,24 @@ export const resolveConfig = async (config, override = {}) => {
     const output = resolve(override.output ?? config.output ?? "./allure-report");
     const known = await readKnownIssues(knownIssuesPath);
     const variables = config.variables ?? {};
-    const environments = config.environments ?? {};
-    const plugins = Object.keys(override?.plugins ?? config?.plugins ?? {}).length === 0
+    const configuredPlugins = override.plugins ?? config.plugins;
+    const plugins = Object.keys(configuredPlugins ?? {}).length === 0
         ? {
             awesome: {
                 options: {},
             },
         }
-        : config.plugins;
+        : configuredPlugins;
     const pluginInstances = await resolvePlugins(plugins);
     return {
         name,
         output,
         open,
         port,
+        hideLabels,
         knownIssuesPath,
         known,
+        environment,
         variables,
         environments,
         appendHistory,
@@ -167,19 +225,26 @@ export const readConfig = async (cwd = process.cwd(), configPath, override) => {
 export const getPluginInstance = (config, predicate) => {
     return config?.plugins?.find(predicate);
 };
+const isModuleNotFoundError = (err) => {
+    return err instanceof Error && "code" in err && err.code === "ERR_MODULE_NOT_FOUND";
+};
 export const resolvePlugin = async (path) => {
     if (!path.startsWith("@allurereport/plugin-")) {
         try {
             const module = await importWrapper(`@allurereport/plugin-${path}`);
             return module.default;
         }
-        catch (err) { }
+        catch (err) {
+            if (!isModuleNotFoundError(err)) {
+                throw err;
+            }
+        }
     }
     try {
         const module = await importWrapper(path);
         return module.default;
     }
-    catch (err) {
+    catch {
         throw new Error(`Cannot resolve plugin: ${path}`);
     }
 };

package/dist/history.d.ts

@@ -1,4 +1,4 @@
-import type { AllureHistory, HistoryDataPoint, TestCase, TestResult } from "@allurereport/core-api";
+import { type AllureHistory, type HistoryDataPoint, type TestCase, type TestResult } from "@allurereport/core-api";
 export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string) => HistoryDataPoint;
 export declare class AllureLocalHistory implements AllureHistory {
     #private;

package/dist/history.js

@@ -15,8 +15,9 @@ import { mkdir, open } from "node:fs/promises";
 import path from "node:path";
 import readline from "node:readline/promises";
 import { pipeline } from "node:stream/promises";
+import { normalizeHistoryDataPointUrls, } from "@allurereport/core-api";
 import { isFileNotFoundError } from "./utils/misc.js";
-const createHistoryItems = (testResults) => {
+const createHistoryItems = (testResults, remoteUrl) => {
     return testResults
         .filter((tr) => tr.historyId)
         .map(({ id, name, fullName, environment, historyId, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
@@ -32,7 +33,7 @@ const createHistoryItems = (testResults) => {
             stop,
             duration,
             labels,
-            url: "",
+            url: remoteUrl,
             historyId: historyId,
             reportLinks: [],
         };
@@ -49,7 +50,7 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         name: reportName,
         timestamp: new Date().getTime(),
         knownTestCaseIds,
-        testResults: createHistoryItems(testResults),
+        testResults: createHistoryItems(testResults, remoteUrl),
         metrics: {},
         url: remoteUrl,
     };
@@ -144,7 +145,7 @@ export class AllureLocalHistory {
                 .createInterface({ input: stream, terminal: false, crlfDelay: Infinity })
                 .on("line", (line) => {
                 if (line && line.trim().length) {
-                    const historyEntry = JSON.parse(line);
+                    const historyEntry = normalizeHistoryDataPointUrls(JSON.parse(line));
                     historyPoints.push(historyEntry);
                 }
             });
@@ -157,6 +158,7 @@ export class AllureLocalHistory {
         }
     }
     async appendHistory(data) {
+        const normalizedData = normalizeHistoryDataPointUrls(data);
         const fullPath = path.resolve(this.params.historyPath);
         const parentDir = path.dirname(fullPath);
         const { limit } = this.params;
@@ -176,7 +178,7 @@ export class AllureLocalHistory {
                 const src = historyFile.createReadStream({ start, autoClose: false });
                 await pipeline(src, dst, { end: false });
             }
-            const sources = [JSON.stringify(data), Buffer.from([0x0a])];
+            const sources = [JSON.stringify(normalizedData), Buffer.from([0x0a])];
             await pipeline(sources, dst);
             if (historyExists) {
                 await historyFile.truncate(dst.bytesWritten);
@@ -185,7 +187,7 @@ export class AllureLocalHistory {
         finally {
             await historyFile.close();
             if (limit !== 0) {
-                __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(data);
+                __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(normalizedData);
             }
             if (limit) {
                 __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").splice(limit);

package/dist/index.d.ts

@@ -4,9 +4,10 @@ export * from "./utils/crypto.js";
 export * from "./utils/path.js";
 export * from "./utils/new.js";
 export * from "./utils/flaky.js";
+export * from "./utils/environment.js";
 export * from "./history.js";
 export * from "./known.js";
 export { resolveConfig, readConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -3,9 +3,10 @@ export * from "./utils/crypto.js";
 export * from "./utils/path.js";
 export * from "./utils/new.js";
 export * from "./utils/flaky.js";
+export * from "./utils/environment.js";
 export * from "./history.js";
 export * from "./known.js";
 export { resolveConfig, readConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/plugin.js

@@ -13,6 +13,7 @@ var _DefaultPluginState_state, _PluginFiles_parent, _PluginFiles_pluginId, _InMe
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { join as joinPosix } from "node:path/posix";
+import { resolvePathUnderOutputRoot } from "./utils/safeOutputPath.js";
 export class DefaultPluginState {
     constructor(state) {
         _DefaultPluginState_state.set(this, void 0);
@@ -58,7 +59,7 @@ export class FileSystemReportFiles {
     constructor(output) {
         _FileSystemReportFiles_output.set(this, void 0);
         this.addFile = async (path, data) => {
-            const targetPath = resolve(__classPrivateFieldGet(this, _FileSystemReportFiles_output, "f"), path);
+            const targetPath = resolvePathUnderOutputRoot(__classPrivateFieldGet(this, _FileSystemReportFiles_output, "f"), path);
             const targetDirPath = dirname(targetPath);
             await mkdir(targetDirPath, { recursive: true });
             await writeFile(targetPath, data, { encoding: "utf-8" });

package/dist/qualityGate/qualityGate.js

@@ -4,7 +4,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _QualityGateState_state;
-import { DEFAULT_ENVIRONMENT } from "@allurereport/core-api";
 import { gray, red } from "yoctocolors";
 import { qualityGateDefaultRules } from "./rules.js";
 export const stringifyQualityGateResults = (results) => {
@@ -77,6 +76,7 @@ export class QualityGate {
                     },
                     expected,
                     knownIssues,
+                    environment,
                 });
                 if (result.success) {
                     continue;
@@ -89,7 +89,7 @@ export class QualityGate {
                         actual: result.actual,
                         expected,
                     }),
-                    environment: environment || DEFAULT_ENVIRONMENT,
+                    environment,
                 });
                 if (ruleset.fastFail) {
                     fastFailed = true;

package/dist/qualityGate/rules.d.ts

@@ -3,4 +3,6 @@ export declare const maxFailuresRule: QualityGateRule<number>;
 export declare const minTestsCountRule: QualityGateRule<number>;
 export declare const successRateRule: QualityGateRule<number>;
 export declare const maxDurationRule: QualityGateRule<number>;
-export declare const qualityGateDefaultRules: QualityGateRule<number>[];
+export declare const allTestsContainEnvRule: QualityGateRule<string>;
+export declare const environmentsTestedRule: QualityGateRule<string[]>;
+export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<string> | QualityGateRule<string[]>)[];

package/dist/qualityGate/rules.js

@@ -1,11 +1,11 @@
-import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
+import { filterSuccessful, filterUnknownByKnownIssues, filterUnsuccessful } from "@allurereport/core-api";
 import { bold } from "yoctocolors";
 export const maxFailuresRule = {
     rule: "maxFailures",
     message: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
     validate: async ({ trs, knownIssues, expected, state }) => {
-        const knownIssuesHistoryIds = knownIssues.map(({ historyId }) => historyId);
-        const unknown = trs.filter((tr) => !tr.historyId || !knownIssuesHistoryIds.includes(tr.historyId));
+        const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
+        const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
         const failedTrs = unknown.filter(filterUnsuccessful);
         const actual = failedTrs.length + (state.getResult() ?? 0);
         state.setResult(actual);
@@ -31,8 +31,8 @@ export const successRateRule = {
     rule: "successRate",
     message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
     validate: async ({ trs, knownIssues, expected }) => {
-        const knownIssuesHistoryIds = knownIssues.map(({ historyId }) => historyId);
-        const unknown = trs.filter((tr) => !tr.historyId || !knownIssuesHistoryIds.includes(tr.historyId));
+        const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
+        const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
         const passedTrs = unknown.filter(filterSuccessful);
         const rate = passedTrs.length === 0 ? 0 : passedTrs.length / unknown.length;
         return {
@@ -52,4 +52,38 @@ export const maxDurationRule = {
         };
     },
 };
-export const qualityGateDefaultRules = [maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule];
+export const allTestsContainEnvRule = {
+    rule: "allTestsContainEnv",
+    message: ({ actual, expected }) => `Not all tests contain the required environment, ${bold(`"${expected}"`)}; ${bold(actual.length === 1 ? "one" : String(actual))} ${actual.length === 1 ? "test has" : "tests have"} different or missing environment`,
+    validate: async ({ trs, expected }) => {
+        const testsWithoutEnv = trs.filter((tr) => (tr.environment ?? "") !== expected);
+        const actual = testsWithoutEnv.length;
+        return {
+            success: actual === 0,
+            actual,
+        };
+    },
+};
+export const environmentsTestedRule = {
+    rule: "environmentsTested",
+    message: ({ actual, expected }) => `The following environments were not tested: "${actual.join('", "')}"; expected all of: "${expected.join('", "')}"`,
+    validate: async ({ trs, expected, state }) => {
+        const previouslyTested = new Set(state.getResult() ?? []);
+        const batchTested = trs.map((tr) => tr.environment).filter((env) => env != null && env !== "");
+        const testedEnvs = new Set([...previouslyTested, ...batchTested]);
+        state.setResult([...testedEnvs]);
+        const missing = expected.filter((env) => !testedEnvs.has(env));
+        return {
+            success: missing.length === 0,
+            actual: missing,
+        };
+    },
+};
+export const qualityGateDefaultRules = [
+    maxFailuresRule,
+    minTestsCountRule,
+    successRateRule,
+    maxDurationRule,
+    allTestsContainEnvRule,
+    environmentsTestedRule,
+];

package/dist/report.js

@@ -9,15 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AllureReport_instances, _AllureReport_reportName, _AllureReport_reportVariables, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_realtimeSubscriber, _AllureReport_realtimeDispatcher, _AllureReport_realTime, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
-import { detect } from "@allurereport/ci";
-import { normalizeCategoriesConfig } from "@allurereport/core-api";
-import { AllureStoreDumpFiles, } from "@allurereport/plugin-api";
-import { allure1, allure2, attachments, cucumberjson, junitXml, readXcResultBundle } from "@allurereport/reader";
-import { PathResultFile } from "@allurereport/reader-api";
-import { AllureRemoteHistory, AllureServiceClient, KnownError, UnknownError } from "@allurereport/service";
-import { generateSummary } from "@allurereport/summary";
-import ZipReadStream from "node-stream-zip";
+var _AllureReport_instances, _AllureReport_reportName, _AllureReport_reportVariables, _AllureReport_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_realtimeSubscriber, _AllureReport_realtimeDispatcher, _AllureReport_realTime, _AllureReport_hideLabels, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_qualityGate, _AllureReport_dump, _AllureReport_categories, _AllureReport_environments, _AllureReport_dumpTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import console from "node:console";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -26,6 +18,14 @@ import { lstat, mkdtemp, opendir, readdir, realpath, rename, rm, writeFile } fro
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
+import { detect } from "@allurereport/ci";
+import { normalizeCategoriesConfig } from "@allurereport/core-api";
+import { AllureStoreDumpFiles, } from "@allurereport/plugin-api";
+import { allure1, allure2, attachments, cucumberjson, junitXml, readXcResultBundle } from "@allurereport/reader";
+import { PathResultFile } from "@allurereport/reader-api";
+import { AllureRemoteHistory, AllureServiceClient, KnownError, UnknownError } from "@allurereport/service";
+import { generateSummary } from "@allurereport/summary";
+import ZipReadStream from "node-stream-zip";
 import pLimit from "p-limit";
 import ProgressBar from "progress";
 import ZipWriteStream from "zip-stream";
@@ -33,7 +33,9 @@ import { AllureLocalHistory, createHistory } from "./history.js";
 import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
+import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
 import { RealtimeEventsDispatcher, RealtimeSubscriber } from "./utils/event.js";
+import { resolveDumpAttachmentPath, UnsafeDumpPathError } from "./utils/safeDumpPath.js";
 const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const initRequired = "report is not initialised. Call the start() method first.";
 export class AllureReport {
@@ -50,12 +52,14 @@ export class AllureReport {
         _AllureReport_realtimeSubscriber.set(this, void 0);
         _AllureReport_realtimeDispatcher.set(this, void 0);
         _AllureReport_realTime.set(this, void 0);
+        _AllureReport_hideLabels.set(this, void 0);
         _AllureReport_output.set(this, void 0);
         _AllureReport_history.set(this, void 0);
         _AllureReport_allureServiceClient.set(this, void 0);
         _AllureReport_qualityGate.set(this, void 0);
         _AllureReport_dump.set(this, void 0);
         _AllureReport_categories.set(this, void 0);
+        _AllureReport_environments.set(this, void 0);
         _AllureReport_dumpTempDirs.set(this, []);
         _AllureReport_state.set(this, void 0);
         _AllureReport_executionStage.set(this, "init");
@@ -102,11 +106,16 @@ export class AllureReport {
         };
         this.validate = async (params) => {
             const { trs, knownIssues, state, environment } = params;
+            const qualityGateEnvironment = environment === undefined
+                ? undefined
+                : (environmentIdentityById(__classPrivateFieldGet(this, _AllureReport_environments, "f"), environment)?.name ??
+                    environmentIdentityByName(__classPrivateFieldGet(this, _AllureReport_environments, "f"), environment)?.name ??
+                    environment);
             return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate({
                 trs: trs.filter(Boolean),
                 knownIssues,
                 state,
-                environment,
+                environment: qualityGateEnvironment,
             });
         };
         this.start = async () => {
@@ -299,12 +308,18 @@ export class AllureReport {
                 try {
                     for (const [attachmentId] of Object.entries(attachmentsEntries)) {
                         const attachmentContentEntry = await dumpArchive.entryData(attachmentId);
-                        const attachmentFilePath = join(dumpTempDir, attachmentId);
+                        const attachmentFilePath = resolveDumpAttachmentPath(dumpTempDir, attachmentId);
                         await writeFile(attachmentFilePath, attachmentContentEntry);
                         resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
                     }
                 }
                 catch (err) {
+                    if (err instanceof UnsafeDumpPathError) {
+                        console.error(`Cannot restore dump from "${dump}": the archive lists attachment paths that would write outside the extract directory (unsafe zip paths such as "../" or absolute names).`);
+                        console.error(err.message);
+                        console.error("Only use dump archives produced by this tool; do not load untrusted or third-party --dump zip files.");
+                        throw err;
+                    }
                     console.error(`Can't restore state from "${dump}", continuing without it`);
                     console.error(err);
                 }
@@ -380,6 +395,7 @@ export class AllureReport {
                 if (!summary) {
                     return;
                 }
+                summary.pluginId = context.id;
                 summary.pullRequestHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestUrl;
                 summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunUrl;
                 if (context.publish && this.reportUrl && !cancelledPluginsIds.has(context.id)) {
@@ -496,6 +512,7 @@ export class AllureReport {
                     allureVersion: version,
                     reportUuid: this.reportUuid,
                     reportName: __classPrivateFieldGet(this, _AllureReport_reportName, "f"),
+                    hideLabels: __classPrivateFieldGet(this, _AllureReport_hideLabels, "f"),
                     state: pluginState,
                     reportFiles: pluginFiles,
                     reportUrl: this.reportUrl,
@@ -515,7 +532,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, historyLimit, defaultLabels = {}, variables = {}, environment, environments, output, qualityGate, dump, categories, allureService: allureServiceConfig, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, historyLimit, defaultLabels = {}, variables = {}, environment, environments, output, hideLabels, qualityGate, dump, categories, allureService: allureServiceConfig, } = opts;
         __classPrivateFieldSet(this, _AllureReport_allureServiceClient, allureServiceConfig?.accessToken
             ? new AllureServiceClient(allureServiceConfig)
             : undefined, "f");
@@ -529,6 +546,8 @@ export class AllureReport {
         __classPrivateFieldSet(this, _AllureReport_realtimeSubscriber, new RealtimeSubscriber(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
         __classPrivateFieldSet(this, _AllureReport_dump, dump, "f");
+        __classPrivateFieldSet(this, _AllureReport_hideLabels, hideLabels, "f");
+        __classPrivateFieldSet(this, _AllureReport_environments, environments ?? {}, "f");
         if (qualityGate) {
             __classPrivateFieldSet(this, _AllureReport_qualityGate, new QualityGate(qualityGate), "f");
         }
@@ -574,7 +593,7 @@ export class AllureReport {
         return __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f");
     }
 }
-_AllureReport_reportName = new WeakMap(), _AllureReport_reportVariables = new WeakMap(), _AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_eventEmitter = new WeakMap(), _AllureReport_realtimeSubscriber = new WeakMap(), _AllureReport_realtimeDispatcher = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_update = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_publish_get = function _AllureReport_publish_get() {
+_AllureReport_reportName = new WeakMap(), _AllureReport_reportVariables = new WeakMap(), _AllureReport_ci = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_eventEmitter = new WeakMap(), _AllureReport_realtimeSubscriber = new WeakMap(), _AllureReport_realtimeDispatcher = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_hideLabels = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_dump = new WeakMap(), _AllureReport_categories = new WeakMap(), _AllureReport_environments = new WeakMap(), _AllureReport_dumpTempDirs = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_executionStage = new WeakMap(), _AllureReport_update = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_publish_get = function _AllureReport_publish_get() {
     return __classPrivateFieldGet(this, _AllureReport_plugins, "f").some(({ enabled, options }) => enabled && options.publish);
 }, _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
     return init ? new DefaultPluginState({}) : __classPrivateFieldGet(this, _AllureReport_state, "f")?.[id];

package/dist/store/convert.js

@@ -1,7 +1,7 @@
+import { randomUUID } from "node:crypto";
 import { findByLabelName, notNull } from "@allurereport/core-api";
 import { md5 } from "@allurereport/plugin-api";
 import { extension, lookupContentType } from "@allurereport/reader-api";
-import { randomUUID } from "node:crypto";
 const defaultStatus = "unknown";
 export const __unknown = "#___unknown_value___#";
 export const testFixtureResultRawToState = (stateData, raw, context) => {

package/dist/store/store.d.ts

@@ -1,4 +1,4 @@
-import { type AllureHistory, type AttachmentLink, type AttachmentLinkLinked, type DefaultLabelsConfig, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
+import { type AllureHistory, type AttachmentLink, type AttachmentLinkLinked, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
 import { type AllureStore, type AllureStoreDump, type ExitCode, type QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
 import type { RawFixtureResult, RawGlobals, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
 export declare const mapToObject: <K extends string | number | symbol, T = any>(map: Map<K, T>) => Record<K, T>;
@@ -6,6 +6,7 @@ export declare const updateMapWithRecord: <K extends string | number | symbol, T
 export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     #private;
     readonly indexTestResultByTestCase: Map<string, TestResult[]>;
+    readonly indexTestResultByEnvironmentId: Map<string, TestResult[]>;
     readonly indexLatestEnvTestResultByHistoryId: Map<string, Map<string, TestResult>>;
     readonly indexTestResultByHistoryId: Map<string, TestResult[]>;
     readonly indexAttachmentByTestResult: Map<string, AttachmentLink[]>;
@@ -26,6 +27,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     appendHistory(history: HistoryDataPoint): Promise<void>;
     qualityGateResults(): Promise<QualityGateValidationResult[]>;
     qualityGateResultsByEnv(): Promise<Record<string, QualityGateValidationResult[]>>;
+    qualityGateResultsByEnvironmentId(): Promise<Record<string, QualityGateValidationResult[]>>;
     globalExitCode(): Promise<ExitCode | undefined>;
     allGlobalErrors(): Promise<TestError[]>;
     allGlobalAttachments(): Promise<AttachmentLinkLinked[]>;
@@ -47,6 +49,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     allFixtures(): Promise<TestFixtureResult[]>;
     allHistoryDataPoints(): Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironment(environment: string): Promise<HistoryDataPoint[]>;
+    allHistoryDataPointsByEnvironmentId(environmentId: string): Promise<HistoryDataPoint[]>;
     allKnownIssues(): Promise<KnownTestFailure[]>;
     allNewTestResults(filter?: TestResultFilter, history?: HistoryDataPoint[]): Promise<TestResult[]>;
     testCaseById(tcId: string): Promise<TestCase | undefined>;
@@ -55,8 +58,9 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     attachmentContentById(attachmentId: string): Promise<ResultFile | undefined>;
     metadataByKey<T>(key: string): Promise<T | undefined>;
     testResultsByTcId(tcId: string): Promise<TestResult[]>;
+    environmentIdByTrId(trId: string): Promise<string | undefined>;
     attachmentsByTrId(trId: string): Promise<AttachmentLink[]>;
-    retriesByTr(tr: TestResult): Promise<TestResult[]>;
+    retriesByTr(tr?: TestResult): Promise<TestResult[]>;
     retriesByTrId(trId: string): Promise<TestResult[]>;
     historyByTr(tr: TestResult): Promise<HistoryTestResult[] | undefined>;
     historyByTrId(trId: string): Promise<HistoryTestResult[] | undefined>;
@@ -69,14 +73,21 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     }>;
     testsStatistic(filter?: TestResultFilter): Promise<Statistic>;
     allEnvironments(): Promise<string[]>;
+    allEnvironmentIdentities(): Promise<EnvironmentIdentity[]>;
     testResultsByEnvironment(env: string, options?: {
-        includeHidden: boolean;
+        includeHidden?: boolean;
+    }): Promise<TestResult[]>;
+    testResultsByEnvironmentId(envId: string, options?: {
+        includeHidden?: boolean;
     }): Promise<TestResult[]>;
     allTestEnvGroups(): Promise<TestEnvGroup[]>;
     allVariables(): Promise<ReportVariables>;
     envVariables(env: string): Promise<{
         [x: string]: string;
     }>;
+    envVariablesByEnvironmentId(envId: string): Promise<{
+        [x: string]: string;
+    }>;
     dumpState(): AllureStoreDump;
     restoreState(stateDump: AllureStoreDump, attachmentsContents?: Record<string, ResultFile>): Promise<void>;
 }