@tiden/reporter-commons 0.1.0

package/dist/client/tiden-client.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TidenApiClient = void 0;
+const axios_1 = require("axios");
+const tiden_http_1 = require("./tiden-http");
+const run_service_1 = require("./services/run-service");
+const attachment_service_1 = require("./services/attachment-service");
+const result_transformer_1 = require("./services/result-transformer");
+const reporter_api_1 = require("./reporter-api");
+const api_error_handler_1 = require("./services/api-error-handler");
+/**
+ * Facade over the Tiden REST API.
+ *
+ * The JSON endpoints (create/report/complete) go through the narrow reporter
+ * API. Its types are checked against the generated OpenAPI snapshot at test
+ * time without making that full client a runtime dependency. Attachment
+ * upload stays hand-written because it is multipart. Both share one axios
+ * instance.
+ */
+class TidenApiClient {
+    logger;
+    config;
+    environment;
+    http;
+    api;
+    runService;
+    attachmentService;
+    resultTransformer;
+    constructor(logger, config, environment, rootSuite) {
+        this.logger = logger;
+        this.config = config;
+        this.environment = environment;
+        this.http = (0, tiden_http_1.createTidenClient)(config.api.baseUrl ?? '', config.api.token);
+        this.api = new reporter_api_1.ReporterApi(this.http);
+        this.runService = new run_service_1.RunService(logger, this.api);
+        this.attachmentService = new attachment_service_1.AttachmentService(logger, this.http);
+        this.resultTransformer = new result_transformer_1.ResultTransformer(logger, rootSuite);
+    }
+    async createRun() {
+        return this.runService.createRun(this.config, this.environment);
+    }
+    async completeRun(runId) {
+        return this.runService.completeRun(runId, this.config);
+    }
+    async uploadAttachment(attachment) {
+        return this.attachmentService.uploadAttachment(this.config.product, attachment);
+    }
+    /** Public run report links have no Tiden equivalent in v1. */
+    enablePublicReport(_runId) {
+        this.logger.logDebug('Public report links are not supported; skipping');
+        return Promise.resolve();
+    }
+    async uploadResults(runId, results) {
+        try {
+            const models = await Promise.all(results.map((result) => this.resultTransformer.transformWithDefect(result, (a) => this.attachmentService
+                .uploadAttachments(this.config.product, [a], this.config.uploadAttachments ?? true)
+                .then((hashes) => hashes[0] ?? ''), this.config.defect ?? false)));
+            await this.postResultsWithRetry(runId, models);
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error on uploading results', results);
+        }
+    }
+    /** 429-only retry (Retry-After honored, exp backoff, 30s cap); 400 is
+     *  terminal — resending an identical batch fails identically, so log
+     *  every per-entry ReportError from details[] and re-throw. */
+    async postResultsWithRetry(runId, models, maxRetries = 5) {
+        let delay = 1000;
+        for (let attempt = 0;; attempt++) {
+            try {
+                const { data } = await this.api.reportResults(this.config.product, runId, { results: models });
+                // `accepted`/`duplicates` are int64s (strings on the wire). Duplicates
+                // are the server's idempotency check recognising a result `id` it has
+                // already stored — a re-reported batch is dropped there, not here.
+                this.logger.logDebug(`Reported ${models.length} result(s): accepted=${data.accepted ?? '?'} duplicates=${data.duplicates ?? '?'}`);
+                return;
+            }
+            catch (error) {
+                if ((0, axios_1.isAxiosError)(error) && error.response?.status === 429 && attempt < maxRetries) {
+                    const retryAfter = Number(error.response.headers['retry-after']);
+                    const wait = Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter * 1000 : delay;
+                    await new Promise((r) => setTimeout(r, Math.min(wait, 30_000)));
+                    delay = Math.min(delay * 2, 30_000);
+                    continue;
+                }
+                if ((0, axios_1.isAxiosError)(error) && error.response?.status === 400) {
+                    const details = error.response.data?.details ?? [];
+                    for (const d of details) {
+                        if ((d['@type'] ?? '').endsWith('ReportError')) {
+                            this.logger.logError(`Result #${d.index ?? '?'} (id=${d.resultId ?? '<none>'}) rejected: ${d.code ?? ''}: ${d.message ?? ''}`);
+                        }
+                    }
+                }
+                throw error;
+            }
+        }
+    }
+}
+exports.TidenApiClient = TidenApiClient;

package/dist/client/tiden-http.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+/**
+ * Thin HTTP client for the Tiden REST API. Tiden authenticates with
+ * `Authorization: Bearer` (tokens are `tfy_...`) and takes the base URL
+ * verbatim — no self-host URL templating.
+ *
+ * This instance is the single transport for everything commons sends: the
+ * narrow reporter API and multipart attachment upload both use it. baseURL,
+ * auth and timeout therefore live here and nowhere else.
+ */
+export declare function createTidenClient(baseUrl: string, token: string): AxiosInstance;

package/dist/client/tiden-http.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTidenClient = createTidenClient;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Thin HTTP client for the Tiden REST API. Tiden authenticates with
+ * `Authorization: Bearer` (tokens are `tfy_...`) and takes the base URL
+ * verbatim — no self-host URL templating.
+ *
+ * This instance is the single transport for everything commons sends: the
+ * narrow reporter API and multipart attachment upload both use it. baseURL,
+ * auth and timeout therefore live here and nowhere else.
+ */
+function createTidenClient(baseUrl, token) {
+    return axios_1.default.create({
+        baseURL: baseUrl.replace(/\/$/, ''),
+        headers: { Authorization: `Bearer ${token}` },
+        timeout: 30_000,
+    });
+}

package/dist/config/config-loader-interface.d.ts

@@ -0,0 +1,4 @@
+import { ConfigType } from './config-type';
+export interface ConfigLoaderInterface<T extends Partial<ConfigType>> {
+    load(files: string[]): (T & ConfigType) | null;
+}

package/dist/config/config-loader-interface.js

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

package/dist/config/config-loader.d.ts

@@ -0,0 +1,10 @@
+import { JSONSchemaType } from 'ajv';
+import { ConfigLoaderInterface } from './config-loader-interface';
+import { ConfigType } from './config-type';
+export declare class ConfigLoader<T extends Partial<ConfigType> & Record<string, unknown>> implements ConfigLoaderInterface<T> {
+    private paths;
+    private validationSchema;
+    constructor(validationSchema?: JSONSchemaType<T>, paths?: string[]);
+    private read;
+    load(): (T & ConfigType) | null;
+}

package/dist/config/config-loader.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lodash_merge_1 = __importDefault(require("lodash.merge"));
+const tiden_error_1 = require("../utils/tiden-error");
+const validate_json_1 = require("../utils/validate-json");
+const config_validation_schema_1 = require("./config-validation-schema");
+class ConfigLoader {
+    paths;
+    validationSchema;
+    constructor(validationSchema, paths = ['tiden.config.json']) {
+        this.paths = paths;
+        this.validationSchema = (0, lodash_merge_1.default)({}, config_validation_schema_1.configValidationSchema, validationSchema);
+    }
+    read() {
+        for (const path of this.paths) {
+            const filePath = (0, path_1.join)(process.cwd(), path);
+            try {
+                return (0, fs_1.readFileSync)(filePath, 'utf8');
+            }
+            catch (error) {
+                const isNotFound = error instanceof Error &&
+                    'code' in error &&
+                    (error.code === 'ENOENT' || error.code === 'EISDIR');
+                if (!isNotFound) {
+                    throw new tiden_error_1.TidenError('Cannot read config file', { cause: error });
+                }
+            }
+        }
+        return null;
+    }
+    load() {
+        try {
+            const data = this.read();
+            if (data) {
+                const json = JSON.parse(data);
+                (0, validate_json_1.validateJson)(this.validationSchema, json);
+                return json;
+            }
+        }
+        catch (error) {
+            if (error instanceof validate_json_1.JsonValidationError) {
+                const [validationError] = error.validationErrors;
+                const { instancePath = '', message = '' } = validationError ?? {};
+                const configPath = instancePath
+                    ? `\`${instancePath.substring(1).replace('/', '.')}\``
+                    : 'it';
+                throw new Error(`Invalid config: "${configPath}" ${message}`);
+            }
+            throw error;
+        }
+        return null;
+    }
+}
+exports.ConfigLoader = ConfigLoader;

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

@@ -0,0 +1,2 @@
+import { OptionsType } from '../options';
+export type ConfigType = Omit<OptionsType, 'frameworkPackage' | 'frameworkName' | 'reporterName'>;

package/dist/config/config-type.js

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

package/dist/config/config-validation-schema.d.ts

@@ -0,0 +1,212 @@
+import { ModeEnum } from '../options';
+import { DriverEnum, FormatEnum } from '../writer';
+/**
+ * @type {JSONSchemaType<ConfigType>}
+ */
+export declare const configValidationSchema: {
+    type: string;
+    properties: {
+        mode: {
+            type: string;
+            enum: ModeEnum[];
+            nullable: boolean;
+        };
+        fallback: {
+            type: string;
+            enum: ModeEnum[];
+            nullable: boolean;
+        };
+        debug: {
+            type: string;
+            nullable: boolean;
+        };
+        environment: {
+            type: string;
+            nullable: boolean;
+        };
+        captureLogs: {
+            type: string;
+            nullable: boolean;
+        };
+        rootSuite: {
+            type: string;
+            nullable: boolean;
+        };
+        statusMapping: {
+            type: string;
+            nullable: boolean;
+            additionalProperties: {
+                type: string;
+            };
+        };
+        logging: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                console: {
+                    type: string;
+                    nullable: boolean;
+                };
+                file: {
+                    type: string;
+                    nullable: boolean;
+                };
+            };
+        };
+        tiden: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                api: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        token: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        baseUrl: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                product: {
+                    type: string;
+                    nullable: boolean;
+                };
+                uploadAttachments: {
+                    type: string;
+                    nullable: boolean;
+                };
+                run: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        id: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        title: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        description: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        complete: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        branch: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                batch: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        size: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                defect: {
+                    type: string;
+                    nullable: boolean;
+                };
+                configurations: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        values: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    name: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                    value: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+                statusFilter: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    nullable: boolean;
+                };
+            };
+        };
+        report: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                driver: {
+                    type: string;
+                    enum: DriverEnum[];
+                    nullable: boolean;
+                };
+                connections: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        local: {
+                            type: string;
+                            nullable: boolean;
+                            properties: {
+                                path: {
+                                    type: string;
+                                    nullable: boolean;
+                                };
+                                format: {
+                                    type: string;
+                                    enum: FormatEnum[];
+                                    nullable: boolean;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        profilers: {
+            type: string;
+            items: {
+                type: string;
+            };
+            nullable: boolean;
+        };
+        networkProfiler: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                skip_domains: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    nullable: boolean;
+                };
+                track_on_fail: {
+                    type: string;
+                    nullable: boolean;
+                };
+            };
+        };
+    };
+};

package/dist/config/config-validation-schema.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configValidationSchema = void 0;
+const options_1 = require("../options");
+const writer_1 = require("../writer");
+/**
+ * @type {JSONSchemaType<ConfigType>}
+ */
+exports.configValidationSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.tiden, options_1.ModeEnum.off],
+            nullable: true,
+        },
+        fallback: {
+            type: 'string',
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.tiden, options_1.ModeEnum.off],
+            nullable: true,
+        },
+        debug: {
+            type: 'boolean',
+            nullable: true,
+        },
+        environment: {
+            type: 'string',
+            nullable: true,
+        },
+        captureLogs: {
+            type: 'boolean',
+            nullable: true,
+        },
+        rootSuite: {
+            type: 'string',
+            nullable: true,
+        },
+        statusMapping: {
+            type: 'object',
+            nullable: true,
+            additionalProperties: {
+                type: 'string',
+            },
+        },
+        logging: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                console: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+                file: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+            },
+        },
+        tiden: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                api: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        token: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                        baseUrl: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                    },
+                },
+                product: {
+                    type: 'string',
+                    nullable: true,
+                },
+                uploadAttachments: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+                run: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        id: {
+                            type: 'number',
+                            nullable: true,
+                        },
+                        title: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                        description: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                        complete: {
+                            type: 'boolean',
+                            nullable: true,
+                        },
+                        branch: {
+                            type: 'string',
+                            nullable: true,
+                        },
+                    },
+                },
+                batch: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        size: {
+                            type: 'number',
+                            nullable: true,
+                        },
+                    },
+                },
+                defect: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+                configurations: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        values: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    name: {
+                                        type: 'string',
+                                        nullable: true,
+                                    },
+                                    value: {
+                                        type: 'string',
+                                        nullable: true,
+                                    },
+                                },
+                                required: ['name', 'value'],
+                            },
+                        },
+                    },
+                    required: ['values'],
+                },
+                statusFilter: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                    },
+                    nullable: true,
+                },
+            },
+        },
+        report: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                driver: {
+                    type: 'string',
+                    enum: [writer_1.DriverEnum.local],
+                    nullable: true,
+                },
+                connections: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        [writer_1.DriverEnum.local]: {
+                            type: 'object',
+                            nullable: true,
+                            properties: {
+                                path: {
+                                    type: 'string',
+                                    nullable: true,
+                                },
+                                format: {
+                                    type: 'string',
+                                    enum: [writer_1.FormatEnum.json, writer_1.FormatEnum.jsonp],
+                                    nullable: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        profilers: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+            nullable: true,
+        },
+        networkProfiler: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                skip_domains: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    nullable: true,
+                },
+                track_on_fail: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+            },
+        },
+    },
+};

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { type ConfigType } from './config-type';
+export { configValidationSchema } from './config-validation-schema';
+export { type ConfigLoaderInterface } from './config-loader-interface';
+export { ConfigLoader } from './config-loader';

package/dist/config/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = exports.configValidationSchema = void 0;
+var config_validation_schema_1 = require("./config-validation-schema");
+Object.defineProperty(exports, "configValidationSchema", { enumerable: true, get: function () { return config_validation_schema_1.configValidationSchema; } });
+var config_loader_1 = require("./config-loader");
+Object.defineProperty(exports, "ConfigLoader", { enumerable: true, get: function () { return config_loader_1.ConfigLoader; } });

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

@@ -0,0 +1,19 @@
+import { ModeEnum, OptionsType } from '../options';
+import { ConfigType } from '../config';
+export interface ResolvedOptions {
+    effectiveMode: ModeEnum;
+    effectiveFallback: ModeEnum;
+    composed: ConfigType & OptionsType;
+    withState: boolean;
+}
+/**
+ * Composes the final options used by TidenReporter:
+ * - restores mode / runId from state (when withState is active)
+ * - merges env-derived config with user options
+ * - determines effective mode / fallback values
+ */
+export declare class OptionsResolver {
+    resolve(options: OptionsType): ResolvedOptions;
+    private detectWithState;
+    private restoreFromState;
+}