@codeyam/codeyam-cli 0.1.0-staging.ad31e3e → 0.1.0-staging.b8a55ba

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateDataStructure.ts

@@ -13,6 +13,7 @@ import {
 import mergeInDependentDataStructure from './mergeInDependentDataStructure';
 import { awsLog } from '~codeyam/utils';
 import gatherDataForMocks from './gatherDataForMocks';
+import enrichArrayTypesFromChildSignatures from './enrichArrayTypesFromChildSignatures';
 
 export interface GenerateDataStructureArgs {
   entity: Entity;
@@ -31,12 +32,6 @@ export default function generateDataStructure({
     awsLog('CodeYam: Generating data structure for', {
       filePath: entity.filePath,
       entityName: entity.name,
-      // dependentAnalyses: Object.keys(dependentAnalyses).flatMap((path) =>
-      //   Object.keys(dependentAnalyses[path]).flatMap((entityName) => ({
-      //     path,
-      //     entityName,
-      //   })),
-      // ),
     });
 
     const allImportedExports = [
@@ -51,6 +46,58 @@ export default function generateDataStructure({
           ),
       ),
     ];
+
+    // For implicit dependencies (like root.tsx layouts), include their mocked nodeModuleImports
+    // This ensures layout file dependencies (like useLoaderData in root.tsx) are included in dataForMocks
+    // when simulating routes that are wrapped by those layout files
+    for (const importedExport of entity.metadata.importedExports ?? []) {
+      if (
+        !('isImplicitDependency' in importedExport) ||
+        !importedExport.isImplicitDependency
+      ) {
+        continue;
+      }
+
+      // Look up the implicit dependency's analysis
+      const implicitDepAnalysis =
+        dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+
+      // Access nodeModuleImports from the entity attached to the analysis
+      const nodeModuleImports =
+        implicitDepAnalysis?.entity?.metadata?.nodeModuleImports;
+      if (!nodeModuleImports) {
+        continue;
+      }
+
+      // Add the implicit dependency's mocked nodeModuleImports to allImportedExports
+      for (const moduleName of Object.keys(nodeModuleImports)) {
+        const moduleImports = nodeModuleImports[moduleName] || [];
+        for (const imported of moduleImports) {
+          if (!imported.isMocked) continue;
+
+          // Only add if not already present (avoid duplicates)
+          const alreadyExists = allImportedExports.some(
+            (existing) =>
+              existing.filePath === moduleName &&
+              existing.name === imported.name,
+          );
+
+          if (!alreadyExists) {
+            allImportedExports.push({
+              filePath: moduleName,
+              name: imported.name,
+              isDefault: imported.isDefault,
+              isMocked: imported.isMocked,
+              calls: imported.calls ? [...imported.calls] : undefined,
+              callVariableNames: imported.callVariableNames
+                ? [...imported.callVariableNames]
+                : undefined,
+            });
+          }
+        }
+      }
+    }
+
     const nonMockedDependentAnalyses: ReadonlyAnalysisMap =
       allImportedExports.reduce((acc, importedExport) => {
         if (importedExport.isMocked) return acc;
@@ -112,6 +159,179 @@ export default function generateDataStructure({
         return acc;
       }, {} as ReadonlyAnalysisMap);
 
+    // For non-mocked child components (like visual components), include their mocked
+    // dependencies in allImportedExports. This ensures that when a parent component
+    // renders a child that uses the same hook with different destructure patterns,
+    // both patterns get separate mock data keys.
+    //
+    // Example: DashboardPage uses QuotesTableCompact (child, not mocked).
+    // Both use useFlags hook but destructure different properties:
+    // - DashboardPage: const { enableNewAdminDashboard } = useFlags()
+    // - QuotesTableCompact: const { flagShowReferenceIdOnQuoteTable } = useFlags()
+    // We need mock data keys for BOTH destructure patterns.
+    //
+    // We need to traverse the ENTIRE dependency tree recursively because nested
+    // child components (e.g., QuotesTableCompact inside AdminDashboard inside
+    // DashboardPage) also have mocked dependencies that need mock data keys.
+
+    // Helper function to add mocked imports from an entity to allImportedExports
+    const addMockedImportsFromEntity = (childEntity: Entity | undefined) => {
+      if (!childEntity?.metadata) return;
+
+      // Add child's mocked nodeModuleImports
+      const childNodeModuleImports = childEntity.metadata.nodeModuleImports;
+      if (childNodeModuleImports) {
+        for (const moduleName of Object.keys(childNodeModuleImports)) {
+          const moduleImports = childNodeModuleImports[moduleName] || [];
+          for (const imported of moduleImports) {
+            if (!imported.isMocked) continue;
+
+            // Check if this import already exists in allImportedExports
+            const existingImport = allImportedExports.find(
+              (existing) =>
+                existing.filePath === moduleName &&
+                existing.name === imported.name,
+            );
+
+            if (existingImport) {
+              // Merge callVariableNames if the same dependency exists with different patterns
+              if (imported.callVariableNames && imported.calls) {
+                existingImport.calls = existingImport.calls || [];
+                existingImport.callVariableNames =
+                  existingImport.callVariableNames || [];
+
+                // Add each call/variable pair that doesn't already exist
+                for (let i = 0; i < imported.calls.length; i++) {
+                  const call = imported.calls[i];
+                  const varName = imported.callVariableNames[i];
+                  if (!varName) continue;
+
+                  // Check if this specific callVariableName already exists
+                  if (!existingImport.callVariableNames.includes(varName)) {
+                    existingImport.calls.push(call);
+                    existingImport.callVariableNames.push(varName);
+                  }
+                }
+              }
+            } else {
+              // Add new import
+              allImportedExports.push({
+                filePath: moduleName,
+                name: imported.name,
+                isDefault: imported.isDefault,
+                isMocked: imported.isMocked,
+                calls: imported.calls ? [...imported.calls] : undefined,
+                callVariableNames: imported.callVariableNames
+                  ? [...imported.callVariableNames]
+                  : undefined,
+              });
+            }
+          }
+        }
+      }
+
+      // Add child's mocked importedExports
+      const childImportedExports = childEntity.metadata.importedExports;
+      if (childImportedExports) {
+        for (const imported of childImportedExports) {
+          if (!imported.isMocked) continue;
+
+          // Check if this import already exists in allImportedExports
+          const existingImport = allImportedExports.find(
+            (existing) =>
+              existing.filePath === imported.filePath &&
+              existing.name === imported.name,
+          );
+
+          if (existingImport) {
+            // Merge callVariableNames if the same dependency exists with different patterns
+            if (imported.callVariableNames && imported.calls) {
+              existingImport.calls = existingImport.calls || [];
+              existingImport.callVariableNames =
+                existingImport.callVariableNames || [];
+
+              // Add each call/variable pair that doesn't already exist
+              for (let i = 0; i < imported.calls.length; i++) {
+                const call = imported.calls[i];
+                const varName = imported.callVariableNames[i];
+                if (!varName) continue;
+
+                // Check if this specific callVariableName already exists
+                if (!existingImport.callVariableNames.includes(varName)) {
+                  existingImport.calls.push(call);
+                  existingImport.callVariableNames.push(varName);
+                }
+              }
+            }
+          } else {
+            // Add new import
+            allImportedExports.push({
+              filePath: imported.filePath,
+              name: imported.name,
+              isDefault: imported.isDefault,
+              isMocked: imported.isMocked,
+              calls: imported.calls ? [...imported.calls] : undefined,
+              callVariableNames: imported.callVariableNames
+                ? [...imported.callVariableNames]
+                : undefined,
+            });
+          }
+        }
+      }
+    };
+
+    // Recursive function to traverse the dependency tree
+    const processedAnalyses = new Set<string>();
+    const traverseDependencyTree = (analyses: ReadonlyAnalysisMap) => {
+      for (const filePath in analyses) {
+        for (const name in analyses[filePath]) {
+          const analysisKey = `${filePath}:${name}`;
+          if (processedAnalyses.has(analysisKey)) continue;
+          processedAnalyses.add(analysisKey);
+
+          const childAnalysis = analyses[filePath][name];
+          const childEntity = childAnalysis?.entity;
+
+          // Add mocked imports from this child entity
+          addMockedImportsFromEntity(childEntity as Entity | undefined);
+
+          // Recursively process this child's non-mocked children
+          // via their mergedDataStructure's nested dependentAnalyses
+          const childMergedDataStructure =
+            childAnalysis?.metadata?.mergedDataStructure;
+          if (childMergedDataStructure?.dependencySchemas) {
+            // We need to find non-mocked child components in the dependency tree
+            // These would be in the child's importedExports that are NOT mocked
+            const childImportedExports =
+              childEntity?.metadata?.importedExports ?? [];
+            const nonMockedChildDeps: ReadonlyAnalysisMap = {};
+
+            for (const dep of childImportedExports) {
+              if (dep.isMocked) continue;
+              if (dep.entityType !== 'visual') continue;
+
+              // Try to find this dependency in dependentAnalyses
+              const depFilePath = dep.resolvedFilePath ?? dep.filePath;
+              const depName = dep.resolvedName ?? dep.name;
+
+              if (dependentAnalyses[depFilePath]?.[depName]) {
+                nonMockedChildDeps[depFilePath] ||= {};
+                nonMockedChildDeps[depFilePath][depName] =
+                  dependentAnalyses[depFilePath][depName];
+              }
+            }
+
+            if (Object.keys(nonMockedChildDeps).length > 0) {
+              traverseDependencyTree(nonMockedChildDeps);
+            }
+          }
+        }
+      }
+    };
+
+    // Start traversal from direct non-mocked children
+    traverseDependencyTree(nonMockedDependentAnalyses);
+
     // console.info(
     //   'CODEYAM DEBUG: start merge',
     //   JSON.stringify(
@@ -129,6 +349,7 @@ export default function generateDataStructure({
     // );
 
     const { isolatedDataStructure } = entity.metadata;
+
     const mergedDataStructure = mergeInDependentDataStructure({
       importedExports: allImportedExports,
       dependentAnalyses: nonMockedDependentAnalyses,
@@ -197,9 +418,59 @@ export default function generateDataStructure({
     analysis.metadata ||= {};
     analysis.metadata.mergedDataStructure = mergedDataStructure;
 
+    // Enrich mocked dependency array types with fields from child component signatures
+    // This ensures that when getSurveysAction returns { data: array }, and SurveyCard
+    // expects survey.updatedAt, the array element type includes updatedAt
+    enrichArrayTypesFromChildSignatures(
+      allImportedExports,
+      mergedDataStructure.dependencySchemas,
+    );
+
+    // DEBUG: Log nodeModuleImports with isMocked status
+    const nodeModuleImportsFlattened = Object.entries(
+      entity.metadata.nodeModuleImports ?? {},
+    ).flatMap(([moduleName, imports]) =>
+      imports.map((i) => ({ moduleName, name: i.name, isMocked: i.isMocked })),
+    );
+    console.log(
+      'CodeYam DEBUG generateDataStructure:',
+      JSON.stringify(
+        {
+          entityName: entity.name,
+          nodeModuleImportsFlattened,
+          dependencySchemasKeys: Object.keys(
+            mergedDataStructure.dependencySchemas ?? {},
+          ),
+          dependencySchemasForRemix: mergedDataStructure.dependencySchemas?.[
+            '@remix-run/react'
+          ]
+            ? Object.keys(
+                mergedDataStructure.dependencySchemas['@remix-run/react'],
+              )
+            : null,
+        },
+        null,
+        2,
+      ),
+    );
+
     const dataForMocks = gatherDataForMocks(
       allImportedExports,
       mergedDataStructure.dependencySchemas,
+      { entityName: entity.name },
+    );
+
+    // DEBUG: Log the resulting dataForMocks
+    console.log(
+      'CodeYam DEBUG generateDataStructure dataForMocks result:',
+      JSON.stringify(
+        {
+          entityName: entity.name,
+          dataForMocksKeys: Object.keys(dataForMocks),
+        },
+        null,
+        2,
+      ),
     );
 
     // console.info(
@@ -215,6 +486,24 @@ export default function generateDataStructure({
     //   ),
     // );
 
+    // Log union types in signatureSchema before processing
+    const unionTypeEntries = Object.entries(
+      mergedDataStructure.signatureSchema,
+    ).filter(
+      ([_, value]) =>
+        typeof value === 'string' &&
+        value.includes("'") &&
+        value.includes(' | '),
+    );
+    if (unionTypeEntries.length > 0) {
+      console.log(
+        `[UNION-TYPE] generateDataStructure for ${entity.name}: Found union types in signatureSchema:`,
+      );
+      unionTypeEntries.forEach(([key, value]) => {
+        console.log(`[UNION-TYPE]   "${key}": ${value}`);
+      });
+    }
+
     const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({
       schema: { ...mergedDataStructure.signatureSchema },
     });

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateKeyAttributes.ts

@@ -29,13 +29,10 @@ export default async function generateKeyAttributes({
 }: GenerateEntityKeyAttributesArgs): Promise<void> {
   if (!['visual', 'library'].includes(entity.entityType)) return;
 
-  // Merge direct dataForMocks with recursively gathered data from dependencies
+  // Gather all mock data, consolidated under the root entity name
   const structure = {
     arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
-    dataForMocks: {
-      ...(analysis.metadata.scenariosDataStructure?.dataForMocks ?? {}),
-      ...gatherDataForMocks(analysis, dependentAnalyses),
-    },
+    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses, entity.name),
   };
 
   awsLog(`🔮 Generating ${error ? 'error ' : ''}scenarios for`, {
@@ -74,6 +71,7 @@ export default async function generateKeyAttributes({
       () =>
         generateEntityKeyAttributes({
           entity,
+          mergedDataStructure: analysis.metadata.mergedDataStructure,
           model,
         }),
       `Generating entity key attributes`,
@@ -82,6 +80,7 @@ export default async function generateKeyAttributes({
 
     const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
       entity,
+      analysis.metadata.mergedDataStructure,
       dependentAnalyses,
     );
 
@@ -92,6 +91,18 @@ export default async function generateKeyAttributes({
         // Spread to convert readonly arrays to mutable arrays (with fallback for undefined)
         validValueOptions: [...(ka.validValueOptions ?? [])],
         errorValueOptions: [...(ka.errorValueOptions ?? [])],
+        // Convert readonly dependencies array to mutable if present
+        ...(ka.dependencies && {
+          dependencies: ka.dependencies.map((dep) => ({ ...dep })),
+        }),
+        // Convert readonly sourceLocations array to mutable if present
+        ...(ka.sourceLocations && {
+          sourceLocations: ka.sourceLocations.map((loc) => ({ ...loc })),
+        }),
+        // Convert readonly compoundConditionalIds array to mutable if present
+        ...(ka.compoundConditionalIds && {
+          compoundConditionalIds: [...ka.compoundConditionalIds],
+        }),
       })),
     ].filter(
       (ka, index, self) =>

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateScenarioData.ts

@@ -1,6 +1,7 @@
 import {
   Analysis,
   Entity,
+  JsonTypeDefinition,
   ReadonlyAnalysis,
   ReadonlyAnalysisMap,
 } from '~codeyam/types';
@@ -21,17 +22,186 @@ export interface GenerateScenarioDataArgs {
   updateProgress?: (detail: string) => void;
 }
 
+/**
+ * Extract the hook/function name from any mock data key format.
+ * Supports:
+ * - Canonical: "EntityName::hookName::index" -> "hookName"
+ * - Variable-qualified: "varName <- funcName" -> "funcName"
+ * - Simple with parens: "funcName()" -> "funcName"
+ * - Simple: "funcName" -> "funcName"
+ */
+function extractHookName(key: string): string | null {
+  // Canonical: "EntityName::hookName::index"
+  const canonicalMatch = key.match(/^[^:]+::([^:]+)::\d+$/);
+  if (canonicalMatch) return canonicalMatch[1];
+
+  // Variable-qualified: "varName <- funcName"
+  const varQualMatch = key.match(/<- (\w+)$/);
+  if (varQualMatch) return varQualMatch[1];
+
+  // Simple with parens: "funcName()" -> "funcName"
+  const simpleParensMatch = key.match(/^(\w+)\(\)$/);
+  if (simpleParensMatch) return simpleParensMatch[1];
+
+  // Simple: "funcName" (alphanumeric only)
+  const simpleMatch = key.match(/^(\w+)$/);
+  if (simpleMatch) return simpleMatch[1];
+
+  return null;
+}
+
+/**
+ * Check if two schemas are structurally equivalent (same shape).
+ * Uses JSON.stringify for deep comparison.
+ */
+function schemasMatch(a: unknown, b: unknown): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
 export function gatherDataForMocks(
   analysis: ReadonlyAnalysis,
   dependentAnalyses: ReadonlyAnalysisMap,
+  rootEntityName?: string,
 ): Analysis['metadata']['scenariosDataStructure']['dataForMocks'] {
-  const dataForMocks = {};
+  const dataForMocks: Analysis['metadata']['scenariosDataStructure']['dataForMocks'] =
+    {};
   const analysesGathered = new Set<string>();
 
+  // Track hook indices for assigning new indices when schemas differ
+  const hookIndices: Record<string, number> = {};
+
+  /**
+   * Find an existing key in dataForMocks that has the same hook name
+   * and matching schema. Returns the key if found, null otherwise.
+   */
+  const findMatchingKey = (
+    hookName: string,
+    schema: unknown,
+  ): string | null => {
+    for (const existingKey of Object.keys(dataForMocks)) {
+      const existingHook = extractHookName(existingKey);
+      if (
+        existingHook === hookName &&
+        schemasMatch(dataForMocks[existingKey], schema)
+      ) {
+        return existingKey;
+      }
+    }
+    return null;
+  };
+
+  /**
+   * Add mock data, consolidating by hook name and schema when rootEntityName is provided.
+   * - Same hook + same schema = merge into existing key
+   * - Same hook + different schema = new key with incremented index
+   * - All keys normalized to "RootEntity::hookName::index" format when rootEntityName provided
+   */
+  const addMockData = (
+    originalKey: string,
+    schema: JsonTypeDefinition[keyof JsonTypeDefinition],
+  ): void => {
+    // Skip if schema is empty object
+    if (
+      typeof schema === 'object' &&
+      schema !== null &&
+      !Array.isArray(schema) &&
+      Object.keys(schema).length === 0
+    ) {
+      return;
+    }
+
+    // Skip null/undefined
+    if (schema === null || schema === undefined) {
+      return;
+    }
+
+    const typedSchema = schema as
+      | JsonTypeDefinition
+      | string
+      | string[]
+      | JsonTypeDefinition[];
+
+    // Helper to merge schemas (only works for objects, otherwise just returns new value)
+    const mergeSchemas = (
+      existing: JsonTypeDefinition[keyof JsonTypeDefinition],
+      incoming: typeof typedSchema,
+    ): JsonTypeDefinition[keyof JsonTypeDefinition] => {
+      // Only merge if both are objects (not arrays, not primitives)
+      if (
+        typeof existing === 'object' &&
+        existing !== null &&
+        !Array.isArray(existing) &&
+        typeof incoming === 'object' &&
+        incoming !== null &&
+        !Array.isArray(incoming)
+      ) {
+        return mergeJsonTypeDefinitions(
+          existing as JsonTypeDefinition,
+          incoming as JsonTypeDefinition,
+        );
+      }
+      // For primitives/arrays, just use the incoming value
+      return incoming;
+    };
+
+    // If no rootEntityName, use legacy behavior (preserve original key)
+    if (!rootEntityName) {
+      if (dataForMocks?.[originalKey]) {
+        dataForMocks[originalKey] = mergeSchemas(
+          dataForMocks[originalKey],
+          typedSchema,
+        );
+      } else if (dataForMocks) {
+        dataForMocks[originalKey] = typedSchema;
+      }
+      return;
+    }
+
+    // Extract hook name for consolidation
+    const hookName = extractHookName(originalKey);
+    if (!hookName) {
+      // Can't parse - preserve original key
+      if (dataForMocks?.[originalKey]) {
+        dataForMocks[originalKey] = mergeSchemas(
+          dataForMocks[originalKey],
+          typedSchema,
+        );
+      } else if (dataForMocks) {
+        dataForMocks[originalKey] = typedSchema;
+      }
+      return;
+    }
+
+    // Look for existing key with same hook and matching schema
+    const matchingKey = findMatchingKey(hookName, typedSchema);
+    if (matchingKey && dataForMocks) {
+      // Same hook + same schema - merge into existing key
+      dataForMocks[matchingKey] = mergeSchemas(
+        dataForMocks[matchingKey],
+        typedSchema,
+      );
+    } else if (dataForMocks) {
+      // Different schema or first occurrence - create new canonical key
+      const index = hookIndices[hookName] ?? 0;
+      hookIndices[hookName] = index + 1;
+      const targetKey = `${rootEntityName}::${hookName}::${index}`;
+      dataForMocks[targetKey] = typedSchema;
+    }
+  };
+
   // inner recursive function to gather data for mocks
   const gatherDataForMocksRecursive = (
     activeAnalysis: ReadonlyAnalysis,
   ): void => {
+    // First, process ALL keys from this analysis's dataForMocks
+    const localDataForMocks =
+      activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
+
+    for (const [key, schema] of Object.entries(localDataForMocks)) {
+      addMockData(key, schema as JsonTypeDefinition[keyof JsonTypeDefinition]);
+    }
+
+    // Then, recurse into dependent analyses based on imports
     const allImportedExports = [
       ...(activeAnalysis.entity?.metadata.importedExports ?? []),
       ...Object.keys(
@@ -46,64 +216,7 @@ export function gatherDataForMocks(
       ),
     ];
 
-    // console.info('CODEYAM DEBUG: gatherDataForMocksRecursive START', {
-    //   filePath: activeAnalysis.filePath,
-    //   analysisEntityName: activeAnalysis.entityName,
-    //   analysisId: activeAnalysis.id,
-    //   entity: !!activeAnalysis.entity,
-    //   entityName: activeAnalysis.entity?.name,
-    //   allImportedExports: allImportedExports.map((ie) => ({
-    //     filePath: ie.filePath,
-    //     name: ie.name,
-    //   })),
-    // });
-
     for (const importedExport of allImportedExports) {
-      const localDataForMocks =
-        activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
-      const relevantKey = Object.keys(localDataForMocks).find((key) =>
-        key.startsWith(importedExport.name),
-      );
-
-      // console.info('CODEYAM DEBUG: Processing import', {
-      //   importedExportName: importedExport.name,
-      //   importedExportFilePath: importedExport.filePath,
-      //   relevantKey,
-      //   hasLocalDataForMocks: Object.keys(localDataForMocks).length > 0,
-      //   localDataForMocksKeys: Object.keys(localDataForMocks),
-      // });
-
-      // First, if we have local data for this mock, add it
-      if (relevantKey) {
-        const localDataForMock = localDataForMocks[relevantKey];
-
-        // console.info('CODEYAM DEBUG: Found relevantKey', {
-        //   relevantKey,
-        //   localDataForMockType: typeof localDataForMock,
-        //   localDataForMockValue: localDataForMock,
-        //   isObject: typeof localDataForMock === 'object',
-        //   objectKeysLength:
-        //     typeof localDataForMock === 'object' && localDataForMock !== null
-        //       ? Object.keys(localDataForMock).length
-        //       : 'N/A',
-        // });
-
-        if (Object.keys(localDataForMock).length > 0) {
-          if ((dataForMocks as any)[relevantKey]) {
-            (dataForMocks as any)[relevantKey] = mergeJsonTypeDefinitions(
-              (dataForMocks as any)[relevantKey],
-              localDataForMock,
-            );
-          } else {
-            (dataForMocks as any)[relevantKey] = localDataForMock;
-          }
-        }
-      }
-
-      // ALWAYS check for dependent analysis to gather nested dependencies,
-      // regardless of whether we found a relevantKey above.
-      // This ensures transitive dependencies are included.
-      // For example: Activity -> CurrentActivityTab -> useLastLogLine
       // Use resolvedFilePath when available (for re-exports from index files)
       const lookupPath =
         ('resolvedFilePath' in importedExport &&
@@ -117,30 +230,10 @@ export function gatherDataForMocks(
         gatherDataForMocksRecursive(dependentAnalysis);
       }
     }
-
-    // console.info('CODEYAM DEBUG: gatherDataForMocksRecursive END', {
-    //   filePath: activeAnalysis.filePath,
-    //   entityName: activeAnalysis.entityName,
-    //   currentDataForMocksKeys: Object.keys(dataForMocks),
-    // });
   };
 
   gatherDataForMocksRecursive(analysis);
 
-  // console.info(
-  //   'CODEYAM DEBUG: gatherDataForMocks FINAL RESULT',
-  //   JSON.stringify(
-  //     {
-  //       filePath: analysis.filePath,
-  //       entityName: analysis.entityName,
-  //       dataForMocksKeys: Object.keys(dataForMocks),
-  //       dataForMocks,
-  //     },
-  //     null,
-  //     2,
-  //   ),
-  // );
-
   return dataForMocks;
 }
 
@@ -155,7 +248,7 @@ export default async function generateScenarioData({
 
   const structure: Analysis['metadata']['scenariosDataStructure'] = {
     arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
-    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses),
+    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses, entity.name),
   };
 
   const scenarios = analysis.scenarios;