@tiden/reporter-commons 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.2.0
+
+- **`rootDir` / `TIDEN_ROOT_DIR` option**, plus `normalizeSpecPath` and `resolveRootDir` on the
+  `/internal` entry point: the base a case signature's spec-file segment is resolved against,
+  defaulting to `process.cwd()`. Consumed by `@tiden/vitest-reporter` and `@tiden/jest-reporter`.
+  Env is read directly by `resolveRootDir` rather than through `OptionsResolver`, whose composed
+  result never reaches a framework reporter — resolving it any other way leaves `TIDEN_ROOT_DIR`
+  silently ignored while looking configured.
+- **Fixed a polynomial ReDoS in `normalizeSpecPath`.** The root's trailing slashes were trimmed
+  with `/\/+$/`, which backtracks quadratically on a root of repeated slashes — and the root is
+  configurable (`rootDir` / `TIDEN_ROOT_DIR`). Measured at 546ms for a 40k-character root against
+  0ms for the scan that replaces it. Caught by CodeQL (`js/polynomial-redos`) before release; same
+  class as the step-marker parser fixed in 0.1.1.
+- **Fixed: `TIDEN_FALLBACK` was silently ignored.** It was declared in `EnvEnum`, `EnvType` and the
+  env validation schema, but `envToConfig` never mapped it into `ConfigType` — so the value
+  validated and was then dropped. It decides what happens when `tiden` mode cannot start, which is
+  the disable path below.
+- **A reporter that stops MID-RUN says so too.** `FallbackCoordinator.disable()` turned reporting
+  off after an upstream (and fallback) failure while logging only the error, not the consequence:
+  the suite carried on, every later result went nowhere, and the run ended green. A present-but-
+  rejected token reached the same silent failure as a missing one by a different path.
+- **The credential list is no longer appended to every disabled message.** It is stated where a
+  missing setting is a live suspect, and omitted where the error above is the answer — a message
+  padded with the same tail every time stops being read.
+- **`buildReporters` says why it disabled the reporter.** Both disabling paths — a config
+  `mode`/`fallback` of `off`, and a `tiden` mode that cannot start because one of the four
+  required settings is missing — used to set `disabled = true` with no output. A disabled reporter
+  is indistinguishable from a working one, which cost a user an hour. Each branch now announces
+  itself through `logReporterDisabled`, naming the reason, the remedy, and the credentials
+  `createRunReporter` requires. Deliberately `logger.log`, not `logDebug`.
+
+## 0.1.1
+
+- **Fixed a polynomial ReDoS in `extractAndCleanStep`** (CodeQL `js/polynomial-redos`, high).
+  Its single regex spanned both the `TidenExpRes:` and `TidenData:` markers and needed an
+  ambiguous `\s*:?\s*` prefix: for a run of N spaces there are O(N) ways to split them across
+  the two `\s*`, so a step name containing a long run of spaces backtracked polynomially.
+  Replaced with index-based slicing, matching what upstream `qase-javascript-commons` moved to.
+- Two bugs fixed along the way: a single marker with no counterpart was silently ignored (the
+  old regex required both), and `.` dropped multiline marker values.
+
 ## 0.1.0
 
 Initial Tiden fork release of `@tiden/reporter-commons`.

package/README.md

@@ -9,7 +9,7 @@ See the [root README](https://github.com/qase-tms/tiden-javascript/blob/main/REA
 ## Who uses this
 
 This package is **not meant to be installed or configured directly** in a test project — it's a
-dependency of framework-specific reporters (currently [`@tiden/playwright-reporter`](https://github.com/qase-tms/tiden-javascript/blob/main/playwright/README.md)).
+dependency of framework-specific reporters ([`@tiden/playwright-reporter`](https://github.com/qase-tms/tiden-javascript/blob/main/playwright/README.md), [`@tiden/vitest-reporter`](https://github.com/qase-tms/tiden-javascript/blob/main/vitest/README.md), and [`@tiden/jest-reporter`](https://github.com/qase-tms/tiden-javascript/blob/main/jest/README.md)).
 Install and configure the reporter for your framework instead; it composes this package's config
 loader, env resolver, and API transport internally.
 

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

@@ -32,6 +32,10 @@ export declare const configValidationSchema: {
             type: string;
             nullable: boolean;
         };
+        rootDir: {
+            type: string;
+            nullable: boolean;
+        };
         statusMapping: {
             type: string;
             nullable: boolean;

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

@@ -35,6 +35,10 @@ exports.configValidationSchema = {
             type: 'string',
             nullable: true,
         },
+        rootDir: {
+            type: 'string',
+            nullable: true,
+        },
         statusMapping: {
             type: 'object',
             nullable: true,

package/dist/env/env-enum.d.ts

@@ -8,6 +8,7 @@ export declare enum EnvEnum {
     environment = "TIDEN_ENVIRONMENT",
     captureLogs = "TIDEN_CAPTURE_LOGS",
     rootSuite = "TIDEN_ROOT_SUITE",
+    rootDir = "TIDEN_ROOT_DIR",
     statusMapping = "TIDEN_STATUS_MAPPING"
 }
 /**

package/dist/env/env-enum.js

@@ -12,6 +12,7 @@ var EnvEnum;
     EnvEnum["environment"] = "TIDEN_ENVIRONMENT";
     EnvEnum["captureLogs"] = "TIDEN_CAPTURE_LOGS";
     EnvEnum["rootSuite"] = "TIDEN_ROOT_SUITE";
+    EnvEnum["rootDir"] = "TIDEN_ROOT_DIR";
     EnvEnum["statusMapping"] = "TIDEN_STATUS_MAPPING";
 })(EnvEnum || (exports.EnvEnum = EnvEnum = {}));
 /**

package/dist/env/env-to-config.js

@@ -9,10 +9,16 @@ const writer_1 = require("../writer");
  */
 const envToConfig = (env) => ({
     mode: env[env_enum_1.EnvEnum.mode],
+    // TIDEN_FALLBACK was declared in EnvEnum, EnvType and the validation schema
+    // but never mapped here, so setting it did nothing: the value validated, then
+    // vanished. It decides what happens when `tiden` mode cannot start, which is
+    // exactly the silent-disable path the reporter now announces.
+    fallback: env[env_enum_1.EnvEnum.fallback],
     debug: env[env_enum_1.EnvEnum.debug],
     environment: env[env_enum_1.EnvEnum.environment],
     captureLogs: env[env_enum_1.EnvEnum.captureLogs],
     rootSuite: env[env_enum_1.EnvEnum.rootSuite],
+    rootDir: env[env_enum_1.EnvEnum.rootDir],
     statusMapping: env[env_enum_1.EnvEnum.statusMapping] ?
         Object.fromEntries(env[env_enum_1.EnvEnum.statusMapping].split(',').map(item => {
             const [from, to] = item.split('=');

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

@@ -8,6 +8,7 @@ export interface EnvType {
     [EnvEnum.environment]?: string;
     [EnvEnum.captureLogs]?: boolean;
     [EnvEnum.rootSuite]?: string;
+    [EnvEnum.rootDir]?: string;
     [EnvEnum.statusMapping]?: string;
     [EnvTidenEnum.product]?: string;
     [EnvTidenEnum.uploadAttachments]?: boolean;

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

@@ -36,6 +36,10 @@ exports.envValidationSchema = {
             type: 'string',
             nullable: true,
         },
+        [env_enum_1.EnvEnum.rootDir]: {
+            type: 'string',
+            nullable: true,
+        },
         [env_enum_1.EnvEnum.statusMapping]: {
             type: 'string',
             nullable: true,

package/dist/internal/index.d.ts

@@ -6,3 +6,5 @@ export type { FileSuiteNode } from './suite-file';
 export { parseTidenIdsFromString } from './ids-parser';
 export { filterPositiveIds } from './filter-positive-ids';
 export { normalizeSuitePart } from './suite-normalizer';
+export { normalizeSpecPath } from './spec-path';
+export { resolveRootDir } from './spec-path';

package/dist/internal/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeSuitePart = exports.filterPositiveIds = exports.parseTidenIdsFromString = exports.getFile = exports.extractAndCleanStep = exports.removeTidenIdsFromTitle = void 0;
+exports.resolveRootDir = exports.normalizeSpecPath = exports.normalizeSuitePart = exports.filterPositiveIds = exports.parseTidenIdsFromString = exports.getFile = exports.extractAndCleanStep = exports.removeTidenIdsFromTitle = void 0;
 var title_1 = require("./title");
 Object.defineProperty(exports, "removeTidenIdsFromTitle", { enumerable: true, get: function () { return title_1.removeTidenIdsFromTitle; } });
 var step_parser_1 = require("./step-parser");
@@ -13,3 +13,7 @@ var filter_positive_ids_1 = require("./filter-positive-ids");
 Object.defineProperty(exports, "filterPositiveIds", { enumerable: true, get: function () { return filter_positive_ids_1.filterPositiveIds; } });
 var suite_normalizer_1 = require("./suite-normalizer");
 Object.defineProperty(exports, "normalizeSuitePart", { enumerable: true, get: function () { return suite_normalizer_1.normalizeSuitePart; } });
+var spec_path_1 = require("./spec-path");
+Object.defineProperty(exports, "normalizeSpecPath", { enumerable: true, get: function () { return spec_path_1.normalizeSpecPath; } });
+var spec_path_2 = require("./spec-path");
+Object.defineProperty(exports, "resolveRootDir", { enumerable: true, get: function () { return spec_path_2.resolveRootDir; } });

package/dist/internal/spec-path.d.ts

@@ -0,0 +1,12 @@
+export declare function normalizeSpecPath(fullPath: string, cwd?: string): string;
+/**
+ * The base a spec-file segment is resolved against, in precedence order:
+ * an explicit `rootDir` option, then `TIDEN_ROOT_DIR`, then undefined
+ * (meaning `normalizeSpecPath` falls back to `process.cwd()`).
+ *
+ * Env is read here rather than through the usual config pipeline because that
+ * pipeline merges env inside `OptionsResolver`, whose result never reaches a
+ * framework reporter — so a framework-side setting would silently ignore its
+ * own environment variable.
+ */
+export declare function resolveRootDir(explicit?: string | undefined): string | undefined;

package/dist/internal/spec-path.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSpecPath = normalizeSpecPath;
+exports.resolveRootDir = resolveRootDir;
+const env_enum_1 = require("../env/env-enum");
+/**
+ * Normalizes an absolute spec-file path to a project-relative one, for use as
+ * the leading segment of a case signature.
+ *
+ * Kept as a SINGLE segment with its slashes intact — it is not split on `/`.
+ * That matches Playwright's `titlePath()` (which yields the spec file as one
+ * element) and the app-side vitest CI transform, so a case reported by the
+ * reporter and the same case reported by CI resolve to one identity.
+ *
+ * Path-shaped only: no filesystem access, and an id that does not live under
+ * `cwd` (a Vite virtual module, for instance) is returned unchanged rather
+ * than forced into a relative form.
+ */
+const SLASH = '/'.charCodeAt(0);
+function normalizeSpecPath(fullPath, cwd = process.cwd()) {
+    const normalized = fullPath.replace(/\\/g, '/');
+    const root = rootPrefix(cwd);
+    return normalized.startsWith(root) ? normalized.slice(root.length) : normalized;
+}
+/**
+ * The root as a `/`-terminated prefix, with any trailing slashes collapsed to
+ * exactly one.
+ *
+ * Trimmed by scanning rather than with `/\/+$/`: that pattern backtracks
+ * quadratically on a root of many slashes, and the root can come from
+ * configuration (`rootDir` / `TIDEN_ROOT_DIR`). Same class of defect as the
+ * step-marker parser fixed in commons 0.1.1 — keep this regex-free.
+ */
+function rootPrefix(cwd) {
+    const normalized = cwd.replace(/\\/g, '/');
+    let end = normalized.length;
+    while (end > 0 && normalized.charCodeAt(end - 1) === SLASH) {
+        end -= 1;
+    }
+    return normalized.slice(0, end) + '/';
+}
+/**
+ * The base a spec-file segment is resolved against, in precedence order:
+ * an explicit `rootDir` option, then `TIDEN_ROOT_DIR`, then undefined
+ * (meaning `normalizeSpecPath` falls back to `process.cwd()`).
+ *
+ * Env is read here rather than through the usual config pipeline because that
+ * pipeline merges env inside `OptionsResolver`, whose result never reaches a
+ * framework reporter — so a framework-side setting would silently ignore its
+ * own environment variable.
+ */
+function resolveRootDir(explicit) {
+    const fromEnv = process.env[env_enum_1.EnvEnum.rootDir];
+    return explicit ?? (fromEnv !== undefined && fromEnv !== '' ? fromEnv : undefined);
+}

package/dist/internal/step-parser.d.ts

@@ -7,5 +7,10 @@ export interface ExtractedStep {
  * Parses a step string for inline `TidenExpRes:` (expected result) and `TidenData:`
  * (data) markers. Returns the extracted parts and the input string with markers
  * removed. If no markers are present, returns nulls and the original string.
+ *
+ * Index-based rather than regex-matched: a single pattern spanning both markers
+ * needs an ambiguous `\s*:?\s*` prefix, which backtracks polynomially on a step
+ * name containing a long run of spaces (CodeQL js/polynomial-redos). Slicing is
+ * linear, and it also keeps multiline marker values intact, which `.` did not.
  */
 export declare function extractAndCleanStep(input: string): ExtractedStep;

package/dist/internal/step-parser.js

@@ -1,28 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractAndCleanStep = extractAndCleanStep;
+const EXPECTED_RESULT_MARKER = 'TidenExpRes:';
+const DATA_MARKER = 'TidenData:';
+/**
+ * Drops the marker's optional second colon and the surrounding whitespace, so
+ * that both `TidenExpRes: value` and `TidenExpRes:: value` yield `value`.
+ *
+ * Anchored and always matchable, so it cannot backtrack.
+ */
+function readMarkerValue(raw) {
+    return raw.replace(/^\s*:?\s*/, '').trim();
+}
 /**
  * Parses a step string for inline `TidenExpRes:` (expected result) and `TidenData:`
  * (data) markers. Returns the extracted parts and the input string with markers
  * removed. If no markers are present, returns nulls and the original string.
+ *
+ * Index-based rather than regex-matched: a single pattern spanning both markers
+ * needs an ambiguous `\s*:?\s*` prefix, which backtracks polynomially on a step
+ * name containing a long run of spaces (CodeQL js/polynomial-redos). Slicing is
+ * linear, and it also keeps multiline marker values intact, which `.` did not.
  */
 function extractAndCleanStep(input) {
-    let expectedResult = null;
-    let data = null;
-    let cleanedString = input;
-    const hasExpectedResult = input.includes('TidenExpRes:');
-    const hasData = input.includes('TidenData:');
-    if (hasExpectedResult || hasData) {
-        const regex = /TidenExpRes:\s*:?\s*(.*?)\s*(?=TidenData:|$)TidenData:\s*:?\s*(.*)?/;
-        const match = input.match(regex);
-        if (match) {
-            expectedResult = match[1]?.trim() ?? null;
-            data = match[2]?.trim() ?? null;
-            cleanedString = input
-                .replace(/TidenExpRes:\s*:?\s*.*?(?=TidenData:|$)/, '')
-                .replace(/TidenData:\s*:?\s*.*/, '')
-                .trim();
-        }
+    const expectedResultIndex = input.indexOf(EXPECTED_RESULT_MARKER);
+    const dataIndex = input.indexOf(DATA_MARKER);
+    if (expectedResultIndex === -1 && dataIndex === -1) {
+        return { expectedResult: null, data: null, cleanedString: input };
     }
-    return { expectedResult, data, cleanedString };
+    // Each marker's value runs until the next marker, or to the end of the input.
+    const expectedResultEnd = dataIndex > expectedResultIndex ? dataIndex : input.length;
+    const dataEnd = expectedResultIndex > dataIndex ? expectedResultIndex : input.length;
+    const expectedResult = expectedResultIndex === -1
+        ? null
+        : readMarkerValue(input.slice(expectedResultIndex + EXPECTED_RESULT_MARKER.length, expectedResultEnd));
+    const data = dataIndex === -1
+        ? ''
+        : readMarkerValue(input.slice(dataIndex + DATA_MARKER.length, dataEnd));
+    const markerIndexes = [expectedResultIndex, dataIndex].filter((index) => index !== -1);
+    return {
+        expectedResult,
+        // an omitted data value stays `null`, matching the long-standing contract
+        data: data === '' ? null : data,
+        cleanedString: input.slice(0, Math.min(...markerIndexes)).trim(),
+    };
 }

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

@@ -25,6 +25,17 @@ export type OptionsType = {
     debug?: boolean | undefined;
     environment?: string | undefined;
     rootSuite?: string | undefined;
+    /**
+     * Base directory the spec-file segment of a case signature is resolved
+     * against. Defaults to `process.cwd()`.
+     *
+     * Set it when the runner's working directory is not the root you want that
+     * segment measured from — a monorepo running vitest from a sub-package, for
+     * instance. The signature is matched byte-for-byte server-side, so every
+     * producer reporting into one product must agree on this base or the same
+     * test lands as two cases.
+     */
+    rootDir?: string | undefined;
     statusMapping?: Record<string, string> | undefined;
     logging?: RecursivePartial<LoggingOptionsType> | undefined;
     tiden?: RecursivePartial<TidenOptionsType> | undefined;

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

@@ -41,6 +41,16 @@ export declare class FallbackCoordinator {
      * disabled or the operation produced no value.
      */
     run<T>(op: (reporter: InternalReporterInterface) => Promise<T>, opName: string): Promise<T | undefined>;
+    /**
+     * Turning the reporter off MID-RUN, after an upstream (and fallback) failure.
+     *
+     * The failure itself is logged by the caller, but the consequence was not:
+     * the suite carried on, every later result went nowhere, and the run ended
+     * green. That is the same silent-failure symptom the construction-time
+     * announcements in `tiden.ts` were added to remove, reached by a different
+     * path — a token that is present but rejected, rather than one that is
+     * missing. Guarded by `this.disabled`, so it says it once.
+     */
     private disable;
     private activateFallback;
     private runOnFallback;

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

@@ -83,10 +83,22 @@ class FallbackCoordinator {
             return this.runOnFallback(op, opName);
         }
     }
+    /**
+     * Turning the reporter off MID-RUN, after an upstream (and fallback) failure.
+     *
+     * The failure itself is logged by the caller, but the consequence was not:
+     * the suite carried on, every later result went nowhere, and the run ended
+     * green. That is the same silent-failure symptom the construction-time
+     * announcements in `tiden.ts` were added to remove, reached by a different
+     * path — a token that is present but rejected, rather than one that is
+     * missing. Guarded by `this.disabled`, so it says it once.
+     */
     disable() {
         if (this.disabled)
             return;
         this.disabled = true;
+        this.logger.log('reporter disabled — the error above stopped it mid-run, and nothing further ' +
+            'from this suite will be reported to Tiden. Results already sent are unaffected.');
         if (!this.onDisabledFired) {
             this.onDisabledFired = true;
             this.callbacks.onDisabled?.();

package/dist/tiden.d.ts

@@ -31,6 +31,17 @@ export declare class TidenReporter implements ReporterInterface {
      */
     private constructor();
     private buildLogger;
+    /**
+     * Announces that this reporter will send nothing, and why.
+     *
+     * A disabled reporter is indistinguishable from a working one: the suite
+     * runs, the tests pass, and nothing is reported. A field user concluded the
+     * reporter was broken and spent an hour on it before finding `mode: 'off'`
+     * in their own jest.config.js — the reporter was merely inert, and had said
+     * so nowhere. This is deliberately `log`, not `logDebug`: a message only
+     * visible once you already suspect the problem does not solve it.
+     */
+    private logReporterDisabled;
     private buildReporters;
     private persistInitialState;
     static getInstance(options: OptionsType): TidenReporter;

package/dist/tiden.js

@@ -87,6 +87,28 @@ class TidenReporter {
         }
         return new logger_1.Logger(opts);
     }
+    /**
+     * Announces that this reporter will send nothing, and why.
+     *
+     * A disabled reporter is indistinguishable from a working one: the suite
+     * runs, the tests pass, and nothing is reported. A field user concluded the
+     * reporter was broken and spent an hour on it before finding `mode: 'off'`
+     * in their own jest.config.js — the reporter was merely inert, and had said
+     * so nowhere. This is deliberately `log`, not `logDebug`: a message only
+     * visible once you already suspect the problem does not solve it.
+     */
+    logReporterDisabled(reason, remedy, credentialsRelevant = false) {
+        // The credentials sentence is opt-in, not a suffix on every message. Telling
+        // someone who set `mode: "off"` on purpose that "tiden" mode needs an API
+        // token answers a question they did not ask, and padding every message with
+        // the same tail is how a message stops being read.
+        const credentials = credentialsRelevant
+            ? ' "tiden" mode also requires tiden.api.token, tiden.product and' +
+                ' tiden.api.baseUrl (TIDEN_API_TOKEN, TIDEN_PRODUCT_ID, TIDEN_BASE_URL).'
+            : '';
+        this.logger.log(`reporter disabled — nothing will be reported to Tiden, because ${reason}. ` +
+            `To enable it, ${remedy}.${credentials}`);
+    }
     buildReporters(factory, resolved) {
         let upstream;
         let fallbackReporter;
@@ -98,11 +120,15 @@ class TidenReporter {
         catch (error) {
             if (error instanceof disabled_exception_1.DisabledException) {
                 disabled = true;
+                this.logReporterDisabled(`mode is "${resolved.effectiveMode}"`, 'set mode to "tiden" (or TIDEN_MODE=tiden) to report this run', 
+                // Enabling it is the next thing they will do, and it needs all four.
+                true);
             }
             else {
                 this.logger.logError('Unable to create upstream reporter:', error);
                 if (resolved.composed.fallback === undefined) {
                     disabled = true;
+                    this.logReporterDisabled('the upstream reporter could not be created and no fallback is configured', 'fix the error above');
                     return { upstream, fallback: fallbackReporter, disabled, useFallbackFromStart: false };
                 }
                 upstreamFailed = true;
@@ -113,13 +139,18 @@ class TidenReporter {
         }
         catch (error) {
             if (error instanceof disabled_exception_1.DisabledException) {
-                if (upstreamFailed)
+                if (upstreamFailed) {
                     disabled = true;
+                    this.logReporterDisabled('the upstream reporter could not be created (see the error above) and ' +
+                        `fallback is "${resolved.effectiveFallback}"`, 'fix the error above, or set a fallback mode', true);
+                }
             }
             else {
                 this.logger.logError('Unable to create fallback reporter:', error);
-                if (upstreamFailed && upstream === undefined)
+                if (upstreamFailed && upstream === undefined) {
                     disabled = true;
+                    this.logReporterDisabled('neither the upstream nor the fallback reporter could be created', 'fix the errors above');
+                }
             }
         }
         const useFallbackFromStart = upstreamFailed && fallbackReporter !== undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiden/reporter-commons",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Tiden JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",