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

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