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

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

@@ -82,6 +82,9 @@ export default function enrichArrayTypesFromChildSignatures(
   if (mockedArrayPaths.length === 0) return;
 
   // Find all non-mocked child components and extract their signature fields
+  // We check both direct imports AND all schemas in dependencySchemas because
+  // transitive dependencies (e.g., SurveyCard imported by SurveysList imported by SurveysPage)
+  // may have signature schemas that we need to use for enrichment.
   const childSignatureFields: {
     filePath: string;
     entityName: string;
@@ -89,28 +92,39 @@ export default function enrichArrayTypesFromChildSignatures(
     propFields: Record<string, string>;
   }[] = [];
 
-  for (const importedExport of importedExports) {
-    // Skip mocked dependencies - we want child components
-    if (importedExport.isMocked || !importedExport.filePath) continue;
-
-    const schema =
-      dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
-        ?.signatureSchema;
-    if (!schema) continue;
-
-    // Extract signature[0].* fields (first prop of child component)
+  // Helper to extract prop fields from a signature schema
+  const extractPropFields = (
+    schema: Record<string, string>,
+  ): Record<string, string> => {
     const propFields: Record<string, string> = {};
     for (const [path, type] of Object.entries(schema)) {
       // Match signature[0].propName.field patterns
       const match = path.match(/^signature\[0\]\.(\w+)\.(.+)$/);
       if (match) {
-        const [, propName, fieldPath] = match;
+        const [, , fieldPath] = match;
         // Store as "fieldPath" without the prop name prefix
         // e.g., signature[0].survey.updatedAt -> updatedAt
         propFields[fieldPath] = type;
       }
     }
+    return propFields;
+  };
+
+  // First, check direct imports (non-mocked)
+  const processedSchemas = new Set<string>();
+  for (const importedExport of importedExports) {
+    // Skip mocked dependencies - we want child components
+    if (importedExport.isMocked || !importedExport.filePath) continue;
+
+    const schemaKey = `${importedExport.filePath}::${importedExport.name}`;
+    processedSchemas.add(schemaKey);
+
+    const schema =
+      dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
+        ?.signatureSchema;
+    if (!schema) continue;
 
+    const propFields = extractPropFields(schema);
     if (Object.keys(propFields).length > 0) {
       childSignatureFields.push({
         filePath: importedExport.filePath,
@@ -120,6 +134,30 @@ export default function enrichArrayTypesFromChildSignatures(
     }
   }
 
+  // Also check all schemas in dependencySchemas for transitive child components
+  // that may not be in importedExports but have signature schemas with prop fields
+  if (dependencySchemas) {
+    for (const [filePath, entities] of Object.entries(dependencySchemas)) {
+      for (const [entityName, schemas] of Object.entries(entities)) {
+        const schemaKey = `${filePath}::${entityName}`;
+        // Skip already processed schemas
+        if (processedSchemas.has(schemaKey)) continue;
+
+        const signatureSchema = schemas?.signatureSchema;
+        if (!signatureSchema) continue;
+
+        const propFields = extractPropFields(signatureSchema);
+        if (Object.keys(propFields).length > 0) {
+          childSignatureFields.push({
+            filePath,
+            entityName,
+            propFields,
+          });
+        }
+      }
+    }
+  }
+
   if (childSignatureFields.length === 0) return;
 
   // Enrich mocked dependency arrays with child signature fields

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;
+            }
+          }
+        }
+      }
+    }
+  }
+}