@playq/core 0.2.77

package/src/helper/actions/apiStepDefs.ts

@@ -0,0 +1,80 @@
+import { Given, When, Then } from "@cucumber/cucumber";
+import { api, vars } from "../../global";
+
+/**
+ * API Step Definitions
+ *
+ * Cucumber step patterns for API request and validation actions.
+ * Mirrors the functions in apiRequestActions.ts and apiValidationActions.ts.
+ */
+
+
+Given("Api: Call api -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action: string, config: string, baseUrl: string, options?: string) {
+  await api.callApi(action, config, baseUrl, options);
+});
+
+Given("Api: Get -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action: string, config: string, baseUrl: string, options?: string) {
+  await api.get(action, config, baseUrl, options);
+});
+
+Given("Api: Post -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action: string, config: string, baseUrl: string, options?: string) {
+  await api.post(action, config, baseUrl, options);
+});
+
+Given("Api: Request -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action: string, config: string, baseUrl: string, options?: string) {
+  await api.request(action, config, baseUrl, options);
+});
+
+Given("Api: Put -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action: string, config: string, baseUrl: string, options?: string) {
+  await api.put(action, config, baseUrl, options);
+});
+
+Given("Api: Patch -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action: string, config: string, baseUrl: string, options?: string) {
+  await api.patch(action, config, baseUrl, options);
+});
+
+Given("Api: Delete -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action: string, config: string, baseUrl: string, options?: string) {
+  await api.del(action, config, baseUrl, options);
+});
+
+Given("Api: Send request -method: {param} -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (method: string, action: string, config: string, baseUrl: string, options?: string) {
+  await api.sendRequest(method, action, config, baseUrl, options);
+});
+
+Given("Api: Verify value -actual: {param} -expected: {param} -options: {param}", async function (actual: string, expected: string, options?: string) {
+  await api.verifyValue(actual, expected, options);
+});
+
+Given("Api: Assert value -actual: {param} -expected: {param} -options: {param}", async function (actual: string, expected: string, options?: string) {
+  await api.assertValue(actual, expected, options);
+});
+
+Given("Api: Verify api path value in last response -path: {param} -expected: {param} -options: {param}", async function (path: string, expected: string, options?: string) {
+  await api.verifyPathValue(path, expected, options);
+});
+
+Given("Api: Assert api path value -path: {param} -expected: {param} -options: {param}", async function (path: string, expected: string, options?: string) {
+  await api.assertPathValue(path, expected, options);
+});
+
+Given("Api: Get last response JSON path value -path: {param} -storeTo: {param}", async function (pathExpr: string, varName: string) {
+  const value = await api.getLastResponseJsonPathValue(pathExpr);
+  if (value !== undefined && value !== null) {
+    vars.setValue(varName, String(value));
+  }
+});
+
+Given("Api: Store last response JSON paths to variables -paths: {param} -vars: {param}", async function (paths: string, varsCsv: string) {
+  await api.storeLastResponseJsonPathsToVariables(paths, varsCsv);
+});
+
+Given("Api: Get path value from last response -path: {param} -storeTo: {param}", async function (pathExpr: string, varName: string) {
+  const value = await api.getPathValueFromLastResponse(pathExpr);
+  if (value !== undefined && value !== null) {
+    vars.setValue(varName, String(value));
+  }
+});
+
+Given("Api: Store paths -paths: {param} -vars: {param}", async function (paths: string, varsCsv: string) {
+  await api.storePaths(paths, varsCsv);
+});

package/src/helper/actions/comm/commonActions.ts

@@ -0,0 +1,165 @@
+import { vars, webFixture, logFixture } from "../../../global";
+import { parseLooseJson } from '../../bundle/vars';
+import * as allure from "allure-js-commons";
+
+function isPlaywrightRunner() { return process.env.TEST_RUNNER === 'playwright'; }
+function isCucumberRunner() { return process.env.TEST_RUNNER === 'cucumber'; }
+
+const __allureAny_comm: any = allure as any;
+if (typeof __allureAny_comm.step !== 'function') {
+  __allureAny_comm.step = async (_name: string, fn: any) => await fn();
+}
+
+/**
+ * Comm: Comment -text: {param}
+ * 
+ * Logs a comment with variable substitution to the console.
+ * Useful for adding contextual information to the test log.
+ *
+ * Variables inside the message string (e.g., ${var.username}) will be replaced using `vars.replaceVariables`.
+ *
+ * @param message - The comment or message to log.
+ *
+ * @throws Error if `message` is not a non-empty string.
+ *
+ * @example
+ * Comm: Comment -text: "LAMBDA TEST COMPLETE"
+ */
+export async function comment(message: string) {
+  if (typeof message !== 'string' || message.trim().length === 0) {
+    throw new Error('❌ comment: message must be a non-empty string.');
+  }
+  const formattedMessage = vars.replaceVariables(message);
+
+  if (isPlaywrightRunner()) {
+    await __allureAny_comm.step(
+      `Comm: Comment -text: ${formattedMessage}`,
+      async () => {
+        console.log(`💬 Comment: ${formattedMessage}`);
+      }
+    );
+  } else {
+    console.log(`💬 Comment: ${formattedMessage}`);
+  }
+}
+
+/**
+ * Comm: Store -value: {param} in -variable: {param} -options: {param}
+ *
+ * Stores a value (with optional variable substitution) into a runtime variable.
+ *
+ * Variables inside the value string (e.g., ${var.username}) will be resolved using `vars.replaceVariables`.
+ *
+ * @param value - The value to store (can include variable references).
+ * @param varName - The name of the variable to store the resolved value into.
+ * @param options - Optional string or object with additional parameters (parsed if string). Currently unused but reserved for future logic.
+ *
+ * @throws Error if `varName` is not a non-empty string or `value` is undefined/null.
+ *
+ * @example
+ * Store -value: "${faker.string.alphanumeric({length:4})}" in -variable: "var.centre.code" -options: ""
+ */
+export async function storeValue(value: string, varName: string, options?: string | Record<string, any>) {
+  const options_json = typeof options === 'string' ? parseLooseJson(options) : (options || {});
+  if (typeof varName !== 'string' || varName.trim().length === 0) {
+    throw new Error('❌ storeValue: varName must be a non-empty string.');
+  }
+  if (value === undefined || value === null) {
+    throw new Error('❌ storeValue: value must be provided.');
+  }
+  const resolvedValue = vars.replaceVariables(value);
+
+  if (isPlaywrightRunner()) {
+    await __allureAny_comm.step(
+      `Comm: Store -value: ${resolvedValue} in -variable: ${varName} -options: ${JSON.stringify(options_json)}`,
+      async () => {
+        vars.setValue(varName, resolvedValue);
+      }
+    );
+  } else {
+    vars.setValue(varName, resolvedValue);
+  }
+}
+
+/**
+ * Comm: Attach-Log -message: {param} -mimeType: {param} -msgType: {param}
+ * 
+ * Attach log or message to the test context (Cucumber or Playwright runner).
+ * @param message The message or buffer to attach
+ * @param mimeType The mime type (default: text/plain)
+ * @param msgType Optional label for the attachment (default: "Log").
+ *
+ * If `message` is empty or undefined, a warning is logged and no attachment is made.
+ */
+export async function attachLog(
+  message: string | Buffer,
+  mimeType?: string,
+  msgType?: string
+
+) {
+  if (message === undefined || message === null || (typeof message === 'string' && message.length === 0)) {
+    console.warn('⚠️ attachLog: empty message provided; skipping attachment');
+    return;
+  }
+  if (!mimeType) mimeType = "text/plain";
+  if (!msgType) msgType = "Log";
+
+
+  if (isCucumberRunner()) {
+    const world = webFixture.getWorld();
+    if (world?.attach) {
+      await world.attach(message, mimeType);
+    } else {
+      console.warn("⚠️ No World.attach() available in Cucumber context");
+    }
+  } else if (isPlaywrightRunner()) {
+    try {
+      const anyAllure: any = allure as any;
+      if (typeof anyAllure.attachment === 'function') {
+        anyAllure.attachment(msgType, message, mimeType);
+      } else if (typeof anyAllure.attach === 'function') {
+        anyAllure.attach(msgType || 'Log', message, mimeType);
+      } else {
+        if (typeof message === 'string') console.log(message);
+      }
+    } catch {
+      if (typeof message === 'string') console.log(message);
+    }
+    // await playwrightTest
+    //   .info()
+    //   .attach("Log", { body: message, contentType: mimeType });
+  } else {
+    console.warn("⚠️ attachLog: Unknown runner type");
+  }
+}
+
+/**
+ * Comm: Wait-In-Milli-Seconds -seconds: {param}
+ * 
+ * Pauses execution for a given number of milliseconds.
+ * Logs a message using the test logger if available.
+ *
+ * @param ms - The number of milliseconds to wait.
+ *
+ * @throws Error if `ms` is not a finite number or is negative.
+ *
+ * @example
+ * Comm: Wait-In-Milli-Seconds -seconds: "1000"
+ */
+export async function waitInMilliSeconds(ms: number) {
+  if (typeof ms !== 'number' || !isFinite(ms) || ms < 0) {
+    throw new Error('❌ waitInMilliSeconds: ms must be a non-negative number.');
+  }
+  const logger = logFixture.getLogger?.();
+  const doWait = async () => {
+    logger?.info?.(`⏳ Waiting for ${ms} ms`);
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  };
+  if (isPlaywrightRunner()) {
+    await __allureAny_comm.step(`Comm: Wait-In-Milli-Seconds -seconds: ${ms}`, async () => {
+      await doWait();
+    });
+  } else {
+    await doWait();
+  }
+}

package/src/helper/actions/comm/utilityActions.ts

@@ -0,0 +1,344 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as allure from 'allure-js-commons';
+import { vars, comm } from '../../../global';
+import * as crypto from '../../util/utilities/cryptoUtil';
+import { TOTPHelper } from '../../util/totp/totpHelper';
+
+function isPlaywrightRunner() { return process.env.TEST_RUNNER === 'playwright'; }
+const __allureAny_comm: any = allure as any;
+if (typeof __allureAny_comm.step !== 'function') {
+  __allureAny_comm.step = async (_name: string, fn: any) => await fn();
+}
+
+/**
+ * Comm: Encrypt-Password -text: {param} -options: {param}
+ * 
+ * Encrypts the given text as a password and returns it with a "pwd." prefix.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param options - Optional string or object of additional options (parsed if string).
+ * @returns A string prefixed with "pwd." followed by the encrypted value.
+ *
+ * @throws Error if `encryptText` is not a non-empty string.
+ *
+ */
+export async function encryptPassword(encryptText: string, options?: string | Record<string, any>) {
+  const options_json = typeof options === 'string' ? vars.parseLooseJson(options) : (options || {});
+  if (typeof encryptText !== 'string' || encryptText.length === 0) {
+    throw new Error('❌ encryptPassword: encryptText must be a non-empty string.');
+  }
+  const doEncrypt = async () => {
+    const encryptedText = crypto.encrypt(encryptText);
+    console.log('🔐 Encrypted Password:', 'pwd.' + encryptedText);
+    return 'pwd.' + encryptedText;
+  };
+  if (isPlaywrightRunner()) {
+    return await __allureAny_comm.step(
+      `Comm: Encrypt-Password -text: [redacted] -options: ${JSON.stringify(options_json)}`,
+      async () => await doEncrypt()
+    );
+  }
+  return await doEncrypt();
+}
+
+/**
+ * Comm: Encrypt-Text -text: {param} -options: {param}
+ * 
+ * Encrypts the given text and returns it with an "enc." prefix.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param options - Optional string or object of additional options (parsed if string).
+ * @returns A string prefixed with "enc." followed by the encrypted value.
+ *
+ * @throws Error if `encryptText` is not a non-empty string.
+ *
+ */
+export async function encryptText(encryptText: string, options?: string | Record<string, any>) {
+  const options_json = typeof options === 'string' ? vars.parseLooseJson(options) : (options || {});
+  if (typeof encryptText !== 'string' || encryptText.length === 0) {
+    throw new Error('❌ encryptText: encryptText must be a non-empty string.');
+  }
+  const doEncrypt = async () => {
+    const encryptedText = crypto.encrypt(encryptText);
+    console.log('🔐 Encrypted Text:', 'enc.' + encryptedText);
+    return 'enc.' + encryptedText;
+  };
+  if (isPlaywrightRunner()) {
+    return await __allureAny_comm.step(
+      `Comm: Encrypt-Text -text: [redacted] -options: ${JSON.stringify(options_json)}`,
+      async () => await doEncrypt()
+    );
+  }
+  return await doEncrypt();
+}
+
+/**
+ * Comm: Encrypt-Password -text: {param} and store in -variable: {param} -options: {param}
+ * 
+ * Encrypts the given password, prefixes it with "pwd.", and stores it in a variable.
+ *
+ * @param encryptText - The plain text password to encrypt.
+ * @param varNameToStore - The name of the variable to store the encrypted password.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptText` or `varNameToStore` are not non-empty strings.
+ *
+ */
+export async function encryptPasswordAndStore(encryptText: string, varNameToStore: string, options?: string | Record<string, any>) {
+  const options_json = typeof options === 'string' ? vars.parseLooseJson(options) : (options || {});
+  if (typeof encryptText !== 'string' || encryptText.length === 0) {
+    throw new Error('❌ encryptPasswordAndStore: encryptText must be a non-empty string.');
+  }
+  if (typeof varNameToStore !== 'string' || varNameToStore.trim().length === 0) {
+    throw new Error('❌ encryptPasswordAndStore: varNameToStore must be a non-empty string.');
+  }
+  const doEncryptAndStore = async () => {
+    const encryptedText = crypto.encrypt(encryptText);
+    console.log('🔐 Encrypted Text:', 'pwd.' + encryptedText);
+    vars.setValue(varNameToStore, 'pwd.' + encryptedText);
+    await comm.attachLog(`✅ Encrypted password stored in "${varNameToStore}"`, 'text/plain');
+  };
+  if (isPlaywrightRunner()) {
+    await __allureAny_comm.step(
+      `Comm: Encrypt-Password and store -variable: ${varNameToStore} -options: ${JSON.stringify(options_json)}`,
+      async () => await doEncryptAndStore()
+    );
+  } else {
+    await doEncryptAndStore();
+  }
+}
+
+/**
+ * Comm: Encrypt -text: {param} and store in -variable: {param} -options: {param}
+ * 
+ * Encrypts the given text, prefixes it with "enc.", and stores it in a variable.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param varNameToStore - The variable name to store the encrypted text.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptText` or `varNameToStore` are not non-empty strings.
+ *
+ */
+export async function encryptTextAndStore(encryptText: string, varNameToStore: string, options?: string | Record<string, any>) {
+  const options_json = typeof options === 'string' ? vars.parseLooseJson(options) : (options || {});
+  if (typeof encryptText !== 'string' || encryptText.length === 0) {
+    throw new Error('❌ encryptTextAndStore: encryptText must be a non-empty string.');
+  }
+  if (typeof varNameToStore !== 'string' || varNameToStore.trim().length === 0) {
+    throw new Error('❌ encryptTextAndStore: varNameToStore must be a non-empty string.');
+  }
+  const doEncryptAndStore = async () => {
+    const encryptedText = crypto.encrypt(encryptText);
+    console.log('🔐 Encrypted Text:', 'enc.' + encryptedText);
+    vars.setValue(varNameToStore, 'enc.' + encryptedText);
+    await comm.attachLog(`✅ Encrypted text stored in "${varNameToStore}"`, 'text/plain');
+  };
+  if (isPlaywrightRunner()) {
+    await __allureAny_comm.step(
+      `Comm: Encrypt-Text and store -variable: ${varNameToStore} -options: ${JSON.stringify(options_json)}`,
+      async () => await doEncryptAndStore()
+    );
+  } else {
+    await doEncryptAndStore();
+  }
+}
+
+/**
+ * Comm: Decrypt -text: {param} and store in -variable: {param} -options: {param}
+ * 
+ * Decrypts the given encrypted text and stores the result in a variable.
+ *
+ * @param encryptedText - The encrypted value to decrypt.
+ * @param varName - The variable name to store the decrypted result.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptedText` or `varName` are not non-empty strings.
+ *
+ */
+export async function decrypt(encryptedText: string, varName: string, options?: string | Record<string, any>) {
+  const options_json = typeof options === 'string' ? vars.parseLooseJson(options) : (options || {});
+  if (typeof encryptedText !== 'string' || encryptedText.length === 0) {
+    throw new Error('❌ decrypt: encryptedText must be a non-empty string.');
+  }
+  if (typeof varName !== 'string' || varName.trim().length === 0) {
+    throw new Error('❌ decrypt: varName must be a non-empty string.');
+  }
+  const doDecryptAndStore = async () => {
+    const decryptedText = crypto.decrypt(encryptedText);
+    vars.setValue(varName, decryptedText);
+    await comm.attachLog(`✅ Decrypted value stored in "${varName}"`, 'text/plain');
+  };
+  if (isPlaywrightRunner()) {
+    await __allureAny_comm.step(
+      `Comm: Decrypt -text: [redacted] and store in -variable: ${varName} -options: ${JSON.stringify(options_json)}`,
+      async () => await doDecryptAndStore()
+    );
+  } else {
+    await doDecryptAndStore();
+  }
+}
+
+/**
+ * Comm: Get-Random-From-List -arrayList: {param}
+ * 
+ * Selects and returns a random item from a given non-empty array.
+ *
+ * @template T
+ * @param list - The array to select a random item from.
+ * @returns A randomly selected item from the array.
+ *
+ * @throws Error if the list is not a non-empty array.
+ *
+ */
+export async function getRandomFromList<T>(list: T[]): Promise<T> {
+  if (!Array.isArray(list) || list.length === 0) {
+    throw new Error("⚠️ getRandomFromList: list must be a non-empty array.");
+  }
+  const index = Math.floor(Math.random() * list.length);
+  return list[index];
+}
+
+/**
+ * Comm: Remove-Leading-Zero-From-Date -text: {param}
+ * 
+ * Removes leading zeros from both the day and month in a date string of format DD/MM/YYYY.
+ * Example: '03/07/2025' => '3/7/2025'
+ * @param dateStr - The date string in DD/MM/YYYY format
+ * @returns The date string with leading zeros removed from day and month
+ *
+ * @throws Error if `dateStr` is not a non-empty string.
+ */
+export async function removeLeadingZeroFromMonthAndDate(dateStr: string): Promise<string> {
+  if (typeof dateStr !== 'string' || dateStr.length === 0) {
+    throw new Error('❌ removeLeadingZeroFromMonthAndDate: dateStr must be a non-empty string.');
+  }
+  return dateStr.replace(/\b0(\d)/g, "$1");
+}
+
+interface WriteJsonOptions {
+  override?: boolean;
+  append?: boolean;
+  toArray?: boolean;
+}
+
+/**
+ * Comm: Write-JSON-To-File -filePath: {param} -data: {param} -options: {param}
+ * 
+ * Writes JSON data to a file with options to override, append, or wrap in array.
+ * 
+ * @param filePath - The destination file path.
+ * @param data - The JSON data to write (object or array).
+ * @param options - { override, append, toArray }
+ *
+ * @throws Error if `filePath` is empty, if append mode file content is not a JSON array, or if both `override` and `append` are false.
+ */
+export async function writeJsonToFile(
+  filePath: string,
+  data: any,
+  options: WriteJsonOptions = { override: true, append: false, toArray: false }
+): Promise<void> {
+  const defaultOptions = { override: true, append: false, toArray: false };
+  const opts = { ...defaultOptions, ...options };
+  if (typeof filePath !== 'string' || filePath.trim().length === 0) {
+    throw new Error('❌ writeJsonToFile: filePath must be a non-empty string.');
+  }
+  const absPath = path.resolve(filePath);
+
+  if (opts.append) {
+    // Only works if file contains an array
+    let arr: any[] = [];
+    if (fs.existsSync(absPath)) {
+      const fileContent = fs.readFileSync(absPath, 'utf-8');
+      try {
+        arr = JSON.parse(fileContent);
+        if (!Array.isArray(arr)) throw new Error('File does not contain a JSON array.');
+      } catch {
+        throw new Error('File is not a valid JSON array.');
+      }
+    }
+    arr.push(data);
+    fs.writeFileSync(absPath, JSON.stringify(arr, null, 2), 'utf-8');
+    await comm.attachLog(`✅ JSON appended to file: ${absPath}`, 'text/plain');
+  } else if (opts.override) {
+    // Overwrite or create new file
+    let out = data;
+    if (opts.toArray) {
+      out = Array.isArray(data) ? data : [data];
+    }
+    fs.writeFileSync(absPath, JSON.stringify(out, null, 2), 'utf-8');
+    await comm.attachLog(`✅ JSON written to file: ${absPath}`, 'text/plain');
+  } else {
+    throw new Error('Either override or append must be true.');
+  }
+}
+
+/**
+ * Ensures the value is formatted as a currency string: $<amount>.00
+ * @param value - The input value (number or string)
+ * @returns {string} - Formatted as $<amount>.00
+ */
+export function toDollarAmount(value: string | number): string {
+  // Remove any non-numeric except dot
+  let num = typeof value === 'number'
+    ? value
+    : parseFloat(String(value).replace(/[^0-9.]/g, ''));
+  if (isNaN(num)) num = 0;
+  return `$${num.toFixed(2)}`;
+}
+
+/**
+ * Comm: Generate TOTP Token to variable -varName: {param} -options: {param}
+ *
+ * Generates a TOTP (Time-based One-Time Password) token using the provided secret and stores it in a variable.
+ *
+ * @param varName - The name of the variable to store the generated TOTP token.
+ * @param options - Optional string or object containing:
+ *   - secret: [string] The TOTP secret key (default: process.env.PLAYQ_TOTP_SECRET_KEY).
+ *
+ * @example
+ * Comm: Generate TOTP Token to variable -varName: "var.otp" -options: '{"secret":"MYSECRET"}'
+ */
+export async function generateTotpTokenToVariable(
+  varName: string,
+  options?: string | Record<string, any>
+) {
+  const options_json = typeof options === "string" ? vars.parseLooseJson(options) : options || {};
+  const { secret, step = 30, digits = 6, algorithm = "SHA-1" } = options_json;
+
+  if (isPlaywrightRunner()) {
+    await __allureAny_comm.step(
+      `Comm: Generate TOTP Token to variable -varName: ${varName} -options: ${JSON.stringify(options_json)}`,
+      async () => {
+        await doGenerateTotpTokenToVariable();
+      }
+    );
+  } else {
+    await doGenerateTotpTokenToVariable();
+  }
+
+  async function doGenerateTotpTokenToVariable() {
+    let secretKey = process.env.PLAYQ_TOTP_SECRET_KEY || secret;
+
+    if (!secretKey) {
+      throw new Error('❌ PLAYQ_TOTP_SECRET_KEY not found in environment variables or in options');
+    }
+
+    if (secretKey.startsWith("enc.")) {
+      secretKey = vars.replaceVariables(`#{${secretKey}}`);
+    }
+    const totpHelper = new TOTPHelper(secretKey);
+    // Generate and return token
+    const token = totpHelper.generateToken();
+    vars.setValue(varName, token);
+  }
+}
+
+/**
+ * Alias: wait
+ * Wrapper to maintain compatibility for step names mapping.
+ */
+export async function wait(ms: number) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/helper/actions/commActions.ts

@@ -0,0 +1,18 @@
+/**
+ * @file commActions.ts
+ *
+ * Communication actions gateway for logging, attachments, and utilities.
+ * Exposes a stable public surface while implementations live under ./comm/*.
+ *
+ * Key Features:
+ * - Allure-friendly logging and attachment helpers
+ * - Error context utilities for diagnostics
+ * - Backward-compatible re-exports via gateway
+ *
+ * Authors: Renish Kozhithottathil [Lead Automation Principal, NCS]
+ * Version: v1.0.0
+ *
+ * Note: This file adheres to the PlayQ Enterprise Automation Standards.
+ */
+export * from './comm/commonActions';
+export * from './comm/utilityActions';

package/src/helper/actions/commStepDefs.ts

@@ -0,0 +1,72 @@
+import { Given, When, Then } from "@cucumber/cucumber";
+import { warn } from "winston";
+import { comm } from "../../global";
+
+// commonActions.ts
+
+Given("Comm: Wait for milliseconds -seconds: {param}", async function (seconds) {
+  await comm.waitInMilliSeconds(parseInt(seconds));
+});
+
+Given("Comm: Comment -text: {param}", async function (comment) {
+  await comm.comment(comment);
+});
+
+Given("Comm: Encrypt password -text: {param} -options: {param}", async function (encryptedText, options) {
+  await comm.encryptPassword(encryptedText, options);
+});
+
+Given("Comm: Encrypt text -text: {param} -options: {param}", async function (encryptedText, options) {
+  await comm.encryptText(encryptedText, options);
+});
+
+Given("Comm: Encrypt password -text: {param} and store in -variable: {param} -options: {param}", async function (textToEncrypt, varToStore, options) {
+  await comm.encryptPasswordAndStore(textToEncrypt, varToStore, options);
+});
+
+Given("Comm: Encrypt text -text: {param} and store in -variable: {param} -options: {param}", async function (textToEncrypt, varToStore, options) {
+  console.log('Text to encrypt:', textToEncrypt);
+  await comm.encryptTextAndStore(textToEncrypt, varToStore, options);
+});
+
+Given("Comm: Decrypt -text: {param} and store in -variable: {param} -options: {param}", async function (encryptedText, varName, options) {
+  await comm.decrypt(encryptedText, varName, options);
+});
+
+Given("Comm: Get random from list -arrayList: {param}", async function (list) {
+  const arrayList = JSON.parse(list);
+  await comm.getRandomFromList(arrayList);
+});
+
+Given("Comm: Remove leading zero from date -text: {param}", async function (dateText) {
+  await comm.removeLeadingZeroFromMonthAndDate(dateText);
+});
+
+Given("Comm: Write JSON to file -filePath: {param} -data: {param} -options: {param}", async function (filePath, data, options) {
+  await comm.writeJsonToFile(filePath, data, options);
+});
+
+Given("Comm: Attach log -message: {param} -mimeType: {param} -msgType: {param}", async function (message, mimeType, msgType) {
+  await comm.attachLog(message, mimeType, msgType);
+});
+
+Given("Comm: Store -value: {param} in -variable: {param} -options: {param}", async function (value, varName, options) {
+  await comm.storeValue(value, varName, options);
+});
+
+// utilityActions.ts
+Given("Comm: To Dollar Amount -value: {param}", async function (value) {
+  const formatted = await comm.toDollarAmount(Number(value));
+  await comm.attachLog(`Formatted dollars: ${formatted}`, 'text/plain', 'COMM');
+});
+
+// TOTP token generation
+Given("Comm: Generate TOTP Token to variable -varName: {param} -options: {param}", async function (varName, options) {
+  await comm.generateTotpTokenToVariable(varName, options);
+});
+
+// utilityActions.ts (alias wait)
+Given("Comm: Wait -ms: {param}", async function (ms) {
+  const value = parseInt(String(ms));
+  await comm.wait(value);
+});