@tiden/reporter-commons 0.1.0

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
+ * `TidenReporter` 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
+ * `TidenReporter` 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/run-constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Default number of test results per upload batch.
+ * Used by RunReporter when no explicit batch size is configured.
+ */
+export declare const DEFAULT_BATCH_SIZE = 200;
+/**
+ * Upper bound on the configurable batch size — protects against
+ * unreasonably large `tiden.batch.size` values overwhelming the
+ * results:report endpoint in a single request.
+ */
+export declare const MAX_BATCH_SIZE = 2000;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_BATCH_SIZE = exports.DEFAULT_BATCH_SIZE = void 0;
+/**
+ * Default number of test results per upload batch.
+ * Used by RunReporter when no explicit batch size is configured.
+ */
+exports.DEFAULT_BATCH_SIZE = 200;
+/**
+ * Upper bound on the configurable batch size — protects against
+ * unreasonably large `tiden.batch.size` values overwhelming the
+ * results:report endpoint in a single request.
+ */
+exports.MAX_BATCH_SIZE = 2000;

package/dist/state/state.d.ts

@@ -0,0 +1,16 @@
+import { ModeEnum } from '../options';
+export interface StateModel {
+    RunId: number | undefined;
+    Mode: ModeEnum | undefined;
+    IsModeChanged: boolean | undefined;
+}
+export declare class StateManager {
+    static statePath: string;
+    static getState(): StateModel;
+    static setRunId(runId: number): void;
+    static setMode(mode: ModeEnum): void;
+    static setIsModeChanged(isModeChanged: boolean): void;
+    static setState(state: StateModel): void;
+    static clearState(): void;
+    static isStateExists(): boolean;
+}

package/dist/state/state.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class StateManager {
+    static statePath = path_1.default.resolve(__dirname, 'reporterState.json');
+    static getState() {
+        let state = {
+            RunId: undefined,
+            Mode: undefined,
+            IsModeChanged: undefined,
+        };
+        if (!this.isStateExists()) {
+            return state;
+        }
+        try {
+            const data = (0, fs_1.readFileSync)(this.statePath, 'utf8');
+            state = JSON.parse(data);
+        }
+        catch (err) {
+            console.error('Error reading state file:', err);
+        }
+        return state;
+    }
+    static setRunId(runId) {
+        const state = this.getState();
+        state.RunId = runId;
+        this.setState(state);
+    }
+    static setMode(mode) {
+        const state = this.getState();
+        state.Mode = mode;
+        state.IsModeChanged = true;
+        this.setState(state);
+    }
+    static setIsModeChanged(isModeChanged) {
+        const state = this.getState();
+        state.IsModeChanged = isModeChanged;
+        this.setState(state);
+    }
+    static setState(state) {
+        try {
+            const data = JSON.stringify(state);
+            (0, fs_1.writeFileSync)(this.statePath, data);
+        }
+        catch (err) {
+            console.error('Error writing state file:', err);
+        }
+    }
+    static clearState() {
+        if (!this.isStateExists()) {
+            return;
+        }
+        try {
+            (0, fs_1.unlinkSync)(this.statePath);
+        }
+        catch (err) {
+            console.error('Error clearing state file:', err);
+        }
+    }
+    static isStateExists() {
+        return (0, fs_1.existsSync)(this.statePath);
+    }
+}
+exports.StateManager = StateManager;

package/dist/steps/step.d.ts

@@ -0,0 +1,16 @@
+import { Attachment, TestStepType } from '../models';
+export type StepFunction<T = unknown> = (this: TidenStep, step: TidenStep) => T | Promise<T>;
+export declare class TidenStep {
+    name: string;
+    attachments: Attachment[];
+    steps: TestStepType[];
+    constructor(name: string);
+    attach(attach: {
+        name?: string;
+        type?: string;
+        content?: string;
+        paths?: string[] | string;
+    }): void;
+    step(name: string, body: StepFunction): Promise<void>;
+    run(body: StepFunction, messageEmitter: (step: TestStepType) => Promise<void>): Promise<void>;
+}

package/dist/steps/step.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TidenStep = void 0;
+const uuid_1 = require("uuid");
+const path_1 = __importDefault(require("path"));
+const models_1 = require("../models");
+class TidenStep {
+    name = '';
+    attachments = [];
+    steps = [];
+    constructor(name) {
+        this.name = name;
+    }
+    attach(attach) {
+        if (attach.paths) {
+            const files = Array.isArray(attach.paths) ? attach.paths : [attach.paths];
+            for (const file of files) {
+                const attachmentName = path_1.default.basename(file);
+                const contentType = 'application/octet-stream';
+                this.attachments.push({
+                    id: (0, uuid_1.v4)(),
+                    file_name: attachmentName,
+                    mime_type: contentType,
+                    content: '',
+                    file_path: file,
+                    size: 0,
+                });
+            }
+            return;
+        }
+        if (attach.content) {
+            const attachmentName = attach.name ?? 'attachment';
+            const contentType = attach.type ?? 'application/octet-stream';
+            this.attachments.push({
+                id: (0, uuid_1.v4)(),
+                file_name: attachmentName,
+                mime_type: contentType,
+                content: attach.content,
+                file_path: null,
+                size: attach.content.length,
+            });
+        }
+    }
+    async step(name, body) {
+        const childStep = new TidenStep(name);
+        // eslint-disable-next-line @typescript-eslint/require-await
+        await childStep.run(body, async (step) => {
+            this.steps.push(step);
+        });
+    }
+    async run(body, messageEmitter) {
+        const startMs = Date.now();
+        const step = new models_1.TestStepType();
+        step.data = {
+            action: this.name,
+            expected_result: null,
+            data: null,
+        };
+        // Per Tiden API spec: start_time / end_time are Unix epoch seconds (with
+        // fractional ms); duration is milliseconds.
+        const buildExecution = (status, endMs) => ({
+            start_time: startMs / 1000,
+            end_time: endMs / 1000,
+            status,
+            duration: endMs - startMs,
+        });
+        try {
+            await body.call(this, this);
+            step.execution = buildExecution(models_1.StepStatusEnum.passed, Date.now());
+            step.attachments = this.attachments;
+            step.steps = this.steps;
+            await messageEmitter(step);
+        }
+        catch (error) {
+            step.execution = buildExecution(models_1.StepStatusEnum.failed, Date.now());
+            step.attachments = this.attachments;
+            step.steps = this.steps;
+            await messageEmitter(step);
+            throw error;
+        }
+    }
+}
+exports.TidenStep = TidenStep;

package/dist/tiden.d.ts

@@ -0,0 +1,48 @@
+import { OptionsType } from './options';
+import { TestResultType, Attachment } from './models';
+export interface ReporterInterface {
+    addTestResult(result: TestResultType): Promise<void>;
+    publish(): Promise<void>;
+    startTestRun(): void;
+    startTestRunAsync(): Promise<void>;
+    isCaptureLogs(): boolean;
+    getResults(): TestResultType[];
+    sendResults(): Promise<void>;
+    complete(): Promise<void>;
+    uploadAttachment(attachment: Attachment): Promise<string>;
+}
+/**
+ * @class TidenReporter
+ *
+ * Thin orchestrator: delegates to OptionsResolver, ReporterFactory,
+ * StatusProcessor, and FallbackCoordinator. Public API is preserved.
+ */
+export declare class TidenReporter implements ReporterInterface {
+    private static instance;
+    private readonly logger;
+    private readonly options;
+    private readonly withState;
+    private readonly captureLogs;
+    private readonly statusProcessor;
+    private readonly fallback;
+    private startTestRunOperation?;
+    /**
+     * @param {OptionsType} options
+     */
+    private constructor();
+    private buildLogger;
+    private buildReporters;
+    private persistInitialState;
+    static getInstance(options: OptionsType): TidenReporter;
+    getStatusMapping(): Record<string, string> | undefined;
+    uploadAttachment(attachment: Attachment): Promise<string>;
+    getResults(): TestResultType[];
+    setTestResults(results: TestResultType[]): void;
+    addTestResult(result: TestResultType): Promise<void>;
+    startTestRun(): void;
+    startTestRunAsync(): Promise<void>;
+    sendResults(): Promise<void>;
+    publish(): Promise<void>;
+    complete(): Promise<void>;
+    isCaptureLogs(): boolean;
+}

package/dist/tiden.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TidenReporter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const options_1 = require("./options");
+const models_1 = require("./models");
+const disabled_exception_1 = require("./utils/disabled-exception");
+const logger_1 = require("./utils/logger");
+const hostData_1 = require("./utils/hostData");
+const token_masker_1 = require("./utils/token-masker");
+const state_1 = require("./state/state");
+const options_resolver_1 = require("./core/options-resolver");
+const reporter_factory_1 = require("./core/reporter-factory");
+const status_processor_1 = require("./core/status-processor");
+const fallback_coordinator_1 = require("./reporters/shared/fallback-coordinator");
+/**
+ * @type {Record<TestStatusEnum, (test: TestResultType) => string>}
+ */
+const resultLogMap = {
+    [models_1.TestStatusEnum.failed]: (test) => (0, chalk_1.default) `{red Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.passed]: (test) => (0, chalk_1.default) `{green Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.skipped]: (test) => (0, chalk_1.default) `{blueBright Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.blocked]: (test) => (0, chalk_1.default) `{blueBright Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.disabled]: (test) => (0, chalk_1.default) `{grey Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.invalid]: (test) => (0, chalk_1.default) `{yellowBright Test ${test.title} ${test.execution.status}}`,
+};
+/**
+ * @class TidenReporter
+ *
+ * Thin orchestrator: delegates to OptionsResolver, ReporterFactory,
+ * StatusProcessor, and FallbackCoordinator. Public API is preserved.
+ */
+class TidenReporter {
+    static instance;
+    logger;
+    options;
+    withState;
+    captureLogs;
+    statusProcessor;
+    fallback;
+    startTestRunOperation;
+    /**
+     * @param {OptionsType} options
+     */
+    constructor(options) {
+        const resolved = new options_resolver_1.OptionsResolver().resolve(options);
+        this.options = resolved.composed;
+        this.withState = resolved.withState;
+        this.captureLogs = resolved.composed.captureLogs;
+        this.logger = this.buildLogger(resolved);
+        this.logger.logDebug(`Config: ${JSON.stringify((0, token_masker_1.sanitizeOptionsForLog)(resolved.composed))}`);
+        const hostData = (0, hostData_1.getHostInfo)(options.frameworkPackage, options.reporterName);
+        this.logger.logDebug(`Host data: ${JSON.stringify(hostData)}`);
+        const factory = new reporter_factory_1.ReporterFactory(this.logger, hostData);
+        const { upstream, fallback, disabled, useFallbackFromStart } = this.buildReporters(factory, resolved);
+        this.statusProcessor = new status_processor_1.StatusProcessor(this.logger, resolved.composed.statusMapping, resolved.composed.tiden?.statusFilter);
+        this.fallback = new fallback_coordinator_1.FallbackCoordinator(this.logger, upstream, fallback, {
+            onFallbackActivated: () => {
+                if (this.withState) {
+                    state_1.StateManager.setMode(resolved.composed.fallback);
+                }
+            },
+            onDisabled: () => {
+                if (this.withState) {
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
+                }
+            },
+        });
+        if (disabled) {
+            this.fallback.setDisabled(true);
+        }
+        if (useFallbackFromStart) {
+            this.fallback.setUseFallback(true);
+        }
+        this.persistInitialState(resolved, disabled, useFallbackFromStart);
+    }
+    buildLogger(resolved) {
+        const opts = { debug: resolved.composed.debug };
+        if (resolved.composed.logging?.console !== undefined) {
+            opts.consoleLogging = resolved.composed.logging.console;
+        }
+        if (resolved.composed.logging?.file !== undefined) {
+            opts.fileLogging = resolved.composed.logging.file;
+        }
+        return new logger_1.Logger(opts);
+    }
+    buildReporters(factory, resolved) {
+        let upstream;
+        let fallbackReporter;
+        let disabled = false;
+        let upstreamFailed = false;
+        try {
+            upstream = factory.create(resolved.effectiveMode, resolved.composed, this.withState);
+        }
+        catch (error) {
+            if (error instanceof disabled_exception_1.DisabledException) {
+                disabled = true;
+            }
+            else {
+                this.logger.logError('Unable to create upstream reporter:', error);
+                if (resolved.composed.fallback === undefined) {
+                    disabled = true;
+                    return { upstream, fallback: fallbackReporter, disabled, useFallbackFromStart: false };
+                }
+                upstreamFailed = true;
+            }
+        }
+        try {
+            fallbackReporter = factory.create(resolved.effectiveFallback, resolved.composed, this.withState);
+        }
+        catch (error) {
+            if (error instanceof disabled_exception_1.DisabledException) {
+                if (upstreamFailed)
+                    disabled = true;
+            }
+            else {
+                this.logger.logError('Unable to create fallback reporter:', error);
+                if (upstreamFailed && upstream === undefined)
+                    disabled = true;
+            }
+        }
+        const useFallbackFromStart = upstreamFailed && fallbackReporter !== undefined;
+        return { upstream, fallback: fallbackReporter, disabled, useFallbackFromStart };
+    }
+    persistInitialState(resolved, disabled, useFallbackFromStart) {
+        if (!this.withState)
+            return;
+        if (state_1.StateManager.isStateExists())
+            return;
+        const state = {
+            RunId: undefined,
+            Mode: useFallbackFromStart
+                ? resolved.composed.fallback
+                : resolved.composed.mode,
+            IsModeChanged: undefined,
+        };
+        if (disabled) {
+            state.Mode = options_1.ModeEnum.off;
+        }
+        state_1.StateManager.setState(state);
+    }
+    static getInstance(options) {
+        if (!TidenReporter.instance) {
+            TidenReporter.instance = new TidenReporter(options);
+        }
+        return TidenReporter.instance;
+    }
+    getStatusMapping() {
+        return this.options.statusMapping;
+    }
+    async uploadAttachment(attachment) {
+        const result = await this.fallback.run((r) => r.uploadAttachment(attachment), 'upload attachment');
+        return result ?? '';
+    }
+    getResults() {
+        if (this.fallback.isDisabled())
+            return [];
+        const active = this.fallback.isUsingFallback()
+            ? this.fallback.getFallback()
+            : this.fallback.getUpstream();
+        return active?.getTestResults() ?? [];
+    }
+    setTestResults(results) {
+        if (this.fallback.isDisabled())
+            return;
+        const active = this.fallback.isUsingFallback()
+            ? this.fallback.getFallback()
+            : this.fallback.getUpstream();
+        active?.setTestResults(results);
+    }
+    async addTestResult(result) {
+        if (this.fallback.isDisabled())
+            return;
+        const processed = this.statusProcessor.process(result);
+        if (!processed)
+            return;
+        await this.startTestRunOperation;
+        this.logger.log(resultLogMap[processed.execution.status](processed));
+        await this.fallback.run((r) => r.addTestResult(processed), 'add the result');
+    }
+    startTestRun() {
+        if (this.withState)
+            state_1.StateManager.clearState();
+        this.fallback.reset();
+        this.logger.logDebug('Starting test run');
+        const runOp = this.fallback.run(async (r) => {
+            await r.startTestRun();
+        }, 'start test run');
+        this.startTestRunOperation = runOp.then(() => undefined);
+    }
+    async startTestRunAsync() {
+        this.startTestRun();
+        await this.startTestRunOperation;
+    }
+    async sendResults() {
+        if (this.fallback.isDisabled())
+            return;
+        await this.fallback.run((r) => r.sendResults(), 'send the results');
+    }
+    async publish() {
+        if (!this.fallback.isDisabled()) {
+            await this.startTestRunOperation;
+            this.logger.logDebug('Publishing test run results');
+            await this.fallback.run((r) => r.publish(), 'publish the run results');
+        }
+        if (this.withState)
+            state_1.StateManager.clearState();
+    }
+    async complete() {
+        if (this.withState)
+            state_1.StateManager.clearState();
+        if (this.fallback.isDisabled())
+            return;
+        await this.fallback.run((r) => r.complete(), 'complete the run');
+    }
+    isCaptureLogs() {
+        return this.captureLogs ?? false;
+    }
+}
+exports.TidenReporter = TidenReporter;

package/dist/utils/disabled-exception.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @class DisabledException
+ * @extends Error
+ */
+export declare class DisabledException extends Error {
+}

package/dist/utils/disabled-exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisabledException = void 0;
+/**
+ * @class DisabledException
+ * @extends Error
+ */
+class DisabledException extends Error {
+}
+exports.DisabledException = DisabledException;

package/dist/utils/get-package-version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {string} name
+ * @returns {undefined | string}
+ */
+export declare const getPackageVersion: (name: string) => string | undefined;