@allurereport/service 3.0.0 → 3.1.0

package/dist/history.d.ts

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

package/dist/history.js

@@ -1,15 +1,18 @@
 import { KnownError } from "./utils/http.js";
 export class AllureRemoteHistory {
-    constructor(allureServiceClient, branch) {
-        this.allureServiceClient = allureServiceClient;
-        this.branch = branch;
+    constructor(params) {
+        this.params = params;
     }
     async readHistory() {
-        if (!this.branch) {
+        const { allureServiceClient, branch, limit } = this.params;
+        if (!branch) {
             return [];
         }
         try {
-            const res = await this.allureServiceClient.downloadHistory(this.branch);
+            const res = await allureServiceClient.downloadHistory({
+                branch,
+                limit,
+            });
             return res;
         }
         catch (err) {

package/dist/service.d.ts

@@ -2,19 +2,16 @@ import { type HistoryDataPoint } from "@allurereport/core-api";
 import { type Config } from "@allurereport/plugin-api";
 export declare class AllureServiceClient {
     #private;
-    readonly config: Config["allureService"] & {
-        pollingDelay?: number;
-    };
-    currentProjectUuid: string | undefined;
-    constructor(config: Config["allureService"] & {
-        pollingDelay?: number;
-    });
-    setProject(project: string): void;
-    login(): Promise<any>;
-    logout(): Promise<void>;
+    readonly config: Config["allureService"];
+    constructor(config: Config["allureService"]);
+    decodeToken(token: string): any;
     profile(): Promise<{
-        email: string;
+        user: {
+            email: string;
+        };
+        project: any;
     }>;
+    generateNewAccessToken(projectUuid: string): Promise<string>;
     projects(): Promise<{
         projects: {
             id: string;
@@ -27,16 +24,10 @@ export declare class AllureServiceClient {
             name: string;
         };
     }>;
-    createProject(payload: {
-        name: string;
-    }): Promise<{
-        id: string;
-        name: string;
-    }>;
-    deleteProject(payload: {
-        id: string;
-    }): Promise<unknown>;
-    downloadHistory(branch: string): Promise<HistoryDataPoint[]>;
+    downloadHistory(payload: {
+        branch: string;
+        limit?: number;
+    }): Promise<HistoryDataPoint[]>;
     createReport(payload: {
         reportName: string;
         reportUuid?: string;

package/dist/service.js

@@ -9,68 +9,50 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AllureServiceClient_instances, _AllureServiceClient_client, _AllureServiceClient_url, _AllureServiceClient_pollingDelay, _AllureServiceClient_getClientUrl;
+var _AllureServiceClient_client, _AllureServiceClient_url;
 import { readFile } from "node:fs/promises";
 import { join as joinPosix } from "node:path/posix";
-import open from "open";
 import { createServiceHttpClient } from "./utils/http.js";
-import { decryptExchangeToken, deleteAccessToken, writeAccessToken, writeExchangeToken } from "./utils/token.js";
 const ASSET_MAX_FILE_SIZE = 200 * 1024 * 1024;
 export class AllureServiceClient {
     constructor(config) {
-        _AllureServiceClient_instances.add(this);
         this.config = config;
         _AllureServiceClient_client.set(this, void 0);
         _AllureServiceClient_url.set(this, void 0);
-        _AllureServiceClient_pollingDelay.set(this, void 0);
-        if (!config.url) {
-            throw new Error("Allure service URL is required!");
+        if (!config?.accessToken) {
+            throw new Error("Allure service access token is required");
         }
-        __classPrivateFieldSet(this, _AllureServiceClient_url, config.url, "f");
-        __classPrivateFieldSet(this, _AllureServiceClient_client, createServiceHttpClient(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), config?.accessToken), "f");
-        __classPrivateFieldSet(this, _AllureServiceClient_pollingDelay, config?.pollingDelay ?? 2500, "f");
-        this.currentProjectUuid = config?.project;
-    }
-    setProject(project) {
-        this.currentProjectUuid = project;
-    }
-    async login() {
-        const clientUrl = await __classPrivateFieldGet(this, _AllureServiceClient_instances, "m", _AllureServiceClient_getClientUrl).call(this);
-        const exchangeToken = await writeExchangeToken();
-        const connectUrl = new URL("/connect", clientUrl);
-        connectUrl.searchParams.set("token", decryptExchangeToken(exchangeToken));
-        await open(connectUrl.toString());
-        let currentExchangeAttemptTimeout;
-        return await new Promise((res) => {
-            const makeExchangeAttempt = () => {
-                return globalThis.setTimeout(async () => {
-                    const token = decryptExchangeToken(exchangeToken);
-                    const { accessToken } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/auth/exchange", {
-                        headers: {
-                            "Content-Type": "application/json",
-                        },
-                        body: {
-                            token,
-                        },
-                    });
-                    if (!accessToken) {
-                        globalThis.clearTimeout(currentExchangeAttemptTimeout);
-                        currentExchangeAttemptTimeout = makeExchangeAttempt();
-                        return;
-                    }
-                    await writeAccessToken(accessToken);
-                    return res(accessToken);
-                }, __classPrivateFieldGet(this, _AllureServiceClient_pollingDelay, "f"));
-            };
-            currentExchangeAttemptTimeout = makeExchangeAttempt();
-        });
+        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");
+        __classPrivateFieldSet(this, _AllureServiceClient_client, createServiceHttpClient(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), config.accessToken), "f");
     }
-    async logout() {
-        await deleteAccessToken();
+    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 } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/user/profile");
-        return user;
+        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,
+            },
+        });
+        return accessToken;
     }
     async projects() {
         return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/projects");
@@ -78,30 +60,17 @@ export class AllureServiceClient {
     async project(uuid) {
         return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get(`/projects/${uuid}`);
     }
-    async createProject(payload) {
-        const { project } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/projects", {
-            body: payload,
-        });
-        return project;
-    }
-    async deleteProject(payload) {
-        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").delete(`/projects/${payload.id}`);
-    }
-    async downloadHistory(branch) {
-        if (!this.currentProjectUuid) {
-            throw new Error("Project is not set");
-        }
-        const { history } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get(`/projects/${this.currentProjectUuid}/${encodeURIComponent(branch)}/history`);
+    async downloadHistory(payload) {
+        const { branch, limit } = payload;
+        const { history } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get(limit
+            ? `/projects/history/${encodeURIComponent(branch)}?limit=${encodeURIComponent(limit.toString())}`
+            : `/projects/history/${encodeURIComponent(branch)}`);
         return history;
     }
     async createReport(payload) {
         const { reportName, reportUuid, branch } = payload;
-        if (!this.currentProjectUuid) {
-            throw new Error("Project is not set");
-        }
         return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/reports", {
             body: {
-                projectUuid: this.currentProjectUuid,
                 reportName,
                 reportUuid,
                 branch,
@@ -110,9 +79,6 @@ export class AllureServiceClient {
     }
     async completeReport(payload) {
         const { reportUuid, historyPoint } = payload;
-        if (!this.currentProjectUuid) {
-            throw new Error("Project is not set");
-        }
         return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/reports/${reportUuid}/complete`, {
             body: {
                 historyPoint,
@@ -121,9 +87,6 @@ export class AllureServiceClient {
     }
     async deleteReport(payload) {
         const { reportUuid, pluginId = "" } = payload;
-        if (!this.currentProjectUuid) {
-            throw new Error("Project is not set");
-        }
         return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/reports/${reportUuid}/delete`, {
             body: {
                 pluginId,
@@ -176,7 +139,4 @@ export class AllureServiceClient {
         return joinPosix(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, filename);
     }
 }
-_AllureServiceClient_client = new WeakMap(), _AllureServiceClient_url = new WeakMap(), _AllureServiceClient_pollingDelay = new WeakMap(), _AllureServiceClient_instances = new WeakSet(), _AllureServiceClient_getClientUrl = async function _AllureServiceClient_getClientUrl() {
-    const { url } = await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/info");
-    return url;
-};
+_AllureServiceClient_client = new WeakMap(), _AllureServiceClient_url = new WeakMap();

package/dist/utils/http.d.ts

@@ -7,7 +7,7 @@ export declare class UnknownError extends Error {
     stack?: string;
     constructor(message: string, stack?: string);
 }
-export declare const createServiceHttpClient: (historyServiceURL?: string, accessToken?: string) => {
+export declare const createServiceHttpClient: (serviceUrl: string, accessToken: string) => {
     get: <T>(endpoint: string, payload?: AxiosRequestConfig & {
         params?: Record<string, any>;
         body?: any;

package/dist/utils/http.js

@@ -1,6 +1,4 @@
 import axios, { isAxiosError } from "axios";
-import { DEFAULT_HISTORY_SERVICE_URL } from "../model.js";
-import { readAccessToken } from "./token.js";
 export class KnownError extends Error {
     constructor(message, status) {
         super(message);
@@ -15,20 +13,17 @@ export class UnknownError extends Error {
         this.stack = stack;
     }
 }
-export const createServiceHttpClient = (historyServiceURL = DEFAULT_HISTORY_SERVICE_URL, accessToken) => {
+export const createServiceHttpClient = (serviceUrl, accessToken) => {
     const client = axios.create({
-        baseURL: historyServiceURL,
+        baseURL: serviceUrl,
         withCredentials: true,
         validateStatus: (status) => status < 400,
     });
     const sendRequest = (method) => async (endpoint, payload) => {
-        const actualAccessToken = accessToken || (await readAccessToken());
         const headers = {
             ...(payload?.headers ?? {}),
+            Authorization: `Bearer ${accessToken}`,
         };
-        if (actualAccessToken) {
-            headers.Authorization = `Bearer ${actualAccessToken}`;
-        }
         try {
             let res;
             if (payload?.body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/service",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Allure Service API",
   "keywords": [
     "allure",
@@ -30,8 +30,8 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0",
-    "@allurereport/plugin-api": "3.0.0",
+    "@allurereport/core-api": "3.1.0",
+    "@allurereport/plugin-api": "3.1.0",
     "axios": "^1.13.1",
     "open": "^10.1.0"
   },

package/dist/utils/token.d.ts

@@ -1,12 +0,0 @@
-export declare class InvalidTokenError extends Error {
-    constructor();
-}
-export declare class ExpiredTokenError extends Error {
-    constructor();
-}
-export declare const generateExchangeToken: () => string;
-export declare const decryptExchangeToken: (exchangeToken: string) => string;
-export declare const writeExchangeToken: () => Promise<string>;
-export declare const writeAccessToken: (token: string) => Promise<void>;
-export declare const readAccessToken: () => Promise<string | undefined>;
-export declare const deleteAccessToken: () => Promise<void>;

package/dist/utils/token.js

@@ -1,56 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { EOL } from "node:os";
-import { ALLURE_ACCESS_TOKEN_PATH, ALLURE_FILES_DIRNAME, ALLURE_LOGIN_EXCHANGE_TOKEN_PATH } from "../model.js";
-export class InvalidTokenError extends Error {
-    constructor() {
-        super("Invalid token");
-        this.name = "InvalidTokenError";
-    }
-}
-export class ExpiredTokenError extends Error {
-    constructor() {
-        super("Expired token");
-        this.name = "ExpiredTokenError";
-    }
-}
-export const generateExchangeToken = () => {
-    const token = randomBytes(32).toString("hex");
-    const validTill = Date.now() + 10 * 60 * 1000;
-    return Buffer.from(`${token}:${validTill}`, "utf8").toString("base64");
-};
-export const decryptExchangeToken = (exchangeToken) => {
-    const [token, validTill] = Buffer.from(exchangeToken, "base64").toString("utf8").split(":");
-    if (!token) {
-        throw new InvalidTokenError();
-    }
-    if (validTill && parseInt(validTill, 10) < Date.now()) {
-        throw new ExpiredTokenError();
-    }
-    return token;
-};
-export const writeExchangeToken = async () => {
-    const tempToken = generateExchangeToken();
-    await mkdir(ALLURE_FILES_DIRNAME, { recursive: true });
-    await writeFile(ALLURE_LOGIN_EXCHANGE_TOKEN_PATH, tempToken);
-    return tempToken;
-};
-export const writeAccessToken = async (token) => {
-    await mkdir(ALLURE_FILES_DIRNAME, { recursive: true });
-    await writeFile(ALLURE_ACCESS_TOKEN_PATH, token);
-};
-export const readAccessToken = async () => {
-    try {
-        const accessToken = await readFile(ALLURE_ACCESS_TOKEN_PATH, "utf-8");
-        return accessToken.replaceAll(EOL, "").trim();
-    }
-    catch (e) {
-        return undefined;
-    }
-};
-export const deleteAccessToken = async () => {
-    try {
-        await rm(ALLURE_ACCESS_TOKEN_PATH, { force: true });
-    }
-    catch (ignore) { }
-};