@testomatio/reporter 2.3.9 → 2.4.0

package/src/pipe/coverage.js

@@ -0,0 +1,440 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { execSync } from 'child_process';
+import { Gaxios } from 'gaxios';
+import { minimatch } from 'minimatch';
+import { APP_PREFIX, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
+import { generateFilterRequestParams } from '../utils/pipe_utils.js';
+import { parsePipeOptions } from '../utils/pipe_utils.js';
+import { config } from '../config.js';
+import createDebugMessages from 'debug';
+
+const debug = createDebugMessages('@testomatio/reporter:pipe:csv');
+
+// Example of use 'coverage:file=coverage/coverage.yml,diff=master' cmd:
+// | Option | Git command | Notes |
+// | --- | --- | --- |
+// | --filter "coverage:file=coverage/coverage.yml,diff=new-branch" | ✅ git diff new-branch --name-only | - |
+// | --filter "coverage:diff=master,file=coverage.yml" | ✅ git diff master --name-only | - |
+// | --filter "coverage:file=coverage/coverage.yml" | ✅ git diff master --name-only | default branch = "master" |
+// | --filter "coverage:file=coverage.yml,dif=noexist-branch" | ❌ Git command failed ...| - |
+// | --filter "coverage:file=coverage.yml,diff=noexist-branch" | ❌ Git command failed ...| because no branch found |
+// | --filter "coverage:file=no-exist-coverage.yml" | ❌ Coverage file not found: <>filename>.yml | - |
+// | --filter "coverage:filepath=coverage.yml" | 🚫 Missing required parameter: "file"... | - |
+// | --filter "coverage:diff=my-branch" | 🚫 Missing required parameter: "file"...| - |
+
+//maybe GitChanges or GitCoverage
+class CoveragePipe { // or Changes for the future???
+    #GIT = {
+        default_branch: 'master',
+        diff_command: 'git diff',
+        only_file_opt: '--name-only',
+        uncommitted_marker: 'uncommitted',
+        // test_defaultGitChangedFile - uses only for unit tests in "coverage_pipe_test.js" file
+        test_defaultGitChangedFile: ['todomvc-tests/edit-todos_test.js'],
+    };
+
+    constructor(params, store) {
+        this.id = 'coverage'; // as future updates -> find by id in client.js
+        this.store = store || {};
+        this.branch = undefined;
+        this.isDefaultGitChanges = false; // COVERAGE_BY_DEFAULT_GIT_FILE env uses only for unit tests
+        this.isEnabled = false;
+
+        const { pipeOptions } = params;
+        const options = parsePipeOptions(pipeOptions || "");
+        debug("Pipe options", options);
+
+        // this.isDefaultGitChanges - COVERAGE_BY_DEFAULT_GIT_FILE env uses only for unit tests
+        this.isDefaultGitChanges = process.env.COVERAGE_BY_DEFAULT_GIT_FILE === '1'? true : false;
+        this.coverageFilePath = options?.file || process.env.COVERAGE_FILEPATH || undefined ;
+
+        if (!this.coverageFilePath) return;
+
+        this.branch = options?.diff || process.env.COVERAGE_BRANCH || this.#GIT.default_branch;
+        this.isBranchDefault = !options.diff && !process.env.COVERAGE_BRANCH;
+        
+        if (this.isBranchDefault) {
+            console.log(
+                APP_PREFIX,
+                `🟡 No "diff" branch provided. That's why we use default one = "${this.branch}".\n` +
+                '👉 You can set it via --filter "coverage:file=coverage.yml,diff=your-branch"'
+            );
+        }
+
+        // Client config section
+        this.formattedDate = new Date().toISOString().replace(/T/, '-').replace(/:/g, '-').split('.')[0];
+        this.title = process.env.TESTOMATIO_TITLE || `Testomatio Coverage Test Execution - ${this.formattedDate}`;
+        this.apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config.TESTOMATIO;
+
+        this.url = params.testomatioUrl || process.env.TESTOMATIO_URL || 'https://app.testomat.io';
+        const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY || null;
+        const proxy = proxyUrl ? new URL(proxyUrl) : null;
+
+        // Create a new instance of gaxios with a custom config
+        this.client = new Gaxios({
+            baseURL: `${this.url.trim()}`,
+            timeout: AXIOS_TIMEOUT,
+            proxy: proxy ? proxy.toString() : undefined,
+            retry: true,
+            retryConfig: {
+            retry: REPORTER_REQUEST_RETRIES.retriesPerRequest,
+            retryDelay: REPORTER_REQUEST_RETRIES.retryTimeout,
+            httpMethodsToRetry: ['GET','PUT','HEAD','OPTIONS','DELETE','POST'],
+            shouldRetry: (error) => {
+                if (!error.response) return false;
+                switch (error.response?.status) {
+                case 400: // Bad request (probably wrong API key)
+                case 404: // Test not matched
+                case 429: // Rate limit exceeded
+                case 500: // Internal server error
+                    return false;
+                default:
+                    break;
+                }
+                return error.response?.status >= 401; // Retry on 401+ and 5xx
+            }
+            }
+        });
+
+        // In case if we have all needed data 
+        this.isEnabled = true;
+
+        debug('Coverage Pipe initialized', {
+            branch: this.branch,
+            coverageFilePath: this.coverageFilePath,
+        });
+
+        this.parsedCoverage = {};
+        this.changedFiles = [];
+        this.matchedLines = new Set();        
+        this.tests = new Set();
+        this.suiteIds = new Set();
+        this.tagLabels = new Set();
+
+        this.results = [];
+
+        debug(`Coverage Pipe: is Enabled = ${this.isEnabled}`);
+    }
+
+    async prepareRun(opts) {       
+        // Reset internal mutable state for isolation
+        this.tests.clear();
+        this.suiteIds.clear();
+        this.tagLabels.clear();
+        this.results = [];
+
+        if (!this.isEnabled) return [];
+
+        // Step 1: Validate coverage file path & Git changes & Coverage parsing
+        if (!this.getGitChangedFiles()?.validateCoverageFile()?.parseCoverageFile()) return [];
+
+        // Step 2: Extract all available tests and compare with coverage file
+        const lines = await this.extractRelevantTestsFromChanges();
+
+        if (lines.size === 0) {
+            console.log(APP_PREFIX, 'ℹ️  No matching entries in coverage file for provided Git changes.');
+            return [];
+        }
+
+        // Step 3: Handle tag labels tests from the server
+        // if (this.tagLabels && this.tagLabels.size > 0) { //TODO: in case if we add labels in future!!!
+        if (this.tagLabels.size > 0) {
+            for (const tag of this.tagLabels) {
+                const tagType = 'tag';
+                const tests = await this.#getTestomatioTestsByParam(tagType, tag);
+
+                if (!tests) return [];
+
+                console.log(
+                    APP_PREFIX, 
+                    `✅ We found ${tests.length === 1 ? 'one entry' : `${tests.length} (test/suite) entries`}` +
+                    ' in Testomat.io service side.'
+                );
+                
+                tests.forEach(testId => this.tests.add(testId));
+            }  
+        }
+
+        if (this.tests.size === 0) {
+            console.log(APP_PREFIX, 'ℹ️  No tests found for execution based on Git changes.');            
+            return [];
+        }
+
+        this.results = [...this.tests];
+        
+        return this.results;
+    }
+
+    addTest(data) {}
+
+    async createRun() {}
+
+    updateRun() {}
+
+    async finishRun(runParams) {}
+
+    toString() {
+        return 'Coverage Reporter';
+    }
+
+    /**
+     * Fetches a list of tests from the Testomat.io server based on a given filter parameter.
+     *
+     * The method parses the provided filter (`type=id`), builds the appropriate request parameters,
+     * sends a GET request to the Testomat.io `/api/test_grep` endpoint, and returns the matching tests.
+     *
+     * If the filter is invalid, no query is generated, or the server responds with no matching tests,
+     * it logs relevant information and returns `undefined`.
+     *
+     * @async function
+     * @param {string} type - The filter string in the format like `tag-name` for tag by.
+     * @param {string} id - The filter string in the format like `smoke`.
+     * @returns {Promise<Array<Object>|undefined>} Resolves to an array of test objects if found, otherwise `undefined`.
+     */
+    async #getTestomatioTestsByParam(type, id) {
+        // Get tests from the server
+        try {
+            const q = generateFilterRequestParams({
+                type,
+                id,
+                apiKey: this?.apiKey?.trim(),
+            });
+
+            if (!q) {
+                return;
+            }
+
+            const resp = await this.client.request({
+                method: 'GET',
+                url: '/api/test_grep',
+                ...q,
+            });
+
+            if (!Array.isArray(resp.data?.tests) && resp.data?.tests?.length === 0) {
+                console.log(APP_PREFIX, `🔍 No test by ${type}=${id} were found on the Testomat.io server side!`);
+                
+                return undefined;
+            }
+
+            return resp.data.tests;
+        } 
+        catch (err) {
+            console.error(
+                APP_PREFIX,
+                `🚩 Error getting available tests from the Testomat.io by "test_grep" option: ${err}`
+            );
+            
+            return undefined;
+        }
+    }
+
+    /**
+     * Executes a Git command to retrieve a list of changed files.
+     *
+     * @param {string} cmd - The Git command to execute.
+     * @returns {string[]} An array of changed file paths. Returns an empty array if an error occurs
+     * (e.g., not a Git repository or command failure).
+     */
+    #getChangedFilesFromGit(cmd) {
+        try {
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore']
+            });
+    
+            return result
+                .split('\n')
+                .map(f => f.trim())
+                .filter(Boolean);
+        } 
+        catch (err) {
+            const errorMessage = err.message || '';
+            // Git edge: Not a git repository or other error
+            if (errorMessage.includes('Not a git repository')) {
+                console.error(APP_PREFIX, '❌ Error: This folder is not a Git repository.');
+            } 
+            else {
+                throw new Error(`❌ Git command failed ("${cmd}"):\n`, errorMessage);
+            }
+    
+            return [];
+        }
+    }
+
+    /**
+     * Builds a Git command string to list file changes between the current state 
+     * and a specified Git branch using `git diff --name-only`.
+     * 
+     * Private pipe function
+     * @throws {Error} Throws an error if `this.branch` is not defined.
+     * @returns {string} A Git command string, e.g., 'git diff <branch> --name-only'.
+     */
+    #buildGitCommand() {
+        if (!this.branch) throw new Error(`❌ Invalid changes option for setted branch!`);
+        
+        return `git diff ${this.branch} --name-only`; // Example: 'git diff <master> --name-only' 
+    }
+
+    /**
+     * Retrieves the list of files changed in the current Git working directory 
+     * compared to a specified branch.
+     *
+     * This method builds a Git diff command and attempts to retrieve the changed 
+     * files using that command. It logs helpful information and errors during the process.
+     *
+     * If no changed files are found, or an error occurs at any stage, the method logs 
+     * the issue and returns `undefined`.
+     *
+     * @returns {this | undefined} Returns the current instance (`this`) if changed files are found;
+     * otherwise, returns `undefined`.
+     */
+    getGitChangedFiles() {
+        let cmd;
+
+        try {
+            cmd = this.#buildGitCommand();
+        } 
+        catch (err) {
+            console.error(APP_PREFIX, err.message);
+            return undefined;
+        }
+        
+        console.error(APP_PREFIX, `ℹ️  We will use '${cmd}' Git command.`);
+
+        try {
+            // For clear unit testing process -> Like test_defaultGitChangedFile = todomvc-tests/edit-todos_test.js
+            if (this.isDefaultGitChanges) {
+                this.changedFiles = this.#GIT.test_defaultGitChangedFile;
+            }
+            else {
+                this.changedFiles =  this.#getChangedFilesFromGit(cmd);
+
+                if (this.changedFiles.length === 0) {
+                    console.log(
+                        APP_PREFIX,
+                        'ℹ️  No files changed in the latest Git commit. Skipping coverage processing.'
+                    );
+
+                    return undefined;
+                }
+            }
+        }
+        catch (err) {
+            console.error(APP_PREFIX, err.message);
+            console.error(APP_PREFIX, "🔍 Pls, check this Git command manually to understand the original problem.");
+            return undefined;
+        }        
+
+        console.log(APP_PREFIX, `📑  GIT changed files:\n  - ${this.changedFiles.join('\n  - ')}`);        
+        return this;
+    }
+
+    /**
+     * Validates the coverage file path (stored in `this.coverageFilePath`).
+     *
+     * This method checks:
+     * - That the file exists on disk.
+     * - That it is a regular file (not a directory or special file).
+     * - That it has a `.yml` extension to ensure it's a YAML file.
+     *
+     * Logs descriptive error messages for any failures.
+     *
+     * @returns {this | undefined} "true" in case if coverage file is valid and we can keep going;
+     * otherwise, `undefined`.
+     */
+    validateCoverageFile() {
+        // Validate the presence of the coverage filepath
+        if (!fs.existsSync(this.coverageFilePath)) {
+            console.log(APP_PREFIX, '❌ Coverage file not found:', this.coverageFilePath);
+            return undefined;
+        }
+
+        // Ensure the given path is a file (not a directory or other type)
+        const stat = fs.statSync(this.coverageFilePath);
+        if (!stat.isFile()) {
+            console.log(APP_PREFIX, '❌ Provided coverage path is not a file:', this.coverageFilePath);
+            return undefined;
+        }
+
+        // Validate the file extension to be ".yml" to ensure it's a YAML file
+        if (path.extname(this.coverageFilePath) !== ".yml") {
+            console.log(APP_PREFIX, '❌ Coverage file must have a .yml extension:', this.coverageFilePath);
+            return undefined;
+        }
+
+        debug('Coverage file validation is OK!');
+
+        return this;
+    }
+
+    /**
+     * Parses the YAML coverage file (located at `this.coverageFilePath`) into a JavaScript object.
+     *
+     * - Reads the file content using UTF-8 encoding.
+     * - Parses it as YAML using the `yaml` library.
+     * - Stores the result in `this.parsedCoverage`.
+     * - If parsing fails, logs an error and returns `undefined`.
+     *
+     * @returns {this | undefined} The current parsed coverage yml file change lines, or "undefined" if parsing fails.
+     */
+    parseCoverageFile() {
+        try {
+            // Read the contents of the YAML file and attempt to parse the YAML into a JavaScript object
+            const rawYml = fs.readFileSync(this.coverageFilePath, 'utf8');
+            this.parsedCoverage = yaml.load(rawYml) || {};
+
+            debug(`Coverage filepath = ${this.coverageFilePath})`);
+            console.log(APP_PREFIX, `✅ Coverage file parsed successfully: ${this.coverageFilePath}`);
+
+            return this;
+        }
+        catch (err) {
+            console.error(APP_PREFIX, '❌ Failed to parse YAML:', err.message);
+            return undefined;
+        }
+    }
+
+    /**
+     * Extracts relevant test identifiers from changed files based on coverage mapping.
+     *
+     * Iterates over changed files and matches them against patterns in the parsed coverage data.
+     * For each match, it extracts test IDs or tags and stores them in corresponding sets:
+     * - Test IDs (starting with '@T' or '@S') are stored in `this.tests`
+     * - Tag labels (starting with 'tag:') are stored in `this.tagLabels`
+     * - Matched file paths are stored in `this.matchedLines`
+     *
+     * @returns {Promise <Set<string>>} A set of file paths that matched coverage patterns (`this.matchedLines`).
+     */
+    async extractRelevantTestsFromChanges() {
+        for (const changedFile of this.changedFiles) {
+            for (const [pattern, ids] of Object.entries(this.parsedCoverage)) {
+              if (minimatch(changedFile, pattern)) {
+                this.matchedLines.add(changedFile);
+      
+                ids.forEach(id => {
+                    // Example: "@Tt74099t1"
+                    if (id.startsWith('@T')) {
+                        this.tests.add(id.slice(1));
+                    }
+                    // Example: "@Sd74099c1"
+                    else if (id.startsWith('@S')) {
+                        this.tests.add(id.slice(1));
+                    }
+                    // Example: "tag:@TestSmoke"
+                    else if (id.startsWith('tag')) {
+                        this.tagLabels.add(id.split(':')[1].slice(1));
+                    }
+                });
+              }
+            }
+        }
+
+        debug(`Matched lines: ${this.matchedLines}`);
+
+        return this.matchedLines;
+    }
+}
+
+export default CoveragePipe;

package/src/pipe/index.js

@@ -7,6 +7,7 @@ import GitHubPipe from './github.js';
 import GitLabPipe from './gitlab.js';
 import CsvPipe from './csv.js';
 import HtmlPipe from './html.js';
+import CoveragePipe from './coverage.js';
 import { BitbucketPipe } from './bitbucket.js';
 import { DebugPipe } from './debug.js';
 
@@ -48,6 +49,7 @@ export async function pipesFactory(params, opts) {
     new CsvPipe(params, opts),
     new HtmlPipe(params, opts),
     new BitbucketPipe(params, opts),
+    new CoveragePipe(params, opts),
     new DebugPipe(params, opts),
     ...extraPipes,
   ];

package/src/pipe/testomatio.js

@@ -3,7 +3,12 @@ import pc from 'picocolors';
 import { Gaxios } from 'gaxios';
 import JsonCycle from 'json-cycle';
 import { APP_PREFIX, STATUS, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
-import { isValidUrl, foundedTestLog, readLatestRunId, transformEnvVarToBoolean } from '../utils/utils.js';
+import { isValidUrl, 
+  foundedTestLog, 
+  readLatestRunId, 
+  transformEnvVarToBoolean, 
+  getGitCommitSha 
+} from '../utils/utils.js';
 import { parseFilterParams, generateFilterRequestParams, setS3Credentials } from '../utils/pipe_utils.js';
 import { config } from '../config.js';
 
@@ -46,7 +51,25 @@ class TestomatioPipe {
     this.store = store || {};
     this.title = params.title || process.env.TESTOMATIO_TITLE;
     this.sharedRun = !!process.env.TESTOMATIO_SHARED_RUN;
-    this.sharedRunTimeout = !!process.env.TESTOMATIO_SHARED_RUN_TIMEOUT;
+    this.sharedRunTimeout = process.env.TESTOMATIO_SHARED_RUN_TIMEOUT
+      ? parseInt(process.env.TESTOMATIO_SHARED_RUN_TIMEOUT, 10)
+      : undefined;
+
+    if (this.sharedRunTimeout && !this.sharedRun) {
+      debug('Auto-enabling sharedRun because sharedRunTimeout is set');
+      this.sharedRun = true;
+    }
+
+    if (!this.title && (this.sharedRun || this.sharedRunTimeout)) {
+      const sha = getGitCommitSha();
+      if (sha) {
+        this.title = `Shared Run - ${sha}`;
+        console.log(APP_PREFIX, `🔄 Auto-generated title for shared run: ${this.title}`);
+      } else {
+        console.log(APP_PREFIX, pc.red('Failed to resolve git commit SHA for shared run title.'));
+        console.log(APP_PREFIX, 'Please run the tests inside a Git repository or set TESTOMATIO_TITLE explicitly.');
+      }
+    }
     this.groupTitle = params.groupTitle || process.env.TESTOMATIO_RUNGROUP_TITLE;
     this.env = process.env.TESTOMATIO_ENV;
     this.label = process.env.TESTOMATIO_LABEL;
@@ -129,17 +152,23 @@ class TestomatioPipe {
   async prepareRun(opts) {
     if (!this.isEnabled) return [];
 
-    const { type, id } = parseFilterParams(opts);
+    const clearOptions = parseFilterParams(opts);
+
+    if (!clearOptions) {
+      return [];
+    }
+
+    const { type, id } = clearOptions;
 
     try {
       const q = generateFilterRequestParams({
         type,
         id,
-        apiKey: this.apiKey.trim(),
+        apiKey: this?.apiKey?.trim(),
       });
 
       if (!q) {
-        return;
+        return [];
       }
 
       const resp = await this.client.request({

package/src/reporter-functions.js

@@ -1,3 +1,4 @@
+import { isPlaywright } from './helpers.js';
 import { services } from './services/index.js';
 
 /**
@@ -7,9 +8,7 @@ import { services } from './services/index.js';
  * @returns {void}
  */
 function saveArtifact(data, context = null) {
-  if (process.env.IS_PLAYWRIGHT)
-    throw new Error(`This function is not available in Playwright framework.
-    /Playwright supports artifacts out of the box`);
+  showPlaywrightWarning('artifact', 'Playwright supports artifacts out of the box.');
   if (!data) return;
   services.artifacts.put(data, context);
 }
@@ -20,7 +19,6 @@ function saveArtifact(data, context = null) {
  * @returns {void}
  */
 function logMessage(...args) {
-  if (process.env.IS_PLAYWRIGHT) throw new Error('This function is not available in Playwright framework');
   services.logger._templateLiteralLog(...args);
 }
 
@@ -30,10 +28,10 @@ function logMessage(...args) {
  * @returns {void}
  */
 function addStep(message) {
-  if (process.env.IS_PLAYWRIGHT)
-    throw new Error('This function is not available in Playwright framework. Use playwright steps');
-
   services.logger.step(message);
+  // this is done because Playwright reporter intercepts console logs and then we gather them and show on Testomat
+  // if not console.log, the step message will be lost from reporter
+  if (isPlaywright) console.log(`Step: ${message}`);
 }
 
 /**
@@ -43,8 +41,7 @@ function addStep(message) {
  * @returns {void}
  */
 function setKeyValue(keyValue, value = null) {
-  if (process.env.IS_PLAYWRIGHT)
-    throw new Error('This function is not available in Playwright framework. Use test tag instead.');
+  showPlaywrightWarning('meta', 'Use test annotations instead.');
 
   if (typeof keyValue === 'string') {
     keyValue = { [keyValue]: value };
@@ -59,6 +56,7 @@ function setKeyValue(keyValue, value = null) {
  * @returns {void}
  */
 function setLabel(key, value = null) {
+  showPlaywrightWarning('label', 'Use test tag instead.');
   if (Array.isArray(value)) {
     return value.forEach(label => setLabel(key, label));
   }
@@ -87,6 +85,12 @@ function linkJira(...jiraIds) {
   services.links.put(links);
 }
 
+function showPlaywrightWarning(functionName, recommendation) {
+  if (isPlaywright) {
+    console.warn(`[TESTOMATIO] '${functionName}' function is not supported for Playwright. ${recommendation}`);
+  }
+}
+
 export default {
   artifact: saveArtifact,
   log: logMessage,

package/src/utils/pipe_utils.js

@@ -15,6 +15,7 @@ function setS3Credentials(artifacts) {
   if (artifacts.BUCKET) process.env.S3_BUCKET = artifacts.BUCKET;
   if (artifacts.SESSION_TOKEN) process.env.S3_SESSION_TOKEN = artifacts.SESSION_TOKEN;
   if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1';
+  if (artifacts.stack_artifacts) process.env.TESTOMATIO_STACK_ARTIFACTS = '1';
   // endpoint is not received from the server; and shuld be empty if IAM used (credentails obtained from the testomat)
   process.env.S3_ENDPOINT = artifacts.ENDPOINT || '';
 }
@@ -25,6 +26,12 @@ function setS3Credentials(artifacts) {
  * @returns {Object|null} - An object containing the generated request parameters, or null if the type is invalid.
  */
 function generateFilterRequestParams(params) {
+  // Defensive check: ensure params is an object
+  if (!params || typeof params !== 'object') {
+    console.error(APP_PREFIX, `Invalid parameters provided. Expected an object, got: ${typeof params}`);
+    return;
+  }
+
   const { type, id, apiKey } = params;
 
   if (!type) {
@@ -53,9 +60,13 @@ function generateFilterRequestParams(params) {
  *                   The object has properties "type" and "id".
  */
 function parseFilterParams(opts) {
-  const [type, id] = opts.split('=');
+  const [type, ...idParts] = opts.split('=');
+  const id = idParts.join('=');
+  
   const validType = updateFilterType(type);
 
+  if (!validType) return undefined;
+
   return {
     type: validType,
     id,
@@ -69,6 +80,8 @@ function parseFilterParams(opts) {
  *                            Returns undefined if the type is not valid.
  */
 function updateFilterType(type) {
+  if (!type || typeof type !== 'string') return;
+
   let typeLowerCase = type.toLowerCase();
 
   const filterTypes = ['tag-name', 'plan', 'label', 'jira-ticket'];
@@ -86,7 +99,7 @@ function updateFilterType(type) {
   ];
 
   if (!filterTypes.includes(typeLowerCase)) {
-    console.log(APP_PREFIX, `❗❗❗ Invalid "filter=${type}" start settings! Available option list: ${filterTypes}`);
+    console.log(APP_PREFIX, `❗❗❗ Invalid filter: "${type}" start settings! Available option list: ${filterTypes}`);
     return;
   }
 
@@ -120,4 +133,40 @@ function fullName(t) {
   return line;
 }
 
-export { updateFilterType, parseFilterParams, generateFilterRequestParams, setS3Credentials, statusEmoji, fullName };
+/**
+ * Parses a comma-separated list of key-value pairs into an options object.
+ *
+ * The input string should be formatted as `"key1=value1,key2=value2,..."`.
+ * Whitespace around keys and values is trimmed. If the input is empty or undefined,
+ * an empty object is returned.
+ *
+ * @param {string} [optionsStr] - A comma-separated string of key=value pairs.
+ * @returns {Object} An object mapping option keys to their string values.
+ *
+ * @example
+ * parsePipeOptions('foo=bar,baz=qux');
+ * => Returns: { foo: 'bar', baz: 'qux' }
+ */
+function parsePipeOptions(optionsStr) {
+  const options = {};
+  if (!optionsStr) return options;
+
+  const pairs = optionsStr.split(',');
+  for (const pair of pairs) {
+    const [key, value] = pair.split('=');
+    if (key && value) {
+      options[key.trim()] = value.trim();
+    }
+  }
+  return options;
+}
+
+export { 
+  updateFilterType, 
+  parseFilterParams, 
+  generateFilterRequestParams, 
+  setS3Credentials, 
+  statusEmoji, 
+  fullName,
+  parsePipeOptions
+};