@zohodesk/testinglibrary 0.1.9 → 0.1.12-experimental

package/build/common/searchFake/steps/searchFake.spec.js

@@ -0,0 +1,85 @@
+import {createBdd} from '@zohodesk/testinglibrary';
+import { jsonpath } from '@zohodesk/testinglibrary/thirdPartyHelper';
+import { executeRpcRequest , entityIdReConstructor } from '../helpers/rpcRequestHelper';
+
+const { Given } = createBdd();
+
+Given('a search entity', async ({page}, dataTable)=>{
+    const data = dataTable.hashes();
+    
+    for (const row of data) {
+        
+        const { moduleName, entityId, searchString } = row;
+        const payload = {
+            className: 'applicationDriver.rpc.desk.integrations.search.SearchFakeDataPopulator',
+            methodName: 'populateSearchData',
+            arguments: {
+                module: moduleName,
+                searchString: searchString, 
+                entityId: entityId
+            }
+        };
+        await entityIdReConstructor(payload);
+
+        await executeRpcRequest(page, payload);
+    }
+});
+
+Given('a search entity and index a data under {string}', async ({page}, parentEntity, dataTable)=>{
+    const data = dataTable.hashes();
+
+    for (const row of data) {
+
+        const payload = {
+            className: 'applicationDriver.rpc.desk.integrations.search.SearchFakeDataPopulator',
+            methodName: 'populateSearchData',
+            arguments: {
+                module: 'ticket_under_contact_count',
+                searchString: '',
+                ...row
+            }
+        };
+        await entityIdReConstructor(payload);
+
+        await executeRpcRequest(page, payload);
+    }
+});
+
+Given('a search entity using {string}', async ({page,cacheLayer}, reference,dataTable)=>{
+    const data = dataTable.hashes();
+    
+    const row = data[0];
+    if (!row || !row.moduleName || !row.searchString) {
+        throw new Error('Invalid or missing data in dataTable');
+    }
+    
+    const { moduleName, searchEntity, searchString } = row;
+    
+    const searchObj = cacheLayer.get(reference);
+    let entityIdValue;
+    
+    if (typeof searchObj === 'string') {
+        entityIdValue = searchObj;
+    } else {
+        const jsonPath = searchEntity?.startsWith?.('$') ? searchEntity : `$.${searchEntity}`;
+        const result = jsonpath.query(searchObj, jsonPath);
+        
+        if (!result || result.length === 0) {
+            throw new Error(`JSONPath query '${jsonPath}' returned no results from cache object for reference: ${reference}`);
+        }
+        
+        entityIdValue = result.length === 1 ? result[0] : result;
+    }
+    
+    const payload = {
+        className: 'applicationDriver.rpc.desk.integrations.search.SearchFakeDataPopulator',
+        methodName: 'populateSearchData',
+        arguments: {
+            module: moduleName,
+            searchString: searchString, 
+            entityId: entityIdValue
+        }
+    };
+    await entityIdReConstructor(payload);
+    await executeRpcRequest(page, payload);
+});

package/build/core/dataGenerator/DataGenerator.js

@@ -0,0 +1,161 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _logger = require("../../utils/logger");
+var _DataGeneratorHelper = require("./DataGeneratorHelper");
+var _Authenticator = _interopRequireDefault(require("./authenticator/Authenticator.js"));
+var _helpers = require("@zohodesk/testinglibrary/helpers");
+var _DataGeneratorError = require("./DataGeneratorError");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _DataGenerator_brand = /*#__PURE__*/new WeakSet();
+class DataGenerator {
+  constructor() {
+    _classPrivateMethodInitSpec(this, _DataGenerator_brand);
+  }
+  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable, page = null) {
+    try {
+      let generators;
+      if (generatorType === 'API') {
+        generators = await _assertClassBrand(_DataGenerator_brand, this, _generateAPIGenerator).call(this, generatorName);
+      } else {
+        generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, testInfo, generatorName);
+      }
+      const generatorOperationIds = generators.map(({
+        generatorOperationId
+      }) => generatorOperationId).filter(Boolean);
+      const domainUrl = _assertClassBrand(_DataGenerator_brand, this, _resolveDomainUrl).call(this, generatorOperationIds);
+      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+      const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo, domainUrl, page);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `API payload for generator: ${generatorName || 'UNKNOWN'} for scenario: ${scenarioName || 'UNKNOWN'}, Response: ${JSON.stringify(apiPayload || {})}`);
+      const response = await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, apiPayload, page);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generated response for the generator: ${generatorName} for scenario: ${scenarioName}, Response: ${JSON.stringify(response)}`);
+      return response;
+    } catch (error) {
+      if (error instanceof _DataGeneratorError.DataGeneratorError) {
+        console.error(error.getMessage());
+        console.error("Stack trace:", error.stack);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error.getMessage());
+      } else {
+        console.error("Error Type:", error.constructor.name);
+        console.error("Error Message:", error.message);
+        console.error("Stack trace:", error.stack);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `${error.constructor.name} - Message: ${error.message}`);
+      }
+      console.error('Data Generation failed for the generator: ', generatorName, "\n\nError response :", error);
+      throw error;
+    }
+  }
+}
+async function _getGenerator(testInfo, generatorName) {
+  let generator = null;
+  const generatorFilePaths = await (0, _DataGeneratorHelper.getGeneratorFilePaths)(testInfo.file);
+  for (const generatorFilePath of generatorFilePaths) {
+    if (!_fs.default.existsSync(generatorFilePath)) {
+      continue;
+    }
+    const data = _fs.default.readFileSync(generatorFilePath, 'utf8');
+    const generatorObj = JSON.parse(data);
+    if (generatorName && generatorObj.generators) {
+      generator = generatorObj.generators[generatorName] || null;
+    }
+    if (generator) {
+      break;
+    }
+  }
+  if (!generator) {
+    throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in any of the paths: ${generatorFilePaths.join(", ")}`);
+  }
+  return generator;
+}
+// Backward-compat: selects portalDomain for portal.* generators, domain otherwise.
+// Remove this method and inline `process.env.portalDomain` directly once all
+// generators use portal.* operation IDs and portalDomain is always configured.
+function _resolveDomainUrl(generatorOperationIds) {
+  const usesPortalDomain = generatorOperationIds.some(id => id.startsWith('portal.'));
+  return usesPortalDomain ? process.env.portalDomain || process.env.domain : process.env.domain;
+}
+async function _generateAPIGenerator(operationId) {
+  return [{
+    type: "dynamic",
+    generatorOperationId: operationId,
+    name: operationId,
+    dataPath: "$.response.body:$"
+  }];
+}
+// Backward-compat: legacy v1 payload format for older DG service deployments.
+// Remove this method and the DG_API_VERSION branch in #constructApiPayload
+// once all environments are migrated to the v2 API.
+async function _constructV1Payload(scenarioName, processedGenerators, actorInfo, domainUrl, page) {
+  const dataGeneratorObj = actorInfo['data-generator'];
+  if (!dataGeneratorObj) {
+    throw new _DataGeneratorError.DataGeneratorConfigurationError(`Data Generator configuration is missing for the profile: ${actorInfo['profile']}`);
+  }
+  let apiPayload = {
+    scenario_name: scenarioName,
+    data_generation_templates: processedGenerators,
+    ...dataGeneratorObj
+  };
+  const account = apiPayload.account;
+  if (account) {
+    account.email = actorInfo.email;
+    account.password = actorInfo.password;
+  }
+  const environmentDetails = apiPayload.environmentDetails || {};
+  environmentDetails.iam_url = process.env.DG_IAM_DOMAIN;
+  environmentDetails.host = new URL(domainUrl).origin;
+  apiPayload.environmentDetails = environmentDetails;
+  apiPayload = await new _Authenticator.default().constructPayload(apiPayload, actorInfo, page);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Final API Payload (v1) after authentication augmentation: ${JSON.stringify(apiPayload)}`);
+  return apiPayload;
+}
+async function _constructV2Payload(scenarioName, processedGenerators, actorInfo, domainUrl, page) {
+  const dataGeneratorObj = actorInfo['data-generator'];
+  if (!dataGeneratorObj) {
+    throw new _DataGeneratorError.DataGeneratorConfigurationError(`Data Generator configuration is missing for the profile: ${actorInfo['profile']}`);
+  }
+  if (!dataGeneratorObj.account) {
+    throw new _DataGeneratorError.DataGeneratorConfigurationError('Missing "account" in data-generator config for profile: ' + actorInfo['profile']);
+  }
+  const account = {
+    ...dataGeneratorObj.account
+  };
+  account.email = actorInfo.email;
+  account.password = actorInfo.password;
+  const selectedDomain = new URL(domainUrl);
+  const environment = {
+    host: selectedDomain.origin,
+    iam_url: process.env.DG_IAM_DOMAIN
+  };
+  const translatedGenerators = (0, _DataGeneratorHelper.translateGeneratorsToV2)(processedGenerators);
+  let apiPayload = {
+    scenario: {
+      name: scenarioName
+    },
+    mode: 'template',
+    spec: {
+      templates: translatedGenerators
+    },
+    account,
+    environment
+  };
+  apiPayload = await new _Authenticator.default().constructPayload(apiPayload, actorInfo, page);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Final API Payload after authentication augmentation: ${JSON.stringify(apiPayload)}`);
+  return apiPayload;
+}
+// Backward-compat: infer v1 from DG_SERVICE_API_PATH containing "/v1/".
+// Remove this method and #constructV1Payload once all environments point to a v2 path.
+async function _constructApiPayload(scenarioName, processedGenerators, actorInfo, domainUrl, page = null) {
+  var _process$env$DG_SERVI;
+  if ((_process$env$DG_SERVI = process.env.DG_SERVICE_API_PATH) !== null && _process$env$DG_SERVI !== void 0 && _process$env$DG_SERVI.includes('/v1/')) {
+    return _assertClassBrand(_DataGenerator_brand, this, _constructV1Payload).call(this, scenarioName, processedGenerators, actorInfo, domainUrl, page);
+  }
+  return _assertClassBrand(_DataGenerator_brand, this, _constructV2Payload).call(this, scenarioName, processedGenerators, actorInfo, domainUrl, page);
+}
+var _default = exports.default = DataGenerator;

package/build/core/dataGenerator/DataGeneratorError.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GeneratorError = exports.DataGeneratorError = exports.DataGeneratorConfigurationError = exports.AuthenticationError = void 0;
+class DataGeneratorError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DataGeneratorError';
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, DataGeneratorError);
+    }
+  }
+
+  /**
+   * Get formatted error message with error type and message
+   * @returns {string} Formatted error message
+   */
+  getMessage() {
+    return `\n\n ${this.name} :::  \n\n Error Message: ${this.message} \n\n `;
+  }
+}
+
+// Specific error for Data Generator configuration issues
+exports.DataGeneratorError = DataGeneratorError;
+class DataGeneratorConfigurationError extends DataGeneratorError {
+  constructor(message) {
+    super(message);
+    this.name = 'DataGeneratorConfigurationError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, DataGeneratorConfigurationError);
+    }
+  }
+}
+
+// Specific error for Generator related issues
+exports.DataGeneratorConfigurationError = DataGeneratorConfigurationError;
+class GeneratorError extends DataGeneratorError {
+  constructor(message) {
+    super(message);
+    this.name = 'GeneratorError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, GeneratorError);
+    }
+  }
+}
+exports.GeneratorError = GeneratorError;
+class AuthenticationError extends DataGeneratorError {
+  constructor(message) {
+    super(message);
+    this.name = 'AuthenticationError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, AuthenticationError);
+    }
+  }
+}
+exports.AuthenticationError = AuthenticationError;

package/build/core/dataGenerator/DataGeneratorHelper.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFeatureNameFromSpec = getFeatureNameFromSpec;
+exports.getGeneratorFilePath = getGeneratorFilePath;
+exports.getGeneratorFilePaths = getGeneratorFilePaths;
+exports.makeRequest = makeRequest;
+exports.postJson = postJson;
+exports.processGenerator = processGenerator;
+exports.translateGeneratorsToV2 = translateGeneratorsToV2;
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _configConstants = _interopRequireDefault(require("../playwright/constants/configConstants"));
+const DATA_GENERATORS_DIR = 'data-generators';
+const SPEC_FILE_SUFFIX = '.feature.spec.js';
+
+// Translate v1 generator field names to v2 equivalents.
+// generators.json files authored in v1 format (type:"dynamic", generatorOperationId, params, dataPath)
+// are converted to the v2 API shape. Only params→inputs is renamed; dataPath and all other fields
+// (including type and generatorOperationId) are passed through unchanged.
+function translateGeneratorsToV2(generators) {
+  if (!(generators !== null && generators !== void 0 && generators.length)) {
+    return [];
+  }
+  return generators.map(generator => {
+    const {
+      params,
+      ...rest
+    } = generator;
+    const translated = {
+      ...rest
+    };
+    if (params !== undefined && translated.inputs === undefined) {
+      translated.inputs = params;
+    }
+    return translated;
+  });
+}
+
+//Create payload for the generators
+async function processGenerator(generators, dataTable) {
+  if (!dataTable) {
+    return generators;
+  }
+  return generators.map(generator => {
+    dataTable.forEach(row => {
+      const generatorName = row.DG_API_NAME;
+      if (generatorName === generator.name) {
+        generator.params = generator.params ? generator.params : {};
+
+        // The API name row is only used for matching the template
+        // Filter out DG_API_NAME and collect other values
+        Object.entries(row).filter(([key]) => key !== 'DG_API_NAME').forEach(([key, value]) => {
+          if (value !== '') {
+            generator.params[key] = value;
+          }
+        });
+      }
+    });
+    return generator;
+  });
+}
+
+// Routes POST requests through Playwright's request context (page.request) so calls pick up
+// the proxy configured in playwright.config.js's `use.proxy`. Node's built-in fetch does not
+// read HTTP_PROXY/HTTPS_PROXY, which causes connect timeouts against internal hosts that are
+// only reachable via the corporate proxy.
+async function postJson(url, payload, page) {
+  try {
+    const response = await page.request.post(url, {
+      data: payload,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+    return {
+      ok: response.ok(),
+      status: response.status(),
+      text: () => response.text(),
+      json: () => response.json()
+    };
+  } catch (err) {
+    _logger.Logger.error(err);
+    throw new Error(`Error while making POST request to ${url}: ${err}`);
+  }
+}
+async function makeRequest(url, payload, page) {
+  const response = await postJson(url, payload, page);
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`Data Generator Service Error: status: ${response.status}, body: ${errorBody}`);
+  }
+  return response.json();
+}
+
+// Kept async for the existing call signature even though the work is synchronous.
+async function getGeneratorFilePath(featureFile) {
+  const GENERATED_FEATURE_SEGMENT = `${_configConstants.default.FEATURES_GEN_DIR}${_path.default.sep}`;
+  let generatorPath = featureFile.replace(GENERATED_FEATURE_SEGMENT, "");
+  return generatorPath;
+}
+
+// Feature name derived from the generated spec file,
+// e.g. ".../feature-files/GetDepartment.feature.spec.js" -> "GetDepartment"
+function getFeatureNameFromSpec(specFilePath) {
+  const specFileName = _path.default.basename(specFilePath);
+  return specFileName.slice(0, -SPEC_FILE_SUFFIX.length);
+}
+
+// Candidate generator files for a feature, in lookup order:
+//  1. per-feature file    -> <module>/data-generators/<FeatureName>.generators.json
+//  2. legacy shared file  -> <module>/data-generators/generators.json
+async function getGeneratorFilePaths(specFilePath) {
+  const featureName = getFeatureNameFromSpec(specFilePath);
+  const basePath = await getGeneratorFilePath(specFilePath);
+  const generatorDir = _path.default.join(basePath, '..', '..', DATA_GENERATORS_DIR);
+  return [_path.default.join(generatorDir, `${featureName}.generators.json`), _path.default.join(generatorDir, 'generators.json')];
+}

package/build/core/dataGenerator/authenticator/Authenticator.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+var _JWTauthenticator = _interopRequireDefault(require("./JWTauthenticator.js"));
+var _OAuthAuthenticator = _interopRequireDefault(require("./OAuthAuthenticator.js"));
+var _OrgOAuthAuthenticator = _interopRequireDefault(require("./OrgOAuthAuthenticator.js"));
+var _CookieAuthenticator = _interopRequireDefault(require("./CookieAuthenticator.js"));
+class Authenticator {
+  // Only route authentication augmentations; do not modify environment or base payload here.
+  async constructPayload(apiPayload, actorInfo, page = null) {
+    var _actorInfo$dataGener;
+    const authenticationLoaders = {
+      'jwt-auth': () => new _JWTauthenticator.default(),
+      'iam-oauth2-schema': () => new _OAuthAuthenticator.default(),
+      'org-oauth': () => new _OrgOAuthAuthenticator.default(),
+      'cookie-auth': () => new _CookieAuthenticator.default()
+    };
+    const authentications = (actorInfo === null || actorInfo === void 0 || (_actorInfo$dataGener = actorInfo['data-generator']) === null || _actorInfo$dataGener === void 0 || (_actorInfo$dataGener = _actorInfo$dataGener.account) === null || _actorInfo$dataGener === void 0 ? void 0 : _actorInfo$dataGener.authentications) || [];
+    const authenticationTypes = authentications.map(auth => String(auth).toLowerCase()).filter(Boolean);
+    for (const authenticationType of authenticationTypes) {
+      const authenticatorLoader = authenticationLoaders[authenticationType];
+      if (!authenticatorLoader) {
+        throw new _DataGeneratorError.AuthenticationError(`Unknown authentication type: "${authenticationType}". Supported types are: ${Object.keys(authenticationLoaders).join(', ')}`);
+      }
+      const authenticatorInstance = await authenticatorLoader();
+      apiPayload = await authenticatorInstance.constructPayload(apiPayload, actorInfo, page);
+      break;
+    }
+    return apiPayload;
+  }
+}
+exports.default = Authenticator;

package/build/core/dataGenerator/authenticator/CookieAuthenticator.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cookieAuthConfig = require("./cookieAuthConfig.js");
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * CookieAuthenticator prepares the payload for cookie-based authentication.
+ * It extracts cookies from the browser page context and attaches them
+ * as cookieAuthHeaders in the account block for the data generator service.
+ */
+class CookieAuthenticator {
+  async constructPayload(apiPayload, actorInfo, page = null) {
+    if (!page) {
+      throw new _DataGeneratorError.AuthenticationError('Cookie authentication failed: "page" is required but was not provided');
+    }
+    const {
+      csrfHeaderName
+    } = _cookieAuthConfig.COOKIE_AUTH_CONFIG;
+    const {
+      csrfToken,
+      cookieString
+    } = await _getCookies.call(CookieAuthenticator, page);
+    apiPayload.account.authHeaders = {
+      Cookie: cookieString,
+      [csrfHeaderName]: csrfToken
+    };
+    return apiPayload;
+  }
+}
+async function _getCookies(page) {
+  const {
+    csrfCookieName,
+    csrfParamName
+  } = _cookieAuthConfig.COOKIE_AUTH_CONFIG;
+  const context = page.context();
+  const pageUrl = new URL(page.url());
+  const currentDomain = pageUrl.hostname;
+  const cookies = await context.cookies([page.url()]);
+  const csrfCookies = cookies.filter(cookie => cookie.domain.includes(currentDomain) && cookie.name === csrfCookieName);
+  return {
+    csrfToken: csrfCookies.map(c => `${csrfParamName}=${c.value}`).join('; '),
+    cookieString: cookies.map(c => `${c.name}=${c.value}`).join('; ')
+  };
+}
+var _default = exports.default = CookieAuthenticator;

package/build/core/dataGenerator/authenticator/JWTauthenticator.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+var _DataGeneratorHelper = require("../DataGeneratorHelper.js");
+/**
+ * JWTauthenticator constructs payload by fetching a JWT access token
+ * from the authenticator app and attaching it to the account.jwt config.
+ */
+class JWTauthenticator {
+  async constructPayload(apiPayload, actorInfo, page = null) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('JWT authentication failed: "account" is missing in actor configuration');
+    }
+    const jwtConf = account['jwt-oauth'];
+    if (!jwtConf) {
+      throw new _DataGeneratorError.AuthenticationError('JWT authentication failed: "jwt-oauth" is missing in actor configuration');
+    }
+
+    // Build payload for authenticator service
+    const userToken = encodeURIComponent((actorInfo === null || actorInfo === void 0 ? void 0 : actorInfo.email) || '');
+    const jwtAuthUrl = process.env.DG_JWT_AUTH_URL;
+    const responseType = jwtConf.response_type;
+    const clientId = jwtConf.client_id;
+    const tokenUrl = jwtConf.token_url;
+    const domainUrl = process.env.DG_DOMAIN_URL;
+    const authPayload = {
+      user_token: userToken,
+      jwt_secret: jwtConf.jwt_secret,
+      jwt_auth_url: jwtAuthUrl,
+      response_type: responseType,
+      client_id: clientId,
+      token_url: tokenUrl,
+      domain_url: domainUrl
+    };
+    const authenticatorApi = process.env.DG_JWT_AUTHENTICATOR_API;
+    const resp = await (0, _DataGeneratorHelper.postJson)(authenticatorApi, authPayload, page);
+    if (!resp.ok) {
+      const errorBody = await resp.text();
+      throw new Error(`JWT authenticator error! status: ${resp.status}, body: ${errorBody}`);
+    }
+    const json = await resp.json();
+    const accessToken = json === null || json === void 0 ? void 0 : json.access_token;
+    if (!accessToken) {
+      throw new Error('JWT authenticator did not return access_token');
+    }
+
+    // Attach access token to authHeaders so downstream API calls can use it directly
+    apiPayload.account = apiPayload.account || {};
+    apiPayload.account.authHeaders = apiPayload.account.authHeaders || {};
+    apiPayload.account.authHeaders.Authorization = `Zoho-oauthtoken ${accessToken}`;
+    return apiPayload;
+  }
+}
+var _default = exports.default = JWTauthenticator;

package/build/core/dataGenerator/authenticator/OAuthAuthenticator.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * OAuthAuthenticator prepares the payload for OAuth2-based authentication.
+ * It ensures oauth2 config is present in the account block so the
+ * data generator service can use it.
+ */
+class OAuthAuthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('OAuth2 authentication failed: "account" is missing in actor configuration');
+    }
+    if (!account.oauth2) {
+      throw new _DataGeneratorError.AuthenticationError('OAuth2 authentication failed: "oauth2" is missing in actor configuration');
+    }
+    apiPayload.account.oauth2 = account.oauth2;
+    return apiPayload;
+  }
+}
+var _default = exports.default = OAuthAuthenticator;

package/build/core/dataGenerator/authenticator/OrgOAuthAuthenticator.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * OrgOAuthAuthenticator prepares the payload for org_oauth authentication.
+ * It ensures org_oauth config is present in the account block so the
+ * data generator service can use it.
+ */
+class OrgOAuthAuthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('OrgOAuth authentication failed: "account" is missing in actor configuration');
+    }
+    if (!account.org_oauth) {
+      throw new _DataGeneratorError.AuthenticationError('OrgOAuth authentication failed: "org_oauth" is missing in actor configuration');
+    }
+    apiPayload.account.org_oauth = account.org_oauth;
+    return apiPayload;
+  }
+}
+var _default = exports.default = OrgOAuthAuthenticator;

package/build/core/dataGenerator/authenticator/cookieAuthConfig.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COOKIE_AUTH_CONFIG = void 0;
+const COOKIE_AUTH_CONFIG = exports.COOKIE_AUTH_CONFIG = {
+  csrfHeaderName: 'X-ZCSRF-TOKEN',
+  csrfCookieName: 'crmcsr',
+  csrfParamName: 'crmcsrfparam'
+};

package/build/core/jest/preprocessor/jsPreprocessor.js

@@ -1,12 +1,7 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _babelJest = _interopRequireDefault(require("babel-jest"));
-var _default = exports.default = _babelJest.default.createTransformer({
+const babelJest = require('babel-jest');
+module.exports = babelJest.createTransformer({
   presets: [require.resolve('@babel/preset-env'), require.resolve('@babel/preset-react')],
   plugins: [require.resolve('babel-plugin-transform-dynamic-import')]
 });

package/build/core/jest/setup/index.js

@@ -1,9 +1,3 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _testUtils = _interopRequireDefault(require("react-dom/test-utils"));
-var _globals = require("@jest/globals");
-var _react = _interopRequireDefault(require("react"));
-var _propTypes = _interopRequireDefault(require("prop-types"));
-var _reactDom = _interopRequireDefault(require("react-dom"));
-require("@testing-library/jest-dom/extend-expect");
+require("@testing-library/jest-dom");