@allurereport/service 3.14.0 → 3.14.1

package/dist/model.d.ts

@@ -13,8 +13,20 @@ export type AllureServiceApiClientConfig = UploadReportConfig & {
 export type UploadReportPayload = {
     reportUuid: string;
     pluginId?: string;
-    files: Record<string, string>;
-    onProgress?: () => void;
+    files: Record<string, string> | Record<string, string>[];
+    onProgress?: (uploadedFilesDelta?: number) => void;
+};
+export type UploadReportFilePayload = {
+    filename: string;
+    file?: Buffer;
+    filepath?: string;
+    signal?: AbortSignal;
+};
+export type UploadReportFilesPayload = {
+    reportUuid: string;
+    pluginId?: string;
+    files: UploadReportFilePayload[];
+    signal?: AbortSignal;
 };
 export type UploadReportResult = {
     indexHref?: string;
@@ -40,19 +52,15 @@ export interface AllureServiceApiClient {
         reportUuid: string;
         pluginId?: string;
     }): Promise<unknown>;
-    addReportAsset(payload: {
-        filename: string;
-        file?: Buffer;
-        filepath?: string;
+    addReportAsset(payload: UploadReportFilePayload): Promise<unknown>;
+    addReportAssets?(payload: {
+        files: UploadReportFilePayload[];
         signal?: AbortSignal;
     }): Promise<unknown>;
-    addReportFile(payload: {
+    addReportFile(payload: UploadReportFilePayload & {
         reportUuid: string;
         pluginId?: string;
-        filename: string;
-        file?: Buffer;
-        filepath?: string;
-        signal?: AbortSignal;
     }): Promise<string>;
+    addReportFiles?(payload: UploadReportFilesPayload): Promise<Record<string, string>>;
     uploadReport(payload: UploadReportPayload): Promise<UploadReportResult>;
 }

package/dist/service.d.ts

@@ -1,5 +1,5 @@
 import { type HistoryDataPoint } from "@allurereport/core-api";
-import { type AllureServiceApiClient, type AllureServiceApiClientConfig, type UploadReportPayload } from "./model.js";
+import { type AllureServiceApiClient, type AllureServiceApiClientConfig, type UploadReportFilePayload, type UploadReportFilesPayload, type UploadReportPayload } from "./model.js";
 export declare class AllureServiceClient implements AllureServiceApiClient {
     #private;
     readonly config: AllureServiceApiClientConfig;
@@ -23,19 +23,17 @@ export declare class AllureServiceClient implements AllureServiceApiClient {
         reportUuid: string;
         pluginId?: string;
     }): Promise<unknown>;
-    addReportAsset(payload: {
-        filename: string;
-        file?: Buffer;
-        filepath?: string;
+    addReportAssets(payload: {
+        files: UploadReportFilePayload[];
         signal?: AbortSignal;
     }): Promise<unknown>;
-    addReportFile(payload: {
+    addReportAsset(payload: UploadReportFilePayload): Promise<unknown>;
+    addReportFiles(payload: UploadReportFilesPayload): Promise<{
+        [k: string]: string;
+    }>;
+    addReportFile(payload: UploadReportFilePayload & {
         reportUuid: string;
         pluginId?: string;
-        filename: string;
-        file?: Buffer;
-        filepath?: string;
-        signal?: AbortSignal;
     }): Promise<string>;
     uploadReport(payload: UploadReportPayload): Promise<import("./model.js").UploadReportResult>;
 }

package/dist/service.js

@@ -19,6 +19,16 @@ const UPLOAD_CONTENT_TYPE = "application/octet-stream";
 const createUploadBlob = (content) => new Blob([content], { type: UPLOAD_CONTENT_TYPE });
 const createReportUrl = (baseUrl, reportUuid) => `${baseUrl}/${reportUuid}`;
 const createReportFileUrl = (baseUrl, reportUuid, reportFilename) => `${baseUrl}/${joinPosix(reportUuid, reportFilename)}`;
+const readUploadContent = async (payload) => {
+    const { file, filepath, signal } = payload;
+    if (file) {
+        return file;
+    }
+    if (!filepath) {
+        throw new Error("File or filepath is required");
+    }
+    return signal ? readFile(filepath, { signal }) : readFile(filepath);
+};
 export class AllureServiceClient {
     constructor(config) {
         this.config = config;
@@ -79,18 +89,20 @@ export class AllureServiceClient {
             },
         });
     }
-    async addReportAsset(payload) {
-        const { filename, file, filepath, signal } = payload;
-        if (!file && !filepath) {
-            throw new Error("File or filepath is required");
-        }
-        let content = file;
-        if (!content) {
-            content = signal ? await readFile(filepath, { signal }) : await readFile(filepath);
+    async addReportAssets(payload) {
+        const { files, signal } = payload;
+        if (files.length === 0) {
+            return undefined;
         }
+        const entries = await Promise.all(files.map(async ({ filename, ...filePayload }) => ({
+            filename,
+            content: await readUploadContent({ filename, ...filePayload, signal: signal ?? filePayload.signal }),
+        })));
         const form = new FormData();
-        form.set("filename", filename);
-        form.set("file", createUploadBlob(content), filename);
+        for (const { filename, content } of entries) {
+            form.append("filename", filename);
+            form.append("file", createUploadBlob(content), filename);
+        }
         return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/assets/upload", {
             body: form,
             headers: {
@@ -99,19 +111,27 @@ export class AllureServiceClient {
             ...(signal ? { signal } : {}),
         });
     }
-    async addReportFile(payload) {
-        const { reportUuid, filename, file, filepath, pluginId, signal } = payload;
-        const reportFilename = pluginId ? joinPosix(pluginId, filename) : filename;
-        if (!file && !filepath) {
-            throw new Error("File or filepath is required");
-        }
-        let content = file;
-        if (!content) {
-            content = signal ? await readFile(filepath, { signal }) : await readFile(filepath);
+    async addReportAsset(payload) {
+        return this.addReportAssets({ files: [payload], ...(payload.signal ? { signal: payload.signal } : {}) });
+    }
+    async addReportFiles(payload) {
+        const { reportUuid, pluginId, files, signal } = payload;
+        if (files.length === 0) {
+            return {};
         }
+        const entries = await Promise.all(files.map(async ({ filename, ...filePayload }) => {
+            const reportFilename = pluginId ? joinPosix(pluginId, filename) : filename;
+            return {
+                filename,
+                reportFilename,
+                content: await readUploadContent({ filename, ...filePayload, signal: signal ?? filePayload.signal }),
+            };
+        }));
         const form = new FormData();
-        form.set("filename", reportFilename);
-        form.set("file", createUploadBlob(content), reportFilename);
+        for (const { reportFilename, content } of entries) {
+            form.append("filename", reportFilename);
+            form.append("file", createUploadBlob(content), reportFilename);
+        }
         await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/reports/${reportUuid}/upload`, {
             body: form,
             headers: {
@@ -119,7 +139,19 @@ export class AllureServiceClient {
             },
             ...(signal ? { signal } : {}),
         });
-        return createReportFileUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, reportFilename);
+        return Object.fromEntries(entries.map(({ filename, reportFilename }) => [
+            filename,
+            createReportFileUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, reportFilename),
+        ]));
+    }
+    async addReportFile(payload) {
+        const result = await this.addReportFiles({
+            reportUuid: payload.reportUuid,
+            pluginId: payload.pluginId,
+            files: [payload],
+            ...(payload.signal ? { signal: payload.signal } : {}),
+        });
+        return result[payload.filename];
     }
     async uploadReport(payload) {
         return uploadReport({
@@ -128,7 +160,9 @@ export class AllureServiceClient {
             uploadMaxAttempts: this.config.uploadMaxAttempts,
             uploadMaxSimultaneousFailures: this.config.uploadMaxSimultaneousFailures,
             addReportAsset: this.addReportAsset.bind(this),
+            addReportAssets: this.addReportAssets.bind(this),
             addReportFile: this.addReportFile.bind(this),
+            addReportFiles: this.addReportFiles.bind(this),
         });
     }
 }

package/dist/utils/http.d.ts

@@ -1,5 +1,5 @@
 import { type AxiosRequestConfig } from "axios";
-import type { UploadReportConfig, UploadReportPayload, UploadReportResult } from "../model.js";
+import type { UploadReportConfig, UploadReportFilePayload, UploadReportFilesPayload, UploadReportPayload, UploadReportResult } from "../model.js";
 export declare class KnownError extends Error {
     status?: number;
     constructor(message: string, status?: number);
@@ -40,16 +40,14 @@ export declare const createServiceHttpClient: (serviceUrl: string, params?: {
 };
 export type HttpClient = ReturnType<typeof createServiceHttpClient>;
 export declare const uploadReport: (payload: UploadReportPayload & UploadReportConfig & {
-    addReportAsset: (payload: {
-        filename: string;
-        filepath: string;
+    addReportAsset: (payload: UploadReportFilePayload) => Promise<unknown>;
+    addReportAssets?: (payload: {
+        files: UploadReportFilePayload[];
         signal?: AbortSignal;
     }) => Promise<unknown>;
-    addReportFile: (payload: {
+    addReportFile: (payload: UploadReportFilePayload & {
         reportUuid: string;
         pluginId?: string;
-        filename: string;
-        filepath: string;
-        signal?: AbortSignal;
     }) => Promise<string>;
+    addReportFiles?: (payload: UploadReportFilesPayload) => Promise<Record<string, string>>;
 }) => Promise<UploadReportResult>;

package/dist/utils/http.js

@@ -24,6 +24,30 @@ const stringifyErrorObject = (value) => {
         return entries.length > 0 ? `{ ${entries.join(", ")} }` : undefined;
     }
 };
+const MAX_UPLOAD_BATCH_FILES = 32;
+const createUploadFileBatches = (files) => {
+    const entries = Object.entries(files);
+    const batches = [];
+    let batch = {};
+    let batchFiles = 0;
+    const flushBatch = () => {
+        if (batchFiles === 0) {
+            return;
+        }
+        batches.push(batch);
+        batch = {};
+        batchFiles = 0;
+    };
+    for (const [filename, filepath] of entries) {
+        if (batchFiles >= MAX_UPLOAD_BATCH_FILES) {
+            flushBatch();
+        }
+        batch[filename] = filepath;
+        batchFiles += 1;
+    }
+    flushBatch();
+    return batches;
+};
 export const formatResponseErrorData = (data) => {
     if (data === undefined || data === null || data === "") {
         return undefined;
@@ -116,21 +140,21 @@ export const createServiceHttpClient = (serviceUrl, params) => {
         delete: sendRequest("delete"),
     };
 };
-const uploadWithRetry = async (filename, uploadAbortController, failedUploads, maxAttempts, maxSimultaneousFailures, uploadFn) => {
+const uploadWithRetry = async (batchId, uploadAbortController, failedUploads, maxAttempts, maxSimultaneousFailures, uploadFn) => {
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         if (uploadAbortController.signal.aborted) {
             return false;
         }
         try {
             await uploadFn();
-            failedUploads.delete(filename);
+            failedUploads.delete(batchId);
             return true;
         }
         catch (error) {
             if (uploadAbortController.signal.aborted) {
                 return false;
             }
-            failedUploads.add(filename);
+            failedUploads.add(batchId);
             if (failedUploads.size > maxSimultaneousFailures || attempt >= maxAttempts) {
                 throw error;
             }
@@ -140,8 +164,8 @@ const uploadWithRetry = async (filename, uploadAbortController, failedUploads, m
 };
 export const uploadReport = async (payload) => {
     const { reportUuid, pluginId, files, onProgress, addReportAsset, addReportFile, uploadConcurrency, uploadMaxAttempts, uploadMaxSimultaneousFailures, } = payload;
-    const fileEntries = Object.entries(files);
-    if (fileEntries.length === 0) {
+    const fileBatches = Array.isArray(files) ? files.flatMap(createUploadFileBatches) : createUploadFileBatches(files);
+    if (fileBatches.length === 0) {
         return {
             hrefs: {},
         };
@@ -150,46 +174,119 @@ export const uploadReport = async (payload) => {
     const failedUploads = new Set();
     const hrefs = {};
     let indexHref;
-    let nextFileIndex = 0;
-    const uploadNext = async () => {
-        while (!uploadAbortController.signal.aborted) {
-            const fileIndex = nextFileIndex++;
-            if (fileIndex >= fileEntries.length) {
-                return;
+    let nextBatchIndex = 0;
+    const uploadBatches = [];
+    const canUploadReportFilesInBatch = !!payload.addReportFiles;
+    const canUploadAssetsInBatch = !!payload.addReportAssets;
+    for (const [batchIndex, batchFiles] of fileBatches.entries()) {
+        const reportDataFiles = [];
+        const assetFiles = [];
+        for (const [filename, filepath] of Object.entries(batchFiles)) {
+            const filePayload = { filename, filepath, signal: uploadAbortController.signal };
+            if (isReportDataFile(filename)) {
+                reportDataFiles.push(filePayload);
             }
-            const [filename, filepath] = fileEntries[fileIndex];
-            let fileUrl;
-            const uploaded = await uploadWithRetry(filename, uploadAbortController, failedUploads, uploadMaxAttempts, uploadMaxSimultaneousFailures, async () => {
-                if (isReportDataFile(filename)) {
-                    fileUrl = await addReportFile({
-                        reportUuid,
-                        pluginId,
-                        filename,
-                        filepath,
-                        signal: uploadAbortController.signal,
+            else {
+                assetFiles.push(filePayload);
+            }
+        }
+        if (reportDataFiles.length > 0) {
+            if (canUploadReportFilesInBatch) {
+                uploadBatches.push({
+                    batchId: `batch-${batchIndex}-report`,
+                    kind: "report",
+                    files: reportDataFiles,
+                });
+            }
+            else {
+                reportDataFiles.forEach((filePayload, fileIndex) => {
+                    uploadBatches.push({
+                        batchId: `batch-${batchIndex}-report-${fileIndex}`,
+                        kind: "report",
+                        files: [filePayload],
+                    });
+                });
+            }
+        }
+        if (assetFiles.length > 0) {
+            if (canUploadAssetsInBatch) {
+                uploadBatches.push({
+                    batchId: `batch-${batchIndex}-asset`,
+                    kind: "asset",
+                    files: assetFiles,
+                });
+            }
+            else {
+                assetFiles.forEach((filePayload, fileIndex) => {
+                    uploadBatches.push({
+                        batchId: `batch-${batchIndex}-asset-${fileIndex}`,
+                        kind: "asset",
+                        files: [filePayload],
                     });
+                });
+            }
+        }
+    }
+    const uploadFileBatch = async ({ kind, files: batchFiles }) => {
+        if (batchFiles.length === 0 || uploadAbortController.signal.aborted) {
+            return;
+        }
+        if (kind === "report") {
+            if (payload.addReportFiles) {
+                const batchResult = await payload.addReportFiles({
+                    reportUuid,
+                    pluginId,
+                    files: batchFiles,
+                    signal: uploadAbortController.signal,
+                });
+                for (const [filename, fileUrl] of Object.entries(batchResult)) {
+                    hrefs[filename] = fileUrl;
+                    if (filename === "index.html") {
+                        indexHref = fileUrl;
+                    }
                 }
-                else {
-                    await addReportAsset({
-                        filename,
-                        filepath,
-                        signal: uploadAbortController.signal,
+            }
+            else {
+                for (const filePayload of batchFiles) {
+                    const fileUrl = await payload.addReportFile({
+                        reportUuid,
+                        pluginId,
+                        ...filePayload,
                     });
+                    hrefs[filePayload.filename] = fileUrl;
+                    if (filePayload.filename === "index.html") {
+                        indexHref = fileUrl;
+                    }
                 }
+            }
+        }
+        else if (payload.addReportAssets) {
+            await payload.addReportAssets({
+                files: batchFiles,
+                signal: uploadAbortController.signal,
             });
-            if (!uploaded || uploadAbortController.signal.aborted) {
+        }
+        else {
+            for (const filePayload of batchFiles) {
+                await payload.addReportAsset(filePayload);
+            }
+        }
+        onProgress?.(batchFiles.length);
+    };
+    const uploadNext = async () => {
+        while (!uploadAbortController.signal.aborted) {
+            const batchIndex = nextBatchIndex++;
+            if (batchIndex >= uploadBatches.length) {
                 return;
             }
-            if (fileUrl) {
-                hrefs[filename] = fileUrl;
-                if (filename === "index.html") {
-                    indexHref = fileUrl;
-                }
+            const batch = uploadBatches[batchIndex];
+            const uploaded = await uploadWithRetry(batch.batchId, uploadAbortController, failedUploads, uploadMaxAttempts, uploadMaxSimultaneousFailures, async () => uploadFileBatch(batch));
+            if (!uploaded || uploadAbortController.signal.aborted) {
+                return;
             }
-            onProgress?.();
         }
     };
-    const uploadTasks = Array.from({ length: Math.min(uploadConcurrency, fileEntries.length) }, () => uploadNext());
+    const uploadTasks = Array.from({ length: Math.min(uploadConcurrency, uploadBatches.length) }, () => uploadNext());
     try {
         await Promise.all(uploadTasks);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/service",
-  "version": "3.14.0",
+  "version": "3.14.1",
   "description": "Allure Service API",
   "keywords": [
     "allure",
@@ -30,8 +30,8 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.14.0",
-    "@allurereport/plugin-api": "3.14.0",
+    "@allurereport/core-api": "3.14.1",
+    "@allurereport/plugin-api": "3.14.1",
     "axios": "^1.18.1",
     "open": "^11.0.0"
   },