@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.3ef993e

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

@@ -101,27 +101,47 @@ export default function enrichArrayTypesFromChildSignatures(
   ): void => {
     // Group by prop name (e.g., signature[0].survey.id, signature[0].survey.name -> "survey")
     const propGroups: Record<string, Record<string, string>> = {};
+    // Also collect direct fields on signature[0] (e.g., signature[0].filePath -> "filePath")
+    const directFields: Record<string, string> = {};
 
     for (const [path, type] of Object.entries(schema)) {
       // Match signature[0].propName.field or signature[0].propName[].field patterns
       // The (?:\[\])? makes array props optional, handling both:
       // - signature[0].survey.updatedAt (object prop)
       // - signature[0].questionAnswers[].question.questionText (array prop)
-      const match = path.match(/^signature\[0\]\.(\w+)(?:\[\])?\.(.+)$/);
-      if (match) {
-        const [, propName, fieldPath] = match;
+      const nestedMatch = path.match(/^signature\[0\]\.(\w+)(?:\[\])?\.(.+)$/);
+      if (nestedMatch) {
+        const [, propName, fieldPath] = nestedMatch;
         propGroups[propName] ||= {};
         propGroups[propName][fieldPath] = type;
+        continue;
+      }
+
+      // Also match direct fields: signature[0].fieldName (single level, no nested path)
+      // This handles cases like TruncatedFilePath where filePath is passed directly
+      const directMatch = path.match(/^signature\[0\]\.(\w+)$/);
+      if (directMatch) {
+        const [, fieldName] = directMatch;
+        directFields[fieldName] = type;
       }
     }
 
-    // Store with the full signature path as key
+    // Store nested prop groups with the full signature path as key
     for (const [propName, fields] of Object.entries(propGroups)) {
       if (Object.keys(fields).length > 0) {
         const signaturePath = `${entityName}().signature[0].${propName}`;
         childSignatureFieldsByPath.set(signaturePath, { propName, fields });
       }
     }
+
+    // Store direct fields with signature[0] as key (for when entire object is passed)
+    if (Object.keys(directFields).length > 0) {
+      const signaturePath = `${entityName}().signature[0]`;
+      childSignatureFieldsByPath.set(signaturePath, {
+        propName: '',
+        fields: directFields,
+      });
+    }
   };
 
   // Process all schemas in dependencySchemas
@@ -187,15 +207,20 @@ export default function enrichArrayTypesFromChildSignatures(
   for (const { filePath, entityName, arrayPath } of mockedArrayPaths) {
     const schema = dependencySchemas[filePath][entityName].returnValueSchema;
 
-    // Check if this array already has element type definitions
+    // Check if this array already has INDEXED element type definitions (e.g., [0]: null)
     // If so, skip it - it's likely a specialized array like [null] for refs
+    // But DON'T skip if it only has general [] element types - those can be enriched
     const elementPathPrefix = `${arrayPath}[`;
-    const hasExistingElementType = Object.keys(schema).some((path) =>
-      path.startsWith(elementPathPrefix),
-    );
-
-    if (hasExistingElementType) {
-      // Array already has element type info (e.g., useAutoAnimate()[0]: null)
+    const hasIndexedElementType = Object.keys(schema).some((path) => {
+      if (!path.startsWith(elementPathPrefix)) return false;
+      // Check if it's an indexed type like [0], [1], etc. vs general []
+      const afterPrefix = path.slice(elementPathPrefix.length);
+      // Indexed types start with a digit: [0], [1], etc.
+      return /^\d/.test(afterPrefix);
+    });
+
+    if (hasIndexedElementType) {
+      // Array already has indexed element type info (e.g., useAutoAnimate()[0]: null)
       // Don't override it with child signature fields
       continue;
     }
@@ -218,7 +243,17 @@ export default function enrichArrayTypesFromChildSignatures(
 
         // Check if this local variable could have come from this mocked function
         // Use heuristics: name matching (getSurveys -> surveys, getUsers -> users)
-        if (!couldBeDerivedFrom(localVarName, entityName)) {
+        // Also check if the array path ends with the local variable name
+        // e.g., useLoaderData().functionCallReturnValue.entities ends with .entities
+        const arrayEndsWithLocalVar = arrayPath.endsWith(`.${localVarName}`);
+        // Full-path usageEquivalencies (e.g., from same-file child components) use
+        // the complete call path as the local var name, which matches arrayPath exactly
+        const exactPathMatch = localVarName === arrayPath;
+        if (
+          !exactPathMatch &&
+          !couldBeDerivedFrom(localVarName, entityName) &&
+          !arrayEndsWithLocalVar
+        ) {
           continue;
         }
 
@@ -257,8 +292,21 @@ export default function enrichArrayTypesFromChildSignatures(
 
     for (const [fieldPath, type] of Object.entries(matchedFields)) {
       const fullPath = `${elementPath}.${fieldPath}`;
-      if (!schema[fullPath]) {
+      const existingType = schema[fullPath];
+      if (!existingType) {
         schema[fullPath] = type;
+      } else {
+        // Prefer the more specific (narrower) type
+        const existingIsOptional =
+          existingType.includes('| undefined') ||
+          existingType.includes('| null');
+        const newIsOptional =
+          type.includes('| undefined') || type.includes('| null');
+        if (existingIsOptional && !newIsOptional) {
+          // Use the new type - it's more specific
+          schema[fullPath] = type;
+        }
+        // Otherwise keep existing (same specificity or existing is more specific)
       }
     }
   }

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

@@ -1,6 +1,8 @@
 import {
   convertDotNotation,
   fillInDirectSchemaGapsAndUnknowns,
+  buildSchemaIndexes,
+  type SchemaIndexes,
   joinParenthesesAndArrays,
   mergeJsonTypeDefinitions,
   splitOutsideParenthesesAndArrays,
@@ -165,6 +167,7 @@ function processCall(
   variableNameOccurrence: number | undefined,
   options: GatherDataForMocksOptions | undefined,
   hookCallIndex: number,
+  prebuiltIndexes?: SchemaIndexes,
 ): { key: string; value: JsonTypeDefinition } | null {
   const callName = importedExport.calls?.[callIndex] ?? importedExport.name;
 
@@ -350,8 +353,6 @@ function processCall(
   // Preprocess to filter signatures and extract functionCallReturnValue
   let preprocessedSchema = preprocessSchemaForMocks(mergedSchema);
 
-  const functionNames: string[] = [];
-
   const isFunctionNameWithoutFunction = (
     path: string,
     functionName: string,
@@ -436,35 +437,63 @@ function processCall(
     }
   }
 
-  const relevantMergedDependencySchema = Object.keys(preprocessedSchema).reduce(
-    (acc, path) => {
-      if (path.endsWith(')')) {
-        const pathParts = splitOutsideParenthesesAndArrays(path);
-        const functionName = joinParenthesesAndArrays([
-          ...pathParts.slice(0, -1),
-          pathParts[pathParts.length - 1].split('(')[0],
-        ]);
-        functionNames.push(functionName);
-        for (const existingPath in acc) {
-          if (isFunctionNameWithoutFunction(existingPath, functionName)) {
-            delete acc[existingPath];
-          }
-        }
-      }
+  // Two-pass function name filtering to avoid O(k²) retroactive deletion.
+  // Pass 1: Discover all unique function names from paths ending with ')'
+  const functionNameSet = new Set<string>();
+  const schemaKeys = Object.keys(preprocessedSchema);
+  for (const path of schemaKeys) {
+    if (path.endsWith(')')) {
+      const pathParts = splitOutsideParenthesesAndArrays(path);
+      const functionName = joinParenthesesAndArrays([
+        ...pathParts.slice(0, -1),
+        pathParts[pathParts.length - 1].split('(')[0],
+      ]);
+      functionNameSet.add(functionName);
+    }
+  }
 
-      if (functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))) {
-        return acc;
-      }
+  // Index function names by first segment for O(1) bucket lookup instead of
+  // checking all function names for every path. Most paths only need to check
+  // 1-2 function names instead of all F.
+  const fnByFirstSegment = new Map<string, string[]>();
+  for (const fn of functionNameSet) {
+    const dotIdx = fn.indexOf('.');
+    const firstSeg = dotIdx >= 0 ? fn.slice(0, dotIdx) : fn;
+    let bucket = fnByFirstSegment.get(firstSeg);
+    if (!bucket) {
+      bucket = [];
+      fnByFirstSegment.set(firstSeg, bucket);
+    }
+    bucket.push(fn);
+  }
 
-      acc[path] = preprocessedSchema[path];
-      return acc;
-    },
-    {} as Record<string, string>,
-  );
+  // Pass 2: Filter paths that match any discovered function name prefix.
+  // Use indexed lookup: extract path's first segment, check only matching function names.
+  const relevantMergedDependencySchema: Record<string, string> = {};
+  for (const path of schemaKeys) {
+    // Extract first segment of path (before first '.', '(', or '<')
+    const dotIdx = path.indexOf('.');
+    const parenIdx = path.indexOf('(');
+    const angleIdx = path.indexOf('<');
+    let minIdx = path.length;
+    if (dotIdx >= 0 && dotIdx < minIdx) minIdx = dotIdx;
+    if (parenIdx >= 0 && parenIdx < minIdx) minIdx = parenIdx;
+    if (angleIdx >= 0 && angleIdx < minIdx) minIdx = angleIdx;
+    const firstSeg = path.slice(0, minIdx);
+
+    const candidates = fnByFirstSegment.get(firstSeg);
+    if (
+      !candidates ||
+      !candidates.some((fn) => isFunctionNameWithoutFunction(path, fn))
+    ) {
+      relevantMergedDependencySchema[path] = preprocessedSchema[path];
+    }
+  }
 
   const filledSchema = fillInDirectSchemaGapsAndUnknowns({
     scopeName: importedExport.name,
     schema: relevantMergedDependencySchema,
+    prebuiltIndexes,
   });
 
   const schema = convertDotNotation(filledSchema);
@@ -568,6 +597,33 @@ export default function gatherDataForMocks(
   dependencySchemas: DataStructure['dependencySchemas'],
   options?: GatherDataForMocksOptions,
 ) {
+  // Build schema indexes ONCE from all dependency schemas combined.
+  // This avoids rebuilding indexes (~1-2 seconds for 18k keys) for each processCall.
+  //
+  // IMPORTANT: We must preprocess schemas BEFORE building indexes!
+  // The schemas contain .functionCallReturnValue paths that get stripped during processing.
+  // If we build indexes from original paths, lookups with preprocessed paths will fail.
+  // Example: 'hook().functionCallReturnValue.x.length' → index maps 'hook().functionCallReturnValue.x' → ['length']
+  //          But preprocessed path 'hook().x.length' looks for 'hook().x' which doesn't exist in the index.
+  const allSchemaKeys: Record<string, string> = {};
+  if (dependencySchemas) {
+    for (const filePath in dependencySchemas) {
+      for (const entityName in dependencySchemas[filePath]) {
+        const schema =
+          dependencySchemas[filePath][entityName]?.returnValueSchema;
+        if (schema) {
+          // Preprocess each schema to remove .functionCallReturnValue before collecting
+          const preprocessed = preprocessSchemaForMocks(schema);
+          Object.assign(allSchemaKeys, preprocessed);
+        }
+      }
+    }
+  }
+  const prebuiltIndexes =
+    Object.keys(allSchemaKeys).length > 0
+      ? buildSchemaIndexes(allSchemaKeys)
+      : undefined;
+
   // Track the global index for each hook name across all imports
   // This enables canonical keys like EntityName::useLoaderData::0, EntityName::useFetcher::0, etc.
   const hookCallIndices: Record<string, number> = {};
@@ -653,6 +709,7 @@ export default function gatherDataForMocks(
             undefined,
             options,
             hookCallIndex,
+            prebuiltIndexes,
           );
 
           if (processResult) {
@@ -717,6 +774,7 @@ export default function gatherDataForMocks(
             occurrence,
             options,
             hookCallIndex,
+            prebuiltIndexes,
           );
           if (processResult) {
             addResultToAccumulator(acc, processResult.key, processResult.value);
@@ -749,6 +807,7 @@ export default function gatherDataForMocks(
             undefined,
             options,
             hookCallIndex,
+            prebuiltIndexes,
           );
 
           if (processResult) {
@@ -769,6 +828,7 @@ export default function gatherDataForMocks(
           undefined,
           options,
           hookCallIndex,
+          prebuiltIndexes,
         );
 
         // Check if we got a meaningful result (not empty object or null)
@@ -813,6 +873,7 @@ export default function gatherDataForMocks(
                 0, // Use 0 to trigger variable-qualified lookup
                 options,
                 hookCallIndex,
+                prebuiltIndexes,
               );
               if (varQualifiedResult && varQualifiedResult.value) {
                 mergedValue = mergeJsonTypeDefinitions(
@@ -849,6 +910,7 @@ export default function gatherDataForMocks(
               0, // Use 0 to trigger variable-qualified lookup
               options,
               hookCallIndex,
+              prebuiltIndexes,
             );
             if (varQualifiedResult && varQualifiedResult.value) {
               // Deep merge the value into the accumulated result