@allurereport/core 3.0.0-beta.3

package/dist/store/store.js

@@ -0,0 +1,240 @@
+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 _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_eventEmitter;
+import { compareBy, nullsLast, ordinal, reverse, } from "@allurereport/core-api";
+import { md5 } from "@allurereport/plugin-api";
+import { extname } from "node:path";
+import { testFixtureResultRawToState, testResultRawToState } from "./convert.js";
+const index = (indexMap, key, ...items) => {
+    if (key) {
+        if (!indexMap.has(key)) {
+            indexMap.set(key, []);
+        }
+        const current = indexMap.get(key);
+        current.push(...items);
+    }
+};
+export class DefaultAllureStore {
+    constructor(history = [], known = [], eventEmitter) {
+        _DefaultAllureStore_testResults.set(this, void 0);
+        _DefaultAllureStore_attachments.set(this, void 0);
+        _DefaultAllureStore_attachmentContents.set(this, void 0);
+        _DefaultAllureStore_testCases.set(this, void 0);
+        _DefaultAllureStore_metadata.set(this, void 0);
+        _DefaultAllureStore_history.set(this, void 0);
+        _DefaultAllureStore_known.set(this, void 0);
+        _DefaultAllureStore_fixtures.set(this, void 0);
+        _DefaultAllureStore_eventEmitter.set(this, void 0);
+        this.indexTestResultByTestCase = new Map();
+        this.indexLatestTestResultByHistoryId = new Map();
+        this.indexTestResultByHistoryId = new Map();
+        this.indexAttachmentByTestResult = new Map();
+        this.indexAttachmentByFixture = new Map();
+        this.indexFixturesByTestResult = new Map();
+        this.indexKnownByHistoryId = new Map();
+        __classPrivateFieldSet(this, _DefaultAllureStore_testResults, new Map(), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_attachments, new Map(), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_attachmentContents, new Map(), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_testCases, new Map(), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_metadata, new Map(), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_fixtures, new Map(), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_history, [...history].sort(compareBy("timestamp", reverse(ordinal()))), "f");
+        __classPrivateFieldSet(this, _DefaultAllureStore_known, [...known], "f");
+        __classPrivateFieldGet(this, _DefaultAllureStore_known, "f").forEach((ktf) => index(this.indexKnownByHistoryId, ktf.historyId, ktf));
+        __classPrivateFieldSet(this, _DefaultAllureStore_eventEmitter, eventEmitter, "f");
+    }
+    async visitTestResult(raw, context) {
+        const attachmentLinks = [];
+        const testResult = testResultRawToState({
+            testCases: __classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f"),
+            attachments: __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"),
+            visitAttachmentLink: (link) => attachmentLinks.push(link),
+        }, raw, context);
+        __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
+        if (testResult.historyId) {
+            const maybeOther = this.indexLatestTestResultByHistoryId.get(testResult.historyId);
+            if (maybeOther) {
+                if (maybeOther.start === undefined || testResult.start === undefined || maybeOther.start < testResult.start) {
+                    this.indexLatestTestResultByHistoryId.set(testResult.historyId, testResult);
+                    maybeOther.hidden = true;
+                }
+                else {
+                    testResult.hidden = true;
+                }
+            }
+            else {
+                this.indexLatestTestResultByHistoryId.set(testResult.historyId, testResult);
+            }
+        }
+        index(this.indexTestResultByTestCase, testResult.testCase?.id, testResult);
+        index(this.indexTestResultByHistoryId, testResult.historyId, testResult);
+        index(this.indexAttachmentByTestResult, testResult.id, ...attachmentLinks);
+        __classPrivateFieldGet(this, _DefaultAllureStore_eventEmitter, "f")?.emit("testResult", testResult.id);
+    }
+    async visitTestFixtureResult(result, context) {
+        const attachmentLinks = [];
+        const testFixtureResult = testFixtureResultRawToState({
+            attachments: __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"),
+            visitAttachmentLink: (link) => attachmentLinks.push(link),
+        }, result, context);
+        __classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f").set(testFixtureResult.id, testFixtureResult);
+        testFixtureResult.testResultIds.forEach((trId) => {
+            index(this.indexFixturesByTestResult, trId, testFixtureResult);
+        });
+        index(this.indexAttachmentByFixture, testFixtureResult.id, ...attachmentLinks);
+        __classPrivateFieldGet(this, _DefaultAllureStore_eventEmitter, "f")?.emit("testFixtureResult", testFixtureResult.id);
+    }
+    async visitAttachmentFile(resultFile, context) {
+        const originalFileName = resultFile.getOriginalFileName();
+        const id = md5(originalFileName);
+        __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(id, resultFile);
+        const maybeLink = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id);
+        if (maybeLink) {
+            const link = maybeLink;
+            link.missed = false;
+            link.ext = link?.ext ?? extname(originalFileName);
+            link.contentType = link.contentType ?? resultFile.getContentType();
+            link.contentLength = resultFile.getContentLength();
+        }
+        else {
+            __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").set(id, {
+                used: false,
+                missed: false,
+                id,
+                originalFileName,
+                ext: extname(originalFileName),
+                contentType: resultFile.getContentType(),
+                contentLength: resultFile.getContentLength(),
+            });
+        }
+        __classPrivateFieldGet(this, _DefaultAllureStore_eventEmitter, "f")?.emit("attachmentFile", id);
+    }
+    async visitMetadata(metadata, context) {
+        Object.keys(metadata).forEach((key) => __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").set(key, metadata[key]));
+    }
+    async allTestCases() {
+        return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f").values());
+    }
+    async allTestResults(options = { includeHidden: false }) {
+        const { includeHidden } = options;
+        const result = Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values());
+        return includeHidden ? result : result.filter((tr) => !tr.hidden);
+    }
+    async allAttachments(options = {}) {
+        const { includeMissed = false, includeUnused = false } = options;
+        const attachments = Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").values());
+        return attachments
+            .filter((link) => (!includeMissed ? !link.missed : true))
+            .filter((link) => (!includeUnused ? link.used : true));
+    }
+    async allMetadata() {
+        const result = {};
+        __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").forEach((value, key) => (result[key] = value));
+        return result;
+    }
+    async allFixtures() {
+        return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f").values());
+    }
+    async allHistoryDataPoints() {
+        console.log(__classPrivateFieldGet(this, _DefaultAllureStore_history, "f"));
+        return __classPrivateFieldGet(this, _DefaultAllureStore_history, "f");
+    }
+    async allKnownIssues() {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_known, "f");
+    }
+    async testCaseById(tcId) {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f").get(tcId);
+    }
+    async testResultById(trId) {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(trId);
+    }
+    async attachmentById(attachmentId) {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(attachmentId);
+    }
+    async attachmentContentById(attachmentId) {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").get(attachmentId);
+    }
+    async metadataByKey(key) {
+        return __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").get(key);
+    }
+    async testResultsByTcId(tcId) {
+        return this.indexTestResultByTestCase.get(tcId) ?? [];
+    }
+    async attachmentsByTrId(trId) {
+        return this.indexAttachmentByTestResult.get(trId) ?? [];
+    }
+    async retriesByTrId(trId) {
+        const tr = await this.testResultById(trId);
+        if (!tr || tr.hidden || !tr.historyId) {
+            return [];
+        }
+        return (this.indexTestResultByHistoryId.get(tr.historyId) ?? [])
+            .filter((tr) => tr.hidden)
+            .sort(nullsLast(compareBy("start", reverse(ordinal()))));
+    }
+    async historyByTrId(trId) {
+        console.log(__classPrivateFieldGet(this, _DefaultAllureStore_history, "f"));
+        const tr = await this.testResultById(trId);
+        if (!tr?.historyId) {
+            return [];
+        }
+        return [...__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")]
+            .filter((dp) => !!dp.testResults[tr.historyId])
+            .map((dp) => ({ ...dp.testResults[tr.historyId] }));
+    }
+    async fixturesByTrId(trId) {
+        return this.indexFixturesByTestResult.get(trId) ?? [];
+    }
+    async failedTestResults() {
+        const allTestResults = await this.allTestResults();
+        return allTestResults.filter(({ status }) => status === "failed" || status === "broken");
+    }
+    async unknownFailedTestResults() {
+        const failedTestResults = await this.failedTestResults();
+        if (!__classPrivateFieldGet(this, _DefaultAllureStore_known, "f")?.length) {
+            return failedTestResults;
+        }
+        const knownHistoryIds = __classPrivateFieldGet(this, _DefaultAllureStore_known, "f").map((ktf) => ktf.historyId);
+        return failedTestResults.filter(({ historyId }) => historyId && !knownHistoryIds.includes(historyId));
+    }
+    async testResultsByLabel(labelName) {
+        const results = {
+            _: [],
+        };
+        const all = await this.allTestResults();
+        all.forEach((test) => {
+            const targetLabels = (test.labels ?? []).filter((label) => label.name === labelName);
+            if (targetLabels.length === 0) {
+                results._.push(test);
+                return;
+            }
+            targetLabels.forEach((label) => {
+                if (!results[label.value]) {
+                    results[label.value] = [];
+                }
+                results[label.value].push(test);
+            });
+        });
+        return results;
+    }
+    async testsStatistic() {
+        const all = await this.allTestResults();
+        return all.reduce((acc, test) => {
+            if (!acc[test.status]) {
+                acc[test.status] = 0;
+            }
+            acc[test.status]++;
+            return acc;
+        }, { total: all.length });
+    }
+}
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_eventEmitter = new WeakMap();

package/dist/utils/crypto.d.ts

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

package/dist/utils/crypto.js

@@ -0,0 +1,2 @@
+import { randomBytes } from "node:crypto";
+export const shortHash = () => randomBytes(8).toString("hex");

package/dist/utils/event.d.ts

@@ -0,0 +1,16 @@
+import type { BatchOptions, Realtime } from "@allurereport/plugin-api";
+import type { EventEmitter } from "node:events";
+export interface AllureStoreEvents {
+    testResult: [string];
+    testFixtureResult: [string];
+    attachmentFile: [string];
+}
+export declare class Events implements Realtime {
+    #private;
+    constructor(emitter: EventEmitter<AllureStoreEvents>);
+    onTestResults: (listener: (trIds: string[]) => Promise<void>, options?: BatchOptions) => void;
+    onTestFixtureResults: (listener: (tfrIds: string[]) => Promise<void>, options?: BatchOptions) => void;
+    onAttachmentFiles(listener: (afIds: string[]) => Promise<void>, options?: BatchOptions): void;
+    onAll(listener: () => Promise<void>, options?: BatchOptions): void;
+    offAll(): void;
+}

package/dist/utils/event.js

@@ -0,0 +1,78 @@
+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 _Events_instances, _Events_emitter, _Events_handlers, _Events_createHandler;
+import console from "node:console";
+import { setTimeout } from "node:timers/promises";
+export class Events {
+    constructor(emitter) {
+        _Events_instances.add(this);
+        _Events_emitter.set(this, void 0);
+        _Events_handlers.set(this, []);
+        this.onTestResults = (listener, options = {}) => {
+            const { maxTimeout = 100 } = options;
+            const handler = __classPrivateFieldGet(this, _Events_instances, "m", _Events_createHandler).call(this, maxTimeout, listener);
+            __classPrivateFieldGet(this, _Events_emitter, "f").on("testResult", handler);
+        };
+        this.onTestFixtureResults = (listener, options = {}) => {
+            const { maxTimeout = 100 } = options;
+            const handler = __classPrivateFieldGet(this, _Events_instances, "m", _Events_createHandler).call(this, maxTimeout, listener);
+            __classPrivateFieldGet(this, _Events_emitter, "f").on("testFixtureResult", handler);
+        };
+        __classPrivateFieldSet(this, _Events_emitter, emitter, "f");
+    }
+    onAttachmentFiles(listener, options = {}) {
+        const { maxTimeout = 100 } = options;
+        const handler = __classPrivateFieldGet(this, _Events_instances, "m", _Events_createHandler).call(this, maxTimeout, listener);
+        __classPrivateFieldGet(this, _Events_emitter, "f").on("attachmentFile", handler);
+    }
+    onAll(listener, options = {}) {
+        const { maxTimeout = 100 } = options;
+        const handler = __classPrivateFieldGet(this, _Events_instances, "m", _Events_createHandler).call(this, maxTimeout, listener);
+        __classPrivateFieldGet(this, _Events_emitter, "f").on("testResult", handler);
+        __classPrivateFieldGet(this, _Events_emitter, "f").on("testFixtureResult", handler);
+        __classPrivateFieldGet(this, _Events_emitter, "f").on("attachmentFile", handler);
+    }
+    offAll() {
+        __classPrivateFieldGet(this, _Events_emitter, "f").removeAllListeners();
+        for (const handler of __classPrivateFieldGet(this, _Events_handlers, "f")) {
+            handler.ac?.abort();
+        }
+        __classPrivateFieldSet(this, _Events_handlers, [], "f");
+    }
+}
+_Events_emitter = new WeakMap(), _Events_handlers = new WeakMap(), _Events_instances = new WeakSet(), _Events_createHandler = function _Events_createHandler(maxTimeout, listener) {
+    const handler = {
+        buffer: [],
+    };
+    __classPrivateFieldGet(this, _Events_handlers, "f").push(handler);
+    return (trId) => {
+        handler.buffer.push(trId);
+        if (handler.timeout) {
+            return;
+        }
+        handler.ac = new AbortController();
+        handler.timeout = setTimeout(maxTimeout, undefined, { signal: handler.ac.signal })
+            .then(() => {
+            handler.timeout = undefined;
+            const bufferCopy = [...handler.buffer];
+            handler.buffer = [];
+            handler.ac = undefined;
+            return listener(bufferCopy);
+        })
+            .catch((err) => {
+            if (err.name === "AbortError") {
+                return;
+            }
+            console.error("can't execute listener", err);
+        });
+    };
+};

package/dist/utils/misc.d.ts

@@ -0,0 +1 @@
+export declare const isFileNotFoundError: (e: unknown) => e is Error;

package/dist/utils/misc.js

@@ -0,0 +1 @@
+export const isFileNotFoundError = (e) => e instanceof Error && "code" in e && e.code === "ENOENT";

package/dist/utils/module.d.ts

@@ -0,0 +1 @@
+export declare const importWrapper: (path: string) => Promise<any>;

package/dist/utils/module.js

@@ -0,0 +1,3 @@
+export const importWrapper = async (path) => {
+    return import(path);
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@allurereport/core",
+  "version": "3.0.0-beta.3",
+  "description": "Collection of generic Allure utilities used across the entire project",
+  "keywords": [
+    "allure"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./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",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@allurereport/core-api": "3.0.0-beta.3",
+    "@allurereport/plugin-api": "3.0.0-beta.3",
+    "@allurereport/plugin-awesome": "3.0.0-beta.3",
+    "@allurereport/plugin-classic": "3.0.0-beta.3",
+    "@allurereport/plugin-csv": "3.0.0-beta.3",
+    "@allurereport/plugin-log": "3.0.0-beta.3",
+    "@allurereport/plugin-progress": "3.0.0-beta.3",
+    "@allurereport/plugin-slack": "3.0.0-beta.3",
+    "@allurereport/plugin-testplan": "3.0.0-beta.3",
+    "@allurereport/reader": "3.0.0-beta.3",
+    "@allurereport/reader-api": "3.0.0-beta.3",
+    "markdown-it": "^14.1.0"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/eslint": "^8.56.11",
+    "@types/markdown-it": "^14.1.2",
+    "@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-js-commons": "^3.0.7",
+    "allure-vitest": "^3.0.7",
+    "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",
+    "tslib": "^2.7.0",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}