@codeyam/codeyam-cli 0.1.0-staging.e38f7bd → 0.1.0

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

@@ -0,0 +1,313 @@
+import { DataStructure } from '~codeyam/types';
+
+/**
+ * Enriches mocked dependency array types with fields from child component signatures.
+ *
+ * When a mocked dependency (e.g., getSurveysAction) returns an array, and elements
+ * from that array are passed to child components (e.g., SurveyCard), the child's
+ * signatureSchema specifies required fields (e.g., survey.updatedAt). This function
+ * enriches the mocked dependency's returnValueSchema so the LLM knows what fields
+ * to generate for array elements.
+ *
+ * Uses usageEquivalencies to trace data flow and ONLY enrich arrays with fields
+ * from children that actually receive elements from that array.
+ *
+ * Example:
+ * - getSurveysAction returns { data: array }
+ * - usageEquivalencies shows: surveys[] -> SurveyCard().signature[0].survey
+ * - SurveyCard expects signature[0].survey.updatedAt: date
+ * - After enrichment: getSurveysAction().data[]: object, data[].updatedAt: date
+ */
+export default function enrichArrayTypesFromChildSignatures(
+  importedExports: {
+    filePath?: string;
+    name: string;
+    isMocked?: boolean;
+  }[],
+  dependencySchemas: DataStructure['dependencySchemas'],
+  usageEquivalencies?: DataStructure['usageEquivalencies'],
+): void {
+  // Find all mocked dependencies with array return types
+  const mockedArrayPaths: {
+    filePath: string;
+    entityName: string;
+    arrayPath: string; // e.g., "getSurveysAction().functionCallReturnValue.data"
+  }[] = [];
+
+  for (const importedExport of importedExports) {
+    if (!importedExport.isMocked || !importedExport.filePath) continue;
+
+    const schema =
+      dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
+        ?.returnValueSchema;
+    if (!schema) continue;
+
+    // Find paths that are top-level data arrays (not deeply nested, not direct returns)
+    // We only want to enrich arrays that likely contain objects passed to children
+    // e.g., getSurveysAction().data but NOT:
+    //   - wrapThrows().data.createdBy (deeply nested)
+    //   - getStatusOptions().functionCallReturnValue (direct array return - usually options/primitives)
+    for (const [path, type] of Object.entries(schema)) {
+      // Check if type is array (including nullable/optional variants like 'array | undefined')
+      if (!type.startsWith('array')) continue;
+
+      // Skip paths with computed property patterns like [key], [i], [0], etc.
+      // These represent dynamic access patterns, not simple data arrays
+      // We only match brackets with content (not empty [] which indicates array element type)
+      if (/\[[^\]]+\]/.test(path)) {
+        continue;
+      }
+
+      // Skip direct array returns (e.g., getStatusOptions().functionCallReturnValue)
+      // These are typically specialized arrays like [{label, value}], not entity arrays
+      if (path.endsWith('.functionCallReturnValue')) {
+        continue;
+      }
+
+      // Check if this is a top-level array (at most one property after functionCallReturnValue)
+      // e.g., "foo().functionCallReturnValue.data" is top-level
+      // e.g., "foo().functionCallReturnValue.data.createdBy" is nested (skip)
+      const returnValueMatch = path.match(/\.functionCallReturnValue\.(.+)$/);
+      if (returnValueMatch) {
+        const afterReturnValue = returnValueMatch[1];
+        // If there's more than one property access, it's nested
+        const propertyCount = afterReturnValue.split('.').length;
+        if (propertyCount > 1) {
+          continue; // Skip deeply nested arrays
+        }
+      }
+
+      mockedArrayPaths.push({
+        filePath: importedExport.filePath,
+        entityName: importedExport.name,
+        arrayPath: path,
+      });
+    }
+  }
+
+  if (mockedArrayPaths.length === 0) return;
+
+  // Build a map from child component signature paths to their prop fields
+  // e.g., "SurveyCard().signature[0].survey" -> { "id": "string", "updatedAt": "date" }
+  const childSignatureFieldsByPath: Map<
+    string,
+    { propName: string; fields: Record<string, string> }
+  > = new Map();
+
+  // Helper to extract prop name and fields from a signature schema
+  const extractSignatureInfo = (
+    entityName: string,
+    schema: Record<string, string>,
+  ): 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 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 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
+  if (dependencySchemas) {
+    for (const [, entities] of Object.entries(dependencySchemas)) {
+      for (const [entityName, schemas] of Object.entries(entities)) {
+        const signatureSchema = schemas?.signatureSchema;
+        if (signatureSchema) {
+          extractSignatureInfo(entityName, signatureSchema);
+        }
+      }
+    }
+  }
+
+  if (childSignatureFieldsByPath.size === 0) return;
+
+  // Helper to check if a local variable name could be derived from a mocked function name
+  // e.g., "getSurveys" -> "surveys", "fetchUsers" -> "users", "loadData" -> "data"
+  // e.g., "getSurveysAction" -> "surveys" (removes "Action" suffix too)
+  const couldBeDerivedFrom = (
+    localVarName: string,
+    mockedFunctionName: string,
+  ): boolean => {
+    const normalizedVar = localVarName.toLowerCase().replace(/\[\]$/, '');
+    let normalizedFunc = mockedFunctionName.toLowerCase();
+
+    // Direct match (e.g., "surveys" from function "surveys")
+    if (normalizedFunc === normalizedVar) return true;
+
+    // Remove common prefixes like "get", "fetch", "load", "use"
+    const prefixPattern = /^(get|fetch|load|use)/i;
+    normalizedFunc = normalizedFunc.replace(prefixPattern, '');
+
+    // Remove common suffixes like "Action", "Query", "Mutation", "Handler"
+    const suffixPattern = /(action|query|mutation|handler)$/i;
+    normalizedFunc = normalizedFunc.replace(suffixPattern, '');
+
+    // Check if function name (without prefix/suffix) matches the variable name
+    if (normalizedFunc === normalizedVar) return true;
+
+    // Check for singular/plural relationship
+    // e.g., "survey" from "getSurveys" or "surveys" from "getSurvey"
+    if (
+      normalizedFunc.endsWith('s') &&
+      normalizedFunc.slice(0, -1) === normalizedVar
+    )
+      return true;
+    if (
+      normalizedVar.endsWith('s') &&
+      normalizedVar.slice(0, -1) === normalizedFunc
+    )
+      return true;
+
+    // Check if the array property name (like "data") is in the variable
+    // This handles cases like "const { data: surveys } = getSurveys()" where
+    // the local var might be the renamed destructured property
+    // Skip this for now as it's too loose
+
+    return false;
+  };
+
+  // For each mocked array, find which child signatures it flows to via usageEquivalencies
+  for (const { filePath, entityName, arrayPath } of mockedArrayPaths) {
+    const schema = dependencySchemas[filePath][entityName].returnValueSchema;
+
+    // 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 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;
+    }
+
+    // Find matching child signatures via usageEquivalencies
+    // Look for equivalencies where this array (or local variables derived from it)
+    // flows to a child component's signature
+    const matchedFields: Record<string, string> = {};
+
+    if (usageEquivalencies) {
+      // Check all equivalency entries for paths that could be derived from this array
+      for (const [sourcePath, targets] of Object.entries(usageEquivalencies)) {
+        // Check if this source path relates to our mocked array
+        // Direct match: "getSurveysAction().functionCallReturnValue.data[]"
+        // Indirect match: local variable like "surveys[]" that comes from the array
+        if (!sourcePath.endsWith('[]')) continue;
+
+        // Get the local variable name from the source path (e.g., "surveys[]" -> "surveys")
+        const localVarName = sourcePath.replace(/\[\]$/, '');
+
+        // Check if this local variable could have come from this mocked function
+        // Use heuristics: name matching (getSurveys -> surveys, getUsers -> users)
+        // 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;
+        }
+
+        for (const target of targets) {
+          // Target should be something like "SurveyCard().signature[0].survey"
+          // or "SurveyCard().signature[0].surveys[]"
+          const { schemaPath } = target;
+
+          // Look for signature fields that match this target
+          // Handle both singular (survey) and plural (surveys[]) forms
+          const normalizedTarget = schemaPath.replace(/\[\]$/, '');
+
+          for (const [signaturePath, info] of childSignatureFieldsByPath) {
+            if (normalizedTarget === signaturePath) {
+              // Found a match! Add all fields from this child signature
+              for (const [fieldPath, type] of Object.entries(info.fields)) {
+                if (!matchedFields[fieldPath]) {
+                  matchedFields[fieldPath] = type;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // If no equivalencies matched, skip this array entirely
+    // This prevents the bug where ALL child signatures get merged into ALL arrays
+    if (Object.keys(matchedFields).length === 0) {
+      continue;
+    }
+
+    // Add array element type and matched fields
+    const elementPath = `${arrayPath}[]`;
+    schema[elementPath] = 'object';
+
+    for (const [fieldPath, type] of Object.entries(matchedFields)) {
+      const fullPath = `${elementPath}.${fieldPath}`;
+      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/enrichUnknownTypesFromSourceEquivalencies.ts

@@ -0,0 +1,102 @@
+import { DataStructure } from '~codeyam/types';
+
+/**
+ * Enriches mocked dependency return value types using sourceEquivalencies.
+ *
+ * When a mocked dependency returns a value with an `unknown` type, and that value
+ * is passed to a child component, we can infer the type from the child's signature.
+ * The sourceEquivalencies track this data flow.
+ *
+ * Example:
+ * - trpc.quote.getQuoteQuestionAnswers.useQuery().functionCallReturnValue.data is `unknown`
+ * - sourceEquivalencies shows this data flows to QuoteHeaderExcel().signature[0].questionAnswers
+ * - QuoteHeaderExcel's signatureSchema says signature[0].questionAnswers is `array | undefined`
+ * - Therefore, data should be `array | undefined`
+ *
+ * Without this enrichment, fillInDirectSchemaGapsAndUnknowns will guess the type
+ * based on the property name, often incorrectly (e.g., 'data' becomes 'number'
+ * because pluralize.isPlural('data') returns true).
+ */
+export default function enrichUnknownTypesFromSourceEquivalencies(
+  isolatedDependencySchemas: DataStructure['dependencySchemas'],
+  mergedDependencySchemas: DataStructure['dependencySchemas'],
+  mockedImports: { filePath?: string; name: string; isMocked?: boolean }[],
+): void {
+  // Build a map of mocked dependency schemas for quick lookup
+  const mockedSchemas = new Map<string, Record<string, string>>();
+  for (const imp of mockedImports) {
+    if (!imp.isMocked || !imp.filePath) continue;
+    const schema =
+      mergedDependencySchemas?.[imp.filePath]?.[imp.name]?.returnValueSchema;
+    if (schema) {
+      mockedSchemas.set(`${imp.filePath}:${imp.name}`, schema);
+    }
+  }
+
+  if (mockedSchemas.size === 0) return;
+
+  // Iterate over all sourceEquivalencies in all dependency schemas
+  for (const filePath in isolatedDependencySchemas) {
+    for (const entityName in isolatedDependencySchemas[filePath]) {
+      const depSchema = isolatedDependencySchemas[filePath][entityName];
+      const sourceEquivs = depSchema.sourceEquivalencies;
+      if (!sourceEquivs) continue;
+
+      // For each sourceEquivalency: key is destination, value contains sources
+      for (const [destinationPath, sources] of Object.entries(sourceEquivs)) {
+        // Parse the destination to get the child entity name and signature path
+        // e.g., "QuoteHeaderExcel().signature[0].questionAnswers" ->
+        //   entityName: "QuoteHeaderExcel", sigPath: "signature[0].questionAnswers"
+        const destMatch = destinationPath.match(/^(\w+)\(\)\.(.+)$/);
+        if (!destMatch) continue;
+
+        const [, destEntityName, destSigPath] = destMatch;
+
+        // Find the child's signatureSchema to get the destination type
+        let destType: string | undefined;
+        for (const depFilePath in mergedDependencySchemas) {
+          const childSchema =
+            mergedDependencySchemas[depFilePath][destEntityName];
+          if (childSchema?.signatureSchema?.[destSigPath]) {
+            destType = childSchema.signatureSchema[destSigPath];
+            break;
+          }
+        }
+
+        if (!destType || destType === 'unknown') continue;
+
+        // Now check each source to see if it's a mocked dependency with unknown type
+        for (const source of sources) {
+          const { scopeNodeName, schemaPath } = source;
+
+          // Find which mocked dependency this belongs to
+          for (const [key, schema] of mockedSchemas) {
+            const [mockedFilePath, mockedName] = key.split(':');
+
+            // Check if this source path is in the mocked dependency's schema
+            // The schemaPath contains the full path like:
+            // "trpc.quote.getQuoteQuestionAnswers.useQuery(...).functionCallReturnValue.data"
+            // We need to find it in the returnValueSchema
+            if (schema[schemaPath] === 'unknown') {
+              // Found an unknown type that flows to a known type!
+              schema[schemaPath] = destType;
+            }
+
+            // Also check without the functionCallReturnValue part
+            // (some schemas might have the transformed path)
+            const transformedPath = schemaPath.replace(
+              /\.functionCallReturnValue/g,
+              '',
+            );
+            if (
+              transformedPath !== schemaPath &&
+              schema[transformedPath] === 'unknown'
+            ) {
+              schema[transformedPath] = destType;
+            }
+          }
+        }
+      }
+    }
+  }
+}