@allurereport/service 3.8.2 → 3.9.0

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export type * from "./model.js";
 export * from "./service.js";
+export * from "./testops.js";
 export * from "./history.js";
-export { KnownError, UnknownError } from "./utils/http.js";
+export { KnownError, UnknownError, createServiceHttpClient } from "./utils/http.js";
+export { isReportDataFile } from "./utils/files.js";

package/dist/index.js

@@ -1,3 +1,5 @@
 export * from "./service.js";
+export * from "./testops.js";
 export * from "./history.js";
-export { KnownError, UnknownError } from "./utils/http.js";
+export { KnownError, UnknownError, createServiceHttpClient } from "./utils/http.js";
+export { isReportDataFile } from "./utils/files.js";

package/dist/model.d.ts

@@ -1,8 +1,25 @@
-import type { HistoryDataPoint } from "@allurereport/core-api";
+import type { AllureServiceConfig, HistoryDataPoint } from "@allurereport/core-api";
 export declare const DEFAULT_HISTORY_SERVICE_URL = "https://history.allurereport.org";
 export declare const ALLURE_FILES_DIRNAME: string;
 export declare const ALLURE_LOGIN_EXCHANGE_TOKEN_PATH: string;
 export declare const ALLURE_ACCESS_TOKEN_PATH: string;
+export declare const ALLURE_SERVICE_STORAGE_PREFIX = "ars1.";
+export declare const ALLURE_SERVICE_TESTOPS_PREFIX = "ato1.";
+export type UploadReportConfig = Required<Pick<AllureServiceConfig, "uploadConcurrency" | "uploadMaxAttempts" | "uploadMaxSimultaneousFailures">>;
+export type AllureServiceApiClientConfig = UploadReportConfig & {
+    accessToken: string;
+    private?: boolean;
+};
+export type UploadReportPayload = {
+    reportUuid: string;
+    pluginId?: string;
+    files: Record<string, string>;
+    onProgress?: () => void;
+};
+export type UploadReportResult = {
+    indexHref?: string;
+    hrefs: Record<string, string>;
+};
 export interface AllureServiceApiClient {
     downloadHistory(payload: {
         repo?: string;
@@ -17,7 +34,7 @@ export interface AllureServiceApiClient {
     }): Promise<URL>;
     completeReport(payload: {
         reportUuid: string;
-        historyPoint: HistoryDataPoint;
+        historyPoint?: HistoryDataPoint;
     }): Promise<unknown>;
     deleteReport(payload: {
         reportUuid: string;
@@ -37,4 +54,5 @@ export interface AllureServiceApiClient {
         filepath?: string;
         signal?: AbortSignal;
     }): Promise<string>;
+    uploadReport(payload: UploadReportPayload): Promise<UploadReportResult>;
 }

package/dist/model.js

@@ -4,3 +4,5 @@ export const DEFAULT_HISTORY_SERVICE_URL = "https://history.allurereport.org";
 export const ALLURE_FILES_DIRNAME = resolve(homedir(), ".allure");
 export const ALLURE_LOGIN_EXCHANGE_TOKEN_PATH = join(ALLURE_FILES_DIRNAME, "exchange_token");
 export const ALLURE_ACCESS_TOKEN_PATH = join(ALLURE_FILES_DIRNAME, "access_token");
+export const ALLURE_SERVICE_STORAGE_PREFIX = "ars1.";
+export const ALLURE_SERVICE_TESTOPS_PREFIX = "ato1.";

package/dist/service.d.ts

@@ -1,10 +1,9 @@
 import { type HistoryDataPoint } from "@allurereport/core-api";
-import { type Config } from "@allurereport/plugin-api";
-import type { AllureServiceApiClient } from "./model.js";
+import { type AllureServiceApiClient, type AllureServiceApiClientConfig, type UploadReportPayload } from "./model.js";
 export declare class AllureServiceClient implements AllureServiceApiClient {
     #private;
-    readonly config: Config["allureService"];
-    constructor(config: Config["allureService"]);
+    readonly config: AllureServiceApiClientConfig;
+    constructor(config: AllureServiceApiClientConfig);
     downloadHistory(payload: {
         repo?: string;
         branch?: string;
@@ -38,4 +37,5 @@ export declare class AllureServiceClient implements AllureServiceApiClient {
         filepath?: string;
         signal?: AbortSignal;
     }): Promise<string>;
+    uploadReport(payload: UploadReportPayload): Promise<import("./model.js").UploadReportResult>;
 }

package/dist/service.js

@@ -12,7 +12,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _AllureServiceClient_client, _AllureServiceClient_url;
 import { readFile } from "node:fs/promises";
 import { join as joinPosix } from "node:path/posix";
-import { createServiceHttpClient } from "./utils/http.js";
+import { ALLURE_SERVICE_STORAGE_PREFIX, } from "./model.js";
+import { createServiceHttpClient, uploadReport } from "./utils/http.js";
 import { parseServiceToken } from "./utils/token.js";
 const UPLOAD_CONTENT_TYPE = "application/octet-stream";
 const createUploadBlob = (content) => new Blob([content], { type: UPLOAD_CONTENT_TYPE });
@@ -26,9 +27,14 @@ export class AllureServiceClient {
         if (!config?.accessToken) {
             throw new Error("Allure service access token is required");
         }
+        if (!config.accessToken.startsWith(ALLURE_SERVICE_STORAGE_PREFIX)) {
+            throw new Error("Allure service access token is invalid");
+        }
         const { url } = parseServiceToken(config.accessToken);
         __classPrivateFieldSet(this, _AllureServiceClient_url, url.replace(/\/$/, ""), "f");
-        __classPrivateFieldSet(this, _AllureServiceClient_client, createServiceHttpClient(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), config.accessToken), "f");
+        __classPrivateFieldSet(this, _AllureServiceClient_client, createServiceHttpClient(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), {
+            accessToken: config.accessToken,
+        }), "f");
     }
     async downloadHistory(payload) {
         const { repo, branch, limit } = payload ?? {};
@@ -115,5 +121,15 @@ export class AllureServiceClient {
         });
         return createReportFileUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, reportFilename);
     }
+    async uploadReport(payload) {
+        return uploadReport({
+            ...payload,
+            uploadConcurrency: this.config.uploadConcurrency,
+            uploadMaxAttempts: this.config.uploadMaxAttempts,
+            uploadMaxSimultaneousFailures: this.config.uploadMaxSimultaneousFailures,
+            addReportAsset: this.addReportAsset.bind(this),
+            addReportFile: this.addReportFile.bind(this),
+        });
+    }
 }
 _AllureServiceClient_client = new WeakMap(), _AllureServiceClient_url = new WeakMap();

package/dist/testops.d.ts

@@ -0,0 +1,37 @@
+import { type HistoryDataPoint } from "@allurereport/core-api";
+import { type AllureServiceApiClient, type AllureServiceApiClientConfig, type UploadReportPayload } from "./model.js";
+export declare class AllureTestOpsClient implements AllureServiceApiClient {
+    #private;
+    readonly config: AllureServiceApiClientConfig;
+    constructor(config: AllureServiceApiClientConfig);
+    downloadHistory(): Promise<HistoryDataPoint[]>;
+    createReport(payload: {
+        reportName: string;
+        reportUuid?: string;
+        repo?: string;
+        branch?: string;
+    }): Promise<import("url").URL>;
+    completeReport(payload: {
+        reportUuid: string;
+        historyPoint?: HistoryDataPoint;
+    }): Promise<unknown>;
+    deleteReport(payload: {
+        reportUuid: string;
+        pluginId?: string;
+    }): Promise<unknown>;
+    addReportAsset(payload: {
+        filename: string;
+        file?: Buffer;
+        filepath?: string;
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+    addReportFile(payload: {
+        reportUuid: string;
+        pluginId?: string;
+        filename: string;
+        file?: Buffer;
+        filepath?: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    uploadReport(payload: UploadReportPayload): Promise<import("./model.js").UploadReportResult>;
+}

package/dist/testops.js

@@ -0,0 +1,155 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _AllureTestOpsClient_instances, _AllureTestOpsClient_url, _AllureTestOpsClient_accessToken, _AllureTestOpsClient_projectId, _AllureTestOpsClient_client, _AllureTestOpsClient_authorizedClient;
+import { readFile } from "node:fs/promises";
+import { extname, join as joinPosix } from "node:path/posix";
+import { ALLURE_SERVICE_TESTOPS_PREFIX, } from "./model.js";
+import { createServiceHttpClient, uploadReport } from "./utils/http.js";
+import { parseServiceToken } from "./utils/token.js";
+const DEFAULT_UPLOAD_CONTENT_TYPE = "application/octet-stream";
+const CONTENT_TYPES = {
+    ".css": "text/css",
+    ".gif": "image/gif",
+    ".html": "text/html",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".map": "application/json",
+    ".mjs": "application/javascript",
+    ".otf": "font/otf",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".ttf": "font/ttf",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+};
+const contentTypeByFilename = (filename) => CONTENT_TYPES[extname(filename)] ?? DEFAULT_UPLOAD_CONTENT_TYPE;
+const createUploadBlob = (content, filename) => new Blob([content], { type: contentTypeByFilename(filename) });
+const createReportFileUrl = (baseUrl, reportUuid, reportFilename) => `${baseUrl}/api/test-report/view/${joinPosix(reportUuid, reportFilename)}`;
+export class AllureTestOpsClient {
+    constructor(config) {
+        _AllureTestOpsClient_instances.add(this);
+        this.config = config;
+        _AllureTestOpsClient_url.set(this, void 0);
+        _AllureTestOpsClient_accessToken.set(this, void 0);
+        _AllureTestOpsClient_projectId.set(this, void 0);
+        _AllureTestOpsClient_client.set(this, void 0);
+        if (!config?.accessToken) {
+            throw new Error("Allure TestOps access token is required");
+        }
+        if (!config.accessToken.startsWith(ALLURE_SERVICE_TESTOPS_PREFIX)) {
+            throw new Error("Allure service access token is invalid");
+        }
+        const accessTokenPayload = parseServiceToken(config.accessToken);
+        const projectId = Number(accessTokenPayload.projectId);
+        if (!Number.isFinite(projectId)) {
+            throw new Error("Given access token doesn't contain project id");
+        }
+        if (!accessTokenPayload.url) {
+            throw new Error("Given access token doesn't contain url");
+        }
+        __classPrivateFieldSet(this, _AllureTestOpsClient_accessToken, accessTokenPayload.accessToken, "f");
+        __classPrivateFieldSet(this, _AllureTestOpsClient_projectId, projectId, "f");
+        __classPrivateFieldSet(this, _AllureTestOpsClient_url, accessTokenPayload.url.replace(/\/$/, ""), "f");
+    }
+    async downloadHistory() {
+        return [];
+    }
+    async createReport(payload) {
+        const client = await __classPrivateFieldGet(this, _AllureTestOpsClient_instances, "m", _AllureTestOpsClient_authorizedClient).call(this);
+        const { reportName, reportUuid } = payload;
+        const { url } = await client.post("/api/test-report", {
+            body: {
+                projectId: __classPrivateFieldGet(this, _AllureTestOpsClient_projectId, "f"),
+                isPublic: !this.config?.private,
+                reportName,
+                reportUuid,
+            },
+        });
+        return new URL(url, __classPrivateFieldGet(this, _AllureTestOpsClient_url, "f"));
+    }
+    async completeReport(payload) {
+        const client = await __classPrivateFieldGet(this, _AllureTestOpsClient_instances, "m", _AllureTestOpsClient_authorizedClient).call(this);
+        const { reportUuid } = payload;
+        return client.post(`/api/test-report/${reportUuid}/complete`);
+    }
+    async deleteReport(payload) {
+        const client = await __classPrivateFieldGet(this, _AllureTestOpsClient_instances, "m", _AllureTestOpsClient_authorizedClient).call(this);
+        const { reportUuid } = payload;
+        return client.delete(`/api/test-report/${reportUuid}`);
+    }
+    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);
+        }
+        const form = new FormData();
+        form.set("filename", filename);
+        form.set("file", createUploadBlob(content, filename), filename);
+        const client = await __classPrivateFieldGet(this, _AllureTestOpsClient_instances, "m", _AllureTestOpsClient_authorizedClient).call(this);
+        return client.post("/api/test-report/upload", {
+            body: form,
+            headers: {
+                "Content-Type": "multipart/form-data",
+            },
+            ...(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);
+        }
+        const form = new FormData();
+        form.set("filename", reportFilename);
+        form.set("file", createUploadBlob(content, reportFilename), reportFilename);
+        const client = await __classPrivateFieldGet(this, _AllureTestOpsClient_instances, "m", _AllureTestOpsClient_authorizedClient).call(this);
+        await client.post(`/api/test-report/${reportUuid}/upload`, {
+            body: form,
+            headers: {
+                "Content-Type": "multipart/form-data",
+            },
+            ...(signal ? { signal } : {}),
+        });
+        return createReportFileUrl(__classPrivateFieldGet(this, _AllureTestOpsClient_url, "f"), reportUuid, reportFilename);
+    }
+    async uploadReport(payload) {
+        return uploadReport({
+            ...payload,
+            uploadConcurrency: this.config.uploadConcurrency,
+            uploadMaxAttempts: this.config.uploadMaxAttempts,
+            uploadMaxSimultaneousFailures: this.config.uploadMaxSimultaneousFailures,
+            addReportAsset: this.addReportAsset.bind(this),
+            addReportFile: this.addReportFile.bind(this),
+        });
+    }
+}
+_AllureTestOpsClient_url = new WeakMap(), _AllureTestOpsClient_accessToken = new WeakMap(), _AllureTestOpsClient_projectId = new WeakMap(), _AllureTestOpsClient_client = new WeakMap(), _AllureTestOpsClient_instances = new WeakSet(), _AllureTestOpsClient_authorizedClient = async function _AllureTestOpsClient_authorizedClient() {
+    if (__classPrivateFieldGet(this, _AllureTestOpsClient_client, "f")) {
+        return __classPrivateFieldGet(this, _AllureTestOpsClient_client, "f");
+    }
+    __classPrivateFieldSet(this, _AllureTestOpsClient_client, createServiceHttpClient(__classPrivateFieldGet(this, _AllureTestOpsClient_url, "f"), {
+        apiToken: __classPrivateFieldGet(this, _AllureTestOpsClient_accessToken, "f"),
+    }), "f");
+    return __classPrivateFieldGet(this, _AllureTestOpsClient_client, "f");
+};

package/dist/utils/files.d.ts

@@ -0,0 +1 @@
+export declare const isReportDataFile: (filename: string) => boolean;

package/dist/utils/files.js

@@ -0,0 +1,5 @@
+export const isReportDataFile = (filename) => filename === "index.html" ||
+    filename === "summary.json" ||
+    filename.startsWith("data/") ||
+    filename.startsWith("widgets/") ||
+    filename.startsWith("history/");

package/dist/utils/http.d.ts

@@ -1,4 +1,5 @@
 import { type AxiosRequestConfig } from "axios";
+import type { UploadReportConfig, UploadReportPayload, UploadReportResult } from "../model.js";
 export declare class KnownError extends Error {
     status?: number;
     constructor(message: string, status?: number);
@@ -7,7 +8,19 @@ export declare class UnknownError extends Error {
     stack?: string;
     constructor(message: string, stack?: string);
 }
-export declare const createServiceHttpClient: (serviceUrl: string, accessToken: string) => {
+export declare const formatResponseErrorData: (data: unknown) => string | undefined;
+export declare const formatServiceHttpErrorMessage: (payload: {
+    method: string;
+    endpoint: string;
+    status?: number;
+    statusText?: string;
+    data?: unknown;
+    fallbackMessage?: string;
+}) => string;
+export declare const createServiceHttpClient: (serviceUrl: string, params?: {
+    accessToken?: string;
+    apiToken?: string;
+}) => {
     get: <T>(endpoint: string, payload?: AxiosRequestConfig & {
         params?: Record<string, any>;
         body?: any;
@@ -26,3 +39,17 @@ export declare const createServiceHttpClient: (serviceUrl: string, accessToken:
     }) => Promise<T>;
 };
 export type HttpClient = ReturnType<typeof createServiceHttpClient>;
+export declare const uploadReport: (payload: UploadReportPayload & UploadReportConfig & {
+    addReportAsset: (payload: {
+        filename: string;
+        filepath: string;
+        signal?: AbortSignal;
+    }) => Promise<unknown>;
+    addReportFile: (payload: {
+        reportUuid: string;
+        pluginId?: string;
+        filename: string;
+        filepath: string;
+        signal?: AbortSignal;
+    }) => Promise<string>;
+}) => Promise<UploadReportResult>;

package/dist/utils/http.js

@@ -1,4 +1,5 @@
 import axios, { isAxiosError } from "axios";
+import { isReportDataFile } from "./files.js";
 export class KnownError extends Error {
     constructor(message, status) {
         super(message);
@@ -13,27 +14,74 @@ export class UnknownError extends Error {
         this.stack = stack;
     }
 }
-export const createServiceHttpClient = (serviceUrl, accessToken) => {
+const ERROR_MESSAGE_FIELDS = ["message", "error_description", "error", "detail", "title", "description"];
+const stringifyErrorObject = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        const entries = Object.entries(value).map(([key, entryValue]) => `${key}=${String(entryValue)}`);
+        return entries.length > 0 ? `{ ${entries.join(", ")} }` : undefined;
+    }
+};
+export const formatResponseErrorData = (data) => {
+    if (data === undefined || data === null || data === "") {
+        return undefined;
+    }
+    if (typeof data === "string") {
+        return data;
+    }
+    if (typeof data === "number" || typeof data === "boolean" || typeof data === "bigint") {
+        return String(data);
+    }
+    if (Array.isArray(data)) {
+        const items = data.map(formatResponseErrorData).filter(Boolean);
+        return items.length > 0 ? items.join("; ") : undefined;
+    }
+    if (typeof data !== "object") {
+        return String(data);
+    }
+    const errorData = data;
+    for (const field of ERROR_MESSAGE_FIELDS) {
+        const message = formatResponseErrorData(errorData[field]);
+        if (message) {
+            return message;
+        }
+    }
+    return stringifyErrorObject(errorData);
+};
+export const formatServiceHttpErrorMessage = (payload) => {
+    const { method, endpoint, status, statusText, data, fallbackMessage } = payload;
+    const request = `${method.toUpperCase()} ${endpoint}`;
+    const statusMessage = status ? ` responded with ${status}${statusText ? ` ${statusText}` : ""}` : " failed";
+    const details = formatResponseErrorData(data) || fallbackMessage;
+    return `Allure service request failed: ${request}${statusMessage}${details ? `: ${details}` : ""}`;
+};
+export const createServiceHttpClient = (serviceUrl, params) => {
     const client = axios.create({
         baseURL: serviceUrl,
-        withCredentials: true,
         validateStatus: (status) => status < 400,
     });
     const sendRequest = (method) => async (endpoint, payload) => {
         const headers = {
             ...(payload?.headers ?? {}),
-            Authorization: `Bearer ${accessToken}`,
         };
+        if (params?.accessToken) {
+            headers.Authorization = `Bearer ${params.accessToken}`;
+        }
+        if (params?.apiToken) {
+            headers.Authorization = `api-token ${params.apiToken}`;
+        }
         try {
             let res;
-            if (payload?.body) {
-                res = await client[method](endpoint, payload.body, {
+            if (method === "get" || method === "delete") {
+                res = await client[method](endpoint, {
                     ...payload,
                     headers,
                 });
             }
             else {
-                res = await client[method](endpoint, {
+                res = await client[method](endpoint, payload?.body, {
                     ...payload,
                     headers,
                 });
@@ -45,10 +93,18 @@ export const createServiceHttpClient = (serviceUrl, accessToken) => {
             if (!axiosError) {
                 throw err;
             }
-            const { status = 500 } = err.response ?? {};
-            const errorMessage = err.response?.data?.error || err.response?.data || err.message;
-            if (status < 500) {
-                throw new KnownError(errorMessage, status);
+            const { data, status, statusText } = err.response ?? {};
+            const responseStatus = status ?? 500;
+            const errorMessage = formatServiceHttpErrorMessage({
+                method,
+                endpoint,
+                status,
+                statusText,
+                data,
+                fallbackMessage: err.message,
+            });
+            if (responseStatus < 500) {
+                throw new KnownError(errorMessage, responseStatus);
             }
             throw new UnknownError(errorMessage, err.stack);
         }
@@ -60,3 +116,90 @@ export const createServiceHttpClient = (serviceUrl, accessToken) => {
         delete: sendRequest("delete"),
     };
 };
+const uploadWithRetry = async (filename, uploadAbortController, failedUploads, maxAttempts, maxSimultaneousFailures, uploadFn) => {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (uploadAbortController.signal.aborted) {
+            return false;
+        }
+        try {
+            await uploadFn();
+            failedUploads.delete(filename);
+            return true;
+        }
+        catch (error) {
+            if (uploadAbortController.signal.aborted) {
+                return false;
+            }
+            failedUploads.add(filename);
+            if (failedUploads.size > maxSimultaneousFailures || attempt >= maxAttempts) {
+                throw error;
+            }
+        }
+    }
+    return false;
+};
+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) {
+        return {
+            hrefs: {},
+        };
+    }
+    const uploadAbortController = new AbortController();
+    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;
+            }
+            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 {
+                    await addReportAsset({
+                        filename,
+                        filepath,
+                        signal: uploadAbortController.signal,
+                    });
+                }
+            });
+            if (!uploaded || uploadAbortController.signal.aborted) {
+                return;
+            }
+            if (fileUrl) {
+                hrefs[filename] = fileUrl;
+                if (filename === "index.html") {
+                    indexHref = fileUrl;
+                }
+            }
+            onProgress?.();
+        }
+    };
+    const uploadTasks = Array.from({ length: Math.min(uploadConcurrency, fileEntries.length) }, () => uploadNext());
+    try {
+        await Promise.all(uploadTasks);
+    }
+    catch (error) {
+        uploadAbortController.abort();
+        await Promise.allSettled(uploadTasks);
+        throw error;
+    }
+    return {
+        indexHref,
+        hrefs,
+    };
+};

package/dist/utils/token.d.ts

@@ -1,4 +1,6 @@
-export declare const parseServiceToken: (token: string) => {
+interface ServiceTokenPayload {
     accessToken: string;
     url: string;
-};
+}
+export declare const parseServiceToken: <T = ServiceTokenPayload>(token: string) => T & ServiceTokenPayload;
+export {};

package/dist/utils/token.js

@@ -11,10 +11,7 @@ export const parseServiceToken = (token) => {
         if (!payload.url) {
             throw new Error("missing url");
         }
-        return {
-            accessToken: payload.accessToken,
-            url: payload.url,
-        };
+        return payload;
     }
     catch {
         throw new Error("Allure service access token is invalid");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/service",
-  "version": "3.8.2",
+  "version": "3.9.0",
   "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.8.2",
-    "@allurereport/plugin-api": "3.8.2",
+    "@allurereport/core-api": "3.9.0",
+    "@allurereport/plugin-api": "3.9.0",
     "axios": "^1.15.2",
     "open": "^10.1.0"
   },
@@ -39,6 +39,7 @@
     "@types/node": "^20.17.9",
     "@vitest/runner": "^2.1.8",
     "@vitest/snapshot": "^2.1.8",
+    "allure-js-commons": "^3.3.3",
     "allure-vitest": "^3.3.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",