@tiden/reporter-commons 0.1.0

package/dist/models/step-data.d.ts

@@ -0,0 +1,19 @@
+export interface StepTextData {
+    action: string;
+    expected_result: string | null;
+    data: string | null;
+}
+export interface StepGherkinData {
+    keyword: string;
+    name: string;
+    line: number;
+}
+export interface StepRequestData {
+    request_method: string;
+    request_url: string;
+    request_headers: Record<string, string> | null;
+    request_body: string | null;
+    status_code: number | null;
+    response_body: string | null;
+    response_headers: Record<string, string> | null;
+}

package/dist/models/step-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/step-execution.d.ts

@@ -0,0 +1,13 @@
+export declare enum StepStatusEnum {
+    passed = "passed",
+    failed = "failed",
+    blocked = "blocked",
+    skipped = "skipped"
+}
+export declare class StepExecution {
+    start_time: number | null;
+    status: StepStatusEnum;
+    end_time: number | null;
+    duration: number | null;
+    constructor();
+}

package/dist/models/step-execution.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepExecution = exports.StepStatusEnum = void 0;
+var StepStatusEnum;
+(function (StepStatusEnum) {
+    StepStatusEnum["passed"] = "passed";
+    StepStatusEnum["failed"] = "failed";
+    StepStatusEnum["blocked"] = "blocked";
+    StepStatusEnum["skipped"] = "skipped";
+})(StepStatusEnum || (exports.StepStatusEnum = StepStatusEnum = {}));
+class StepExecution {
+    start_time;
+    status;
+    end_time;
+    duration;
+    constructor() {
+        this.status = StepStatusEnum.passed;
+        this.start_time = null;
+        this.end_time = null;
+        this.duration = null;
+    }
+}
+exports.StepExecution = StepExecution;

package/dist/models/test-execution.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @enum {string}
+ */
+export declare enum TestStatusEnum {
+    passed = "passed",
+    failed = "failed",
+    skipped = "skipped",
+    disabled = "disabled",
+    blocked = "blocked",
+    invalid = "invalid"
+}
+export declare class TestExecution {
+    start_time: number | null;
+    status: TestStatusEnum;
+    end_time: number | null;
+    duration: number | null;
+    stacktrace: string | null;
+    thread: string | null;
+    constructor();
+}

package/dist/models/test-execution.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestExecution = exports.TestStatusEnum = void 0;
+/**
+ * @enum {string}
+ */
+var TestStatusEnum;
+(function (TestStatusEnum) {
+    TestStatusEnum["passed"] = "passed";
+    TestStatusEnum["failed"] = "failed";
+    TestStatusEnum["skipped"] = "skipped";
+    TestStatusEnum["disabled"] = "disabled";
+    TestStatusEnum["blocked"] = "blocked";
+    TestStatusEnum["invalid"] = "invalid";
+})(TestStatusEnum || (exports.TestStatusEnum = TestStatusEnum = {}));
+class TestExecution {
+    start_time;
+    status;
+    end_time;
+    duration;
+    stacktrace;
+    thread;
+    constructor() {
+        this.status = TestStatusEnum.passed;
+        this.start_time = null;
+        this.end_time = null;
+        this.duration = null;
+        this.stacktrace = null;
+        this.thread = null;
+    }
+}
+exports.TestExecution = TestExecution;

package/dist/models/test-result.d.ts

@@ -0,0 +1,44 @@
+import { TestStepType } from './test-step';
+import { Attachment } from './attachment';
+import { TestExecution } from './test-execution';
+/**
+ * Project code to test case IDs mapping for multi-project support.
+ * Key: project code (string), Value: array of test case IDs (numbers).
+ */
+export type ProjectCaseMapping = Record<string, number[]>;
+export declare class TestResultType {
+    id: string;
+    title: string;
+    signature: string;
+    run_id: number | null;
+    case_id: number | number[] | null;
+    /**
+     * Multi-project mapping: project code -> array of test case IDs.
+     * When set, overrides case_id for multi-project mode.
+     * If empty/null, fall back to case_id for single project.
+     */
+    project_case_mapping: ProjectCaseMapping | null;
+    execution: TestExecution;
+    fields: Record<string, string>;
+    attachments: Attachment[];
+    steps: TestStepType[];
+    params: Record<string, string>;
+    group_params: Record<string, string>;
+    author: string | null;
+    relations: Relation | null;
+    muted: boolean;
+    message: string | null;
+    tags: string[];
+    preparedAttachments?: string[];
+    constructor(title: string);
+}
+export interface Relation {
+    suite?: Suite;
+}
+export interface Suite {
+    data: SuiteData[];
+}
+export interface SuiteData {
+    title: string;
+    public_id: number | null;
+}

package/dist/models/test-result.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestResultType = void 0;
+const test_execution_1 = require("./test-execution");
+class TestResultType {
+    id;
+    title;
+    signature;
+    run_id;
+    case_id;
+    /**
+     * Multi-project mapping: project code -> array of test case IDs.
+     * When set, overrides case_id for multi-project mode.
+     * If empty/null, fall back to case_id for single project.
+     */
+    project_case_mapping;
+    execution;
+    fields;
+    attachments;
+    steps;
+    params;
+    group_params;
+    author;
+    relations;
+    muted;
+    message;
+    tags;
+    preparedAttachments;
+    constructor(title) {
+        this.id = '';
+        this.title = title;
+        this.signature = '';
+        this.run_id = null;
+        this.case_id = null;
+        this.project_case_mapping = null;
+        this.execution = new test_execution_1.TestExecution();
+        this.fields = {};
+        this.attachments = [];
+        this.steps = [];
+        this.params = {};
+        this.group_params = {};
+        this.author = null;
+        this.relations = null;
+        this.muted = false;
+        this.message = null;
+        this.tags = [];
+        this.preparedAttachments = [];
+    }
+}
+exports.TestResultType = TestResultType;

package/dist/models/test-step.d.ts

@@ -0,0 +1,18 @@
+import { StepGherkinData, StepRequestData, StepTextData } from './step-data';
+import { StepExecution } from './step-execution';
+import { Attachment } from './attachment';
+export declare enum StepType {
+    TEXT = "text",
+    GHERKIN = "gherkin",
+    REQUEST = "request"
+}
+export declare class TestStepType {
+    id: string;
+    step_type: StepType;
+    data: StepTextData | StepGherkinData | StepRequestData;
+    parent_id: string | null;
+    execution: StepExecution;
+    attachments: Attachment[];
+    steps: TestStepType[];
+    constructor(type?: StepType);
+}

package/dist/models/test-step.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestStepType = exports.StepType = void 0;
+const step_execution_1 = require("./step-execution");
+var StepType;
+(function (StepType) {
+    StepType["TEXT"] = "text";
+    StepType["GHERKIN"] = "gherkin";
+    StepType["REQUEST"] = "request";
+})(StepType || (exports.StepType = StepType = {}));
+class TestStepType {
+    id;
+    step_type;
+    data;
+    parent_id;
+    execution;
+    attachments;
+    steps;
+    constructor(type = StepType.TEXT) {
+        this.id = '';
+        this.step_type = type;
+        this.parent_id = null;
+        this.execution = new step_execution_1.StepExecution();
+        this.attachments = [];
+        this.steps = [];
+        if (type === StepType.TEXT) {
+            this.data = {
+                action: '',
+                expected_result: null,
+                data: null,
+            };
+        }
+        else if (type === StepType.GHERKIN) {
+            this.data = {
+                keyword: '',
+                name: '',
+                line: 0,
+            };
+        }
+        else {
+            this.data = {
+                request_method: '',
+                request_url: '',
+                request_headers: null,
+                request_body: null,
+                status_code: null,
+                response_body: null,
+                response_headers: null,
+            };
+        }
+    }
+}
+exports.TestStepType = TestStepType;

package/dist/options/composeOptions.d.ts

@@ -0,0 +1,8 @@
+type MergedType<T extends unknown[], A = NonNullable<unknown>> = T extends [infer F, ...(infer R)] ? MergedType<R, F & A> : A;
+declare module 'lodash' {
+    interface LoDashStatic {
+        mergeWith<T extends unknown[]>(...args: [...T, MergeWithCustomizer]): MergedType<T>;
+    }
+}
+export declare const composeOptions: <T extends unknown[]>(...args: T) => MergedType<[NonNullable<unknown>, ...T]>;
+export {};

package/dist/options/composeOptions.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeOptions = void 0;
+const lodash_mergewith_1 = __importDefault(require("lodash.mergewith"));
+const skipUndef = (value, src) => (src === undefined ? value : undefined);
+const composeOptions = (...args) => {
+    return (0, lodash_mergewith_1.default)({}, ...args, skipUndef);
+};
+exports.composeOptions = composeOptions;

package/dist/options/index.d.ts

@@ -0,0 +1,3 @@
+export { ModeEnum } from './mode-enum';
+export { type OptionsType } from './options-type';
+export { composeOptions } from './composeOptions';

package/dist/options/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeOptions = exports.ModeEnum = void 0;
+var mode_enum_1 = require("./mode-enum");
+Object.defineProperty(exports, "ModeEnum", { enumerable: true, get: function () { return mode_enum_1.ModeEnum; } });
+var composeOptions_1 = require("./composeOptions");
+Object.defineProperty(exports, "composeOptions", { enumerable: true, get: function () { return composeOptions_1.composeOptions; } });

package/dist/options/mode-enum.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @enum {string}
+ */
+export declare enum ModeEnum {
+    report = "report",
+    tiden = "tiden",
+    off = "off"
+}

package/dist/options/mode-enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModeEnum = void 0;
+/**
+ * @enum {string}
+ */
+var ModeEnum;
+(function (ModeEnum) {
+    ModeEnum["report"] = "report";
+    ModeEnum["tiden"] = "tiden";
+    ModeEnum["off"] = "off";
+})(ModeEnum || (exports.ModeEnum = ModeEnum = {}));

package/dist/options/options-type.d.ts

@@ -0,0 +1,38 @@
+import { ModeEnum } from './mode-enum';
+import { DriverEnum, FsWriterOptionsType } from '../writer';
+import { TidenOptionsType } from '../models/config/TidenOptionsType';
+type RecursivePartial<T> = {
+    [K in keyof T]?: RecursivePartial<T[K]> | undefined;
+};
+export type ConnectionsType = {
+    [DriverEnum.local]?: FsWriterOptionsType;
+};
+export type AdditionalReportOptionsType = {
+    driver?: `${DriverEnum}`;
+    connections?: ConnectionsType;
+};
+export type LoggingOptionsType = {
+    console?: boolean | undefined;
+    file?: boolean | undefined;
+};
+export type OptionsType = {
+    frameworkPackage: string;
+    frameworkName: string;
+    reporterName: string;
+    mode?: `${ModeEnum}` | undefined;
+    fallback?: `${ModeEnum}` | undefined;
+    captureLogs?: boolean | undefined;
+    debug?: boolean | undefined;
+    environment?: string | undefined;
+    rootSuite?: string | undefined;
+    statusMapping?: Record<string, string> | undefined;
+    logging?: RecursivePartial<LoggingOptionsType> | undefined;
+    tiden?: RecursivePartial<TidenOptionsType> | undefined;
+    report?: RecursivePartial<AdditionalReportOptionsType> | undefined;
+    profilers?: string[] | undefined;
+    networkProfiler?: {
+        skip_domains?: string[] | undefined;
+        track_on_fail?: boolean | undefined;
+    } | undefined;
+};
+export {};

package/dist/options/options-type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const writer_1 = require("../writer");

package/dist/profilers/abstract-profiler.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class AbstractProfiler {
+    abstract enable(): void;
+    abstract disable(): void;
+    abstract restore(): void;
+}

package/dist/profilers/abstract-profiler.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractProfiler = void 0;
+class AbstractProfiler {
+}
+exports.AbstractProfiler = AbstractProfiler;

package/dist/profilers/fetch-interceptor.d.ts

@@ -0,0 +1,60 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { TestStepType } from '../models/test-step';
+interface ProfilerRef {
+    shouldSkip(url: string): boolean;
+    trackOnFail: boolean;
+    fallbackSteps: TestStepType[];
+}
+/**
+ * FetchInterceptor subscribes to undici diagnostics_channel events to capture
+ * outgoing fetch() calls as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Works with Node.js 18+ global fetch (which uses undici internally).
+ * Gracefully skips subscription on Node < 18 (no global fetch).
+ *
+ * Key design decisions:
+ *  - WeakMap keyed on undici request objects (same reference across all events)
+ *  - ALS context captured at undici:request:create time, NOT at headers time.
+ *    This is critical because undici connection pooling can break AsyncLocalStorage
+ *    propagation between the create and headers events when connections are reused.
+ *  - globalThis.fetch wrapping intercepts error response bodies (undici:request:bodyChunkReceived
+ *    is not available in Node 22's built-in undici)
+ *  - All handlers wrapped in try/catch (INTC-06: silent failure)
+ *
+ * Event flow:
+ *  undici:request:create   → capture method, URL, start time, ALS context → WeakMap
+ *  undici:request:headers  → build step using WeakMap data, push to ALS accumulator
+ *  undici:request:trailers → cleanup WeakMap entry
+ *  fetch wrapper           → update response_body for error responses (>= 400)
+ */
+export declare class FetchInterceptor {
+    private readonly store;
+    private readonly profiler;
+    private readonly pendingRequests;
+    private readonly bodyHandlers;
+    private readonly createHandler;
+    private readonly headersHandler;
+    private readonly trailersHandler;
+    private origFetch;
+    constructor(store: AsyncLocalStorage<TestStepType[]>, profiler: ProfilerRef);
+    /**
+     * Subscribe to undici diagnostics_channel events and wrap global fetch for
+     * error response body capture.
+     *
+     * No-op on Node < 18 (no global fetch) or if diagnostics_channel unavailable.
+     */
+    subscribe(): void;
+    /**
+     * Unsubscribe from diagnostics_channel events and restore original global fetch.
+     */
+    unsubscribe(): void;
+    private handleCreate;
+    private handleHeaders;
+    private handleTrailers;
+    /**
+     * Called by the fetch wrapper when an error response body is available.
+     * Finds the most recently added step for this URL/status and updates its response_body.
+     */
+    private applyResponseBody;
+}
+export {};