@allurereport/service 3.6.2 → 3.8.0

package/dist/history.d.ts

@@ -1,17 +1,20 @@
 import { type AllureHistory } from "@allurereport/core-api";
-import type { AllureServiceClient } from "./service.js";
+import type { AllureServiceApiClient } from "./model.js";
 export declare class AllureRemoteHistory implements AllureHistory {
     readonly params: {
-        allureServiceClient: AllureServiceClient;
+        allureServiceClient: AllureServiceApiClient;
         limit?: number;
+        repo?: string;
         branch?: string;
     };
     constructor(params: {
-        allureServiceClient: AllureServiceClient;
+        allureServiceClient: AllureServiceApiClient;
         limit?: number;
+        repo?: string;
         branch?: string;
     });
     readHistory(params?: {
+        repo?: string;
         branch?: string;
     }): Promise<import("@allurereport/core-api").HistoryDataPoint[]>;
     appendHistory(): Promise<void>;

package/dist/history.js

@@ -8,7 +8,8 @@ export class AllureRemoteHistory {
         const { limit } = this.params;
         try {
             const res = await this.params.allureServiceClient.downloadHistory({
-                branch: params?.branch ?? this.params.branch,
+                repo: params?.repo || this.params.repo || undefined,
+                branch: params?.branch || this.params.branch || undefined,
                 limit,
             });
             return res?.map(normalizeHistoryDataPointUrls);

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export type * from "./model.js";
 export * from "./service.js";
+export * from "./legacyService.js";
 export * from "./history.js";
 export { KnownError, UnknownError } from "./utils/http.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./service.js";
+export * from "./legacyService.js";
 export * from "./history.js";
 export { KnownError, UnknownError } from "./utils/http.js";

package/dist/legacyService.d.ts

@@ -0,0 +1,41 @@
+import { type HistoryDataPoint } from "@allurereport/core-api";
+import { type Config } from "@allurereport/plugin-api";
+import type { AllureServiceApiClient } from "./model.js";
+export declare class AllureLegacyServiceClient implements AllureServiceApiClient {
+    #private;
+    readonly config: Config["allureService"];
+    constructor(config: Config["allureService"]);
+    downloadHistory(payload: {
+        repo?: string;
+        branch?: string;
+        limit?: number;
+    }): Promise<HistoryDataPoint[]>;
+    createReport(payload: {
+        reportName: string;
+        reportUuid?: string;
+        repo?: string;
+        branch?: string;
+    }): Promise<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>;
+}

package/dist/legacyService.js

@@ -0,0 +1,128 @@
+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 _AllureLegacyServiceClient_client, _AllureLegacyServiceClient_url, _AllureLegacyServiceClient_reportUrl;
+import { readFile } from "node:fs/promises";
+import { join as joinPosix } from "node:path/posix";
+import { createServiceHttpClient } from "./utils/http.js";
+import { parseServiceToken } from "./utils/token.js";
+const ASSET_MAX_FILE_SIZE = 200 * 1024 * 1024;
+const UPLOAD_CONTENT_TYPE = "application/octet-stream";
+const createUploadBlob = (content) => new Blob([content], { type: UPLOAD_CONTENT_TYPE });
+const createReportFileUrl = (reportUrl, reportFilename) => {
+    const fileUrl = new URL(reportUrl);
+    fileUrl.pathname = joinPosix(fileUrl.pathname, reportFilename);
+    fileUrl.search = "";
+    fileUrl.hash = "";
+    return fileUrl.toString();
+};
+const createFallbackReportUrl = (baseUrl, reportUuid) => {
+    const reportUrl = new URL(`${baseUrl}/`);
+    reportUrl.pathname = joinPosix(reportUrl.pathname, reportUuid);
+    return reportUrl;
+};
+export class AllureLegacyServiceClient {
+    constructor(config) {
+        this.config = config;
+        _AllureLegacyServiceClient_client.set(this, void 0);
+        _AllureLegacyServiceClient_url.set(this, void 0);
+        _AllureLegacyServiceClient_reportUrl.set(this, void 0);
+        if (!config?.accessToken) {
+            throw new Error("Allure service access token is required");
+        }
+        const { accessToken, url } = parseServiceToken(config.accessToken);
+        __classPrivateFieldSet(this, _AllureLegacyServiceClient_url, url.replace(/\/$/, ""), "f");
+        __classPrivateFieldSet(this, _AllureLegacyServiceClient_client, createServiceHttpClient(__classPrivateFieldGet(this, _AllureLegacyServiceClient_url, "f"), accessToken), "f");
+    }
+    async downloadHistory(payload) {
+        const { branch, limit } = payload ?? {};
+        const { history } = await __classPrivateFieldGet(this, _AllureLegacyServiceClient_client, "f").get("/projects/history", {
+            params: {
+                limit: limit ? encodeURIComponent(limit) : undefined,
+                branch: branch ? encodeURIComponent(branch) : undefined,
+            },
+        });
+        return history;
+    }
+    async createReport(payload) {
+        const { reportName, reportUuid, branch } = payload;
+        const { url } = await __classPrivateFieldGet(this, _AllureLegacyServiceClient_client, "f").post("/reports", {
+            body: {
+                reportName,
+                reportUuid,
+                branch,
+            },
+        });
+        __classPrivateFieldSet(this, _AllureLegacyServiceClient_reportUrl, new URL(url), "f");
+        return __classPrivateFieldGet(this, _AllureLegacyServiceClient_reportUrl, "f");
+    }
+    async completeReport(payload) {
+        const { reportUuid, historyPoint } = payload;
+        return __classPrivateFieldGet(this, _AllureLegacyServiceClient_client, "f").post(`/reports/${reportUuid}/complete`, {
+            body: {
+                historyPoint,
+            },
+        });
+    }
+    async deleteReport(payload) {
+        const { reportUuid, pluginId = "" } = payload;
+        return __classPrivateFieldGet(this, _AllureLegacyServiceClient_client, "f").post(`/reports/${reportUuid}/delete`, {
+            body: {
+                pluginId,
+            },
+        });
+    }
+    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);
+        }
+        if (content.length > ASSET_MAX_FILE_SIZE) {
+            throw new Error(`Asset size exceeds the maximum allowed size of ${ASSET_MAX_FILE_SIZE / (1024 * 1024)}MB`);
+        }
+        const form = new FormData();
+        form.set("filename", filename);
+        form.set("file", createUploadBlob(content), filename);
+        return __classPrivateFieldGet(this, _AllureLegacyServiceClient_client, "f").post("/assets/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);
+        }
+        if (content.length > ASSET_MAX_FILE_SIZE) {
+            throw new Error(`Report file size exceeds the maximum allowed size of ${ASSET_MAX_FILE_SIZE / (1024 * 1024)}MB`);
+        }
+        const form = new FormData();
+        form.set("filename", reportFilename);
+        form.set("file", createUploadBlob(content), reportFilename);
+        await __classPrivateFieldGet(this, _AllureLegacyServiceClient_client, "f").post(`/reports/${reportUuid}/upload`, {
+            body: form,
+            headers: { "Content-Type": "multipart/form-data" },
+            ...(signal ? { signal } : {}),
+        });
+        return createReportFileUrl(__classPrivateFieldGet(this, _AllureLegacyServiceClient_reportUrl, "f") ?? createFallbackReportUrl(__classPrivateFieldGet(this, _AllureLegacyServiceClient_url, "f"), reportUuid), reportFilename);
+    }
+}
+_AllureLegacyServiceClient_client = new WeakMap(), _AllureLegacyServiceClient_url = new WeakMap(), _AllureLegacyServiceClient_reportUrl = new WeakMap();

package/dist/model.d.ts

@@ -1,4 +1,40 @@
+import type { 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 interface AllureServiceApiClient {
+    downloadHistory(payload: {
+        repo?: string;
+        branch?: string;
+        limit?: number;
+    }): Promise<HistoryDataPoint[]>;
+    createReport(payload: {
+        reportName: string;
+        reportUuid?: string;
+        repo?: string;
+        branch?: string;
+    }): Promise<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>;
+}

package/dist/service.d.ts

@@ -1,40 +1,21 @@
 import { type HistoryDataPoint } from "@allurereport/core-api";
 import { type Config } from "@allurereport/plugin-api";
-export declare class AllureServiceClient {
+import type { AllureServiceApiClient } from "./model.js";
+export declare class AllureServiceClient implements AllureServiceApiClient {
     #private;
     readonly config: Config["allureService"];
     constructor(config: Config["allureService"]);
-    decodeToken(token: string): any;
-    profile(): Promise<{
-        user: {
-            email: string;
-        };
-        project: any;
-    }>;
-    generateNewAccessToken(projectUuid: string): Promise<string>;
-    projects(): Promise<{
-        projects: {
-            id: string;
-            name: string;
-        }[];
-    }>;
-    project(uuid: string): Promise<{
-        project: {
-            id: string;
-            name: string;
-        };
-    }>;
     downloadHistory(payload: {
+        repo?: string;
         branch?: string;
         limit?: number;
     }): Promise<HistoryDataPoint[]>;
     createReport(payload: {
         reportName: string;
         reportUuid?: string;
+        repo?: string;
         branch?: string;
-    }): Promise<{
-        url: string;
-    }>;
+    }): Promise<import("url").URL>;
     completeReport(payload: {
         reportUuid: string;
         historyPoint: HistoryDataPoint;
@@ -47,6 +28,7 @@ export declare class AllureServiceClient {
         filename: string;
         file?: Buffer;
         filepath?: string;
+        signal?: AbortSignal;
     }): Promise<unknown>;
     addReportFile(payload: {
         reportUuid: string;
@@ -54,5 +36,6 @@ export declare class AllureServiceClient {
         filename: string;
         file?: Buffer;
         filepath?: string;
+        signal?: AbortSignal;
     }): Promise<string>;
 }

package/dist/service.js

@@ -13,7 +13,12 @@ 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 { parseServiceToken } from "./utils/token.js";
 const ASSET_MAX_FILE_SIZE = 200 * 1024 * 1024;
+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)}`;
 export class AllureServiceClient {
     constructor(config) {
         this.config = config;
@@ -22,126 +27,100 @@ export class AllureServiceClient {
         if (!config?.accessToken) {
             throw new Error("Allure service access token is required");
         }
-        const { iss, projectId, url: baseUrl } = this.decodeToken(config.accessToken) ?? {};
-        if (iss !== "allure-service" || !baseUrl || !projectId) {
-            throw new Error("Invalid access token");
-        }
-        __classPrivateFieldSet(this, _AllureServiceClient_url, baseUrl, "f");
+        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");
     }
-    decodeToken(token) {
-        try {
-            const base64Url = token.split(".")[1];
-            const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
-            return JSON.parse(atob(base64));
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async profile() {
-        const { user, project } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/user/profile");
-        return {
-            user,
-            project,
-        };
-    }
-    async generateNewAccessToken(projectUuid) {
-        const { accessToken } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/auth/tokens", {
-            body: {
-                projectId: projectUuid,
+    async downloadHistory(payload) {
+        const { repo, branch, limit } = payload ?? {};
+        const { history } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/api/history", {
+            params: {
+                limit: limit ? encodeURIComponent(limit) : undefined,
+                repo: repo ? encodeURIComponent(repo) : undefined,
+                branch: branch ? encodeURIComponent(branch) : undefined,
             },
         });
-        return accessToken;
-    }
-    async projects() {
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/projects");
-    }
-    async project(uuid) {
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get(`/projects/${uuid}`);
-    }
-    async downloadHistory(payload) {
-        const { branch, limit } = payload ?? {};
-        const params = new URLSearchParams();
-        if (limit) {
-            params.append("limit", encodeURIComponent(limit));
-        }
-        if (branch) {
-            params.append("branch", encodeURIComponent(branch));
-        }
-        const { history } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get(params.size > 0 ? `/projects/history?${params.toString()}` : "/projects/history");
         return history;
     }
     async createReport(payload) {
-        const { reportName, reportUuid, branch } = payload;
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/reports", {
+        const { reportName, reportUuid, repo, branch } = payload;
+        const { url } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/reports", {
             body: {
                 reportName,
                 reportUuid,
+                repo,
                 branch,
             },
         });
+        return new URL(url, __classPrivateFieldGet(this, _AllureServiceClient_url, "f"));
     }
     async completeReport(payload) {
         const { reportUuid, historyPoint } = payload;
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/reports/${reportUuid}/complete`, {
+        const completedHistoryPoint = {
+            ...historyPoint,
+            url: createReportUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid),
+        };
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/reports/${reportUuid}/complete`, {
             body: {
-                historyPoint,
+                historyPoint: completedHistoryPoint,
             },
         });
     }
     async deleteReport(payload) {
         const { reportUuid, pluginId = "" } = payload;
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/reports/${reportUuid}/delete`, {
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/reports/${reportUuid}/delete`, {
             body: {
                 pluginId,
             },
         });
     }
     async addReportAsset(payload) {
-        const { filename, file, filepath } = payload;
+        const { filename, file, filepath, signal } = payload;
         if (!file && !filepath) {
             throw new Error("File or filepath is required");
         }
         let content = file;
         if (!content) {
-            content = await readFile(filepath);
+            content = signal ? await readFile(filepath, { signal }) : await readFile(filepath);
         }
         if (content.length > ASSET_MAX_FILE_SIZE) {
             throw new Error(`Asset size exceeds the maximum allowed size of ${ASSET_MAX_FILE_SIZE / (1024 * 1024)}MB`);
         }
         const form = new FormData();
         form.set("filename", filename);
-        form.set("file", content);
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/assets/upload", {
+        form.set("file", createUploadBlob(content), filename);
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/assets/upload", {
             body: form,
             headers: {
                 "Content-Type": "multipart/form-data",
             },
+            ...(signal ? { signal } : {}),
         });
     }
     async addReportFile(payload) {
-        const { reportUuid, filename, file, filepath, pluginId } = 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 = await readFile(filepath);
+            content = signal ? await readFile(filepath, { signal }) : await readFile(filepath);
         }
         if (content.length > ASSET_MAX_FILE_SIZE) {
             throw new Error(`Report file size exceeds the maximum allowed size of ${ASSET_MAX_FILE_SIZE / (1024 * 1024)}MB`);
         }
         const form = new FormData();
-        form.set("filename", pluginId ? joinPosix(pluginId, filename) : filename);
-        form.set("file", content);
-        await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/reports/${reportUuid}/upload`, {
+        form.set("filename", reportFilename);
+        form.set("file", createUploadBlob(content), reportFilename);
+        await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/reports/${reportUuid}/upload`, {
             body: form,
             headers: {
                 "Content-Type": "multipart/form-data",
             },
+            ...(signal ? { signal } : {}),
         });
-        return joinPosix(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, filename);
+        return createReportFileUrl(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, reportFilename);
     }
 }
 _AllureServiceClient_client = new WeakMap(), _AllureServiceClient_url = new WeakMap();

package/dist/utils/token.d.ts

@@ -0,0 +1,4 @@
+export declare const parseServiceToken: (token: string) => {
+    accessToken: string;
+    url: string;
+};

package/dist/utils/token.js

@@ -0,0 +1,22 @@
+export const parseServiceToken = (token) => {
+    try {
+        const encodedPayload = token.split(".")[1];
+        if (!encodedPayload) {
+            throw new Error("missing payload");
+        }
+        const payload = JSON.parse(Buffer.from(encodedPayload, "base64url").toString("utf-8"));
+        if (!payload.accessToken) {
+            throw new Error("missing access token");
+        }
+        if (!payload.url) {
+            throw new Error("missing url");
+        }
+        return {
+            accessToken: payload.accessToken,
+            url: payload.url,
+        };
+    }
+    catch {
+        throw new Error("Allure service access token is invalid");
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/service",
-  "version": "3.6.2",
+  "version": "3.8.0",
   "description": "Allure Service API",
   "keywords": [
     "allure",
@@ -30,9 +30,9 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.6.2",
-    "@allurereport/plugin-api": "3.6.2",
-    "axios": "^1.15.0",
+    "@allurereport/core-api": "3.8.0",
+    "@allurereport/plugin-api": "3.8.0",
+    "axios": "^1.15.2",
     "open": "^10.1.0"
   },
   "devDependencies": {