@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

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

@@ -2,7 +2,7 @@ import { Entity, File, Project } from '~codeyam/types';
 import { FileAnalyzer } from '../FileAnalyzer';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import type { FunctionDependenciesMap } from '../asts/sourceFiles/getPseudoFile';
-// import { generateSha } from '~codeyam/supabase';
+// import { generateSha } from '~codeyam/database';
 
 export default function getImportedExports(
   file: File,
@@ -63,19 +63,116 @@ export default function getImportedExports(
           imports[filePath].resolvedPath ??
           filePath;
 
-        const importedExportFile = project.files.find(
+        let importedExportFile = project.files.find(
           (f) => f.path === searchPath,
         );
 
-        if (!importedExportFile) {
-          console.log(
-            'CodeYam Error: File not found for imported export',
-            file.path,
-            filePath,
-            importedExportInfo,
-            imports[filePath],
+        // Track the actual path we found (may differ from searchPath after dist->src mapping)
+        let actualResolvedPath = imports[filePath].resolvedPath;
+
+        // Workspace packages often resolve to dist/ paths (from package.json "types" or "main"),
+        // but our project.files contains source files in src/. Try mapping dist -> src.
+        if (!importedExportFile && searchPath.includes('/dist/')) {
+          // Some build tools create nested structures like dist/packageName/src/file.d.ts
+          // when the source is at packages/packageName/src/file.ts
+          // Pattern: packages/X/dist/X/src/Y -> packages/X/src/Y
+          const nestedDistMatch = searchPath.match(
+            /^(packages\/[^/]+)\/dist\/[^/]+\/src\/(.+)$/,
           );
-          return;
+          if (nestedDistMatch) {
+            const [, packagePath, relativePath] = nestedDistMatch;
+            const srcPath = `${packagePath}/src/${relativePath}`
+              .replace(/\.d\.ts$/, '.ts')
+              .replace(/\.js$/, '.ts');
+            importedExportFile = project.files.find((f) => f.path === srcPath);
+            if (importedExportFile) {
+              actualResolvedPath = srcPath;
+              console.log(
+                `CodeYam: Mapped nested dist->src path: ${searchPath} -> ${srcPath}`,
+              );
+            }
+          }
+
+          // Try simple dist -> src replacement if nested pattern didn't match
+          if (!importedExportFile) {
+            const srcPath = searchPath.replace('/dist/', '/src/');
+            // Try exact match first
+            importedExportFile = project.files.find((f) => f.path === srcPath);
+            if (importedExportFile) {
+              actualResolvedPath = srcPath;
+              console.log(
+                `CodeYam: Mapped dist->src path: ${searchPath} -> ${srcPath}`,
+              );
+            }
+          }
+
+          // If not found, the dist file might be index.d.ts but src might be index.ts
+          // or the export might be re-exported from another file
+          if (!importedExportFile) {
+            const srcPath = searchPath.replace('/dist/', '/src/');
+            // Try removing .d.ts extension and finding any matching src file
+            const basePath = srcPath
+              .replace(/\.d\.ts$/, '')
+              .replace(/\.js$/, '');
+            importedExportFile = project.files.find(
+              (f) =>
+                f.path === basePath + '.ts' ||
+                f.path === basePath + '.tsx' ||
+                (f.path.startsWith(basePath.replace('/index', '/')) &&
+                  !f.path.includes('/dist/')),
+            );
+            if (importedExportFile) {
+              actualResolvedPath = importedExportFile.path;
+              console.log(
+                `CodeYam: Mapped dist->src path (extension): ${searchPath} -> ${importedExportFile.path}`,
+              );
+            }
+          }
+        }
+
+        if (!importedExportFile) {
+          // Check if this looks like a path alias (starts with @/ or similar patterns)
+          // Path aliases should resolve to project files - if they don't, it's a config issue
+          // Also check for ~packageName/ patterns like ~codeyam/supabase
+          const isPathAlias =
+            filePath.startsWith('@/') ||
+            filePath.startsWith('~/') ||
+            filePath.startsWith('#/') ||
+            /^~[a-zA-Z]/.test(filePath); // ~packageName patterns like ~codeyam/
+
+          const name =
+            importedExportInfo.importName ?? importedExportInfo.importAlias;
+
+          if (isPathAlias) {
+            // Path aliases should resolve - if they don't, it's a configuration issue
+            // Don't treat as node module, just log and skip
+            console.log(
+              'CodeYam Warning: Path alias import not resolved (file may be missing or path alias misconfigured):',
+              file.path,
+              filePath,
+              importedExportInfo,
+            );
+            return;
+          }
+
+          // If still not found, track as unresolved import
+          // Don't set isMocked here - let later processing determine based on mockedDependencies
+          // This ensures the import is tracked (not dropped) while deferring the mocking decision
+          if (!importedExportFile) {
+            const name =
+              importedExportInfo.importName ?? importedExportInfo.importAlias;
+            console.log(
+              `CodeYam: Tracking unresolved import (mocking decision deferred): ${filePath} -> ${name}`,
+            );
+            return {
+              filePath,
+              name,
+              isDefault: importedExportInfo.isImportDefault,
+              // isMocked intentionally undefined - will be determined later by prepareDataStructures
+              // based on mockedDependencies analysis
+              entityType: 'library' as const,
+            };
+          }
         }
 
         try {
@@ -91,19 +188,39 @@ export default function getImportedExports(
           const name =
             importedExportInfo.importName ?? importedExportInfo.importAlias;
 
-          const resolvedFilePath = importedExportInfo.resolvedPath;
+          // Map nested dist paths in resolvedPath to src paths
+          // Pattern: packages/X/dist/X/src/Y -> packages/X/src/Y
+          let resolvedFilePath = importedExportInfo.resolvedPath;
+          if (resolvedFilePath) {
+            const nestedDistMatch = resolvedFilePath.match(
+              /^(packages\/[^/]+)\/dist\/[^/]+\/src\/(.+)$/,
+            );
+            if (nestedDistMatch) {
+              const [, packagePath, relativePath] = nestedDistMatch;
+              resolvedFilePath = `${packagePath}/src/${relativePath}`
+                .replace(/\.d\.ts$/, '.ts')
+                .replace(/\.js$/, '.ts');
+            }
+          }
           const resolvedName = importedExportInfo.exportName;
 
+          // When a default export is re-exported as named (e.g., `export { default as X }`),
+          // isExportDefault will be false (it's exported as named from the barrel),
+          // but resolvedName will be 'default'. In this case, we need resolvedIsDefault
+          // to be true so that writeScenarioComponents adds the named re-export.
+          const resolvedIsDefault =
+            importedExportInfo.isExportDefault || resolvedName === 'default';
+
           return {
             fileId: importedExportFile.id,
-            filePath: imports[filePath].resolvedPath,
+            filePath: actualResolvedPath,
             isDefault: importedExportInfo.isImportDefault,
             resolvedFilePath:
-              resolvedFilePath === imports[filePath].resolvedPath
+              resolvedFilePath === actualResolvedPath
                 ? undefined
                 : resolvedFilePath,
             resolvedName: resolvedName === name ? undefined : resolvedName,
-            resolvedIsDefault: importedExportInfo.isExportDefault,
+            resolvedIsDefault,
             entityType,
             name,
             code,

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

@@ -68,128 +68,268 @@ function preprocessSchemaForMocks(
   return result;
 }
 
-export default function gatherDataForMocks(
-  importedExports: {
+/**
+ * Processes a single call (with optional variable name) and returns the mock data entry.
+ * Returns null if no valid schema is found.
+ *
+ * @param importedExport - The imported export to process
+ * @param dependencySchemas - The dependency schemas
+ * @param callIndex - The index of the call to process
+ * @param variableNameOccurrence - When a variable name is reused, this is the occurrence index
+ *                                  (e.g., first 'data' = 0, second 'data' = 1)
+ *                                  Used to disambiguate keys when the same variable is reused.
+ */
+function processCall(
+  importedExport: {
     filePath?: string;
     name: string;
     isMocked?: boolean;
     calls?: string[];
-  }[],
+    callVariableNames?: string[];
+  },
   dependencySchemas: DataStructure['dependencySchemas'],
-) {
-  return importedExports.reduce(
-    (acc, importedExport) => {
-      if (!importedExport.isMocked) return acc;
+  callIndex: number,
+  variableNameOccurrence?: number,
+): { key: string; value: JsonTypeDefinition } | null {
+  const callName = importedExport.calls?.[callIndex] ?? importedExport.name;
+  const variableName = importedExport.callVariableNames?.[callIndex];
 
-      const functionNames: string[] = [];
-
-      const isFunctionNameWithoutFunction = (
-        path: string,
-        functionName: string,
-      ) => {
-        // Check if path starts with functionName but isn't a function call
-        // Must also handle generics: useLoaderData<typeof loader>() should NOT
-        // be filtered when functionName is 'useLoaderData'
-        return (
-          path.startsWith(functionName) &&
-          !path.startsWith(functionName + '(') &&
-          !path.startsWith(functionName + '.(') &&
-          !path.startsWith(functionName + '<') // Handle generics
-        );
-      };
+  // Build the schema lookup key - use variable-qualified key if available
+  const schemaLookupKey = variableName
+    ? `${importedExport.name}::${variableName}`
+    : importedExport.name;
 
-      const rawSchema =
-        dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
-          ?.returnValueSchema ?? {};
-
-      // Preprocess to filter signatures and extract functionCallReturnValue
-      let preprocessedSchema = preprocessSchemaForMocks(rawSchema);
-
-      // Merge non-generic variants into generic variants
-      // e.g., if callName is "useFetcher<T>()", also include paths from "useFetcher()"
-      const callName = importedExport.calls?.[0] ?? importedExport.name;
-      if (callName.includes('<') && callName.includes('(')) {
-        // Extract the base function name without generics
-        const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
-        const nonGenericCall = baseFunctionName + '()';
-        const genericCallPrefix = callName.endsWith(')')
-          ? callName
-          : callName + '()';
-
-        // If we have a generic call, merge paths from non-generic variant
-        const mergedSchema: Record<string, string> = { ...preprocessedSchema };
-        for (const path of Object.keys(preprocessedSchema)) {
-          if (path.startsWith(nonGenericCall)) {
-            // Create corresponding generic path
-            const genericPath =
-              genericCallPrefix + path.slice(nonGenericCall.length);
-            // Only add if the generic path doesn't already exist
-            if (!mergedSchema[genericPath]) {
-              mergedSchema[genericPath] = preprocessedSchema[path];
-            }
-          }
+  const rawSchema =
+    dependencySchemas?.[importedExport.filePath]?.[schemaLookupKey]
+      ?.returnValueSchema ?? {};
+
+  // If no schema found with variable-qualified key, fall back to base name
+  const fallbackSchema =
+    Object.keys(rawSchema).length === 0
+      ? (dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
+          ?.returnValueSchema ?? {})
+      : rawSchema;
+
+  // Preprocess to filter signatures and extract functionCallReturnValue
+  let preprocessedSchema = preprocessSchemaForMocks(fallbackSchema);
+
+  const functionNames: string[] = [];
+
+  const isFunctionNameWithoutFunction = (
+    path: string,
+    functionName: string,
+  ) => {
+    // Check if path starts with functionName but isn't a function call
+    // Must also handle generics: useLoaderData<typeof loader>() should NOT
+    // be filtered when functionName is 'useLoaderData'
+    return (
+      path.startsWith(functionName) &&
+      !path.startsWith(functionName + '(') &&
+      !path.startsWith(functionName + '.(') &&
+      !path.startsWith(functionName + '<') // Handle generics
+    );
+  };
+
+  // For variable-qualified schemas, the paths also include the variable qualifier
+  // e.g., "useFetcher()::entityDiffFetcher.functionCallReturnValue.data"
+  // We need to handle both qualified and non-qualified paths
+
+  // Merge non-generic variants into generic variants
+  // e.g., if callName is "useFetcher<T>()", also include paths from "useFetcher()"
+  if (callName.includes('<') && callName.includes('(')) {
+    // Extract the base function name without generics
+    const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
+    const nonGenericCall = variableName
+      ? `${baseFunctionName}()::${variableName}`
+      : baseFunctionName + '()';
+    const genericCallPrefix = variableName
+      ? `${callName.endsWith(')') ? callName : callName + '()'}::${variableName}`
+      : callName.endsWith(')')
+        ? callName
+        : callName + '()';
+
+    // If we have a generic call, merge paths from non-generic variant
+    const mergedSchema: Record<string, string> = { ...preprocessedSchema };
+    for (const path of Object.keys(preprocessedSchema)) {
+      if (path.startsWith(nonGenericCall)) {
+        // Create corresponding generic path
+        const genericPath =
+          genericCallPrefix + path.slice(nonGenericCall.length);
+        // Only add if the generic path doesn't already exist
+        if (!mergedSchema[genericPath]) {
+          mergedSchema[genericPath] = preprocessedSchema[path];
         }
-        preprocessedSchema = mergedSchema;
       }
+    }
+    preprocessedSchema = mergedSchema;
+  }
 
-      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];
-              }
-            }
-          }
+  // Merge generic call (e.g., "foo()") data into specific argument calls (e.g., "foo(arg1, arg2)")
+  // This handles the case where the generic schema has richer nested data than the specific call
+  if (callName.includes('(') && !callName.includes('<')) {
+    // Extract the base function name and create generic call
+    const baseFunctionName = callName.split('(')[0];
 
+    // For path matching, use non-qualified call names since schema paths don't include
+    // variable qualifiers. Variable qualifiers are only for schema lookup, not path matching.
+    const genericCallForMatching = baseFunctionName + '()';
+    const specificCallForMatching = callName;
+
+    // Only merge if the callName has arguments (not just empty parens)
+    if (specificCallForMatching !== genericCallForMatching) {
+      const mergedSchema: Record<string, string> = {
+        ...preprocessedSchema,
+      };
+      for (const path of Object.keys(preprocessedSchema)) {
+        if (path.startsWith(genericCallForMatching)) {
+          // Create corresponding specific path
+          const specificPath =
+            specificCallForMatching + path.slice(genericCallForMatching.length);
+          // Add if the specific path doesn't exist, OR if it exists but is "unknown"
+          // The generic call's schema often has more precise type info than the specific call
           if (
-            functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))
+            !mergedSchema[specificPath] ||
+            mergedSchema[specificPath] === 'unknown'
           ) {
-            return acc;
+            mergedSchema[specificPath] = preprocessedSchema[path];
           }
+        }
+      }
+      preprocessedSchema = mergedSchema;
+    }
+  }
 
-          acc[path] = preprocessedSchema[path];
-          return acc;
-        },
-        {} as Record<string, string>,
-      );
-
-      const schema = convertDotNotation(
-        fillInDirectSchemaGapsAndUnknowns({
-          scopeName: importedExport.name,
-          schema: relevantMergedDependencySchema,
-        }),
-      );
-
-      // Determine if this is an object-style or hook-style dependency:
-      // - Hook-style: calls = ['useAuth()'] - call starts with name + '('
-      // - Object-style: calls = ['supabase.from(...)'] - call starts with name + '.'
-      //
-      // After convertDotNotation:
-      // - Hook-style schema has the callName as top-level key: schema['useAuth()']
-      // - Object-style schema has the import name as top-level key: schema['supabase']
-      // Note: callName is already defined above for generic/non-generic merging
-      const isObjectStyle =
-        callName.startsWith(importedExport.name + '.') ||
-        (!callName.includes('(') && callName === importedExport.name);
-
-      const schemaKey = isObjectStyle ? importedExport.name : callName;
-      const outputKey = isObjectStyle ? importedExport.name : callName;
-      const returnValue = schema[schemaKey] ?? schema['returnValue'];
-
-      if (!returnValue) {
+  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];
+          }
+        }
+      }
+
+      if (functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))) {
         return acc;
       }
 
-      acc[outputKey] = returnValue as JsonTypeDefinition;
+      acc[path] = preprocessedSchema[path];
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+
+  const schema = convertDotNotation(
+    fillInDirectSchemaGapsAndUnknowns({
+      scopeName: importedExport.name,
+      schema: relevantMergedDependencySchema,
+    }),
+  );
+
+  // Determine if this is an object-style or hook-style dependency:
+  // - Hook-style: calls = ['useAuth()'] - call starts with name + '('
+  // - Object-style: calls = ['supabase.from(...)'] - call starts with name + '.'
+  const isObjectStyle =
+    callName.startsWith(importedExport.name + '.') ||
+    (!callName.includes('(') && callName === importedExport.name);
+
+  // Build schema key with variable qualifier if present
+  const baseSchemaKey = isObjectStyle ? importedExport.name : callName;
+  const schemaKey = variableName
+    ? `${baseSchemaKey}::${variableName}`
+    : baseSchemaKey;
+
+  // Build output key - for variable-qualified, use "variableName <- functionName" format
+  // This reads naturally as "variableName receives from functionName"
+  // When a variable name is reused (variableNameOccurrence > 0), disambiguate with index
+  let outputKey: string;
+  if (variableName) {
+    // When the same variable name is used multiple times, append the occurrence index
+    // to create unique keys: "data[0] <- useFetch", "data[1] <- useFetch"
+    const disambiguator =
+      variableNameOccurrence !== undefined && variableNameOccurrence > 0
+        ? `[${variableNameOccurrence}]`
+        : '';
+    outputKey = `${variableName}${disambiguator} <- ${importedExport.name}`;
+  } else if (isObjectStyle) {
+    outputKey = importedExport.name;
+  } else {
+    outputKey = callName;
+  }
+
+  // Try to find return value - check with variable qualifier first, then without
+  let returnValue = schema[schemaKey];
+  if (!returnValue && variableName) {
+    returnValue = schema[baseSchemaKey];
+  }
+  if (!returnValue) {
+    returnValue = schema['returnValue'];
+  }
+
+  if (!returnValue) {
+    return null;
+  }
+
+  return { key: outputKey, value: returnValue as JsonTypeDefinition };
+}
+
+export default function gatherDataForMocks(
+  importedExports: {
+    filePath?: string;
+    name: string;
+    isMocked?: boolean;
+    calls?: string[];
+    callVariableNames?: string[];
+  }[],
+  dependencySchemas: DataStructure['dependencySchemas'],
+) {
+  return importedExports.reduce(
+    (acc, importedExport) => {
+      if (!importedExport.isMocked) return acc;
+
+      // Check if we have multiple calls with variable names
+      const hasMultipleCalls =
+        importedExport.calls &&
+        importedExport.calls.length > 1 &&
+        importedExport.callVariableNames &&
+        importedExport.callVariableNames.length === importedExport.calls.length;
+
+      if (hasMultipleCalls) {
+        // Track how many times each variable name has been seen
+        // to disambiguate keys when the same variable is reused
+        const variableNameCounts: Record<string, number> = {};
+
+        // Process each call separately with its variable name
+        for (let i = 0; i < importedExport.calls!.length; i++) {
+          const varName = importedExport.callVariableNames![i];
+
+          // Calculate the occurrence index for this variable name
+          const occurrence = variableNameCounts[varName] ?? 0;
+          variableNameCounts[varName] = occurrence + 1;
+
+          const result = processCall(
+            importedExport,
+            dependencySchemas,
+            i,
+            occurrence,
+          );
+          if (result) {
+            acc[result.key] = result.value;
+          }
+        }
+      } else {
+        // Original behavior for single calls or calls without variable names
+        const result = processCall(importedExport, dependencySchemas, 0);
+        if (result) {
+          acc[result.key] = result.value;
+        }
+      }
 
       return acc;
     },