@allurereport/core 3.8.0 → 3.8.2

package/dist/report.js

@@ -22,7 +22,7 @@ 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 { AllureLegacyServiceClient, AllureRemoteHistory, AllureServiceClient, KnownError, UnknownError, } from "@allurereport/service";
+import { AllureRemoteHistory, AllureServiceClient, KnownError, UnknownError, } from "@allurereport/service";
 import { generateSummary } from "@allurereport/summary";
 import { glob } from "glob";
 import ZipReadStream from "node-stream-zip";
@@ -44,6 +44,11 @@ const remoteReportParams = (ci) => {
     const branch = ci?.jobRunBranch;
     return repo && branch ? { repo, branch } : {};
 };
+const REMOTE_UPLOAD_CONCURRENCY = 50;
+const REMOTE_UPLOAD_MAX_ATTEMPTS = 5;
+const REMOTE_UPLOAD_MAX_SIMULTANEOUS_FAILED = 5;
+const errorDetails = (err) => (err instanceof Error ? (err.stack ?? err.message) : String(err));
+const isAbortError = (err) => typeof err === "object" && err !== null && "name" in err && err?.name === "AbortError";
 export class AllureReport {
     constructor(opts) {
         _AllureReport_instances.add(this);
@@ -300,125 +305,152 @@ export class AllureReport {
         this.restoreState = async (dumps) => {
             for (const dump of dumps) {
                 if (!existsSync(dump)) {
+                    console.error(`Failed to restore state from "${dump}", continuing without it`);
+                    console.error("Dump file does not exist");
                     continue;
                 }
-                const dumpArchive = new ZipReadStream.async({
-                    file: dump,
-                });
                 try {
-                    const dumpEntries = await dumpArchive.entries();
-                    const dumpEntriesList = Object.entries(dumpEntries);
-                    const optionalEntryData = async (entryName) => dumpEntries[entryName] ? dumpArchive.entryData(entryName) : undefined;
-                    if (!dumpEntries[AllureStoreDumpFiles.TestResults]) {
-                        const nestedDumpEntries = dumpEntriesList.filter(([entryName, entry]) => !entry.isDirectory &&
-                            !entryName.startsWith("__MACOSX/") &&
-                            !basename(entryName).startsWith("._") &&
-                            entryName.toLowerCase().endsWith(".zip"));
-                        if (nestedDumpEntries.length > 0) {
-                            const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
-                            const nestedDumpPaths = [];
-                            __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
-                            for (const [entryName] of nestedDumpEntries) {
-                                const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
-                                await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
-                                nestedDumpPaths.push(nestedDumpPath);
+                    const dumpArchive = new ZipReadStream.async({
+                        file: dump,
+                    });
+                    let restoreError;
+                    try {
+                        const dumpEntries = await dumpArchive.entries();
+                        const dumpEntriesList = Object.entries(dumpEntries);
+                        const requiredEntryData = async (entryName) => {
+                            if (!dumpEntries[entryName]) {
+                                throw new Error(`Missing required dump entry "${entryName}"`);
+                            }
+                            return dumpArchive.entryData(entryName);
+                        };
+                        const optionalEntryData = async (entryName) => dumpEntries[entryName] ? dumpArchive.entryData(entryName) : undefined;
+                        if (!dumpEntries[AllureStoreDumpFiles.TestResults]) {
+                            const nestedDumpEntries = dumpEntriesList.filter(([entryName, entry]) => !entry.isDirectory &&
+                                !entryName.startsWith("__MACOSX/") &&
+                                !basename(entryName).startsWith("._") &&
+                                entryName.toLowerCase().endsWith(".zip"));
+                            if (nestedDumpEntries.length > 0) {
+                                const nestedDumpsTempDir = await mkdtemp(join(tmpdir(), `${basename(dump, ".zip")}-nested-`));
+                                const nestedDumpPaths = [];
+                                __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(nestedDumpsTempDir);
+                                for (const [entryName] of nestedDumpEntries) {
+                                    const nestedDumpPath = join(nestedDumpsTempDir, `${nestedDumpPaths.length}-${basename(entryName)}`);
+                                    await writeFile(nestedDumpPath, await dumpArchive.entryData(entryName));
+                                    nestedDumpPaths.push(nestedDumpPath);
+                                }
+                                await this.restoreState(nestedDumpPaths);
+                                continue;
                             }
-                            await this.restoreState(nestedDumpPaths);
-                            continue;
                         }
-                    }
-                    const testResultsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.TestResults);
-                    const testCasesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.TestCases);
-                    const fixturesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Fixtures);
-                    const attachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Attachments);
-                    const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
-                    const environmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.Environments);
-                    const reportVariablesEntry = await dumpArchive.entryData(AllureStoreDumpFiles.ReportVariables);
-                    const globalAttachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.GlobalAttachments);
-                    const globalErrorsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.GlobalErrors);
-                    const indexAttachmentsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
-                    const indexTestResultsByHistoryId = await dumpArchive.entryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
-                    const indexTestResultsByTestCaseEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
-                    const indexLatestEnvTestResultsByHistoryIdEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
-                    const indexAttachmentsByFixtureEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
-                    const indexFixturesByTestResultEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
-                    const indexKnownByHistoryIdEntry = await dumpArchive.entryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
-                    const qualityGateResultsEntry = await dumpArchive.entryData(AllureStoreDumpFiles.QualityGateResults);
-                    const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
-                    const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
-                        switch (entryName) {
-                            case AllureStoreDumpFiles.Attachments:
-                            case AllureStoreDumpFiles.CheckResults:
-                            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:
-                            case AllureStoreDumpFiles.QualityGateResults:
-                                return acc;
-                            default:
-                                if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
+                        const testResultsEntry = await requiredEntryData(AllureStoreDumpFiles.TestResults);
+                        const testCasesEntry = await requiredEntryData(AllureStoreDumpFiles.TestCases);
+                        const fixturesEntry = await requiredEntryData(AllureStoreDumpFiles.Fixtures);
+                        const attachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Attachments);
+                        const checkResultsEntry = await optionalEntryData(AllureStoreDumpFiles.CheckResults);
+                        const environmentsEntry = await requiredEntryData(AllureStoreDumpFiles.Environments);
+                        const reportVariablesEntry = await requiredEntryData(AllureStoreDumpFiles.ReportVariables);
+                        const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
+                        const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
+                        const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
+                        const indexTestResultsByHistoryId = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
+                        const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
+                        const indexLatestEnvTestResultsByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId);
+                        const indexAttachmentsByFixtureEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
+                        const indexFixturesByTestResultEntry = await requiredEntryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
+                        const indexKnownByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
+                        const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
+                        const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
+                        const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
+                            switch (entryName) {
+                                case AllureStoreDumpFiles.Attachments:
+                                case AllureStoreDumpFiles.CheckResults:
+                                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:
+                                case AllureStoreDumpFiles.QualityGateResults:
                                     return acc;
-                                }
-                                return Object.assign(acc, {
-                                    [entryName]: entry,
-                                });
+                                default:
+                                    if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
+                                        return acc;
+                                    }
+                                    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: attachmentsLinks,
+                            checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
+                            environments: JSON.parse(environmentsEntry.toString("utf8")),
+                            reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
+                            globalAttachmentIds: 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")),
+                            qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
+                        };
+                        const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
+                        const resultsAttachments = {};
+                        __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(dumpTempDir);
+                        try {
+                            for (const [attachmentId] of Object.entries(attachmentsEntries)) {
+                                const attachmentContentEntry = await dumpArchive.entryData(attachmentId);
+                                const attachmentFilePath = resolveDumpAttachmentPath(dumpTempDir, attachmentId);
+                                await writeFile(attachmentFilePath, attachmentContentEntry);
+                                resultsAttachments[attachmentId] = new PathResultFile(attachmentFilePath, attachmentId);
+                            }
                         }
-                    }, {});
-                    const dumpState = {
-                        testResults: JSON.parse(testResultsEntry.toString("utf8")),
-                        testCases: JSON.parse(testCasesEntry.toString("utf8")),
-                        fixtures: JSON.parse(fixturesEntry.toString("utf8")),
-                        attachments: attachmentsLinks,
-                        checkResults: checkResultsEntry ? JSON.parse(checkResultsEntry.toString("utf8")) : [],
-                        environments: JSON.parse(environmentsEntry.toString("utf8")),
-                        reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
-                        globalAttachmentIds: 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")),
-                        qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
-                    };
-                    const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
-                    const resultsAttachments = {};
-                    __classPrivateFieldGet(this, _AllureReport_dumpTempDirs, "f").push(dumpTempDir);
-                    try {
-                        for (const [attachmentId] of Object.entries(attachmentsEntries)) {
-                            const attachmentContentEntry = await dumpArchive.entryData(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 attachment contents from "${dump}", continuing without them`);
+                            console.error(errorDetails(err));
                         }
+                        await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
+                        console.info(`Successfully restored state from "${dump}"`);
                     }
                     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;
+                        restoreError = err;
+                        throw err;
+                    }
+                    finally {
+                        try {
+                            await dumpArchive.close();
+                        }
+                        catch (err) {
+                            if (!restoreError) {
+                                console.error(`Failed to close dump archive "${dump}"`);
+                                console.error(errorDetails(err));
+                            }
                         }
-                        console.error(`Can't restore state from "${dump}", continuing without it`);
-                        console.error(err);
                     }
-                    await __classPrivateFieldGet(this, _AllureReport_store, "f").restoreState(dumpState, resultsAttachments);
-                    console.info(`Successfully restored state from "${dump}"`);
                 }
-                finally {
-                    await dumpArchive.close();
+                catch (err) {
+                    console.error(`Failed to restore state from "${dump}", continuing without it`);
+                    console.error(errorDetails(err));
                 }
             }
         };
@@ -427,6 +459,8 @@ export class AllureReport {
             const remoteHrefs = new Set();
             const remoteHrefsByPluginId = {};
             const cancelledPluginsIds = new Set();
+            let remoteCleanupFailed = false;
+            const getSuccessfulPublishedPlugins = () => __classPrivateFieldGet(this, _AllureReport_plugins, "f").filter(({ enabled, id, options }) => enabled && !!options?.publish && !cancelledPluginsIds.has(id));
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(initRequired);
             }
@@ -458,59 +492,97 @@ export class AllureReport {
                             width: 20,
                         })
                         : undefined;
-                    const limitFn = pLimit(50);
+                    const limitFn = pLimit(REMOTE_UPLOAD_CONCURRENCY);
                     const uploadAbortController = new AbortController();
-                    const fns = pluginFilesEntries.map(([filename, filepath]) => limitFn(async () => {
-                        if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
+                    const failedUploads = new Set();
+                    let terminalUploadError;
+                    let remoteReportDeleted = false;
+                    let fns = [];
+                    const cleanupFailedPluginUpload = async (err) => {
+                        if (remoteReportDeleted) {
                             return;
                         }
-                        if (/^(data|widgets|index\.html$|summary\.json$)/.test(filename)) {
-                            const uploadedFileUrl = await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").addReportFile({
+                        remoteReportDeleted = true;
+                        cancelledPluginsIds.add(context.id);
+                        uploadAbortController.abort();
+                        await Promise.allSettled(fns);
+                        const pluginRemoteHref = remoteHrefsByPluginId[context.id];
+                        if (pluginRemoteHref) {
+                            remoteHrefs.delete(pluginRemoteHref);
+                            delete remoteHrefsByPluginId[context.id];
+                        }
+                        try {
+                            await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").deleteReport({
                                 reportUuid: this.reportUuid,
                                 pluginId: context.id,
-                                filename,
-                                filepath,
-                                signal: uploadAbortController.signal,
                             });
-                            if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
-                                return;
-                            }
-                            if (filename === "index.html") {
-                                remoteHrefsByPluginId[context.id] = uploadedFileUrl;
-                                remoteHrefs.add(uploadedFileUrl);
-                            }
                         }
-                        else {
-                            await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").addReportAsset({
-                                filename,
-                                filepath,
-                                signal: uploadAbortController.signal,
-                            });
+                        catch (cleanupErr) {
+                            remoteCleanupFailed = true;
+                            console.error(`Plugin "${context.id}" upload cleanup has failed, the remote report won't be completed`);
+                            console.error(cleanupErr);
                         }
+                        console.error(`Plugin "${context.id}" upload has failed, the plugin won't be published`);
+                        console.error(err);
+                    };
+                    fns = pluginFilesEntries.map(([filename, filepath]) => limitFn(async () => {
                         if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
                             return;
                         }
-                        progressBar?.tick?.();
+                        for (let attempt = 1; attempt <= REMOTE_UPLOAD_MAX_ATTEMPTS; attempt++) {
+                            if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
+                                return;
+                            }
+                            try {
+                                if (/^(data|widgets|index\.html$|summary\.json$)/.test(filename)) {
+                                    const uploadedFileUrl = await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").addReportFile({
+                                        reportUuid: this.reportUuid,
+                                        pluginId: context.id,
+                                        filename,
+                                        filepath,
+                                        signal: uploadAbortController.signal,
+                                    });
+                                    if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
+                                        return;
+                                    }
+                                    if (filename === "index.html") {
+                                        remoteHrefsByPluginId[context.id] = uploadedFileUrl;
+                                        remoteHrefs.add(uploadedFileUrl);
+                                    }
+                                }
+                                else {
+                                    await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").addReportAsset({
+                                        filename,
+                                        filepath,
+                                        signal: uploadAbortController.signal,
+                                    });
+                                }
+                                failedUploads.delete(filename);
+                                progressBar?.tick?.();
+                                return;
+                            }
+                            catch (err) {
+                                if (cancelledPluginsIds.has(context.id) || uploadAbortController.signal.aborted) {
+                                    return;
+                                }
+                                if (isAbortError(err)) {
+                                    throw err;
+                                }
+                                failedUploads.add(filename);
+                                if (failedUploads.size > REMOTE_UPLOAD_MAX_SIMULTANEOUS_FAILED ||
+                                    attempt >= REMOTE_UPLOAD_MAX_ATTEMPTS) {
+                                    terminalUploadError ?? (terminalUploadError = err);
+                                    throw terminalUploadError;
+                                }
+                            }
+                        }
                     }));
                     progressBar?.render?.();
                     try {
                         await Promise.all(fns);
                     }
                     catch (err) {
-                        cancelledPluginsIds.add(context.id);
-                        uploadAbortController.abort();
-                        await Promise.allSettled(fns);
-                        const pluginRemoteHref = remoteHrefsByPluginId[context.id];
-                        if (pluginRemoteHref) {
-                            remoteHrefs.delete(pluginRemoteHref);
-                            delete remoteHrefsByPluginId[context.id];
-                        }
-                        await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f").deleteReport({
-                            reportUuid: this.reportUuid,
-                            pluginId: context.id,
-                        });
-                        console.error(`Plugin "${context.id}" upload has failed, the plugin won't be published`);
-                        console.error(err);
+                        await cleanupFailedPluginUpload(terminalUploadError ?? err);
                     }
                 }
                 const summary = await plugin?.info?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
@@ -535,9 +607,7 @@ export class AllureReport {
             });
             if (summaries.length > 1) {
                 const summaryPath = await generateSummary(__classPrivateFieldGet(this, _AllureReport_output, "f"), summaries);
-                const publishedReports = __classPrivateFieldGet(this, _AllureReport_plugins, "f")
-                    .map((plugin) => !!plugin?.options?.publish && !cancelledPluginsIds.has(plugin.id))
-                    .filter(Boolean);
+                const publishedReports = getSuccessfulPublishedPlugins();
                 if (__classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get) && summaryPath && publishedReports.length > 1) {
                     await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")?.addReportFile({
                         reportUuid: this.reportUuid,
@@ -546,7 +616,8 @@ export class AllureReport {
                     });
                 }
             }
-            if (__classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get)) {
+            const publishedReports = getSuccessfulPublishedPlugins();
+            if (__classPrivateFieldGet(this, _AllureReport_instances, "a", _AllureReport_publish_get) && !remoteCleanupFailed && publishedReports.length > 0) {
                 await __classPrivateFieldGet(this, _AllureReport_allureServiceClient, "f")?.completeReport({
                     reportUuid: this.reportUuid,
                     historyPoint: historyDataPoint,
@@ -595,7 +666,7 @@ export class AllureReport {
                     }
                 }
             }
-            if (remoteHrefs.size > 0) {
+            if (!remoteCleanupFailed && remoteHrefs.size > 0) {
                 console.info("Next reports have been published:");
                 remoteHrefs.forEach((href) => {
                     console.info(`- ${href}`);
@@ -659,12 +730,7 @@ export class AllureReport {
         });
         const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, reportFiles, realTime, historyPath, historyLimit, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, dump, categories, allureService: allureServiceConfig, globalAttachments, } = opts;
         if (allureServiceConfig?.accessToken) {
-            if (allureServiceConfig?.legacy) {
-                __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureLegacyServiceClient(allureServiceConfig), "f");
-            }
-            else {
-                __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureServiceClient(allureServiceConfig), "f");
-            }
+            __classPrivateFieldSet(this, _AllureReport_allureServiceClient, new AllureServiceClient(allureServiceConfig), "f");
         }
         this.reportUuid = randomUUID();
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");

package/dist/store/store.js

@@ -11,7 +11,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResults, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps;
 import { extname } from "node:path";
-import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, nullsLast, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
+import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, nullsLast, normalizeHistoryDataPoint, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
 import { environmentIdentityById, normalizeEnvironmentDescriptorMap, resolveEnvironmentIdentity, resolveStoredEnvironmentIdentity, validateAllowedEnvironmentId, } from "../utils/environment.js";
 import { isFlaky } from "../utils/flaky.js";
@@ -196,7 +196,9 @@ export class DefaultAllureStore {
         if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")) {
             return [];
         }
-        __classPrivateFieldSet(this, _DefaultAllureStore_historyPoints, (await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").readHistory()) ?? [], "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_historyPoints, ((await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").readHistory()) ?? [])
+            .filter((historyPoint) => typeof historyPoint === "object" && historyPoint !== null)
+            .map(normalizeHistoryDataPoint), "f");
         __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").sort(compareBy("timestamp", reverse(ordinal())));
         return __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f");
     }
@@ -488,7 +490,7 @@ export class DefaultAllureStore {
         }
         return __classPrivateFieldGet(this, _DefaultAllureStore_historyPoints, "f").reduce((result, dp) => {
             const filteredTestResults = [];
-            for (const tr of Object.values(dp.testResults)) {
+            for (const tr of Object.values(dp.testResults ?? {})) {
                 const storedEnvironmentKey = typeof tr.environment === "string" ? tr.environment : undefined;
                 const trEnvId = (storedEnvironmentKey ? __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByName).call(this, storedEnvironmentKey) : undefined) ??
                     resolveStoredEnvironmentIdentity({
@@ -526,7 +528,7 @@ export class DefaultAllureStore {
         if (allHistoryDps.length === 0) {
             return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values());
         }
-        const historicalIds = new Set(allHistoryDps.flatMap((dp) => Object.keys(dp.testResults)));
+        const historicalIds = new Set(allHistoryDps.flatMap((dp) => Object.keys(dp.testResults ?? {})));
         const newTrs = [];
         for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (tr.hidden) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,25 +25,25 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.8.0",
-    "@allurereport/core-api": "3.8.0",
-    "@allurereport/plugin-agent": "3.8.0",
-    "@allurereport/plugin-allure2": "3.8.0",
-    "@allurereport/plugin-api": "3.8.0",
-    "@allurereport/plugin-awesome": "3.8.0",
-    "@allurereport/plugin-classic": "3.8.0",
-    "@allurereport/plugin-csv": "3.8.0",
-    "@allurereport/plugin-dashboard": "3.8.0",
-    "@allurereport/plugin-jira": "3.8.0",
-    "@allurereport/plugin-log": "3.8.0",
-    "@allurereport/plugin-progress": "3.8.0",
-    "@allurereport/plugin-slack": "3.8.0",
-    "@allurereport/plugin-testops": "3.8.0",
-    "@allurereport/plugin-testplan": "3.8.0",
-    "@allurereport/reader": "3.8.0",
-    "@allurereport/reader-api": "3.8.0",
-    "@allurereport/service": "3.8.0",
-    "@allurereport/summary": "3.8.0",
+    "@allurereport/ci": "3.8.2",
+    "@allurereport/core-api": "3.8.2",
+    "@allurereport/plugin-agent": "3.8.2",
+    "@allurereport/plugin-allure2": "3.8.2",
+    "@allurereport/plugin-api": "3.8.2",
+    "@allurereport/plugin-awesome": "3.8.2",
+    "@allurereport/plugin-classic": "3.8.2",
+    "@allurereport/plugin-csv": "3.8.2",
+    "@allurereport/plugin-dashboard": "3.8.2",
+    "@allurereport/plugin-jira": "3.8.2",
+    "@allurereport/plugin-log": "3.8.2",
+    "@allurereport/plugin-progress": "3.8.2",
+    "@allurereport/plugin-slack": "3.8.2",
+    "@allurereport/plugin-testops": "3.8.2",
+    "@allurereport/plugin-testplan": "3.8.2",
+    "@allurereport/reader": "3.8.2",
+    "@allurereport/reader-api": "3.8.2",
+    "@allurereport/service": "3.8.2",
+    "@allurereport/summary": "3.8.2",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "node-stream-zip": "^1.15.0",