@playq/core 0.2.77

package/dist/helper/actions/api/apiValidationActions.js

@@ -0,0 +1,615 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storePaths = exports.assertPathValue = exports.assertValue = void 0;
+exports.verifyValue = verifyValue;
+exports.verifyPathValue = verifyPathValue;
+exports.getLastResponseJsonPathValue = getLastResponseJsonPathValue;
+exports.storeLastResponseJsonPathsToVariables = storeLastResponseJsonPathsToVariables;
+exports.getPathValueFromLastResponse = getPathValueFromLastResponse;
+exports.getLastResponseArray = getLastResponseArray;
+exports.getPropertyFromLastResponseArray = getPropertyFromLastResponseArray;
+exports.extractFromLastResponse = extractFromLastResponse;
+exports.verifyStatus = verifyStatus;
+exports.verifyHeader = verifyHeader;
+exports.verifySchema = verifySchema;
+exports.verifyError = verifyError;
+/**
+ * @file apiValidationActions.ts
+ *
+ * Validation utilities for API testing across Playwright and Cucumber runners.
+ * Provides value and JSON path assertions with variable interpolation.
+ *
+ * Key Features:
+ * - Hybrid runner support with Allure-compatible steps.
+ * - Flexible path resolution for body, headers, status, and status text.
+ * - Optional partial text checks and assertion control.
+ *
+ * Authors: Renish Kozhithottathil [Lead Automation Principal, NCS]
+ * Date: 2025-07-01
+ * Version: v1.0.0
+ *
+ * Note: This file adheres to the PlayQ Enterprise Automation Standards.
+ */
+const allure = __importStar(require("allure-js-commons"));
+const global_1 = require("../../../global");
+const test_1 = require("@playwright/test");
+// Inline runner helpers
+function isPlaywrightRunner() { return process.env.TEST_RUNNER === 'playwright'; }
+function isCucumberRunner() { return process.env.TEST_RUNNER === 'cucumber'; }
+const __allureAny_api = allure;
+if (typeof __allureAny_api.step !== 'function') {
+    __allureAny_api.step = async (_name, fn) => await fn();
+}
+/**
+ * Api: Verify value -actual: {param} -expected: {param} -options: {param}
+ *
+ * Verifies that a given value matches the expected value.
+ * Throws an error if the values do not match.
+ *
+ * @param actual - The actual value to verify.
+ * @param expected - The expected value to compare against.
+ * @param message - Optional. Custom error message on failure.
+ */
+async function verifyValue(actual, expected, options) {
+    const resolvedActual = global_1.vars.replaceVariables(String(actual));
+    const resolvedExpected = global_1.vars.replaceVariables(expected);
+    const options_json = typeof options === "string" ? global_1.vars.parseLooseJson(options) : options || {};
+    const { assert = true, partial_text = false } = options_json;
+    // Input validation
+    if (expected === undefined || expected === null) {
+        throw new Error("Expected value must be provided for verification.");
+    }
+    const stepName = `Api: Verify value -actual: ${resolvedActual} -expected: ${resolvedExpected} -options: ${JSON.stringify(options_json)}`;
+    if (isPlaywrightRunner()) {
+        await test_1.test.step(stepName, async () => {
+            await doVerifyValue();
+        });
+    }
+    else {
+        await doVerifyValue();
+    }
+    async function doVerifyValue() {
+        // Debug log for type and value
+        console.debug(`[verifyValue] actual (type: ${typeof actual}):`, actual);
+        if (partial_text) {
+            if (!resolvedActual.includes(resolvedExpected)) {
+                console.warn(`❌ Verification failed (partial_text): expected '${resolvedActual}' to include '${resolvedExpected}'`);
+                await global_1.comm.attachLog(`❌ Verification failed (partial_text): expected '${resolvedActual}' to include '${resolvedExpected}'`, "text/plain", "Verification Details");
+                if (assert)
+                    throw new Error(`Verification failed (partial_text): expected '${resolvedActual}' to include '${resolvedExpected}'`);
+            }
+            else {
+                console.info(`✅ Verification passed (partial_text): expected '${resolvedActual}' to include '${resolvedExpected}'`);
+                await global_1.comm.attachLog(`✅ Verification passed (partial_text): expected '${resolvedActual}' to include '${resolvedExpected}'`, "text/plain", "Verification Details");
+            }
+            return;
+        }
+        if (resolvedActual !== resolvedExpected) {
+            console.warn(`❌ Verification failed: expected: '${resolvedExpected}', actual: '${resolvedActual}'`);
+            await global_1.comm.attachLog(`❌ Verification failed: expected: '${resolvedExpected}', actual: '${resolvedActual}'`, "text/plain", "Verification Details");
+            if (assert)
+                throw new Error(`Verification failed: expected '${resolvedExpected}', but got '${resolvedActual}'`);
+        }
+        else {
+            console.info(`✅ Verification passed: expected: '${resolvedExpected}', actual: '${resolvedActual}'`);
+            await global_1.comm.attachLog(`✅ Verification passed: expected: '${resolvedExpected}', actual: '${resolvedActual}'`, "text/plain", "Verification Details");
+        }
+    }
+}
+/**
+ * Api: Verify api path value in last response -path: {param} -expected: {param} -options: {param}
+ *
+ * Verifies that a value at a given JSON path in the last API response matches the expected value.
+ * Throws an error if the values do not match.
+ *
+ * @param path - The JSON path to extract from the last response body/header/status.
+ * @param expected - The expected value to compare against.
+ * @param options - Optional. Supports { assert: boolean, partial_text: boolean }
+ */
+async function verifyPathValue(path, expected, options) {
+    const resolvedExpected = global_1.vars.replaceVariables(expected);
+    const options_json = typeof options === "string" ? global_1.vars.parseLooseJson(options) : options || {};
+    const { assert = true, partial_text = false } = options_json;
+    // Input validation
+    if (!path || typeof path !== 'string') {
+        throw new Error("Path must be a non-empty string for verification.");
+    }
+    if (expected === undefined || expected === null) {
+        throw new Error("Expected value must be provided for verification.");
+    }
+    const sources = {
+        body: global_1.vars.getValue("playq.api.last.resBody"),
+        header: global_1.vars.getValue("playq.api.last.resHeader"),
+        status: global_1.vars.getValue("playq.api.last.resStatus"),
+        statusText: global_1.vars.getValue("playq.api.last.resStatusText")
+    };
+    let actual;
+    let allureMsg = "";
+    const stepName = `Api: Verify api path value in last response -path: ${path} -expected: ${resolvedExpected} -options: ${JSON.stringify(options_json)}`;
+    if (isPlaywrightRunner()) {
+        await test_1.test.step(stepName, async () => {
+            await doVerifyPathValue();
+        });
+    }
+    else {
+        await doVerifyPathValue();
+    }
+    async function doVerifyPathValue() {
+        actual = getPathValue(path, sources);
+        // Debug log for extracted value
+        console.debug(`[verifyPathValue] path: ${path},  extracted value (type: ${typeof actual}):`, actual, `Expected: ${resolvedExpected}`);
+        // verifyValue(actual, resolvedExpected, options);
+        if (partial_text) {
+            if (!actual || !actual.includes(resolvedExpected)) {
+                console.warn(`❌ Verification failed (partial_text): expected '${actual}' to include '${resolvedExpected}'`);
+                await global_1.comm.attachLog(`❌ Verification failed (partial_text): expected '${actual}' to include '${resolvedExpected}'`, "text/plain", "Verification Details");
+                if (assert)
+                    throw new Error(`Verification failed (partial_text): expected '${actual}' to include '${resolvedExpected}'`);
+            }
+            else {
+                await global_1.comm.attachLog(`✅ Verification passed (partial_text): expected '${actual}' to include '${resolvedExpected}'`, "text/plain", "Verification Details");
+                console.assert(`✅ Verification passed (partial_text): expected '${actual}' to include '${resolvedExpected}'`);
+            }
+            return;
+        }
+        // Handle null/undefined actual values
+        const actualString = (actual !== null && actual !== undefined) ? actual.toString() : String(actual);
+        if (actualString !== resolvedExpected) {
+            console.warn(`❌ Verification failed: expected: '${resolvedExpected}', actual: '${actual}'`);
+            await global_1.comm.attachLog(`❌ Verification failed: expected: '${resolvedExpected}', actual: '${actual}'`, "text/plain", "Verification Details");
+            if (assert)
+                throw new Error(`Verification failed: expected '${resolvedExpected}', but got '${actual}'`);
+        }
+        else {
+            await global_1.comm.attachLog(`✅ Verification passed: expected: '${resolvedExpected}', actual: '${actual}'`, "text/plain", "Verification Details");
+            console.assert(`✅ Verification passed: expected: '${resolvedExpected}', actual: '${actual}'`);
+        }
+    }
+}
+/**
+ * Api: Get last response JSON path value -path: {param} -storeTo: {param}
+ *
+ * Get the value at a given JSON path from the last API response body.
+ * Example: path = "data[0].id" will return the id of the first item in data array.
+ * Supports paths like "x.data[0].id" (where "x" is treated as the root).
+ *
+ * @param path - JSON path string; supports leading "x." as body alias.
+ * @returns The extracted value or undefined if not found.
+ * @throws Error if `path` is not a non-empty string.
+
+ */
+async function getLastResponseJsonPathValue(path) {
+    // Input validation
+    if (!path || typeof path !== 'string') {
+        throw new Error("Path must be a non-empty string for JSON path extraction.");
+    }
+    const stepName = `Api: Get last response JSON path value -path: ${path}`;
+    if (isPlaywrightRunner()) {
+        return await test_1.test.step(stepName, async () => {
+            return await doGetLastResponseJsonPathValue();
+        });
+    }
+    return await doGetLastResponseJsonPathValue();
+    async function doGetLastResponseJsonPathValue() {
+        const resBody = global_1.vars.getValue("playq.api.last.resBody");
+        if (!resBody)
+            return undefined;
+        const json = JSON.parse(resBody);
+        // Remove leading "x." if present
+        const normalisedPath = path.startsWith('x.') ? path.slice(2) : path;
+        // Simple dot/bracket notation path resolver
+        const segments = normalisedPath
+            .replace(/^\[(\d+)\]/, '$1') // handle root array [0]
+            .replace(/\[(\d+)\]/g, '.$1') // handle nested arrays
+            .split('.')
+            .filter(Boolean);
+        let result = json;
+        for (const seg of segments) {
+            if (result == null)
+                return undefined;
+            result = result[seg];
+        }
+        return result;
+    }
+}
+/**
+ * Api: Store last response JSON paths to variables -paths: {param} -vars: {param}
+ *
+ * Assign multiple values from the last API response body, header, status, or status text to variables.
+ * @param pathVarString Comma-separated JSON paths (e.g. "x.data[1].email,h.content-type,s.,t.")
+ * @param varKeyString  Comma-separated variable keys (e.g. "var.email,var.contentType,var.status,var.statusText")
+ * Prefixes (case-insensitive):
+ *   x. / (body). = response body (default if no prefix)
+ *   h. / (header). = response header
+ *   s / (status) / (statusCode) = response status code
+ *   t / (statusText) = response status text
+ * Examples:
+ *   "x.data[0].id" or "(body).data[0].id" → from body
+ *   "h.content-type" or "(header).content-type" → from header
+ *   "s" or "(status)" or "(statusCode)" → response status code
+ *   "t" or "(statusText)" → response status text
+ *   "data[0].id" → from body (default)
+ *
+ * @throws Error if inputs are missing or the number of paths and variable keys differ.
+ */
+async function storeLastResponseJsonPathsToVariables(pathVarString, varKeyString) {
+    // Input validation
+    if (!pathVarString || !varKeyString) {
+        throw new Error("Both pathVarString and varKeyString must be provided.");
+    }
+    const execute = async () => {
+        var _a, _b;
+        const resBody = global_1.vars.getValue("playq.api.last.resBody");
+        const resHeader = global_1.vars.getValue("playq.api.last.resHeader");
+        const resStatus = global_1.vars.getValue("playq.api.last.resStatus");
+        const resStatusText = global_1.vars.getValue("playq.api.last.resStatusText");
+        if (!resBody && !resHeader && !resStatus && !resStatusText)
+            return;
+        const jsonBody = resBody ? JSON.parse(resBody) : {};
+        const jsonHeader = resHeader ? JSON.parse(resHeader) : {};
+        const paths = pathVarString.split(',').map(s => s.trim());
+        const varKeys = varKeyString.split(',').map(s => s.trim());
+        if (paths.length !== varKeys.length) {
+            throw new Error("Number of paths and variable keys must match.");
+        }
+        for (let i = 0; i < paths.length; i++) {
+            let path = paths[i];
+            const varKey = varKeys[i];
+            let result;
+            const lowerPath = path.toLowerCase();
+            if (lowerPath.startsWith('h.')) {
+                // Header: h.header-name
+                const headerKey = path.slice(2).toLowerCase();
+                result = (_a = Object.entries(jsonHeader).find(([k]) => k.toLowerCase() === headerKey)) === null || _a === void 0 ? void 0 : _a[1];
+            }
+            else if (lowerPath.startsWith('(header).')) {
+                // Header: (header).header-name
+                const headerKey = path.slice(9).toLowerCase();
+                result = (_b = Object.entries(jsonHeader).find(([k]) => k.toLowerCase() === headerKey)) === null || _b === void 0 ? void 0 : _b[1];
+            }
+            else if (lowerPath.startsWith('s') || lowerPath.startsWith('s.')) {
+                // Status: s.
+                result = resStatus;
+            }
+            else if (lowerPath.startsWith('(status)') || lowerPath.startsWith('(statuscode)') || lowerPath.startsWith('(status).') || lowerPath.startsWith('(statuscode).')) {
+                // Status: (status).
+                result = resStatus;
+            }
+            else if (lowerPath.startsWith('t.')) {
+                // Status Text: t.
+                result = resStatusText;
+            }
+            else if (lowerPath.startsWith('(statustext)') || lowerPath.startsWith('(statustext).')) {
+                // Status Text: (statusText).
+                result = resStatusText;
+            }
+            else {
+                // Body: x., (body)., or no prefix
+                let normalisedPath = path;
+                if (lowerPath.startsWith('x.'))
+                    normalisedPath = path.slice(2);
+                else if (lowerPath.startsWith('(body).'))
+                    normalisedPath = path.slice(7);
+                const segments = normalisedPath
+                    .replace(/^\[(\d+)\]/, '$1')
+                    .replace(/\[(\d+)\]/g, '.$1')
+                    .split('.')
+                    .filter(Boolean);
+                result = jsonBody;
+                for (const seg of segments) {
+                    if (result == null)
+                        break;
+                    result = result[seg];
+                }
+            }
+            if (result !== undefined && result !== null) {
+                global_1.vars.setValue(varKey, result.toString());
+            }
+        }
+    };
+    if (isPlaywrightRunner()) {
+        await test_1.test.step(`Api: Store last response JSON paths to variables -paths: ${pathVarString} -vars: ${varKeyString}`, async () => {
+            await execute();
+        });
+    }
+    else {
+        await execute();
+    }
+}
+// Internal helper used only by verifyPathValue
+function getPathValueInternal(path, sources) {
+    var _a, _b;
+    const lowerPath = path.toLowerCase();
+    const jsonBody = typeof sources.body === "string" && sources.body ? JSON.parse(sources.body) : sources.body || {};
+    const jsonHeader = typeof sources.header === "string" && sources.header ? JSON.parse(sources.header) : sources.header || {};
+    if (lowerPath.startsWith('h.')) {
+        const headerKey = path.slice(2).toLowerCase();
+        return (_a = Object.entries(jsonHeader).find(([k]) => k.toLowerCase() === headerKey)) === null || _a === void 0 ? void 0 : _a[1];
+    }
+    if (lowerPath.startsWith('(header).')) {
+        const headerKey = path.slice(9).toLowerCase();
+        return (_b = Object.entries(jsonHeader).find(([k]) => k.toLowerCase() === headerKey)) === null || _b === void 0 ? void 0 : _b[1];
+    }
+    if (lowerPath === 's' || lowerPath === 's.' || lowerPath.startsWith('s.') || lowerPath.startsWith('(status)') || lowerPath.startsWith('(statuscode)') || lowerPath.startsWith('(status).') || lowerPath.startsWith('(statuscode).')) {
+        return sources.status;
+    }
+    if (lowerPath === 't' || lowerPath === 't.' || lowerPath.startsWith('(statustext)') || lowerPath.startsWith('(statustext).')) {
+        return sources.statusText;
+    }
+    let normalisedPath = path;
+    if (lowerPath.startsWith('x.'))
+        normalisedPath = path.slice(2);
+    else if (lowerPath.startsWith('(body).'))
+        normalisedPath = path.slice(7);
+    const segments = normalisedPath
+        .replace(/^\[(\d+)\]/, '$1') // handle root array [0]
+        .replace(/\[(\d+)\]/g, '.$1') // handle nested arrays
+        .split('.')
+        .filter(Boolean);
+    let result = jsonBody;
+    for (const seg of segments) {
+        if (result == null)
+            return undefined;
+        result = result[seg];
+    }
+    return result;
+}
+/**
+ * Generic internal function to extract a value from a JSON object, header, status, or status text
+ * using a flexible path syntax.
+ *
+ * @param path - Path string with optional prefix (e.g., "x.data[0].id", "h.content-type", "s", "t")
+ * @param sources - Object containing { body, header, status, statusText }
+ * @returns The extracted value or undefined if not found.
+ */
+function getPathValue(path, sources) {
+    var _a, _b;
+    const lowerPath = path.toLowerCase();
+    // Prepare parsed objects
+    const jsonBody = typeof sources.body === "string" && sources.body
+        ? JSON.parse(sources.body)
+        : sources.body || {};
+    const jsonHeader = typeof sources.header === "string" && sources.header
+        ? JSON.parse(sources.header)
+        : sources.header || {};
+    if (lowerPath.startsWith('h.')) {
+        // Header: h.header-name
+        const headerKey = path.slice(2).toLowerCase();
+        return (_a = Object.entries(jsonHeader).find(([k]) => k.toLowerCase() === headerKey)) === null || _a === void 0 ? void 0 : _a[1];
+    }
+    if (lowerPath.startsWith('(header).')) {
+        // Header: (header).header-name
+        const headerKey = path.slice(9).toLowerCase();
+        return (_b = Object.entries(jsonHeader).find(([k]) => k.toLowerCase() === headerKey)) === null || _b === void 0 ? void 0 : _b[1];
+    }
+    if (lowerPath === 's' || lowerPath === 's.' ||
+        lowerPath.startsWith('s.') ||
+        lowerPath.startsWith('(status)') || lowerPath.startsWith('(statuscode)') ||
+        lowerPath.startsWith('(status).') || lowerPath.startsWith('(statuscode).')) {
+        return sources.status;
+    }
+    if (lowerPath === 't' || lowerPath === 't.' ||
+        lowerPath.startsWith('(statustext)') || lowerPath.startsWith('(statustext).')) {
+        return sources.statusText;
+    }
+    // Body: x., (body)., or no prefix
+    let normalisedPath = path;
+    if (lowerPath.startsWith('x.'))
+        normalisedPath = path.slice(2);
+    else if (lowerPath.startsWith('(body).'))
+        normalisedPath = path.slice(7);
+    const segments = normalisedPath
+        .replace(/^\[(\d+)\]/, '$1') // handle root array [0]
+        .replace(/\[(\d+)\]/g, '.$1') // handle nested arrays
+        .split('.')
+        .filter(Boolean);
+    let result = jsonBody;
+    for (const seg of segments) {
+        if (result == null)
+            return undefined;
+        result = result[seg];
+    }
+    return result;
+}
+/**
+ * Api: Get path value from last response -path: {param} -storeTo: {param}
+ *
+ * Get a value from the last API response using a flexible path.
+ * Supports body, header, status, and statusText via prefixes:
+ *  - Body: default or `x.` or `(body).`
+ *  - Header: `h.` or `(header).`
+ *  - Status code: `s` or `(status)` or `(statusCode)`
+ *  - Status text: `t` or `(statusText)`
+ *
+ * @param path - Path string (e.g., `title`, `x.data[0].id`, `h.content-type`, `s`, `t`)
+ * @param options - Optional JSON string or object (reserved)
+ * @returns Extracted value or undefined
+ * @throws Error if `path` is not a non-empty string
+ */
+async function getPathValueFromLastResponse(path, options) {
+    if (!path || typeof path !== 'string') {
+        throw new Error("Path must be a non-empty string");
+    }
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {};
+    const sources = {
+        body: global_1.vars.getValue("playq.api.last.resBody"),
+        header: global_1.vars.getValue("playq.api.last.resHeader"),
+        status: global_1.vars.getValue("playq.api.last.resStatus"),
+        statusText: global_1.vars.getValue("playq.api.last.resStatusText")
+    };
+    const stepName = `Api: Get path value from last response -path: ${path} -options: ${JSON.stringify(options_json)}`;
+    const run = async () => getPathValue(path, sources);
+    if (isPlaywrightRunner()) {
+        return await test_1.test.step(stepName, run);
+    }
+    return run();
+}
+// Friendly aliases
+exports.assertValue = verifyValue;
+exports.assertPathValue = verifyPathValue;
+exports.storePaths = storeLastResponseJsonPathsToVariables;
+/**
+ * Api: Extract the entire root-level array from the last API response body.
+ * @returns {any[]} The parsed array, or throws if not an array.
+ */
+async function getLastResponseArray() {
+    const resBody = global_1.vars.getValue("playq.api.last.resBody");
+    if (!resBody)
+        throw new Error("No last response body found.");
+    const arr = JSON.parse(resBody);
+    if (!Array.isArray(arr))
+        throw new Error("Last response body is not an array.");
+    return arr;
+}
+/**
+ * Api: Extract a property from each object in the root-level array from the last API response body.
+ * @param {string} property - The property name to extract from each object.
+ * @returns {any[]} Array of property values.
+ */
+async function getPropertyFromLastResponseArray(property) {
+    const arr = await getLastResponseArray();
+    return arr.map(obj => obj && typeof obj === 'object' ? obj[property] : undefined);
+}
+/**
+ * Api: Generic extractor for last response body (array, object, or primitive).
+ * If a path is provided, will attempt to extract using dot/bracket notation.
+ * If no path is provided, returns the parsed body (array/object/primitive).
+ * @param {string} [path] - Optional dot/bracket path (e.g., 'data[0].id').
+ * @returns {any} Extracted value or the parsed body.
+ */
+async function extractFromLastResponse(path) {
+    const resBody = global_1.vars.getValue("playq.api.last.resBody");
+    if (!resBody)
+        throw new Error("No last response body found.");
+    const json = JSON.parse(resBody);
+    if (!path)
+        return json;
+    // Simple dot/bracket notation path resolver
+    const segments = path.replace(/\[(\w+)\]/g, '.$1').split('.').filter(Boolean);
+    let result = json;
+    for (const seg of segments) {
+        if (result == null)
+            return undefined;
+        result = result[seg];
+    }
+    return result;
+}
+/**
+ * Api: Assert last response status code.
+ * @param expectedStatus - Expected HTTP status code (string or number).
+ * @param options - Optional: { assert: boolean }
+ */
+async function verifyStatus(expectedStatus, options) {
+    const actual = global_1.vars.getValue("playq.api.last.resStatus");
+    const expected = String(expectedStatus);
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {};
+    const { assert = true } = options_json;
+    if (actual !== expected) {
+        await global_1.comm.attachLog(`❌ Status code mismatch: expected ${expected}, got ${actual}`, "text/plain");
+        if (assert)
+            throw new Error(`Status code mismatch: expected ${expected}, got ${actual}`);
+    }
+    else {
+        await global_1.comm.attachLog(`✅ Status code matched: ${expected}`, "text/plain");
+    }
+}
+/**
+ * Api: Assert last response header value.
+ * @param header - Header name (case-insensitive).
+ * @param expectedValue - Expected value (string).
+ * @param options - Optional: { assert: boolean, partial_text: boolean }
+ */
+async function verifyHeader(header, expectedValue, options) {
+    var _a;
+    const resHeader = global_1.vars.getValue("playq.api.last.resHeader");
+    const jsonHeader = resHeader ? JSON.parse(resHeader) : {};
+    const actual = (_a = Object.entries(jsonHeader).find(([k]) => k.toLowerCase() === header.toLowerCase())) === null || _a === void 0 ? void 0 : _a[1];
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {};
+    const { assert = true, partial_text = false } = options_json;
+    if (partial_text
+        ? !(typeof actual === "string" && actual.includes(expectedValue))
+        : actual !== expectedValue) {
+        await global_1.comm.attachLog(`❌ Header mismatch: ${header} expected ${expectedValue}, got ${actual}`, "text/plain");
+        if (assert)
+            throw new Error(`Header mismatch: ${header} expected ${expectedValue}, got ${actual}`);
+    }
+    else {
+        await global_1.comm.attachLog(`✅ Header matched: ${header} = ${expectedValue}`, "text/plain");
+    }
+}
+/**
+ * Api: Assert last response body matches JSON schema.
+ * @param schema - JSON schema object.
+ * @param options - Optional: { assert: boolean }
+ */
+async function verifySchema(schema, options) {
+    const resBody = global_1.vars.getValue("playq.api.last.resBody");
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {};
+    const { assert = true } = options_json;
+    if (!resBody)
+        throw new Error("No last response body found.");
+    const Ajv = require('ajv');
+    const ajv = new Ajv();
+    const json = JSON.parse(resBody);
+    const valid = ajv.validate(schema, json);
+    if (!valid) {
+        await global_1.comm.attachLog(`❌ Schema validation failed: ${JSON.stringify(ajv.errors)}`, "application/json");
+        if (assert)
+            throw new Error(`Schema validation failed: ${JSON.stringify(ajv.errors)}`);
+    }
+    else {
+        await global_1.comm.attachLog(`✅ Schema validation passed.`, "text/plain");
+    }
+}
+/**
+ * Api: Assert last response is error/timeout (negative test).
+ * @param expectedStatus - Expected error status code (string or number).
+ * @param options - Optional: { assert: boolean }
+ */
+async function verifyError(expectedStatus, options) {
+    const actual = global_1.vars.getValue("playq.api.last.resStatus");
+    const expected = String(expectedStatus);
+    const options_json = typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {};
+    const { assert = true } = options_json;
+    if (actual !== expected) {
+        await global_1.comm.attachLog(`❌ Expected error status ${expected}, got ${actual}`, "text/plain");
+        if (assert)
+            throw new Error(`Expected error status ${expected}, got ${actual}`);
+    }
+    else {
+        await global_1.comm.attachLog(`✅ Error status matched: ${expected}`, "text/plain");
+    }
+}

package/dist/helper/actions/apiActions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file apiActions.ts
+ *
+ * Unified API actions bridging Playwright and Cucumber.
+ * Provides request helpers and validation utilities with reporting.
+ *
+ * Key Features:
+ * - Hybrid context: Playwright Runner (page) and Cucumber World (webFixture)
+ * - Rich options for assertions, timeouts, and attachments
+ * - Robust error handling, logging, and Allure-compatible step wrappers
+ *
+ * Authors: Renish Kozhithottathil [Lead Automation Principal, NCS]
+ * Version: v1.0.0
+ *
+ * Note: This file adheres to the PlayQ Enterprise Automation Standards.
+ */
+export * from './api/apiRequestActions';
+export * from './api/apiValidationActions';

package/dist/helper/actions/apiActions.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @file apiActions.ts
+ *
+ * Unified API actions bridging Playwright and Cucumber.
+ * Provides request helpers and validation utilities with reporting.
+ *
+ * Key Features:
+ * - Hybrid context: Playwright Runner (page) and Cucumber World (webFixture)
+ * - Rich options for assertions, timeouts, and attachments
+ * - Robust error handling, logging, and Allure-compatible step wrappers
+ *
+ * Authors: Renish Kozhithottathil [Lead Automation Principal, NCS]
+ * Version: v1.0.0
+ *
+ * Note: This file adheres to the PlayQ Enterprise Automation Standards.
+ */
+__exportStar(require("./api/apiRequestActions"), exports);
+__exportStar(require("./api/apiValidationActions"), exports);

package/dist/helper/actions/apiStepDefs.d.ts

@@ -0,0 +1 @@
+export {};