qase-javascript-commons 2.6.2 → 2.6.4

package/dist/reporters/report-reporter.d.ts

@@ -3,6 +3,7 @@ import { Attachment } from '../models';
 import { WriterInterface } from '../writer';
 import { LoggerInterface } from '../utils/logger';
 import { HostData } from '../models/host-data';
+import { ReportSerializerInterface } from '../formatter/report-serializer';
 /**
  * @class ReportReporter
  * @extends AbstractReporter
@@ -15,6 +16,7 @@ export declare class ReportReporter extends AbstractReporter {
     private readonly runId;
     private readonly rootSuite;
     private readonly hostData;
+    private readonly serializer;
     private startTime;
     /**
      * @param {LoggerInterface} logger
@@ -25,8 +27,9 @@ export declare class ReportReporter extends AbstractReporter {
      * @param {string | undefined} rootSuite
      * @param {number | undefined} runId
      * @param {HostData | undefined} hostData
+     * @param {ReportSerializerInterface} serializer
      */
-    constructor(logger: LoggerInterface, writer: WriterInterface, frameworkName: string, reporterName: string, environment?: string, rootSuite?: string, runId?: number, hostData?: HostData);
+    constructor(logger: LoggerInterface, writer: WriterInterface, frameworkName: string, reporterName: string, environment?: string, rootSuite?: string, runId?: number, hostData?: HostData, serializer?: ReportSerializerInterface);
     /**
      * @returns {Promise<void>}
      */
@@ -44,38 +47,4 @@ export declare class ReportReporter extends AbstractReporter {
      * @returns {TestStepType[]}
      */
     private copyStepAttachments;
-    /**
-     * Serialize a test result to spec-compliant JSON format.
-     * Transforms internal model fields to match the Qase Report specification.
-     * @private
-     */
-    private serializeResultForReport;
-    /**
-     * Transform group_params Record to param_groups array of arrays.
-     * Same logic as clientV2.ts transformGroupParams.
-     * @private
-     */
-    private transformGroupParams;
-    /**
-     * Serialize attachment for report output (exclude size and content fields).
-     * @private
-     */
-    private serializeAttachment;
-    /**
-     * Serialize steps recursively, transforming:
-     * - data.data -> data.input_data (STEP-01)
-     * - attachments -> execution.attachments (STEP-02)
-     * @private
-     */
-    private serializeSteps;
-    /**
-     * Serialize a single step to spec-compliant format.
-     * @private
-     */
-    private serializeStep;
-    /**
-     * Serialize step data, transforming data.data -> data.input_data for text steps.
-     * @private
-     */
-    private serializeStepData;
 }

package/dist/reporters/report-reporter.js

@@ -4,6 +4,7 @@ exports.ReportReporter = void 0;
 const abstract_reporter_1 = require("./abstract-reporter");
 const models_1 = require("../models");
 const hostData_1 = require("../utils/hostData");
+const report_serializer_1 = require("../formatter/report-serializer");
 /**
  * @class ReportReporter
  * @extends AbstractReporter
@@ -16,6 +17,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
     runId;
     rootSuite;
     hostData;
+    serializer;
     startTime = Date.now();
     /**
      * @param {LoggerInterface} logger
@@ -26,8 +28,9 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
      * @param {string | undefined} rootSuite
      * @param {number | undefined} runId
      * @param {HostData | undefined} hostData
+     * @param {ReportSerializerInterface} serializer
      */
-    constructor(logger, writer, frameworkName, reporterName, environment, rootSuite, runId, hostData) {
+    constructor(logger, writer, frameworkName, reporterName, environment, rootSuite, runId, hostData, serializer = new report_serializer_1.ReportSerializer()) {
         super(logger);
         this.writer = writer;
         this.frameworkName = frameworkName;
@@ -36,6 +39,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
         this.runId = runId;
         this.rootSuite = rootSuite;
         this.hostData = hostData;
+        this.serializer = serializer;
     }
     /**
      * @returns {Promise<void>}
@@ -80,7 +84,7 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                 };
             }
             // Serialize to spec-compliant format before writing
-            const serialized = this.serializeResultForReport(result);
+            const serialized = this.serializer.serializeResult(result);
             await this.writer.writeTestResult(serialized);
         }
     }
@@ -158,133 +162,5 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
         }
         return steps;
     }
-    /**
-     * Serialize a test result to spec-compliant JSON format.
-     * Transforms internal model fields to match the Qase Report specification.
-     * @private
-     */
-    serializeResultForReport(result) {
-        // Transform testops_id -> testops_ids (RSLT-01)
-        let testopsIds = null;
-        if (result.testops_id !== null) {
-            testopsIds = Array.isArray(result.testops_id)
-                ? result.testops_id
-                : [result.testops_id];
-        }
-        // Transform group_params -> param_groups (RSLT-02)
-        const paramGroups = this.transformGroupParams(result.group_params);
-        // Serialize attachments (exclude size and content fields)
-        const attachments = result.attachments.map(att => this.serializeAttachment(att));
-        // Serialize steps (handle data.data -> data.input_data and attachments -> execution.attachments)
-        const steps = this.serializeSteps(result.steps);
-        // Build spec-compliant result object
-        const serialized = {
-            id: result.id,
-            title: result.title,
-            signature: result.signature,
-            execution: result.execution,
-            fields: result.fields,
-            attachments: attachments,
-            steps: steps,
-            params: result.params,
-            param_groups: paramGroups,
-            testops_ids: testopsIds,
-            relations: result.relations,
-            muted: result.muted,
-            message: result.message,
-            tags: result.tags,
-        };
-        // Internal-only fields are excluded: testops_id, group_params, run_id, author, testops_project_mapping, preparedAttachments
-        return serialized;
-    }
-    /**
-     * Transform group_params Record to param_groups array of arrays.
-     * Same logic as clientV2.ts transformGroupParams.
-     * @private
-     */
-    transformGroupParams(groupParams) {
-        const keys = Object.keys(groupParams);
-        if (keys.length === 0) {
-            return [];
-        }
-        return [keys];
-    }
-    /**
-     * Serialize attachment for report output (exclude size and content fields).
-     * @private
-     */
-    serializeAttachment(att) {
-        return {
-            id: att.id,
-            file_name: att.file_name,
-            mime_type: att.mime_type,
-            file_path: att.file_path,
-        };
-    }
-    /**
-     * Serialize steps recursively, transforming:
-     * - data.data -> data.input_data (STEP-01)
-     * - attachments -> execution.attachments (STEP-02)
-     * @private
-     */
-    serializeSteps(steps) {
-        return steps.map(step => this.serializeStep(step));
-    }
-    /**
-     * Serialize a single step to spec-compliant format.
-     * @private
-     */
-    serializeStep(step) {
-        // Transform step data (handle data.data -> data.input_data for text steps)
-        const data = this.serializeStepData(step);
-        // Serialize step attachments
-        const attachments = step.attachments.map(att => this.serializeAttachment(att));
-        // Move attachments into execution.attachments (STEP-02)
-        const execution = {
-            ...step.execution,
-            attachments: attachments,
-        };
-        // Recursively serialize nested steps
-        const nestedSteps = this.serializeSteps(step.steps);
-        return {
-            id: step.id,
-            step_type: step.step_type,
-            data: data,
-            parent_id: step.parent_id,
-            execution: execution,
-            steps: nestedSteps,
-            // Note: attachments field is NOT at top-level in serialized output
-        };
-    }
-    /**
-     * Serialize step data, transforming data.data -> data.input_data for text steps.
-     * @private
-     */
-    serializeStepData(step) {
-        const data = { ...step.data };
-        // For text steps, rename data.data to data.input_data (STEP-01)
-        if (step.step_type === models_1.StepType.TEXT && 'data' in data) {
-            const textData = data;
-            return {
-                action: textData.action,
-                expected_result: textData.expected_result,
-                input_data: textData.data, // Rename: data -> input_data
-            };
-        }
-        // For gherkin steps, convert to text format (STEP-03)
-        if (step.step_type === models_1.StepType.GHERKIN && 'keyword' in data && 'name' in data) {
-            const gherkinData = data;
-            return {
-                action: `${gherkinData.keyword} ${gherkinData.name}`,
-                expected_result: null,
-                input_data: null, // JS GherkinData has no data field
-            };
-        }
-        // For request steps, pass raw fields through (all 7 StepRequestData fields are preserved)
-        if (step.step_type === models_1.StepType.REQUEST && 'request_method' in data) {
-            return data;
-        }
-        return data;
-    }
 }
 exports.ReportReporter = ReportReporter;

package/dist/reporters/shared/fallback-coordinator.d.ts

@@ -0,0 +1,47 @@
+import { InternalReporterInterface } from '../abstract-reporter';
+import { LoggerInterface } from '../../utils/logger';
+export interface FallbackCoordinatorCallbacks {
+    onUpstreamFailure?: () => void;
+    onFallbackFailure?: () => void;
+    onFallbackActivated?: () => void;
+    onDisabled?: () => void;
+}
+/**
+ * Encapsulates the upstream → fallback → disabled cascade used across all
+ * `QaseReporter` lifecycle methods. Keeps both reporters' state (useFallback
+ * / disabled) in one place instead of spreading try/catch blocks everywhere.
+ */
+export declare class FallbackCoordinator {
+    private readonly logger;
+    private readonly upstream;
+    private readonly fallback;
+    private readonly callbacks;
+    private useFallback;
+    private disabled;
+    private onDisabledFired;
+    constructor(logger: LoggerInterface, upstream: InternalReporterInterface | undefined, fallback: InternalReporterInterface | undefined, callbacks?: FallbackCoordinatorCallbacks);
+    isDisabled(): boolean;
+    isUsingFallback(): boolean;
+    setDisabled(value: boolean): void;
+    setUseFallback(value: boolean): void;
+    getUpstream(): InternalReporterInterface | undefined;
+    getFallback(): InternalReporterInterface | undefined;
+    /**
+     * Clear the disabled / useFallback flags so the coordinator can be reused
+     * for a fresh test run. Does not re-arm the `onDisabled` callback — it
+     * only fires once per coordinator lifetime regardless of resets.
+     */
+    reset(): void;
+    /**
+     * Run `op` on the currently active reporter. On upstream failure, switch to
+     * the fallback (copying accumulated results over once) and retry. On
+     * fallback failure, disable the coordinator.
+     *
+     * Returns the operation's result, or `undefined` if the coordinator is
+     * disabled or the operation produced no value.
+     */
+    run<T>(op: (reporter: InternalReporterInterface) => Promise<T>, opName: string): Promise<T | undefined>;
+    private disable;
+    private activateFallback;
+    private runOnFallback;
+}

package/dist/reporters/shared/fallback-coordinator.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackCoordinator = void 0;
+/**
+ * Encapsulates the upstream → fallback → disabled cascade used across all
+ * `QaseReporter` lifecycle methods. Keeps both reporters' state (useFallback
+ * / disabled) in one place instead of spreading try/catch blocks everywhere.
+ */
+class FallbackCoordinator {
+    logger;
+    upstream;
+    fallback;
+    callbacks;
+    useFallback = false;
+    disabled = false;
+    onDisabledFired = false;
+    constructor(logger, upstream, fallback, callbacks = {}) {
+        this.logger = logger;
+        this.upstream = upstream;
+        this.fallback = fallback;
+        this.callbacks = callbacks;
+    }
+    isDisabled() {
+        return this.disabled;
+    }
+    isUsingFallback() {
+        return this.useFallback;
+    }
+    setDisabled(value) {
+        this.disabled = value;
+    }
+    setUseFallback(value) {
+        this.useFallback = value;
+    }
+    getUpstream() {
+        return this.upstream;
+    }
+    getFallback() {
+        return this.fallback;
+    }
+    /**
+     * Clear the disabled / useFallback flags so the coordinator can be reused
+     * for a fresh test run. Does not re-arm the `onDisabled` callback — it
+     * only fires once per coordinator lifetime regardless of resets.
+     */
+    reset() {
+        this.disabled = false;
+        this.useFallback = false;
+    }
+    /**
+     * Run `op` on the currently active reporter. On upstream failure, switch to
+     * the fallback (copying accumulated results over once) and retry. On
+     * fallback failure, disable the coordinator.
+     *
+     * Returns the operation's result, or `undefined` if the coordinator is
+     * disabled or the operation produced no value.
+     */
+    async run(op, opName) {
+        if (this.disabled)
+            return undefined;
+        if (this.useFallback) {
+            return this.runOnFallback(op, opName);
+        }
+        if (!this.upstream) {
+            // No upstream configured — route directly to fallback without
+            // copying results (there are none to copy).
+            if (!this.fallback)
+                return undefined;
+            this.useFallback = true;
+            return this.runOnFallback(op, opName);
+        }
+        try {
+            return await op(this.upstream);
+        }
+        catch (error) {
+            this.logger.logError(`Unable to ${opName} in the upstream reporter:`, error);
+            this.callbacks.onUpstreamFailure?.();
+            if (!this.fallback) {
+                this.disable();
+                return undefined;
+            }
+            this.activateFallback();
+            return this.runOnFallback(op, opName);
+        }
+    }
+    disable() {
+        if (this.disabled)
+            return;
+        this.disabled = true;
+        if (!this.onDisabledFired) {
+            this.onDisabledFired = true;
+            this.callbacks.onDisabled?.();
+        }
+    }
+    activateFallback() {
+        if (this.useFallback)
+            return;
+        const results = this.upstream?.getTestResults() ?? [];
+        this.fallback?.setTestResults(results);
+        this.useFallback = true;
+        this.callbacks.onFallbackActivated?.();
+    }
+    async runOnFallback(op, opName) {
+        if (!this.fallback) {
+            this.disable();
+            return undefined;
+        }
+        try {
+            return await op(this.fallback);
+        }
+        catch (error) {
+            this.logger.logError(`Unable to ${opName} in the fallback reporter:`, error);
+            this.callbacks.onFallbackFailure?.();
+            this.disable();
+            return undefined;
+        }
+    }
+}
+exports.FallbackCoordinator = FallbackCoordinator;

package/dist/reporters/shared/testops-constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Default number of test results per upload batch.
+ * Used by TestOpsReporter and TestOpsMultiReporter when no explicit batch size is configured.
+ */
+export declare const DEFAULT_BATCH_SIZE = 200;

package/dist/reporters/shared/testops-constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BATCH_SIZE = void 0;
+/**
+ * Default number of test results per upload batch.
+ * Used by TestOpsReporter and TestOpsMultiReporter when no explicit batch size is configured.
+ */
+exports.DEFAULT_BATCH_SIZE = 200;

package/dist/reporters/shared/testops-url.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve the TestOps app URL from an API host.
+ *
+ * Rules:
+ * - undefined / empty / "qase.io" → "https://app.qase.io"
+ * - "api.domain"                  → "https://app.domain"
+ * - anything else                 → "https://<host>"
+ */
+export declare function resolveTestOpsBaseUrl(host: string | undefined): string;

package/dist/reporters/shared/testops-url.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTestOpsBaseUrl = resolveTestOpsBaseUrl;
+/**
+ * Resolve the TestOps app URL from an API host.
+ *
+ * Rules:
+ * - undefined / empty / "qase.io" → "https://app.qase.io"
+ * - "api.domain"                  → "https://app.domain"
+ * - anything else                 → "https://<host>"
+ */
+function resolveTestOpsBaseUrl(host) {
+    if (!host || host === 'qase.io') {
+        return 'https://app.qase.io';
+    }
+    return `https://${host.replace('api', 'app')}`;
+}

package/dist/reporters/testops-multi-reporter.d.ts

@@ -45,6 +45,5 @@ export declare class TestOpsMultiReporter extends AbstractReporter {
     publish(): Promise<void>;
     complete(): Promise<void>;
     uploadAttachment(attachment: Attachment): Promise<string>;
-    private getBaseUrl;
     private showLink;
 }

package/dist/reporters/testops-multi-reporter.js

@@ -10,7 +10,8 @@ const abstract_reporter_1 = require("./abstract-reporter");
 const models_1 = require("../models");
 const async_mutex_1 = require("async-mutex");
 const clientV2_1 = require("../client/clientV2");
-const defaultChunkSize = 200;
+const testops_constants_1 = require("./shared/testops-constants");
+const testops_url_1 = require("./shared/testops-url");
 /**
  * Multi-project TestOps reporter. Sends test results to multiple Qase projects
  * with different test case IDs per project. Each project gets its own run.
@@ -33,8 +34,8 @@ class TestOpsMultiReporter extends abstract_reporter_1.AbstractReporter {
     showPublicReportLink;
     constructor(logger, testopsOptions, multiConfig, withState, hostData, reporterName, frameworkPackage, environment, baseUrl, batchSize, showPublicReportLink) {
         super(logger);
-        this.baseUrl = this.getBaseUrl(baseUrl ?? testopsOptions.api?.host);
-        this.batchSize = batchSize ?? testopsOptions.batch?.size ?? defaultChunkSize;
+        this.baseUrl = (0, testops_url_1.resolveTestOpsBaseUrl)(baseUrl ?? testopsOptions.api?.host);
+        this.batchSize = batchSize ?? testopsOptions.batch?.size ?? testops_constants_1.DEFAULT_BATCH_SIZE;
         this.showPublicReportLink = showPublicReportLink ?? testopsOptions.showPublicReportLink;
         this.defaultProject =
             multiConfig.default_project ??
@@ -288,12 +289,6 @@ class TestOpsMultiReporter extends abstract_reporter_1.AbstractReporter {
         }
         return '';
     }
-    getBaseUrl(url) {
-        if (!url || url === 'qase.io') {
-            return 'https://app.qase.io';
-        }
-        return `https://${url.replace('api', 'app')}`;
-    }
     showLink(projectCode, id, title) {
         const runId = this.runIds.get(projectCode);
         if (runId === undefined)

package/dist/reporters/testops-reporter.d.ts

@@ -62,12 +62,6 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @returns {Promise<void>}
      */
     complete(): Promise<void>;
-    /**
-     * @param {string | undefined} url
-     * @return string
-     * @private
-     */
-    private getBaseUrl;
     /**
      * @param {number | null} id
      * @param {string} title

package/dist/reporters/testops-reporter.js

@@ -9,7 +9,8 @@ const abstract_reporter_1 = require("./abstract-reporter");
 const models_1 = require("../models");
 const state_1 = require("../state/state");
 const async_mutex_1 = require("async-mutex");
-const defaultChunkSize = 200;
+const testops_constants_1 = require("./shared/testops-constants");
+const testops_url_1 = require("./shared/testops-url");
 /**
  * @class TestOpsReporter
  * @extends AbstractReporter
@@ -39,8 +40,8 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         this.withState = withState;
         this.projectCode = projectCode;
         this.showPublicReportLink = showPublicReportLink;
-        this.baseUrl = this.getBaseUrl(baseUrl);
-        this.batchSize = batchSize ?? defaultChunkSize;
+        this.baseUrl = (0, testops_url_1.resolveTestOpsBaseUrl)(baseUrl);
+        this.batchSize = batchSize ?? testops_constants_1.DEFAULT_BATCH_SIZE;
         this.runId = runId;
     }
     /**
@@ -128,12 +129,12 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         }
         const remainingResults = this.results.slice(this.firstIndex);
         if (this.firstIndex < this.results.length) {
-            if (remainingResults.length <= defaultChunkSize) {
+            if (remainingResults.length <= testops_constants_1.DEFAULT_BATCH_SIZE) {
                 await this.publishResults(remainingResults);
                 return;
             }
-            for (let i = 0; i < remainingResults.length; i += defaultChunkSize) {
-                await this.publishResults(remainingResults.slice(i, i + defaultChunkSize));
+            for (let i = 0; i < remainingResults.length; i += testops_constants_1.DEFAULT_BATCH_SIZE) {
+                await this.publishResults(remainingResults.slice(i, i + testops_constants_1.DEFAULT_BATCH_SIZE));
             }
         }
         // Clear results because we don't need to send them again then we use Cypress reporter
@@ -164,17 +165,6 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         }
         this.logger.log((0, chalk_1.default) `{green Run ${this.runId} completed}`);
     }
-    /**
-     * @param {string | undefined} url
-     * @return string
-     * @private
-     */
-    getBaseUrl(url) {
-        if (!url || url === 'qase.io') {
-            return 'https://app.qase.io';
-        }
-        return `https://${url.replace('api', 'app')}`;
-    }
     /**
      * @param {number | null} id
      * @param {string} title

package/dist/utils/token-masker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Mask a token for safe logging.
+ * Tokens with 7 chars or fewer are fully masked. Longer tokens expose only
+ * the first 3 and last 4 characters.
+ */
+export declare function maskToken(token: string): string;
+/**
+ * Produce a deep-cloned copy of options with `testops.api.token` masked.
+ * Safe to log — never mutates the input.
+ */
+export declare function sanitizeOptionsForLog<T>(options: T): T;

package/dist/utils/token-masker.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskToken = maskToken;
+exports.sanitizeOptionsForLog = sanitizeOptionsForLog;
+/**
+ * Mask a token for safe logging.
+ * Tokens with 7 chars or fewer are fully masked. Longer tokens expose only
+ * the first 3 and last 4 characters.
+ */
+function maskToken(token) {
+    if (token.length <= 7) {
+        return '*'.repeat(token.length);
+    }
+    return `${token.slice(0, 3)}****${token.slice(-4)}`;
+}
+/**
+ * Produce a deep-cloned copy of options with `testops.api.token` masked.
+ * Safe to log — never mutates the input.
+ */
+function sanitizeOptionsForLog(options) {
+    const sanitized = JSON.parse(JSON.stringify(options));
+    if (sanitized.testops?.api?.token) {
+        sanitized.testops.api.token = maskToken(sanitized.testops.api.token);
+    }
+    return sanitized;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",