@allurereport/core 3.0.0-beta.17 → 3.0.0-beta.19

package/dist/report.js

@@ -9,45 +9,54 @@ 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_ci, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_events, _AllureReport_qualityGate, _AllureReport_realTime, _AllureReport_output, _AllureReport_history, _AllureReport_allureServiceClient, _AllureReport_state, _AllureReport_stage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+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_stage, _AllureReport_stageTempDirs, _AllureReport_state, _AllureReport_executionStage, _AllureReport_publish_get, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
 import { detect } from "@allurereport/ci";
+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 console from "node:console";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { readFileSync } from "node:fs";
-import { lstat, opendir, readdir, realpath, rename, rm } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { createReadStream, createWriteStream, existsSync, readFileSync } from "node:fs";
+import { lstat, mkdtemp, opendir, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import ZipWriteStream from "zip-stream";
 import { AllureLocalHistory, createHistory } from "./history.js";
 import { DefaultPluginState, PluginFiles } from "./plugin.js";
-import { QualityGate } from "./qualityGate.js";
+import { QualityGate } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
-import { Events } from "./utils/event.js";
+import { RealtimeEventsDispatcher, RealtimeSubscriber } from "./utils/event.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 {
     constructor(opts) {
         _AllureReport_instances.add(this);
         _AllureReport_reportName.set(this, void 0);
+        _AllureReport_reportVariables.set(this, void 0);
         _AllureReport_ci.set(this, void 0);
         _AllureReport_store.set(this, void 0);
         _AllureReport_readers.set(this, void 0);
         _AllureReport_plugins.set(this, void 0);
         _AllureReport_reportFiles.set(this, void 0);
         _AllureReport_eventEmitter.set(this, void 0);
-        _AllureReport_events.set(this, void 0);
-        _AllureReport_qualityGate.set(this, void 0);
+        _AllureReport_realtimeSubscriber.set(this, void 0);
+        _AllureReport_realtimeDispatcher.set(this, void 0);
         _AllureReport_realTime.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_stage.set(this, void 0);
+        _AllureReport_stageTempDirs.set(this, []);
         _AllureReport_state.set(this, void 0);
-        _AllureReport_stage.set(this, "init");
+        _AllureReport_executionStage.set(this, "init");
         this.readDirectory = async (resultsDir) => {
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             const resultsDirPath = resolve(resultsDir);
@@ -68,13 +77,13 @@ export class AllureReport {
             }
         };
         this.readFile = async (resultsFile) => {
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             await this.readResult(new PathResultFile(resultsFile));
         };
         this.readResult = async (data) => {
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
             for (const reader of __classPrivateFieldGet(this, _AllureReport_readers, "f")) {
@@ -87,15 +96,23 @@ export class AllureReport {
                 catch (ignored) { }
             }
         };
+        this.validate = async (params) => {
+            const { trs, knownIssues, state } = params;
+            return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate({
+                trs: trs.filter(Boolean),
+                knownIssues,
+                state,
+            });
+        };
         this.start = async () => {
             await __classPrivateFieldGet(this, _AllureReport_store, "f").readHistory();
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") === "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "running") {
                 throw new Error("the report is already started");
             }
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") === "done") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "done") {
                 throw new Error("the report is already stopped, the restart isn't supported at the moment");
             }
-            __classPrivateFieldSet(this, _AllureReport_stage, "running", "f");
+            __classPrivateFieldSet(this, _AllureReport_executionStage, "running", "f");
             if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f") && __classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get)) {
                 const { url } = await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").createReport({
                     reportUuid: this.reportUuid,
@@ -104,31 +121,196 @@ export class AllureReport {
                 this.reportUrl = url;
             }
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, true, async (plugin, context) => {
-                await plugin.start?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_events, "f"));
+                await plugin.start?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f"));
             });
             if (__classPrivateFieldGet(this, _AllureReport_realTime, "f")) {
                 await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
-                __classPrivateFieldGet(this, _AllureReport_events, "f").onAll(async () => {
+                __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f").onAll(async () => {
                     await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
                 });
             }
         };
         _AllureReport_update.set(this, async () => {
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 return;
             }
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
                 await plugin.update?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
             });
         });
+        this.dumpState = async () => {
+            const { testResults, testCases, fixtures, attachments: attachmentsLinks, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, } = __classPrivateFieldGet(this, _AllureReport_store, "f").dumpState();
+            const allAttachments = await __classPrivateFieldGet(this, _AllureReport_store, "f").allAttachments();
+            const dumpArchive = new ZipWriteStream({
+                zlib: { level: 5 },
+            });
+            const addEntry = promisify(dumpArchive.entry.bind(dumpArchive));
+            const dumpArchiveWriteStream = createWriteStream(`${__classPrivateFieldGet(this, _AllureReport_stage, "f")}.zip`);
+            const promise = new Promise((res, rej) => {
+                dumpArchive.on("error", (err) => rej(err));
+                dumpArchiveWriteStream.on("finish", () => res(void 0));
+                dumpArchiveWriteStream.on("error", (err) => rej(err));
+            });
+            dumpArchive.pipe(dumpArchiveWriteStream);
+            await addEntry(Buffer.from(JSON.stringify(testResults)), {
+                name: AllureStoreDumpFiles.TestResults,
+            });
+            await addEntry(Buffer.from(JSON.stringify(testCases)), {
+                name: AllureStoreDumpFiles.TestCases,
+            });
+            await addEntry(Buffer.from(JSON.stringify(fixtures)), {
+                name: AllureStoreDumpFiles.Fixtures,
+            });
+            await addEntry(Buffer.from(JSON.stringify(attachmentsLinks)), {
+                name: AllureStoreDumpFiles.Attachments,
+            });
+            await addEntry(Buffer.from(JSON.stringify(environments)), {
+                name: AllureStoreDumpFiles.Environments,
+            });
+            await addEntry(Buffer.from(JSON.stringify(__classPrivateFieldGet(this, _AllureReport_reportVariables, "f"))), {
+                name: AllureStoreDumpFiles.ReportVariables,
+            });
+            await addEntry(Buffer.from(JSON.stringify(globalAttachments)), {
+                name: AllureStoreDumpFiles.GlobalAttachments,
+            });
+            await addEntry(Buffer.from(JSON.stringify(globalErrors)), {
+                name: AllureStoreDumpFiles.GlobalErrors,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexAttachmentByTestResult)), {
+                name: AllureStoreDumpFiles.IndexAttachmentsByTestResults,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexTestResultByHistoryId)), {
+                name: AllureStoreDumpFiles.IndexTestResultsByHistoryId,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexTestResultByTestCase)), {
+                name: AllureStoreDumpFiles.IndexTestResultsByTestCase,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexLatestEnvTestResultByHistoryId)), {
+                name: AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexAttachmentByFixture)), {
+                name: AllureStoreDumpFiles.IndexAttachmentsByFixture,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexFixturesByTestResult)), {
+                name: AllureStoreDumpFiles.IndexFixturesByTestResult,
+            });
+            await addEntry(Buffer.from(JSON.stringify(indexKnownByHistoryId)), {
+                name: AllureStoreDumpFiles.IndexKnownByHistoryId,
+            });
+            for (const attachment of allAttachments) {
+                const content = await __classPrivateFieldGet(this, _AllureReport_store, "f").attachmentContentById(attachment.id);
+                if (!content) {
+                    continue;
+                }
+                if (content instanceof PathResultFile) {
+                    await addEntry(createReadStream(content.path), {
+                        name: attachment.id,
+                    });
+                }
+                else {
+                    await addEntry(await content.asBuffer(), {
+                        name: attachment.id,
+                    });
+                }
+            }
+            dumpArchive.finalize();
+            return promise;
+        };
+        this.restoreState = async (stages) => {
+            for (const stage of stages) {
+                if (!existsSync(stage)) {
+                    continue;
+                }
+                const dump = new ZipReadStream.async({
+                    file: stage,
+                });
+                const testResultsEntry = await dump.entryData(AllureStoreDumpFiles.TestResults);
+                const testCasesEntry = await dump.entryData(AllureStoreDumpFiles.TestCases);
+                const fixturesEntry = await dump.entryData(AllureStoreDumpFiles.Fixtures);
+                const attachmentsEntry = await dump.entryData(AllureStoreDumpFiles.Attachments);
+                const environmentsEntry = await dump.entryData(AllureStoreDumpFiles.Environments);
+                const reportVariablesEntry = await dump.entryData(AllureStoreDumpFiles.ReportVariables);
+                const globalAttachmentsEntry = await dump.entryData(AllureStoreDumpFiles.GlobalAttachments);
+                const globalErrorsEntry = await dump.entryData(AllureStoreDumpFiles.GlobalErrors);
+                const indexAttachmentsEntry = await dump.entryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
+                const indexTestResultsByHistoryId = await dump.entryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
+                const indexTestResultsByTestCaseEntry = await dump.entryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
+                const indexLatestEnvTestResultsByHistoryIdEntry = await dump.entryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
+                const indexAttachmentsByFixtureEntry = await dump.entryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
+                const indexFixturesByTestResultEntry = await dump.entryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
+                const indexKnownByHistoryIdEntry = await dump.entryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
+                const attachmentsEntries = Object.entries(await dump.entries()).reduce((acc, [entryName, entry]) => {
+                    switch (entryName) {
+                        case AllureStoreDumpFiles.Attachments:
+                        case AllureStoreDumpFiles.TestResults:
+                        case AllureStoreDumpFiles.TestCases:
+                        case AllureStoreDumpFiles.Fixtures:
+                        case AllureStoreDumpFiles.Environments:
+                        case AllureStoreDumpFiles.ReportVariables:
+                        case AllureStoreDumpFiles.GlobalAttachments:
+                        case AllureStoreDumpFiles.GlobalErrors:
+                        case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
+                        case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
+                        case AllureStoreDumpFiles.IndexTestResultsByTestCase:
+                        case AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId:
+                        case AllureStoreDumpFiles.IndexAttachmentsByFixture:
+                        case AllureStoreDumpFiles.IndexFixturesByTestResult:
+                        case AllureStoreDumpFiles.IndexKnownByHistoryId:
+                            return acc;
+                        default:
+                            return Object.assign(acc, {
+                                [entryName]: entry,
+                            });
+                    }
+                }, {});
+                const dumpState = {
+                    testResults: JSON.parse(testResultsEntry.toString("utf8")),
+                    testCases: JSON.parse(testCasesEntry.toString("utf8")),
+                    fixtures: JSON.parse(fixturesEntry.toString("utf8")),
+                    attachments: JSON.parse(attachmentsEntry.toString("utf8")),
+                    environments: JSON.parse(environmentsEntry.toString("utf8")),
+                    reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
+                    globalAttachments: JSON.parse(globalAttachmentsEntry.toString("utf8")),
+                    globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
+                    indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
+                    indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
+                    indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
+                    indexLatestEnvTestResultByHistoryId: JSON.parse(indexLatestEnvTestResultsByHistoryIdEntry.toString("utf8")),
+                    indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
+                    indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
+                    indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
+                };
+                const stageTempDir = await mkdtemp(join(tmpdir(), basename(stage, ".zip")));
+                const resultsAttachments = {};
+                __classPrivateFieldGet(this, _AllureReport_stageTempDirs, "f").push(stageTempDir);
+                try {
+                    for (const [attachmentId] of Object.entries(attachmentsEntries)) {
+                        const attachmentContentEntry = await dump.entryData(attachmentId);
+                        const attachmentFilePath = join(stageTempDir, attachmentId);
+                        await writeFile(attachmentFilePath, attachmentContentEntry);
+                        resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
+                    }
+                }
+                catch (err) {
+                    console.error(`Can't restore state from "${stage}", continuing without it`);
+                    console.error(err);
+                }
+                await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
+                console.info(`Successfully restored state from "${stage}"`);
+            }
+        };
         this.done = async () => {
             const summaries = [];
             const remoteHrefs = [];
-            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
-            __classPrivateFieldGet(this, _AllureReport_events, "f").offAll();
-            __classPrivateFieldSet(this, _AllureReport_stage, "done", "f");
+            __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f").offAll();
+            __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f")) {
+                await this.dumpState();
+                return;
+            }
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
                 await plugin.done?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
                 if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f") && context.publish) {
@@ -155,7 +337,7 @@ export class AllureReport {
                     return;
                 }
                 summary.pullRequestHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestUrl;
-                summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobUrl;
+                summary.jobHref = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunUrl;
                 if (context.publish) {
                     summary.remoteHref = `${this.reportUrl}/${context.id}/`;
                     remoteHrefs.push(summary.remoteHref);
@@ -171,7 +353,11 @@ export class AllureReport {
                     reportUuid: this.reportUuid,
                 });
             }
-            const outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
+            let outputDirFiles = [];
+            try {
+                outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
+            }
+            catch (ignored) { }
             if (outputDirFiles.length === 0) {
                 return;
             }
@@ -187,6 +373,12 @@ export class AllureReport {
                 }
                 await rm(reportPath, { recursive: true });
             }
+            for (const dir of __classPrivateFieldGet(this, _AllureReport_stageTempDirs, "f")) {
+                try {
+                    await rm(dir, { recursive: true });
+                }
+                catch (ignored) { }
+            }
             if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
                 const testResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
                 const testCases = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
@@ -215,6 +407,11 @@ export class AllureReport {
                     console.info(`- ${href}`);
                 });
             }
+            if (!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
+                return;
+            }
+            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResults();
+            await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), "quality-gate.json"), JSON.stringify(qualityGateResults));
         };
         _AllureReport_eachPlugin.set(this, async (initState, consumer) => {
             if (initState) {
@@ -261,52 +458,59 @@ export class AllureReport {
                 }
             }
         });
-        this.validate = async () => {
-            await __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate(__classPrivateFieldGet(this, _AllureReport_store, "f"));
-        };
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, qualityGate, realTime, historyPath, defaultLabels = {}, variables = {}, environments, output, allureService: allureServiceConfig, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, defaultLabels = {}, variables = {}, environment, environments, output, qualityGate, stage, allureService: allureServiceConfig, } = opts;
         __classPrivateFieldSet(this, _AllureReport_allureServiceClient, allureServiceConfig?.url ? new AllureServiceClient(allureServiceConfig) : undefined, "f");
         this.reportUuid = randomUUID();
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");
         const reportTitleSuffix = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestName ?? __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunName;
         __classPrivateFieldSet(this, _AllureReport_reportName, [name, reportTitleSuffix].filter(Boolean).join(" – "), "f");
+        __classPrivateFieldSet(this, _AllureReport_reportVariables, variables, "f");
         __classPrivateFieldSet(this, _AllureReport_eventEmitter, new EventEmitter(), "f");
-        __classPrivateFieldSet(this, _AllureReport_events, new Events(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
+        __classPrivateFieldSet(this, _AllureReport_realtimeDispatcher, new RealtimeEventsDispatcher(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
+        __classPrivateFieldSet(this, _AllureReport_realtimeSubscriber, new RealtimeSubscriber(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
+        __classPrivateFieldSet(this, _AllureReport_stage, stage, "f");
         if (__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")) {
             __classPrivateFieldSet(this, _AllureReport_history, new AllureRemoteHistory(__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")), "f");
         }
         else if (historyPath) {
             __classPrivateFieldSet(this, _AllureReport_history, new AllureLocalHistory(historyPath), "f");
         }
+        if (qualityGate) {
+            __classPrivateFieldSet(this, _AllureReport_qualityGate, new QualityGate(qualityGate), "f");
+        }
         __classPrivateFieldSet(this, _AllureReport_store, new DefaultAllureStore({
-            eventEmitter: __classPrivateFieldGet(this, _AllureReport_eventEmitter, "f"),
+            realtimeSubscriber: __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f"),
+            realtimeDispatcher: __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f"),
             reportVariables: variables,
             environmentsConfig: environments,
             history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
             known,
             defaultLabels,
+            environment,
         }), "f");
         __classPrivateFieldSet(this, _AllureReport_readers, [...readers], "f");
         __classPrivateFieldSet(this, _AllureReport_plugins, [...plugins], "f");
         __classPrivateFieldSet(this, _AllureReport_reportFiles, reportFiles, "f");
         __classPrivateFieldSet(this, _AllureReport_output, output, "f");
-        __classPrivateFieldSet(this, _AllureReport_qualityGate, new QualityGate(qualityGate), "f");
         __classPrivateFieldSet(this, _AllureReport_history, __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")
             ? new AllureRemoteHistory(__classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f"))
             : new AllureLocalHistory(historyPath), "f");
     }
+    get hasQualityGate() {
+        return !!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f");
+    }
     get store() {
         return __classPrivateFieldGet(this, _AllureReport_store, "f");
     }
-    get exitCode() {
-        return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").exitCode;
+    get realtimeSubscriber() {
+        return __classPrivateFieldGet(this, _AllureReport_realtimeSubscriber, "f");
     }
-    get validationResults() {
-        return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").result;
+    get realtimeDispatcher() {
+        return __classPrivateFieldGet(this, _AllureReport_realtimeDispatcher, "f");
     }
 }
-_AllureReport_reportName = 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_events = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_stage = 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_output = new WeakMap(), _AllureReport_history = new WeakMap(), _AllureReport_allureServiceClient = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_stage = new WeakMap(), _AllureReport_stageTempDirs = 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/store.d.ts

@@ -1,8 +1,8 @@
-import { type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type RepoData, type ReportVariables, type TestCase, type TestEnvGroup, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
-import { type AllureStore, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
+import { type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type RepoData, type ReportVariables, 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, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
-import type { EventEmitter } from "node:events";
-import type { AllureStoreEvents } from "../utils/event.js";
+export declare const mapToObject: <K extends string | number | symbol, T = any>(map: Map<K, T>) => Record<K, T>;
+export declare const mergeMapWithRecord: <K extends string | number | symbol, T = any>(map: Map<K, T>, record: Record<K, T>) => Map<K, T>;
 export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     #private;
     readonly indexTestResultByTestCase: Map<string, TestResult[]>;
@@ -15,14 +15,20 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     constructor(params?: {
         history?: AllureHistory;
         known?: KnownTestFailure[];
-        eventEmitter?: EventEmitter<AllureStoreEvents>;
+        realtimeDispatcher?: RealtimeEventsDispatcher;
+        realtimeSubscriber?: RealtimeSubscriber;
         defaultLabels?: DefaultLabelsConfig;
+        environment?: string;
         environmentsConfig?: EnvironmentsConfig;
         reportVariables?: ReportVariables;
     });
     readHistory(): Promise<HistoryDataPoint[]>;
     appendHistory(history: HistoryDataPoint): Promise<void>;
     repoData(): Promise<RepoData | undefined>;
+    qualityGateResults(): Promise<QualityGateValidationResult[]>;
+    globalExitCode(): Promise<ExitCode | undefined>;
+    allGlobalErrors(): Promise<TestError[]>;
+    allGlobalAttachments(): Promise<AttachmentLink[]>;
     visitTestResult(raw: RawTestResult, context: ReaderContext): Promise<void>;
     visitTestFixtureResult(result: RawFixtureResult, context: ReaderContext): Promise<void>;
     visitAttachmentFile(resultFile: ResultFile, context: ReaderContext): Promise<void>;
@@ -68,4 +74,6 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     envVariables(env: string): Promise<{
         [x: string]: string;
     }>;
+    dumpState(): AllureStoreDump;
+    restoreState(stateDump: AllureStoreDump, attachmentsContents?: Record<string, ResultFile>): Promise<void>;
 }