@zohodesk/testinglibrary 0.0.54-n20-experimental → 0.0.58-n20-experimental

package/AUTO_CLEANUP_PLAN.md

@@ -0,0 +1,171 @@
+# Data Generator System — Design & Current State
+
+## Data Generator Overview
+
+### How It Works
+- BDD step: `Given generate a "{Type}" entity "{name}" with generator "{GeneratorName}"`
+- Framework builds a **global generator index** at first use — scans all `*.generators.json` files under `modules/`
+- Generator names must be **unique across the entire UAT suite**
+- `ZDTestingFramework validate` checks for duplicate generator names before test run
+- Data generated using **org-level OAuth credentials** (org-oauth) by default
+- When scenario runs under a non-admin profile (`@profile_agent`), data generation still uses org-level `data-generator` — falls back automatically if profile has no own credentials
+
+### Generator File Convention
+- **Pattern:** `*.generators.json` (configurable via `generatorFilePattern` in `uat.config.js`)
+- **Location:** anywhere under `modules/` — discovered globally via recursive scan
+- **Examples:** `ticket.generators.json`, `account.generators.json`, `webhook.generators.json`
+
+### Generator JSON Structure
+```json
+{
+    "generators": {
+        "GeneratorName": [
+            {
+                "type": "dynamic",
+                "name": "stepName",
+                "generatorOperationId": "support.Module.operationName",
+                "dataPath": "$.response.body:$",
+                "params": { "key": "$previousStep.value" }
+            }
+        ]
+    }
+}
+```
+
+### Discovery Mechanism
+- **Index-based** — built once, O(1) lookups
+- `#getModulesRoot()` uses `configConstants.TEST_SLICE_FOLDER + stage + 'modules'` (deterministic)
+- Scans recursively for files matching `generatorFilePattern` (default: `*.generators.json`)
+- First generator name match wins (no duplicates enforced by validator)
+
+### Profile Resolution for Data Generation
+- **Default (no `using` profile):** Uses org-level `data-generator` from edition JSON. If scenario profile (e.g., `@profile_agent`) has no `data-generator`, falls back to org-level via `getListOfActors()`.
+- **Explicit profile (`using "agent" profile`):** Resolves that profile's credentials via `getUserForSelectedEditionAndProfile()`.
+
+### Constraints
+| Constraint | Detail |
+|---|---|
+| **Unique generator names** | Generator names must be unique across all `*.generators.json` files |
+| **Global discovery** | Framework scans entire `modules/` tree — generators in any module are accessible from any feature file |
+| **File pattern** | Configurable via `generatorFilePattern` in `uat.config.js` (default: `*.generators.json`) |
+| **DG_API_NAME matching** | In Gherkin data tables, `DG_API_NAME` column matches generator step's `name` field to inject params |
+| **Chained steps** | Multi-step generators use `$previousStep.value` syntax to pass output between steps |
+| **dataPath extraction** | `dataPath` uses JSONPath to extract specific fields from DG service response |
+| **Cached response** | Generated data is cached via `cacheLayer.set(entityName, response.data)` for use in subsequent steps |
+| **Org-level auth fallback** | If profile has no `data-generator`, org-level config from edition JSON is used automatically |
+
+---
+
+## Current Generators
+
+| Generator | File | Steps | Used By |
+|---|---|---|---|
+| `TicketWithDepartment` | `Ticket/data-generators/ticket.generators.json` | getDepartments → createProduct → createTicket | 452+ scenarios |
+| `TicketBasic` | `Ticket/data-generators/ticket.generators.json` | getDepartments → createTicket (no product) | Express/Free editions |
+| `CreateAccountRecord` | `Account/data-generators/account.generators.json` | createAccount | 37 scenarios |
+| `CreateContactRecord` | `Contact/data-generators/contact.generators.json` | createContact | 42 scenarios |
+| `CreateContractRecord` | `Contract/DV/Subtabs/*/data-generators/contract.generators.json` | getDepartments → createAccount → createContract | 4 scenarios |
+| `CreateWebhookRecord` | `Webhooks/List/data-generators/webhook.generators.json` | createWebhook (with default subscriptions) | Webhook scenarios |
+| `ProductWithDepartment` | `Search/products/data-generators/products.generators.json` | getDepartments → createProduct | Product/Search scenarios |
+
+---
+
+## Auto-Cleanup — Design (Not Yet Implemented)
+
+### Status
+- **V1 implemented then removed** in `0.0.47` — CleanupTracker + DataCleanup were too tightly coupled
+- **V2 planned** — proper redesign needed
+
+### Why Cleanup Was Removed
+1. `cleanupTracker` fixture added complexity to all step definitions (extra parameter)
+2. Cleanup ran inside fixture teardown — failures were hard to debug
+3. REST API cleanup needed auth that wasn't available in the cleanup context
+4. No way to control cleanup order for cross-entity dependencies
+
+### V2 Design Principles
+1. **Cleanup config stays in generator JSON** — `cleanup` property on each step (same as V1)
+2. **Separate cleanup phase** — not in fixture teardown, but as explicit post-scenario hook
+3. **Auth-aware** — cleanup uses the same `actorInfo` that created the data
+4. **Configurable** — cleanup can be disabled per scenario or globally
+5. **Non-blocking** — cleanup failures never fail the test
+
+### Cleanup Types (unchanged from V1 design)
+
+#### Type 1: `oas` — DG service delete
+```json
+"cleanup": {
+    "type": "oas",
+    "operationId": "support.Contact.deleteContact",
+    "idPath": "$.id"
+}
+```
+
+#### Type 2: `api` — Direct REST API DELETE
+```json
+"cleanup": {
+    "type": "api",
+    "method": "DELETE",
+    "apiPath": "/api/v1/contracts/{id}",
+    "idPath": "$.id"
+}
+```
+
+#### Type 3: `api` — Disable via PATCH
+```json
+"cleanup": {
+    "type": "api",
+    "method": "PATCH",
+    "apiPath": "/api/v1/webhooks/{id}",
+    "idPath": "$.id",
+    "body": { "isActive": false }
+}
+```
+
+#### No cleanup — read-only operations
+Steps without `cleanup` property are skipped (e.g., `getDepartments`).
+
+### V2 Implementation Plan
+
+1. **CleanupManager** (replaces CleanupTracker + DataCleanup)
+   - Single class managing both tracking and execution
+   - Runs after scenario via `testSetup` hook (not fixture teardown)
+   - Uses `actorInfo` from the generation step for auth
+
+2. **Config flag** in `uat.config.js`:
+   ```javascript
+   autoCleanup: true,  // default: true
+   cleanupTimeout: 30000  // per-entity timeout
+   ```
+
+3. **Per-scenario opt-out** via tag:
+   ```gherkin
+   @skip_cleanup
+   Scenario: Test that needs data to persist
+   ```
+
+4. **Cleanup order**: reverse of creation (dependent entities first)
+
+---
+
+## Seed Data System — Design (Planned)
+
+See `SEED_DATA_PLAN.md` in the consumer repo for the full design.
+
+### Summary
+- **Edition-scoped** — data maps to edition tiers, not portal names
+- **Profile-based** — support creating data as specific profiles (agent login)
+- **OAS + REST** — both API types supported
+- **Runs before scenarios** — in `page.js` fixture after login
+- **Idempotent** — skips existing data, creates only missing
+
+---
+
+## Multi-DC Portability — Design (Planned)
+
+See `MULTI_DC_STRATEGY.md` in the consumer repo for the full design.
+
+### Summary
+- **`capability` field** on each portal for DC-agnostic resolution
+- **Department aliases** in portal config for cross-DC mapping
+- **Framework resolves** by `capability` first, `orgName` fallback
+- **Same feature files** work across all DCs

package/README.md

@@ -17,6 +17,14 @@
 
      - npm run report
 
+### v0.0.44-n20-experimental - 23-03-2026
+
+#### Enhancement
+- DataGenerator now walks up the directory tree to discover data-generators folders
+- Supports multiple JSON files in data-generators directory (no longer hardcoded to generators.json)
+- Removed hardcoded folder name dependencies for flexible generator file placement
+- Added duplicate generator name validation to `ZDTestingFramework validate` command
+
 ### v4.1.1/v3.3.0 - 28-01-2026
 
 #### Features

package/build/common/data-generator/steps/DataGenerator.spec.js

@@ -1,5 +1,5 @@
 import { createBdd , test } from '@zohodesk/testinglibrary';
-import { generateAndCacheTestData } from './DataGeneratorStepsHelper';  
+import { generateAndCacheTestData } from './DataGeneratorStepsHelper';
 
 const { Given } = createBdd();
 

package/build/common/data-generator/steps/DataGeneratorStepsHelper.js

@@ -1,6 +1,6 @@
 import { test } from '@zohodesk/testinglibrary';
 import DataGenerator from '@zohodesk/testinglibrary/DataGenerator';
- import {getUserForSelectedEditionAndProfile} from '@zohodesk/testinglibrary/helpers'
+import {getUserForSelectedEditionAndProfile, getListOfActors} from '@zohodesk/testinglibrary/helpers'
 
 const dataGenerator = new DataGenerator();
 
@@ -10,12 +10,27 @@ export async function generateAndCacheTestData(executionContext, type, identifie
     const scenarioName = testInfo.title.split('/').pop() || 'Unknown Scenario';
 
     if (profile) {
+        // Explicit profile requested — resolve that profile's credentials
         const { edition, orgName: portal, beta } = executionContext.actorInfo;
         actorInfo = await getUserForSelectedEditionAndProfile(edition, profile, beta, portal);
     } else {
+        // Default — use current actor, fall back to org-level data-generator if profile has none
         actorInfo = executionContext.actorInfo;
+        if (!actorInfo['data-generator']) {
+            const { edition, orgName: portal, beta } = actorInfo;
+            const actorsData = getListOfActors(beta);
+            const portalData = actorsData.editions[edition]?.find(e => e.orgName === portal);
+            if (portalData?.['data-generator']) {
+                actorInfo = { ...actorInfo, 'data-generator': portalData['data-generator'] };
+            }
+        }
+    }
+
+    const { response, generators } = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : [], cacheLayer);
+    if (cacheLayer._trackForCleanup) {
+        cacheLayer._trackForCleanup(entityName, response.data, generators, actorInfo, response.logs, identifier);
+    } else {
+        cacheLayer.set(entityName, response.data);
+        cacheLayer.set(`${entityName}_logs`, response.logs);
     }
-    
-    const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
-    await cacheLayer.set(entityName, generatedData.data);
 }

package/build/core/dataGenerator/DataGenerator.js

@@ -8,61 +8,140 @@ exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _logger = require("../../utils/logger");
+var _timeFormat = require("../../utils/timeFormat");
 var _DataGeneratorHelper = require("./DataGeneratorHelper");
-var _helpers = require("@zohodesk/testinglibrary/helpers");
+var _datePlaceholders = require("../../utils/datePlaceholders");
 var _DataGeneratorError = require("./DataGeneratorError");
+var _readConfigFile = require("../playwright/readConfigFile");
+var _configConstants = _interopRequireDefault(require("../playwright/constants/configConstants"));
+var _ConfigurationHelper = require("../playwright/configuration/ConfigurationHelper");
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
 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 _generatorIndex = /*#__PURE__*/new WeakMap();
 var _DataGenerator_brand = /*#__PURE__*/new WeakSet();
 class DataGenerator {
   constructor() {
     _classPrivateMethodInitSpec(this, _DataGenerator_brand);
+    _classPrivateFieldInitSpec(this, _generatorIndex, null);
   }
-  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable) {
+  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable, cacheLayer) {
+    const startMs = Date.now();
+    const startLabel = (0, _timeFormat.formatTimestamp)(startMs);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Data generation started   | generator="${generatorName}" | scenario="${scenarioName}" | startTime=${startLabel}`);
     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);
+        generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, generatorName);
       }
-      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
+
+      // Clone to prevent cross-test mutation of the cached generator index.
+      const generatorsCopy = generators.map(g => ({
+        ...g,
+        params: g.params ? {
+          ...g.params
+        } : undefined
+      }));
+      (0, _datePlaceholders.resolveDatePlaceholdersInGenerators)(generatorsCopy);
+      const dateResolvedTable = (0, _datePlaceholders.resolveDatePlaceholders)(dataTable);
+      const resolvedDataTable = await (0, _DataGeneratorHelper.resolveCacheReferences)(dateResolvedTable, cacheLayer);
+      const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generatorsCopy, resolvedDataTable);
       const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo);
-      const response = await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, apiPayload);
-      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generated response for the generator: ${generatorName} for scenario: ${scenarioName}, Response: ${JSON.stringify(response)}`);
-      return response;
+      const featureFlags = process.env.featureflags ? process.env.featureflags : '';
+      const headers = {
+        'Content-Type': 'application/json',
+        'featureflags': featureFlags
+      };
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Making request headers:', headers);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Payload:  ${JSON.stringify(apiPayload, null, 4)}`);
+      const response = await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, apiPayload, headers);
+      const endMs = Date.now();
+      const endLabel = (0, _timeFormat.formatTimestamp)(endMs);
+      const totalLabel = (0, _timeFormat.formatDuration)(endMs - startMs);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generated response for the generator: ${generatorName} for scenario: ${scenarioName}, Response: ${JSON.stringify(response, null, 4)}`);
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `Data generation completed | generator="${generatorName}" | scenario="${scenarioName}" | startTime=${startLabel} | endTime=${endLabel} | totalTime=${totalLabel}`);
+      return {
+        response,
+        generators
+      };
     } catch (error) {
+      const endMs = Date.now();
+      const endLabel = (0, _timeFormat.formatTimestamp)(endMs);
+      const totalLabel = (0, _timeFormat.formatDuration)(endMs - startMs);
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Data generation failed    | generator="${generatorName}" | scenario="${scenarioName}" | startTime=${startLabel} | endTime=${endLabel} | totalTime=${totalLabel}`);
       if (error instanceof _DataGeneratorError.DataGeneratorError) {
-        console.error(error.getMessage());
-        console.error("Stack trace:", error.stack);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error.getMessage());
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "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 Type:", error.constructor.name);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "Error Message:", error.message);
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, "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);
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Data Generation failed for the generator: ${generatorName}\n\nError response: ${error}`);
       throw error;
     }
   }
 }
-async function _getGenerator(testInfo, generatorName) {
-  let generator = null;
-  let generatorFilePath = await (0, _DataGeneratorHelper.getGeneratorFilePath)(testInfo.file);
-  generatorFilePath = _path.default.join(generatorFilePath, "../../data-generators/generators.json");
-  if (_fs.default.existsSync(generatorFilePath)) {
-    const data = _fs.default.readFileSync(generatorFilePath, 'utf8');
-    const generatorObj = JSON.parse(data);
-    if (generatorName || generatorObj.generators) {
-      generator = generatorObj.generators[generatorName] || null;
+function _matchesPattern(filename, pattern) {
+  const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+  return regex.test(filename);
+}
+function _scanDir(dir, index, pattern) {
+  const entries = _fs.default.readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const fullPath = _path.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      _assertClassBrand(_DataGenerator_brand, this, _scanDir).call(this, fullPath, index, pattern);
+    } else if (_assertClassBrand(_DataGenerator_brand, this, _matchesPattern).call(this, entry.name, pattern)) {
+      try {
+        const data = _fs.default.readFileSync(fullPath, 'utf8');
+        const obj = JSON.parse(data);
+        if (obj.generators) {
+          for (const [name, config] of Object.entries(obj.generators)) {
+            if (!index.has(name)) {
+              index.set(name, config);
+            }
+          }
+        }
+      } catch (err) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse generator file: ${fullPath} - ${err.message}`);
+      }
+    }
+  }
+}
+function _buildIndex(modulesRoot, pattern) {
+  const index = new Map();
+  _assertClassBrand(_DataGenerator_brand, this, _scanDir).call(this, modulesRoot, index, pattern);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generator index built: ${index.size} generators found`);
+  return index;
+}
+function _getModulesRoot() {
+  const stage = (0, _ConfigurationHelper.getRunStage)();
+  return _path.default.join(process.cwd(), _configConstants.default.TEST_SLICE_FOLDER, stage, 'modules');
+}
+async function _getGenerator(generatorName) {
+  if (!_classPrivateFieldGet(_generatorIndex, this)) {
+    const modulesRoot = _assertClassBrand(_DataGenerator_brand, this, _getModulesRoot).call(this);
+    const {
+      generatorFilePattern: pattern = '*.generators.json'
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    if (modulesRoot) {
+      _classPrivateFieldSet(_generatorIndex, this, _assertClassBrand(_DataGenerator_brand, this, _buildIndex).call(this, modulesRoot, pattern));
     }
   }
-  if (!generator) {
-    throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in the path located at "${generatorFilePath}"`);
+  if (_classPrivateFieldGet(_generatorIndex, this) && _classPrivateFieldGet(_generatorIndex, this).has(generatorName)) {
+    return _classPrivateFieldGet(_generatorIndex, this).get(generatorName);
   }
-  return generator;
+  throw new _DataGeneratorError.GeneratorError(`Generator "${generatorName}" could not be found in any generator file`);
 }
 async function _generateAPIGenerator(operationId) {
   return [{

package/build/core/dataGenerator/DataGeneratorHelper.js

@@ -6,6 +6,54 @@ Object.defineProperty(exports, "__esModule", {
 exports.getGeneratorFilePath = getGeneratorFilePath;
 exports.makeRequest = makeRequest;
 exports.processGenerator = processGenerator;
+exports.resolveCacheReferences = resolveCacheReferences;
+// Matches a single ${EntityName} or ${EntityName.field.path} cell value.
+// Anchored — values like "foo ${E1.id} bar" are left as-is on purpose.
+const CACHE_REF = /^\$\{([A-Za-z_][\w-]*)(?:\.([A-Za-z_][\w.-]*))?\}$/;
+
+// Resolve ${EntityName} / ${EntityName.field.path} references in a dataTable
+// against the cacheLayer. Lets a later `generate ...` step reference an entity
+// that an earlier step cached (e.g. ${E1.id} for an event created in a prior
+// generator invocation).
+async function resolveCacheReferences(rows, cacheLayer) {
+  if (!rows || !rows.length || !cacheLayer || typeof cacheLayer.get !== 'function') {
+    return rows || [];
+  }
+  const out = [];
+  for (const row of rows) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(row)) {
+      const match = typeof value === 'string' ? value.match(CACHE_REF) : null;
+      if (!match) {
+        resolved[key] = value;
+        continue;
+      }
+      const [, entityName, fieldPath] = match;
+      const entity = await cacheLayer.get(entityName);
+      if (entity === undefined || entity === null) {
+        throw new Error(`DataGenerator: ${value} references entity "${entityName}" which is not in the cache.`);
+      }
+      if (!fieldPath) {
+        resolved[key] = entity;
+        continue;
+      }
+      let acc = entity;
+      for (const part of fieldPath.split('.')) {
+        if (acc === undefined || acc === null) {
+          break;
+        }
+        acc = acc[part];
+      }
+      if (acc === undefined) {
+        throw new Error(`DataGenerator: ${value} resolved to undefined (entity "${entityName}" has no path "${fieldPath}").`);
+      }
+      resolved[key] = acc;
+    }
+    out.push(resolved);
+  }
+  return out;
+}
+
 //Create payload for the generators
 async function processGenerator(generators, dataTable) {
   if (!dataTable) {
@@ -29,12 +77,12 @@ async function processGenerator(generators, dataTable) {
     return generator;
   });
 }
-async function makeRequest(url, payload) {
+async function makeRequest(url, payload, headers = {
+  'Content-Type': 'application/json'
+}) {
   const response = await fetch(url, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
+    headers: headers,
     body: JSON.stringify(payload)
   });
   if (!response.ok) {

package/build/core/dataGenerator/validateGenerators.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateGenerators = validateGenerators;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _logger = require("../../utils/logger");
+var _readConfigFile = require("../playwright/readConfigFile");
+function matchesPattern(filename, pattern) {
+  const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+  return regex.test(filename);
+}
+function findGeneratorFiles(dir, pattern, results = []) {
+  const entries = _fs.default.readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const fullPath = _path.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      findGeneratorFiles(fullPath, pattern, results);
+    } else if (matchesPattern(entry.name, pattern)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function validateGenerators(modulesRoot) {
+  if (!_fs.default.existsSync(modulesRoot)) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Modules directory not found: ${modulesRoot}. Skipping generator validation.`);
+    return {
+      valid: true,
+      duplicates: []
+    };
+  }
+  const {
+    generatorFilePattern: pattern = '*.generators.json'
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const generatorMap = {};
+  const generatorFiles = findGeneratorFiles(modulesRoot, pattern);
+  for (const filePath of generatorFiles) {
+    try {
+      const data = _fs.default.readFileSync(filePath, 'utf8');
+      const generatorObj = JSON.parse(data);
+      if (generatorObj.generators) {
+        for (const name of Object.keys(generatorObj.generators)) {
+          if (!generatorMap[name]) {
+            generatorMap[name] = [];
+          }
+          generatorMap[name].push(filePath);
+        }
+      }
+    } catch (err) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Failed to parse generator file: ${filePath} - ${err.message}`);
+    }
+  }
+  const duplicates = Object.entries(generatorMap).filter(([, files]) => files.length > 1).map(([name, files]) => ({
+    name,
+    files
+  }));
+  if (duplicates.length > 0) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Duplicate generator names found:');
+    for (const dup of duplicates) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `  Generator "${dup.name}" defined in:`);
+      for (const file of dup.files) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `    - ${file}`);
+      }
+    }
+    return {
+      valid: false,
+      duplicates
+    };
+  }
+  const generatorCount = Object.keys(generatorMap).length;
+  _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `Generator validation passed. ${generatorCount} unique generators found across ${generatorFiles.length} generator files.`);
+  return {
+    valid: true,
+    duplicates: []
+  };
+}