@qanalyzer/forge-commons 1.1.1

package/dist/models/meta-qa.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * FR41 wire shape for `assertionResults[].meta.qa`
+ * (architecture ingest contract — simplified TestResultType serialization).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQaMetaAccumulator = createQaMetaAccumulator;
+exports.applyQaAnnotation = applyQaAnnotation;
+exports.applyQaAnnotations = applyQaAnnotations;
+exports.toQaMetaWire = toQaMetaWire;
+exports.qaMetaFromEntries = qaMetaFromEntries;
+function createQaMetaAccumulator() {
+    return { steps: [], attachments: [] };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asStringRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (v != null)
+            out[String(k)] = String(v);
+    }
+    return out;
+}
+function resolveType(ann) {
+    if (ann.type?.startsWith('qa-')) {
+        return ann.type;
+    }
+    const message = ann.message ?? '';
+    if (message.startsWith('QA Title:'))
+        return 'qa-title';
+    if (message.startsWith('QA Comment:'))
+        return 'qa-comment';
+    if (message.startsWith('QA Suite:'))
+        return 'qa-suite';
+    if (message.startsWith('QA Fields:'))
+        return 'qa-fields';
+    if (message.startsWith('QA Parameters:'))
+        return 'qa-parameters';
+    if (message.startsWith('QA Step Failed:'))
+        return 'qa-step-failed';
+    if (message.startsWith('QA Step End:'))
+        return 'qa-step-end';
+    if (message.startsWith('QA Step Start:'))
+        return 'qa-step-start';
+    if (message.startsWith('QA Step:'))
+        return 'qa-step';
+    if (message.startsWith('QA Attach:'))
+        return 'qa-attach';
+    if (message.startsWith('QA Ignore'))
+        return 'qa-ignore';
+    return undefined;
+}
+function stripPrefix(message, prefix) {
+    return message.startsWith(prefix) ? message.slice(prefix.length).trim() : message.trim();
+}
+/**
+ * Apply a Vitest/Jest QA annotation (or typed helper entry) onto an accumulator.
+ * Non-QA annotations are ignored.
+ */
+function applyQaAnnotation(acc, ann) {
+    const type = resolveType(ann);
+    if (!type)
+        return;
+    const message = ann.message ?? '';
+    switch (type) {
+        case 'qa-title':
+            acc.title =
+                typeof ann.body === 'string' ? ann.body : stripPrefix(message, 'QA Title:');
+            break;
+        case 'qa-comment':
+            acc.comment =
+                typeof ann.body === 'string' ? ann.body : stripPrefix(message, 'QA Comment:');
+            break;
+        case 'qa-suite':
+            acc.suite =
+                typeof ann.body === 'string' ? ann.body : stripPrefix(message, 'QA Suite:');
+            break;
+        case 'qa-fields': {
+            const fromBody = asStringRecord(ann.body);
+            if (fromBody) {
+                acc.fields = { ...acc.fields, ...fromBody };
+                break;
+            }
+            try {
+                const parsed = JSON.parse(stripPrefix(message, 'QA Fields:'));
+                const record = asStringRecord(parsed);
+                if (record)
+                    acc.fields = { ...acc.fields, ...record };
+            }
+            catch {
+                // ignore malformed
+            }
+            break;
+        }
+        case 'qa-parameters': {
+            const fromBody = asStringRecord(ann.body);
+            if (fromBody) {
+                acc.parameters = { ...acc.parameters, ...fromBody };
+                break;
+            }
+            try {
+                const parsed = JSON.parse(stripPrefix(message, 'QA Parameters:'));
+                const record = asStringRecord(parsed);
+                if (record)
+                    acc.parameters = { ...acc.parameters, ...record };
+            }
+            catch {
+                // ignore malformed
+            }
+            break;
+        }
+        case 'qa-step': {
+            const name = typeof ann.body === 'string'
+                ? ann.body
+                : stripPrefix(message, 'QA Step:');
+            if (name)
+                acc.steps.push({ name, status: 'passed' });
+            break;
+        }
+        case 'qa-step-start': {
+            // WDIO helpers emit start; same as qa-step for accumulator
+            const name = typeof ann.body === 'string'
+                ? ann.body
+                : stripPrefix(message, 'QA Step Start:');
+            if (name)
+                acc.steps.push({ name, status: 'passed' });
+            break;
+        }
+        case 'qa-step-end': {
+            const name = isRecord(ann.body) && typeof ann.body.name === 'string'
+                ? ann.body.name
+                : stripPrefix(message, 'QA Step End:');
+            const status = isRecord(ann.body) && ann.body.status === 'failed' ? 'failed' : 'passed';
+            const step = [...acc.steps].reverse().find((s) => s.name === name);
+            if (step)
+                step.status = status;
+            break;
+        }
+        case 'qa-step-failed': {
+            const name = isRecord(ann.body) && typeof ann.body.name === 'string'
+                ? ann.body.name
+                : stripPrefix(message, 'QA Step Failed:');
+            const step = [...acc.steps].reverse().find((s) => s.name === name);
+            if (step)
+                step.status = 'failed';
+            else if (name)
+                acc.steps.push({ name, status: 'failed' });
+            break;
+        }
+        case 'qa-attach': {
+            if (isRecord(ann.body)) {
+                acc.attachments.push({
+                    file_name: typeof ann.body.name === 'string' ? ann.body.name : undefined,
+                    mime_type: typeof ann.body.contentType === 'string'
+                        ? ann.body.contentType
+                        : typeof ann.body.type === 'string'
+                            ? ann.body.type
+                            : undefined,
+                    size: typeof ann.body.size === 'number' ? ann.body.size : undefined,
+                    content_ref: typeof ann.body.content_ref === 'string'
+                        ? ann.body.content_ref
+                        : typeof ann.body.contentRef === 'string'
+                            ? ann.body.contentRef
+                            : undefined,
+                });
+            }
+            else {
+                acc.attachments.push({
+                    file_name: stripPrefix(message, 'QA Attach:') || undefined,
+                });
+            }
+            break;
+        }
+        case 'qa-ignore':
+            acc.ignore = true;
+            break;
+        default:
+            break;
+    }
+}
+function applyQaAnnotations(acc, annotations) {
+    for (const ann of annotations) {
+        applyQaAnnotation(acc, ann);
+    }
+}
+function defaultReporterName(framework) {
+    if (framework === 'jest')
+        return '@qanalyzer/forge-jest';
+    if (framework === 'mocha')
+        return '@qanalyzer/forge-mocha';
+    if (framework === 'cucumberjs')
+        return '@qanalyzer/forge-cucumberjs';
+    if (framework === 'cypress')
+        return '@qanalyzer/forge-cypress';
+    if (framework === 'playwright')
+        return '@qanalyzer/forge-playwright';
+    if (framework === 'wdio')
+        return '@qanalyzer/forge-wdio';
+    return '@qanalyzer/forge-vitest';
+}
+/** Returns undefined when accumulator has no QA data (omit empty meta.qa). */
+function toQaMetaWire(acc, options) {
+    const hasData = acc.title !== undefined ||
+        acc.comment !== undefined ||
+        acc.suite !== undefined ||
+        (acc.fields && Object.keys(acc.fields).length > 0) ||
+        (acc.parameters && Object.keys(acc.parameters).length > 0) ||
+        acc.steps.length > 0 ||
+        acc.attachments.length > 0 ||
+        acc.ignore === true;
+    if (!hasData)
+        return undefined;
+    const wire = {
+        framework: options.framework,
+        host: {
+            framework: options.framework,
+            reporter: options.reporter ?? defaultReporterName(options.framework),
+        },
+    };
+    if (acc.title !== undefined)
+        wire.title = acc.title;
+    if (acc.comment !== undefined)
+        wire.comment = acc.comment;
+    if (acc.fields && Object.keys(acc.fields).length > 0)
+        wire.fields = acc.fields;
+    if (acc.parameters && Object.keys(acc.parameters).length > 0) {
+        wire.parameters = acc.parameters;
+    }
+    if (acc.suite) {
+        wire.suite = acc.suite.split('\t').filter(Boolean).map((title) => ({ title }));
+    }
+    if (acc.steps.length > 0) {
+        wire.steps = acc.steps.map((step, index) => ({
+            id: `s${index + 1}`,
+            stepType: 'text',
+            name: step.name,
+            status: step.status,
+        }));
+    }
+    if (acc.attachments.length > 0)
+        wire.attachments = acc.attachments;
+    if (acc.ignore)
+        wire.ignore = true;
+    return wire;
+}
+/** Build meta.qa from typed helper buffer entries (`{ type, body }`). */
+function qaMetaFromEntries(entries, options) {
+    const acc = createQaMetaAccumulator();
+    for (const entry of entries) {
+        applyQaAnnotation(acc, { type: entry.type, body: entry.body });
+    }
+    return toQaMetaWire(acc, options);
+}

package/dist/models/report.d.ts

@@ -0,0 +1,15 @@
+import { HostData } from './host-data';
+import { ShortResult } from './short-result';
+import { Stats } from './stats';
+import { ExecutionSum } from './execution-sum';
+/** One persisted launch aggregate (results + stats + host). */
+export interface Report {
+    environment: string;
+    execution: ExecutionSum;
+    host_data: HostData;
+    results: ShortResult[];
+    stats: Stats;
+    suites: string[];
+    threads: string[];
+    title: string;
+}

package/dist/models/report.js

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

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

@@ -0,0 +1,8 @@
+/** Compact result row for launch lists and summaries. */
+export interface ShortResult {
+    id: string;
+    title: string;
+    status: string;
+    duration: number;
+    thread: string | null;
+}

package/dist/models/short-result.js

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

package/dist/models/stats.d.ts

@@ -0,0 +1,10 @@
+/** Pass/fail/skip counts for a launch. */
+export interface Stats {
+    passed: number;
+    failed: number;
+    skipped: number;
+    blocked: number;
+    invalid: number;
+    muted: number;
+    total: number;
+}

package/dist/models/stats.js

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

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

@@ -0,0 +1,20 @@
+/** Step payload variants (text, Gherkin, HTTP request). */
+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,14 @@
+/** Step status and timing. */
+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,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepExecution = exports.StepStatusEnum = void 0;
+/** Step status and timing. */
+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,18 @@
+/** Test status and timing for a single result. */
+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,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestExecution = exports.TestStatusEnum = void 0;
+/** Test status and timing for a single result. */
+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,34 @@
+import { TestStepType } from './test-step';
+import { Attachment } from './attachment';
+import { TestExecution } from './test-execution';
+/**
+ * Normalized test result for Forge ingest.
+ * Jira traceability via title/tags (issue keys).
+ */
+export declare class TestResultType {
+    id: string;
+    title: string;
+    signature: string;
+    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;
+}

package/dist/models/test-result.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestResultType = void 0;
+const test_execution_1 = require("./test-execution");
+/**
+ * Normalized test result for Forge ingest.
+ * Jira traceability via title/tags (issue keys).
+ */
+class TestResultType {
+    id;
+    title;
+    signature;
+    execution;
+    fields;
+    attachments;
+    steps;
+    params;
+    group_params;
+    author;
+    relations;
+    muted;
+    message;
+    tags;
+    preparedAttachments;
+    constructor(title) {
+        this.id = '';
+        this.title = title;
+        this.signature = '';
+        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,19 @@
+import { StepGherkinData, StepRequestData, StepTextData } from './step-data';
+import { StepExecution } from './step-execution';
+import { Attachment } from './attachment';
+/** Step type discriminant and step record. */
+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,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestStepType = exports.StepType = void 0;
+const step_execution_1 = require("./step-execution");
+/** Step type discriminant and step record. */
+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/compose-options.d.ts

@@ -0,0 +1,2 @@
+/** Deep-merge sources; later defined keys win; `undefined` is skipped. */
+export declare function composeOptions<T extends Record<string, unknown>>(...sources: Array<Partial<T> | null | undefined>): T;

package/dist/options/compose-options.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeOptions = composeOptions;
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Deep-merge sources; later defined keys win; `undefined` is skipped. */
+function composeOptions(...sources) {
+    const result = {};
+    for (const source of sources) {
+        if (!source)
+            continue;
+        for (const [key, value] of Object.entries(source)) {
+            if (value === undefined)
+                continue;
+            const existing = result[key];
+            if (isPlainObject(existing) && isPlainObject(value)) {
+                result[key] = composeOptions(existing, value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}

package/dist/options/index.d.ts

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

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 compose_options_1 = require("./compose-options");
+Object.defineProperty(exports, "composeOptions", { enumerable: true, get: function () { return compose_options_1.composeOptions; } });

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

@@ -0,0 +1,5 @@
+export declare enum ModeEnum {
+    ingest = "ingest",
+    file = "file",
+    off = "off"
+}

package/dist/options/mode-enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModeEnum = void 0;
+var ModeEnum;
+(function (ModeEnum) {
+    ModeEnum["ingest"] = "ingest";
+    ModeEnum["file"] = "file";
+    ModeEnum["off"] = "off";
+})(ModeEnum || (exports.ModeEnum = ModeEnum = {}));

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

@@ -0,0 +1,11 @@
+import type { ModeEnum } from './mode-enum';
+import type { ConfigType } from '../config';
+export type FrameworkOptionsType = {
+    frameworkPackage?: string;
+    frameworkName?: string;
+    reporterName?: string;
+};
+export type OptionsType = FrameworkOptionsType & Partial<ConfigType> & {
+    mode?: `${ModeEnum}`;
+    fallback?: `${ModeEnum}`;
+};

package/dist/options/options-type.js

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

package/dist/qanalyzer/index.d.ts

@@ -0,0 +1,2 @@
+export { OptionsResolver, createDefaultConfig, type ResolvedOptions } from './options-resolver';
+export { ReporterFactory } from './reporter-factory';

package/dist/qanalyzer/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReporterFactory = exports.createDefaultConfig = exports.OptionsResolver = void 0;
+var options_resolver_1 = require("./options-resolver");
+Object.defineProperty(exports, "OptionsResolver", { enumerable: true, get: function () { return options_resolver_1.OptionsResolver; } });
+Object.defineProperty(exports, "createDefaultConfig", { enumerable: true, get: function () { return options_resolver_1.createDefaultConfig; } });
+var reporter_factory_1 = require("./reporter-factory");
+Object.defineProperty(exports, "ReporterFactory", { enumerable: true, get: function () { return reporter_factory_1.ReporterFactory; } });

package/dist/qanalyzer/options-resolver.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigType } from '../config';
+import { ModeEnum, type OptionsType } from '../options';
+export type ResolvedOptions = {
+    effectiveMode: ModeEnum;
+    effectiveFallback: ModeEnum;
+    composed: ConfigType & OptionsType;
+};
+export declare class OptionsResolver {
+    resolve(options?: OptionsType): ResolvedOptions;
+}
+export declare function createDefaultConfig(): ConfigType;