@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.d0ad4ae

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

@@ -38,7 +38,7 @@ export default async function generateChangesScenarioData({
   const fullStructure = analysis.metadata.scenariosDataStructure;
   const structure: Analysis['metadata']['scenariosDataStructure'] = {
     arguments: fullStructure.arguments ?? [],
-    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses),
+    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses, entity.name),
   };
 
   for (const key in fullStructure.dataForMocks) {

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

@@ -5,12 +5,12 @@ import {
   Entity,
   DEFAULT_SCENARIO_NAME,
 } from '~codeyam/types';
-import deepEqual from '../../utils/deepEqual';
 import measureAndReportExecutionTime from '../../utils/measureAndReportExecutionTime';
 import {
   AI,
   generateChangesEntityScenarios,
   generateChangesEntityKeyAttributes,
+  gatherRelevantDependentKeyAttributes,
 } from '~codeyam/ai';
 import { awsLog } from '~codeyam/utils';
 import detectChangedDataStructureFields from './detectChangedDataStructureFields';
@@ -120,7 +120,54 @@ export default async function generateChangesScenarios({
     updateProgress,
   );
 
-  analysis.metadata.keyAttributes = keyAttributes;
+  // Merge in dependent key attributes (same as initial flow)
+  // This ensures dependent entity key attributes aren't incorrectly seen as "removed"
+  const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
+    entity,
+    analysis.metadata.mergedDataStructure,
+    dependentAnalyses,
+  );
+
+  // Log dependent key attributes gathered
+  awsLog(`CodeYam: Dependent key attributes gathered for ${entity.name}`, {
+    dependentKeyAttributeCount: relevantDependentKeyAttributes.length,
+    dependentKeyAttributes: relevantDependentKeyAttributes.map((ka) => ({
+      internalPath: ka.internalPath,
+      externalPath: ka.externalPath,
+      dependentEntityName: (ka as any).dependentEntityName,
+      originalEntityName: (ka as any).originalEntityName,
+      filePath: (ka as any).filePath,
+    })),
+    dependentAnalysesEntities: Object.entries(dependentAnalyses).flatMap(
+      ([path, entities]) =>
+        Object.keys(entities).map((name) => ({ path, name })),
+    ),
+  });
+
+  analysis.metadata.keyAttributes = [
+    ...keyAttributes,
+    ...relevantDependentKeyAttributes.map((ka) => ({
+      ...ka,
+      // 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) =>
+      self.findIndex((k) => k.internalPath === ka.internalPath) === index,
+  );
 
   if (keyAttributesLLMCall) {
     analysis.metadata.llmCalls ||= [];
@@ -144,6 +191,84 @@ export default async function generateChangesScenarios({
       ),
   );
 
+  // Log key attribute changes for debugging
+  awsLog(`CodeYam: Key attribute comparison for ${entity.name}`, {
+    previousKeyAttributePaths: previousAnalysis.metadata.keyAttributes?.map(
+      (ka) => ({
+        internalPath: ka.internalPath,
+        isDependentAttr: !!(ka as any).dependentEntityName,
+        dependentEntityName: (ka as any).dependentEntityName,
+      }),
+    ),
+    currentKeyAttributePaths: analysis.metadata.keyAttributes?.map((ka) => ({
+      internalPath: ka.internalPath,
+      isDependentAttr: !!(ka as any).dependentEntityName,
+      dependentEntityName: (ka as any).dependentEntityName,
+    })),
+    addedKeyAttributePaths: addedKeyAttributes?.map((ka) => ({
+      internalPath: ka.internalPath,
+      isDependentAttr: !!(ka as any).dependentEntityName,
+      dependentEntityName: (ka as any).dependentEntityName,
+      filePath: (ka as any).filePath,
+    })),
+    removedKeyAttributePaths: removedKeyAttributes?.map((ka) => ({
+      internalPath: ka.internalPath,
+      isDependentAttr: !!(ka as any).dependentEntityName,
+      dependentEntityName: (ka as any).dependentEntityName,
+      filePath: (ka as any).filePath,
+    })),
+  });
+
+  // Detect key attributes with NEW source locations (usages)
+  // These are existing attributes that gained new conditional usages in the code
+  const modifiedKeyAttributes = analysis.metadata.keyAttributes
+    ?.filter((ka) => {
+      // Only consider attributes that existed before (not newly added)
+      const previousAttr = previousAnalysis.metadata.keyAttributes?.find(
+        (ka2) => ka.internalPath === ka2.internalPath,
+      );
+      if (!previousAttr) return false;
+
+      // Check if there are new source locations
+      const previousSnippets = new Set(
+        previousAttr.sourceLocations?.map((loc) => loc.codeSnippet) ?? [],
+      );
+      const newSourceLocations = ka.sourceLocations?.filter(
+        (loc) => !previousSnippets.has(loc.codeSnippet),
+      );
+
+      return newSourceLocations && newSourceLocations.length > 0;
+    })
+    .map((ka) => {
+      const previousAttr = previousAnalysis.metadata.keyAttributes?.find(
+        (ka2) => ka.internalPath === ka2.internalPath,
+      );
+      const previousSnippets = new Set(
+        previousAttr?.sourceLocations?.map((loc) => loc.codeSnippet) ?? [],
+      );
+      const newSourceLocations = ka.sourceLocations?.filter(
+        (loc) => !previousSnippets.has(loc.codeSnippet),
+      );
+
+      return {
+        keyAttribute: ka,
+        newSourceLocations,
+      };
+    });
+
+  // Log modified key attributes
+  if (modifiedKeyAttributes && modifiedKeyAttributes.length > 0) {
+    awsLog(`CodeYam: Modified key attributes for ${entity.name}`, {
+      modifiedKeyAttributePaths: modifiedKeyAttributes.map((mod) => ({
+        internalPath: mod.keyAttribute.internalPath,
+        isDependentAttr: !!(mod.keyAttribute as any).dependentEntityName,
+        dependentEntityName: (mod.keyAttribute as any).dependentEntityName,
+        newUsageCount: mod.newSourceLocations?.length ?? 0,
+        newUsages: mod.newSourceLocations?.map((loc) => loc.codeSnippet),
+      })),
+    });
+  }
+
   // Detect which specific data structure fields changed
   const changedDataStructureFields = detectChangedDataStructureFields(
     previousAnalysis.metadata?.scenariosDataStructure,
@@ -159,6 +284,7 @@ export default async function generateChangesScenarios({
         keyAttributes: analysis.metadata.keyAttributes,
         addedKeyAttributes,
         removedKeyAttributes,
+        modifiedKeyAttributes,
         dependentAnalyses,
         existingScenarios,
         commitDiff,

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

@@ -9,10 +9,13 @@ import {
   fillInDirectSchemaGapsAndUnknowns,
   deduplicateFunctionSchemas,
   clearAttributesFromMapping,
+  mergeJsonTypeDefinitions,
 } from '~codeyam/ai';
 import mergeInDependentDataStructure from './mergeInDependentDataStructure';
 import { awsLog } from '~codeyam/utils';
 import gatherDataForMocks from './gatherDataForMocks';
+import enrichArrayTypesFromChildSignatures from './enrichArrayTypesFromChildSignatures';
+import enrichUnknownTypesFromSourceEquivalencies from './enrichUnknownTypesFromSourceEquivalencies';
 
 export interface GenerateDataStructureArgs {
   entity: Entity;
@@ -31,12 +34,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 +48,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 +161,252 @@ 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.
+
+    // Collect child dependency schemas to merge after mergeInDependentDataStructure
+    // This ensures that when we look up schemas for child imports in gatherDataForMocks,
+    // the child's schemas are available in mergedDataStructure.dependencySchemas.
+    type DependencySchemas = NonNullable<
+      Analysis['metadata']['mergedDataStructure']
+    >['dependencySchemas'];
+    const childDependencySchemas: DependencySchemas = {};
+
+    // 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;
+
+          // Collect the child's dependency schemas for merging later.
+          // This ensures schemas for child imports are available in gatherDataForMocks.
+          if (childMergedDataStructure?.dependencySchemas) {
+            for (const schemaFilePath in childMergedDataStructure.dependencySchemas) {
+              for (const schemaName in childMergedDataStructure
+                .dependencySchemas[schemaFilePath]) {
+                childDependencySchemas[schemaFilePath] ||= {};
+                const existingSchema =
+                  childDependencySchemas[schemaFilePath][schemaName];
+                const newSchema =
+                  childMergedDataStructure.dependencySchemas[schemaFilePath][
+                    schemaName
+                  ];
+
+                if (existingSchema) {
+                  // Merge schemas if the same dependency exists from multiple children
+                  childDependencySchemas[schemaFilePath][schemaName] = {
+                    signatureSchema: {
+                      ...existingSchema.signatureSchema,
+                      ...newSchema.signatureSchema,
+                    },
+                    returnValueSchema: mergeJsonTypeDefinitions(
+                      existingSchema.returnValueSchema as Record<
+                        string,
+                        unknown
+                      >,
+                      newSchema.returnValueSchema as Record<string, unknown>,
+                    ) as Record<string, string>,
+                  };
+                } else {
+                  childDependencySchemas[schemaFilePath][schemaName] = {
+                    signatureSchema: { ...newSchema.signatureSchema },
+                    returnValueSchema: { ...newSchema.returnValueSchema },
+                  };
+                }
+              }
+            }
+          }
+
+          // Also collect the child's OWN signatureSchema for enrichment.
+          // This allows enrichArrayTypesFromChildSignatures to find what fields
+          // non-mocked child components expect on their props (e.g., SurveyCard
+          // expecting survey.createdAt, survey.updatedAt, etc.)
+          if (childMergedDataStructure?.signatureSchema) {
+            childDependencySchemas[filePath] ||= {};
+            const existingSchema = childDependencySchemas[filePath][name];
+            if (existingSchema) {
+              childDependencySchemas[filePath][name] = {
+                signatureSchema: {
+                  ...existingSchema.signatureSchema,
+                  ...childMergedDataStructure.signatureSchema,
+                },
+                returnValueSchema: existingSchema.returnValueSchema,
+              };
+            } else {
+              childDependencySchemas[filePath][name] = {
+                signatureSchema: {
+                  ...childMergedDataStructure.signatureSchema,
+                },
+                returnValueSchema: {},
+              };
+            }
+          }
+
+          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 +424,7 @@ export default function generateDataStructure({
     // );
 
     const { isolatedDataStructure } = entity.metadata;
+
     const mergedDataStructure = mergeInDependentDataStructure({
       importedExports: allImportedExports,
       dependentAnalyses: nonMockedDependentAnalyses,
@@ -146,6 +442,36 @@ export default function generateDataStructure({
     mergedDataStructure.environmentVariables =
       isolatedDataStructure.environmentVariables || [];
 
+    // Merge collected child dependency schemas into mergedDataStructure.
+    // This ensures that when gatherDataForMocks looks up schemas for child imports,
+    // the child's schemas are available.
+    for (const schemaFilePath in childDependencySchemas) {
+      for (const schemaName in childDependencySchemas[schemaFilePath]) {
+        mergedDataStructure.dependencySchemas[schemaFilePath] ||= {};
+        const existingSchema =
+          mergedDataStructure.dependencySchemas[schemaFilePath][schemaName];
+        const childSchema = childDependencySchemas[schemaFilePath][schemaName];
+
+        if (existingSchema) {
+          // Merge schemas - child schemas add to parent schemas
+          mergedDataStructure.dependencySchemas[schemaFilePath][schemaName] = {
+            signatureSchema: {
+              ...existingSchema.signatureSchema,
+              ...childSchema.signatureSchema,
+            },
+            returnValueSchema: mergeJsonTypeDefinitions(
+              existingSchema.returnValueSchema as Record<string, unknown>,
+              childSchema.returnValueSchema as Record<string, unknown>,
+            ) as Record<string, string>,
+          };
+        } else {
+          // No existing schema - just add the child's schema
+          mergedDataStructure.dependencySchemas[schemaFilePath][schemaName] =
+            childSchema;
+        }
+      }
+    }
+
     // console.info(
     //   'CODEYAM DEBUG: end merge',
     //   JSON.stringify(
@@ -197,23 +523,30 @@ export default function generateDataStructure({
     analysis.metadata ||= {};
     analysis.metadata.mergedDataStructure = mergedDataStructure;
 
-    const dataForMocks = gatherDataForMocks(
+    // 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,
     );
 
-    // console.info(
-    //   'CODEYAM DEBUG: dataForMocks',
-    //   JSON.stringify(
-    //     {
-    //       filePath: entity.filePath,
-    //       entityName: entity.name,
-    //       dataForMocks,
-    //     },
-    //     null,
-    //     2,
-    //   ),
-    // );
+    // Enrich mocked dependency unknown types using sourceEquivalencies
+    // When a mocked dependency returns unknown, but that data flows to a child component
+    // with a known type, propagate the type back to the mocked dependency.
+    // This prevents fillInDirectSchemaGapsAndUnknowns from guessing incorrectly
+    // (e.g., 'data' becoming 'number' because pluralize thinks it's plural)
+    enrichUnknownTypesFromSourceEquivalencies(
+      isolatedDataStructure.dependencySchemas || {},
+      mergedDataStructure.dependencySchemas,
+      allImportedExports,
+    );
+
+    const dataForMocks = gatherDataForMocks(
+      allImportedExports,
+      mergedDataStructure.dependencySchemas,
+      { entityName: entity.name },
+    );
 
     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) =>