@allurereport/service 3.0.0-beta.16

package/README.md

@@ -0,0 +1,13 @@
+# Allure Service API
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+TODO:

package/dist/history.d.ts

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

package/dist/history.js

@@ -0,0 +1,26 @@
+import { KnownError } from "./utils/http.js";
+export class AllureRemoteHistory {
+    constructor(allureServiceClient) {
+        this.allureServiceClient = allureServiceClient;
+    }
+    async readHistory(branch) {
+        try {
+            const res = await this.allureServiceClient.downloadHistory({
+                branch,
+            });
+            return res;
+        }
+        catch (err) {
+            if (err instanceof KnownError && err.status === 404) {
+                return [];
+            }
+            throw err;
+        }
+    }
+    async appendHistory(data, branch) {
+        await this.allureServiceClient.appendHistory({
+            history: data,
+            branch,
+        });
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/model.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/model.js

@@ -0,0 +1,6 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+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");

package/dist/service.d.ts

@@ -0,0 +1,62 @@
+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;
+    };
+    project: string | undefined;
+    constructor(config: Config["allureService"] & {
+        pollingDelay?: number;
+    });
+    setProject(project: string): void;
+    login(): Promise<string>;
+    logout(): Promise<void>;
+    profile(): Promise<{
+        email: string;
+    }>;
+    projects(): Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    createProject(payload: {
+        name: string;
+    }): Promise<{
+        id: string;
+        name: string;
+    }>;
+    deleteProject(payload: {
+        name: string;
+    }): Promise<{
+        id: string;
+        name: string;
+    }>;
+    appendHistory(payload: {
+        history: HistoryDataPoint;
+        branch?: string;
+    }): Promise<unknown>;
+    downloadHistory(payload?: {
+        branch?: string;
+    }): Promise<HistoryDataPoint[]>;
+    createReport(payload: {
+        reportName: string;
+        reportUuid?: string;
+    }): Promise<{
+        url: string;
+    }>;
+    completeReport(payload: {
+        reportUuid: string;
+    }): Promise<unknown>;
+    addReportAsset(payload: {
+        filename: string;
+        file?: Buffer;
+        filepath?: string;
+    }): Promise<unknown>;
+    addReportFile(payload: {
+        reportUuid: string;
+        pluginId: string;
+        filename: string;
+        file?: Buffer;
+        filepath?: string;
+    }): Promise<string>;
+}

package/dist/service.js

@@ -0,0 +1,173 @@
+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 _AllureServiceClient_client, _AllureServiceClient_url, _AllureServiceClient_pollingDelay;
+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";
+export class AllureServiceClient {
+    constructor(config) {
+        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!");
+        }
+        __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.project = config?.project;
+    }
+    setProject(project) {
+        this.project = project;
+    }
+    async login() {
+        const exchangeToken = await writeExchangeToken();
+        const connectUrl = new URL("/connect", __classPrivateFieldGet(this, _AllureServiceClient_url, "f"));
+        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("/api/auth/tokens/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();
+        });
+    }
+    async logout() {
+        await deleteAccessToken();
+    }
+    async profile() {
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/api/user/profile");
+    }
+    async projects() {
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/api/projects/list");
+    }
+    async createProject(payload) {
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/projects/create", {
+            body: payload,
+        });
+    }
+    async deleteProject(payload) {
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/projects/delete", {
+            body: payload,
+        });
+    }
+    async appendHistory(payload) {
+        if (!this.project) {
+            throw new Error("Project is not set");
+        }
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/history/append", {
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: {
+                ...payload,
+                project: this.project,
+            },
+        });
+    }
+    async downloadHistory(payload) {
+        if (!this.project) {
+            throw new Error("Project is not set");
+        }
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").get("/api/history/download", {
+            params: {
+                project: this.project,
+                ...payload,
+            },
+        });
+    }
+    async createReport(payload) {
+        const { reportName, reportUuid } = payload;
+        if (!this.project) {
+            throw new Error("Project is not set");
+        }
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/reports/create", {
+            body: {
+                project: this.project,
+                reportName,
+                reportUuid,
+            },
+        });
+    }
+    async completeReport(payload) {
+        const { reportUuid } = payload;
+        if (!this.project) {
+            throw new Error("Project is not set");
+        }
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/reports/complete", {
+            body: {
+                id: reportUuid,
+            },
+        });
+    }
+    async addReportAsset(payload) {
+        const { filename, file, filepath } = payload;
+        if (!file && !filepath) {
+            throw new Error("File or filepath is required");
+        }
+        let content = file;
+        if (!content) {
+            content = await readFile(filepath);
+        }
+        const form = new FormData();
+        form.set("filename", filename);
+        form.set("file", content);
+        return __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post("/api/assets/upload", {
+            body: form,
+            headers: {
+                "Content-Type": "multipart/form-data",
+            },
+        });
+    }
+    async addReportFile(payload) {
+        const { reportUuid, filename, file, filepath, pluginId } = payload;
+        if (!file && !filepath) {
+            throw new Error("File or filepath is required");
+        }
+        let content = file;
+        if (!content) {
+            content = await readFile(filepath);
+        }
+        const form = new FormData();
+        form.set("filename", joinPosix(pluginId, filename));
+        form.set("file", content);
+        await __classPrivateFieldGet(this, _AllureServiceClient_client, "f").post(`/api/reports/upload/${reportUuid}`, {
+            body: form,
+            headers: {
+                "Content-Type": "multipart/form-data",
+            },
+        });
+        return joinPosix(__classPrivateFieldGet(this, _AllureServiceClient_url, "f"), reportUuid, filename);
+    }
+}
+_AllureServiceClient_client = new WeakMap(), _AllureServiceClient_url = new WeakMap(), _AllureServiceClient_pollingDelay = new WeakMap();

package/dist/utils/http.d.ts

@@ -0,0 +1,28 @@
+import { type AxiosRequestConfig } from "axios";
+export declare class KnownError extends Error {
+    status?: number;
+    constructor(message: string, status?: number);
+}
+export declare class UnknownError extends Error {
+    stack?: string;
+    constructor(message: string, stack?: string);
+}
+export declare const createServiceHttpClient: (historyServiceURL?: string, accessToken?: string) => {
+    get: <T>(endpoint: string, payload?: AxiosRequestConfig & {
+        params?: Record<string, any>;
+        body?: any;
+    }) => Promise<T>;
+    post: <T>(endpoint: string, payload?: AxiosRequestConfig & {
+        params?: Record<string, any>;
+        body?: any;
+    }) => Promise<T>;
+    put: <T>(endpoint: string, payload?: AxiosRequestConfig & {
+        params?: Record<string, any>;
+        body?: any;
+    }) => Promise<T>;
+    delete: <T>(endpoint: string, payload?: AxiosRequestConfig & {
+        params?: Record<string, any>;
+        body?: any;
+    }) => Promise<T>;
+};
+export type HttpClient = ReturnType<typeof createServiceHttpClient>;

package/dist/utils/http.js

@@ -0,0 +1,66 @@
+import axios, { AxiosError } 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);
+        this.name = "KnownError";
+        this.status = status;
+    }
+}
+export class UnknownError extends Error {
+    constructor(message, stack) {
+        super(message);
+        this.name = "UnknownError";
+        this.stack = stack;
+    }
+}
+export const createServiceHttpClient = (historyServiceURL = DEFAULT_HISTORY_SERVICE_URL, accessToken) => {
+    const client = axios.create({
+        baseURL: historyServiceURL,
+        withCredentials: true,
+        validateStatus: (status) => status < 400,
+    });
+    const sendRequest = (method) => async (endpoint, payload) => {
+        const actualAccessToken = accessToken || (await readAccessToken());
+        const headers = {
+            ...(payload?.headers ?? {}),
+        };
+        if (actualAccessToken) {
+            headers.Authorization = `Bearer ${actualAccessToken}`;
+        }
+        try {
+            let res;
+            if (payload?.body) {
+                res = await client[method](endpoint, payload.body, {
+                    ...payload,
+                    headers,
+                });
+            }
+            else {
+                res = await client[method](endpoint, {
+                    ...payload,
+                    headers,
+                });
+            }
+            return res.data;
+        }
+        catch (err) {
+            if (!(err instanceof AxiosError)) {
+                throw err;
+            }
+            const { status = 500 } = err.response ?? {};
+            if (status < 500) {
+                throw new KnownError(err.response?.data ?? err.message, status);
+            }
+            const { response, message, errors, stack } = err;
+            throw new UnknownError(response?.data ?? errors?.[0]?.message?.trim?.() ?? message, stack);
+        }
+    };
+    return {
+        get: sendRequest("get"),
+        post: sendRequest("post"),
+        put: sendRequest("put"),
+        delete: sendRequest("delete"),
+    };
+};

package/dist/utils/token.d.ts

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,56 @@
+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) { }
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@allurereport/service",
+  "version": "3.0.0-beta.16",
+  "description": "Allure Service API",
+  "keywords": [
+    "allure",
+    "testing",
+    "report",
+    "plugin",
+    "html"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "./dist"
+  ],
+  "scripts": {
+    "build": "run clean && tsc --project ./tsconfig.json",
+    "clean": "rimraf ./dist",
+    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
+    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
+    "test": "rimraf ./out && vitest run"
+  },
+  "dependencies": {
+    "@allurereport/core-api": "3.0.0-beta.16",
+    "@allurereport/plugin-api": "3.0.0-beta.16",
+    "axios": "^1.8.4",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/eslint": "^8.56.11",
+    "@types/node": "^20.17.9",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/runner": "^2.1.8",
+    "@vitest/snapshot": "^2.1.8",
+    "allure-vitest": "^3.0.9",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^50.0.0",
+    "eslint-plugin-n": "^17.10.1",
+    "eslint-plugin-no-null": "^1.0.2",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}