@allurereport/core 3.3.1 → 3.4.1

package/dist/utils/environment.js

@@ -0,0 +1,160 @@
+import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, formatNormalizedEnvironmentCollision, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
+const createIdentity = (id, descriptor) => ({
+    id,
+    name: descriptor?.name ?? id,
+});
+const compatibilityIdentityFromName = (normalizedName) => normalizedName === DEFAULT_ENVIRONMENT ? DEFAULT_ENVIRONMENT_IDENTITY : { id: normalizedName, name: normalizedName };
+export const normalizeEnvironmentDescriptorMap = (input, sourcePath) => {
+    const normalized = {};
+    const identities = [];
+    const originalIdsByNormalized = new Map();
+    const originalIdsByNormalizedName = new Map();
+    const errors = [];
+    Object.entries(input).forEach(([environmentId, environmentDescriptor]) => {
+        const idResult = validateEnvironmentId(environmentId);
+        if (!idResult.valid) {
+            errors.push(`${sourcePath}[${JSON.stringify(environmentId)}]: ${idResult.reason}`);
+            return;
+        }
+        const nameResult = validateEnvironmentName(environmentDescriptor.name ?? environmentId);
+        if (!nameResult.valid) {
+            errors.push(`${sourcePath}[${JSON.stringify(environmentId)}]: ${nameResult.reason}`);
+            return;
+        }
+        const normalizedName = nameResult.normalized;
+        const normalizedId = idResult.normalized;
+        const originalIds = originalIdsByNormalized.get(normalizedId) ?? [];
+        const originalIdsForName = originalIdsByNormalizedName.get(normalizedName) ?? [];
+        originalIds.push(environmentId);
+        originalIdsForName.push(environmentId);
+        originalIdsByNormalized.set(normalizedId, originalIds);
+        originalIdsByNormalizedName.set(normalizedName, originalIdsForName);
+        if (!(normalizedId in normalized)) {
+            normalized[normalizedId] = {
+                ...environmentDescriptor,
+                name: normalizedName,
+            };
+            identities.push({
+                id: normalizedId,
+                name: normalizedName,
+            });
+        }
+    });
+    originalIdsByNormalized.forEach((originalIds, normalizedId) => {
+        if (originalIds.length <= 1) {
+            return;
+        }
+        errors.push(formatNormalizedEnvironmentCollision(sourcePath, normalizedId, originalIds));
+    });
+    originalIdsByNormalizedName.forEach((originalIds, normalizedName) => {
+        if (originalIds.length <= 1) {
+            return;
+        }
+        errors.push(`${sourcePath}: normalized environment name ${JSON.stringify(normalizedName)} is produced by ids [${originalIds.map((id) => JSON.stringify(id)).join(",")}]`);
+    });
+    return {
+        normalized,
+        identities,
+        errors,
+    };
+};
+export const environmentIdentityById = (environmentsConfig, environmentId) => {
+    if (!Object.prototype.hasOwnProperty.call(environmentsConfig, environmentId)) {
+        return undefined;
+    }
+    const descriptor = environmentsConfig[environmentId];
+    if (!descriptor) {
+        return undefined;
+    }
+    return createIdentity(environmentId, descriptor);
+};
+export const environmentIdentityByName = (environmentsConfig, environmentName) => {
+    for (const [id, descriptor] of Object.entries(environmentsConfig)) {
+        if ((descriptor?.name ?? id) === environmentName) {
+            return createIdentity(id, descriptor);
+        }
+    }
+    return undefined;
+};
+export const resolveStoredEnvironmentIdentity = (params, environmentsConfig, options) => {
+    if (params.environment !== undefined) {
+        const idResult = validateEnvironmentId(params.environment);
+        if (idResult.valid) {
+            const byId = environmentIdentityById(environmentsConfig, idResult.normalized);
+            if (byId) {
+                return byId;
+            }
+            const byName = environmentIdentityByName(environmentsConfig, idResult.normalized);
+            if (byName) {
+                return byName;
+            }
+            const nameResult = validateEnvironmentName(params.environmentName ?? params.environment);
+            return {
+                id: idResult.normalized,
+                name: nameResult.valid ? nameResult.normalized : idResult.normalized,
+            };
+        }
+        const nameResult = validateEnvironmentName(params.environment);
+        if (nameResult.valid) {
+            return (environmentIdentityByName(environmentsConfig, nameResult.normalized) ??
+                compatibilityIdentityFromName(nameResult.normalized));
+        }
+    }
+    if (params.environmentName !== undefined) {
+        const nameResult = validateEnvironmentName(params.environmentName);
+        if (nameResult.valid) {
+            return (environmentIdentityByName(environmentsConfig, nameResult.normalized) ??
+                compatibilityIdentityFromName(nameResult.normalized));
+        }
+    }
+    if (options?.fallbackToMatch === false) {
+        return undefined;
+    }
+    if (options?.forcedEnvironment) {
+        return options.forcedEnvironment;
+    }
+    const match = Object.entries(environmentsConfig).find(([, { matcher }]) => matcher({ labels: params.labels ?? [] }));
+    if (!match) {
+        return DEFAULT_ENVIRONMENT_IDENTITY;
+    }
+    const [id, descriptor] = match;
+    return { id, name: descriptor.name ?? id };
+};
+export const resolveEnvironmentIdentity = (params, environmentsConfig, sourcePath) => {
+    const errors = [];
+    let identityFromEnvironment;
+    let identityFromName;
+    if (params.environment !== undefined) {
+        const environmentResult = validateEnvironmentId(params.environment);
+        if (!environmentResult.valid) {
+            errors.push(`${sourcePath}: environment ${environmentResult.reason}`);
+        }
+        else {
+            const normalizedEnvironment = environmentResult.normalized;
+            identityFromEnvironment = environmentIdentityById(environmentsConfig, normalizedEnvironment) ??
+                environmentIdentityByName(environmentsConfig, normalizedEnvironment) ?? {
+                id: normalizedEnvironment,
+                name: normalizedEnvironment,
+            };
+        }
+    }
+    if (params.environmentName !== undefined) {
+        const environmentNameResult = validateEnvironmentName(params.environmentName);
+        if (!environmentNameResult.valid) {
+            errors.push(`${sourcePath}: environmentName ${environmentNameResult.reason}`);
+        }
+        else {
+            identityFromName = environmentIdentityByName(environmentsConfig, environmentNameResult.normalized) ?? {
+                id: environmentNameResult.normalized,
+                name: environmentNameResult.normalized,
+            };
+        }
+    }
+    if (identityFromEnvironment && identityFromName && identityFromEnvironment.id !== identityFromName.id) {
+        errors.push(`${sourcePath}: environment ${JSON.stringify(identityFromEnvironment.id)} and environmentName ${JSON.stringify(identityFromName.name)} resolve to different environments`);
+    }
+    return {
+        identity: identityFromEnvironment ?? identityFromName,
+        errors,
+    };
+};

package/dist/utils/event.d.ts

@@ -1,6 +1,6 @@
+import type { EventEmitter } from "node:events";
 import type { TestError } from "@allurereport/core-api";
 import type { BatchOptions, ExitCode, QualityGateValidationResult, RealtimeEventsDispatcher as RealtimeEventsDispatcherType, RealtimeSubscriber as RealtimeSubscriberType, ResultFile } from "@allurereport/plugin-api";
-import type { EventEmitter } from "node:events";
 export declare enum RealtimeEvents {
     TestResult = "testResult",
     TestFixtureResult = "testFixtureResult",

package/dist/utils/safeDumpPath.d.ts

@@ -0,0 +1,4 @@
+export declare class UnsafeDumpPathError extends Error {
+    constructor(entryName: string, reason?: string);
+}
+export declare function resolveDumpAttachmentPath(rootDir: string, entryName: string): string;

package/dist/utils/safeDumpPath.js

@@ -0,0 +1,22 @@
+import { resolve } from "node:path";
+import { isPathContainedInDir } from "./safeOutputPath.js";
+export class UnsafeDumpPathError extends Error {
+    constructor(entryName, reason) {
+        const suffix = reason ? ` (${reason})` : "";
+        super(`Refusing to restore dump: unsafe attachment path ${JSON.stringify(entryName)}${suffix}`);
+        this.name = "UnsafeDumpPathError";
+    }
+}
+export function resolveDumpAttachmentPath(rootDir, entryName) {
+    if (entryName.length === 0) {
+        throw new UnsafeDumpPathError(entryName, "empty name");
+    }
+    if (entryName.includes("\0")) {
+        throw new UnsafeDumpPathError(entryName, "NUL byte");
+    }
+    const resolved = resolve(resolve(rootDir), entryName);
+    if (!isPathContainedInDir(rootDir, resolved)) {
+        throw new UnsafeDumpPathError(entryName);
+    }
+    return resolved;
+}

package/dist/utils/safeOutputPath.d.ts

@@ -0,0 +1,5 @@
+export declare class UnsafeReportOutputPathError extends Error {
+    constructor(relativePath: string);
+}
+export declare function isPathContainedInDir(rootDir: string, candidatePath: string): boolean;
+export declare function resolvePathUnderOutputRoot(outputRoot: string, relativePath: string): string;

package/dist/utils/safeOutputPath.js

@@ -0,0 +1,31 @@
+import { resolve, sep } from "node:path";
+import { isWindows } from "./windows.js";
+export class UnsafeReportOutputPathError extends Error {
+    constructor(relativePath) {
+        super(`Refusing to write outside report output directory: ${JSON.stringify(relativePath)}`);
+        this.name = "UnsafeReportOutputPathError";
+    }
+}
+export function isPathContainedInDir(rootDir, candidatePath) {
+    const rootResolved = resolve(rootDir);
+    const candidateResolved = resolve(candidatePath);
+    if (isWindows()) {
+        const rootLower = rootResolved.toLowerCase();
+        const candLower = candidateResolved.toLowerCase();
+        const prefix = rootLower.endsWith("\\") ? rootLower : `${rootLower}\\`;
+        return candLower === rootLower || candLower.startsWith(prefix);
+    }
+    const prefix = rootResolved.endsWith(sep) ? rootResolved : `${rootResolved}${sep}`;
+    return candidateResolved === rootResolved || candidateResolved.startsWith(prefix);
+}
+export function resolvePathUnderOutputRoot(outputRoot, relativePath) {
+    if (relativePath.includes("\0")) {
+        throw new UnsafeReportOutputPathError(relativePath);
+    }
+    const rootResolved = resolve(outputRoot);
+    const targetPath = resolve(rootResolved, relativePath);
+    if (!isPathContainedInDir(rootResolved, targetPath)) {
+        throw new UnsafeReportOutputPathError(relativePath);
+    }
+    return targetPath;
+}

package/dist/utils/windows.d.ts

@@ -0,0 +1,2 @@
+export declare function isWindows(): boolean;
+export declare function assertValidPluginIdForWindows(id: string): void;

package/dist/utils/windows.js

@@ -0,0 +1,51 @@
+import { platform } from "node:os";
+export function isWindows() {
+    return platform() === "win32";
+}
+const hasWindowsForbiddenPluginIdChar = (id) => {
+    if (/["<>|?*:]/.test(id)) {
+        return true;
+    }
+    for (let i = 0; i < id.length; i++) {
+        const code = id.charCodeAt(i);
+        if (code <= 0x1f) {
+            return true;
+        }
+    }
+    return false;
+};
+const PLUGIN_ID_WINDOWS_RESERVED = new Set([
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM0",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT0",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9",
+]);
+export function assertValidPluginIdForWindows(id) {
+    if (hasWindowsForbiddenPluginIdChar(id)) {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: contains characters not allowed in Windows file names`);
+    }
+    const dotSegment = id.includes(".") ? id.slice(0, id.indexOf(".")) : id;
+    if (PLUGIN_ID_WINDOWS_RESERVED.has(dotSegment.toUpperCase())) {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: reserved device name on Windows`);
+    }
+}

package/package.json

@@ -1,76 +1,64 @@
 {
   "name": "@allurereport/core",
-  "version": "3.3.1",
+  "version": "3.4.1",
   "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",
+  "repository": "https://github.com/allure-framework/allure3",
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "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",
-    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
-    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
-    "test": "vitest run"
+    "test": "vitest run",
+    "lint": "oxlint --import-plugin src test features stories",
+    "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.3.1",
-    "@allurereport/core-api": "3.3.1",
-    "@allurereport/plugin-allure2": "3.3.1",
-    "@allurereport/plugin-api": "3.3.1",
-    "@allurereport/plugin-awesome": "3.3.1",
-    "@allurereport/plugin-classic": "3.3.1",
-    "@allurereport/plugin-csv": "3.3.1",
-    "@allurereport/plugin-dashboard": "3.3.1",
-    "@allurereport/plugin-jira": "3.3.1",
-    "@allurereport/plugin-log": "3.3.1",
-    "@allurereport/plugin-progress": "3.3.1",
-    "@allurereport/plugin-slack": "3.3.1",
-    "@allurereport/plugin-testops": "3.3.1",
-    "@allurereport/plugin-testplan": "3.3.1",
-    "@allurereport/reader": "3.3.1",
-    "@allurereport/reader-api": "3.3.1",
-    "@allurereport/service": "3.3.1",
-    "@allurereport/summary": "3.3.1",
-    "handlebars": "^4.7.8",
+    "@allurereport/ci": "3.4.1",
+    "@allurereport/core-api": "3.4.1",
+    "@allurereport/plugin-allure2": "3.4.1",
+    "@allurereport/plugin-api": "3.4.1",
+    "@allurereport/plugin-awesome": "3.4.1",
+    "@allurereport/plugin-classic": "3.4.1",
+    "@allurereport/plugin-csv": "3.4.1",
+    "@allurereport/plugin-dashboard": "3.4.1",
+    "@allurereport/plugin-jira": "3.4.1",
+    "@allurereport/plugin-log": "3.4.1",
+    "@allurereport/plugin-progress": "3.4.1",
+    "@allurereport/plugin-slack": "3.4.1",
+    "@allurereport/plugin-testops": "3.4.1",
+    "@allurereport/plugin-testplan": "3.4.1",
+    "@allurereport/reader": "3.4.1",
+    "@allurereport/reader-api": "3.4.1",
+    "@allurereport/service": "3.4.1",
+    "@allurereport/summary": "3.4.1",
+    "handlebars": "^4.7.9",
     "node-stream-zip": "^1.15.0",
     "p-limit": "^7.2.0",
     "progress": "^2.0.3",
-    "yaml": "^2.8.1",
+    "yaml": "^2.8.3",
     "yoctocolors": "^2.1.1",
     "zip-stream": "^7.0.2"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "^2.6.1",
-    "@types/eslint": "^8.56.11",
-    "@types/handlebars": "^4.1.0",
     "@types/node": "^20.17.9",
     "@types/progress": "^2",
     "@types/zip-stream": "^7.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.9",
     "@vitest/snapshot": "^2.1.9",
     "allure-js-commons": "^3.3.3",
     "allure-vitest": "^3.3.3",
-    "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",