@codeyam/codeyam-cli 0.1.0-staging.483fdc2 → 0.1.0-staging.57cd50f

package/background/src/lib/virtualized/project/constructMockCode.js

@@ -257,7 +257,8 @@ options) {
     let dataStructureValue;
     let foundEntityWithSignature = false;
     let signatureSchema;
-    for (const filePath in dependencySchemas) {
+    let baseSchemaHasMethodCalls = false;
+    entitySearch: for (const filePath in dependencySchemas) {
         for (const entityName in dependencySchemas[filePath]) {
             // Match entity by base name (without generics/args)
             const entityBaseName = entityName.split(/[<(]/)[0];
@@ -281,15 +282,51 @@ options) {
                     pathParts[mockNameParts.length - 1].startsWith(mockNameParts[mockNameParts.length - 1]));
             });
             if (dataStructurePath) {
+                // Start with the base entity's return value schema
+                const baseReturnValueSchema = dependencySchemas[filePath][entityName]?.returnValueSchema;
+                const mergedSchema = {
+                    ...baseReturnValueSchema,
+                };
+                // Check if the base schema has method-call entries (e.g., .map().functionCallReturnValue)
+                // When it does, the scenario data is stored as an object with method keys, and
+                // array prototype methods need mock implementations. When it doesn't, the data
+                // is a raw array and native methods like .includes() work directly.
+                if (baseReturnValueSchema) {
+                    baseSchemaHasMethodCalls = Object.keys(baseReturnValueSchema).some((k) => k.startsWith(baseMockName + '.') &&
+                        k.includes('(') &&
+                        k.includes('.functionCallReturnValue'));
+                }
+                // Merge in method-call dependencies that are separate entries.
+                // e.g., "activityTypes.find((a) => a.value === type)" is a separate dependency
+                // for a .find() call on activityTypes. We need to include these with a
+                // .functionCallReturnValue path so constructMockCode generates callable mock methods.
+                for (const otherEntityName in dependencySchemas[filePath]) {
+                    if (otherEntityName === entityName)
+                        continue;
+                    if (otherEntityName.startsWith(baseMockName + '.') &&
+                        otherEntityName.includes('(')) {
+                        // Add a functionCallReturnValue entry for this method call.
+                        // This ensures constructMockCode treats it as a function that returns data,
+                        // generating a proper mock method with data lookup.
+                        const fcrvPath = `${otherEntityName}.functionCallReturnValue`;
+                        if (!mergedSchema[fcrvPath]) {
+                            // Infer the return type from the method-call dependency's schema
+                            const otherSchema = dependencySchemas[filePath][otherEntityName]?.returnValueSchema;
+                            // Look for element type (baseMockName[]) or fall back to 'unknown'
+                            const elementType = otherSchema?.[`${baseMockName}[]`];
+                            mergedSchema[fcrvPath] = elementType || 'unknown';
+                        }
+                    }
+                }
                 relevantReturnValueSchema = fillInDirectSchemaGapsAndUnknowns({
-                    schema: dependencySchemas[filePath][entityName]?.returnValueSchema,
+                    schema: mergedSchema,
                 });
                 // NOTE: clearAttributesFromMapping is disabled because it deletes
                 // method calls on arrays (like .eq() after functionCallReturnValue: 'array')
                 // However, we still need to remove duplicate function calls that create invalid syntax
                 removeDuplicateFunctionCalls(relevantReturnValueSchema);
                 dataStructureValue = relevantReturnValueSchema?.[dataStructurePath];
-                break;
+                break entitySearch;
             }
         }
     }
@@ -352,7 +389,10 @@ options) {
             args.push('...rest');
             const argsString = args.join(', ');
             // Generate empty mock function
-            return `function ${mockName}(${argsString}) {
+            // Use baseMockName (not mockName) because mockName may contain a full call
+            // signature with argument expressions (e.g., "logSignOutAction(sessionUser.id, ...)")
+            // which would produce invalid syntax as function parameter names.
+            return `function ${baseMockName}(${argsString}) {
   // Empty mock - original function mocked out
 }`;
         }
@@ -391,12 +431,12 @@ options) {
             : false;
         if (firstArgIsFunctionOrUnknown && returnsFunction) {
             // HOC pattern detected - return the first argument
-            return `function ${mockName}(${argsString}) {
+            return `function ${baseMockName}(${argsString}) {
   return arg1;
 }`;
         }
         // Generate empty mock function
-        return `function ${mockName}(${argsString}) {
+        return `function ${baseMockName}(${argsString}) {
   // Empty mock - original function mocked out
 }`;
     }
@@ -536,17 +576,23 @@ options) {
                 return [];
             }
             const addReturnValueFunctionAccessor = (dataPath) => {
-                // Add function call accessor if:
-                // - There are actual arguments, OR
-                // - This is a callable (not a method that returns an array directly)
-                // For methods like getAll() that return arrays, the data is at ["getAll()"] not ["getAll()"]["()"]
                 if (returnValue.returnsFunctionArgs &&
                     (returnValue.returnsFunctionArgs.length > 0 ||
                         !returnValue.returnsFunctionArray)) {
                     if (returnValue.isArray) {
                         dataPath = `${dataPath}${optionalAccess('[0]')}`;
                     }
-                    dataPath = `${dataPath}${optionalAccess(`(${safeString(returnValue.returnsFunctionArgs.join(', '))})`)}`;
+                    // Only add the function call accessor ?.["(args)"] when there are actual
+                    // arguments. When returnsFunctionArgs is empty [] (function-returns-function
+                    // with no specific arg patterns), skip the ?.["()"] because:
+                    // 1. preprocessSchemaForMocks collapses nested functionCallReturnValue chains
+                    //    into flat entries (e.g., getTranslate() = string, not {(): string})
+                    // 2. The mock data is a flat value, so ?.["()"] on a string returns undefined
+                    // 3. constructContent still wraps the return in a function (via returnsFunctionArgs)
+                    //    so the function-returns-function behavior is preserved without data nesting
+                    if (returnValue.returnsFunctionArgs.length > 0) {
+                        dataPath = `${dataPath}${optionalAccess(`(${safeString(returnValue.returnsFunctionArgs.join(', '))})`)}`;
+                    }
                 }
                 return dataPath;
             };
@@ -572,20 +618,6 @@ options) {
         };
         const constructContent = (dataPaths) => {
             const { name, args, nested, isArray, isGenericArray, returnsFunctionArgs, returnsFunctionArray, isAsyncFunction, hasNoReturnData, } = returnValue;
-            // When an array has differentiated indices ([0], [1], etc.), filter out any
-            // non-index items from nested. These non-index items come from generic [] paths
-            // like [].filter or [].sort, which describe element properties, not array elements.
-            // Including them would generate invalid syntax like "sort: ..." inside an array literal.
-            const hasDifferentiatedIndices = isArray &&
-                nested &&
-                nested.some((n) => n.name.match(/^\[\d+\]$/) && n.name !== '[0]');
-            const filteredNested = hasDifferentiatedIndices && nested
-                ? nested.filter((n) => n.name.match(/^\[\d+\]$/))
-                : nested;
-            const nestedContent = (filteredNested ?? []).map((nestedItem) => {
-                const nestedContent = constructReturnValueString(nestedItem, dataPaths);
-                return nestedContent;
-            });
             // Array prototype methods that should be ignored when building mocks
             // (these work on any array - we don't need to mock them)
             const ARRAY_PROTOTYPE_METHODS = new Set([
@@ -629,6 +661,36 @@ options) {
                 'with',
                 'length',
             ]);
+            // When an array has differentiated indices ([0], [1], etc.), filter out any
+            // non-index items from nested. These non-index items come from generic [] paths
+            // like [].filter or [].sort, which describe element properties, not array elements.
+            // Including them would generate invalid syntax like "sort: ..." inside an array literal.
+            const hasDifferentiatedIndices = isArray &&
+                nested &&
+                nested.some((n) => n.name.match(/^\[\d+\]$/) && n.name !== '[0]');
+            let filteredNested = hasDifferentiatedIndices && nested
+                ? nested.filter((n) => n.name.match(/^\[\d+\]$/))
+                : nested;
+            // When a variable IS an array (not a function returning an array),
+            // filter out array prototype methods like .includes(), .filter(), etc.
+            // ONLY when the base schema has no method-call entries. When the base
+            // schema has methods (e.g., .map().functionCallReturnValue), the scenario
+            // data is stored as an object with method-call keys, and ALL methods
+            // need mock implementations. When the base schema has no methods, the
+            // data is a raw array and native methods like .includes() work directly.
+            if (isArray &&
+                !returnsFunctionArray &&
+                !baseSchemaHasMethodCalls &&
+                filteredNested) {
+                filteredNested = filteredNested.filter((n) => {
+                    const methodName = n.name.replace(/[<(].*$/, '');
+                    return !ARRAY_PROTOTYPE_METHODS.has(methodName);
+                });
+            }
+            const nestedContent = (filteredNested ?? []).map((nestedItem) => {
+                const nestedContent = constructReturnValueString(nestedItem, dataPaths);
+                return nestedContent;
+            });
             const levelContentItems = [];
             // Add spread for data paths when:
             // - Not a function returning an array, OR function returns array with custom methods
@@ -1170,6 +1232,16 @@ options) {
                                     returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => (\n${indent(trimmedContent)}\n))`;
                                 }
                                 else {
+                                    // When generating object-wrapped .map(), ensure original item data is preserved.
+                                    // If no data spread was included (e.g., because this is a plain array property,
+                                    // not a function return), add ...__item__ to spread the original item properties.
+                                    // Without this, the .map() would create new objects with only nested function
+                                    // properties, losing data like filePath, frontmatter, body, etc.
+                                    const hasDataSpread = mappedContents.includes('...scenarios()') ||
+                                        mappedContents.includes('...__item__');
+                                    if (!hasDataSpread) {
+                                        mappedContents = `...__item__,\n${mappedContents}`;
+                                    }
                                     returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => ({\n${indent(mappedContents)}\n}))`;
                                 }
                             } // Close the empty content check else block
@@ -1231,6 +1303,13 @@ options) {
                             mappedContents = filterOutArrowFunctions(mappedContents);
                             mappedContents = filterOutBareObjects(mappedContents, true);
                             mappedContents = cleanupContent(mappedContents);
+                            // Same as needsWrapper branch: ensure item data is preserved in .map()
+                            const hasDataSpreadInner = mappedContents.includes('...scenarios()') ||
+                                mappedContents.includes('...__item__');
+                            if (!hasDataSpreadInner && mappedContents.trim().length > 0) {
+                                // Insert ...__item__ after the opening brace
+                                mappedContents = mappedContents.replace(/^\s*\{/, '{\n...__item__,');
+                            }
                             returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => (\n${indent(mappedContents)}\n))`;
                         }
                     }
@@ -1343,20 +1422,39 @@ options) {
                     content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
                 }
                 else {
-                    // No argument variants - use existing behavior
-                    // But if there's nested content, we need to include it in the return object
-                    // (similar to how argument variant branches handle this at line 1070-1072)
-                    const hasNestedContent = validNestedContent.length > 0;
-                    let funcReturnContents;
-                    if (hasNestedContent && levelContentItems.length > 1) {
-                        // Include both spread and nested content in the return
-                        funcReturnContents = `{\n${indent(levelContents)}\n}`;
+                    // No argument variants
+                    // Check if this is an array method callback containing JSX.
+                    // JSX can't be serialized to JSON, so the LLM generates [{}] as data.
+                    // Instead of returning that unusable data, generate a passthrough that
+                    // calls the real callback on the best available array data from siblings.
+                    const containsJsx = dataPaths.some((p) => /<[A-Z]/.test(p));
+                    const isArrayMethod = ARRAY_PROTOTYPE_METHODS.has(name);
+                    if (containsJsx && isArrayMethod && dataPaths.length > 0) {
+                        // Extract parent data path by removing the last ?.["..."] segment
+                        const parentPath = dataPaths[0].replace(/\?\.\["[^"]*"\]$/, '');
+                        const funcLines = [
+                            `const _d = ${parentPath};`,
+                            `const _a = Object.values(_d || {}).filter(v => Array.isArray(v) && v.length > 0 && v.some(i => i && typeof i === "object" && Object.keys(i).length > 0)).sort((a, b) => b.length - a.length);`,
+                            `return _a[0] ? _a[0].${name}(${argsString}) : []`,
+                        ];
+                        const funcContents = funcLines.join('\n');
+                        content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
                     }
                     else {
-                        funcReturnContents = returnValueContents;
+                        // But if there's nested content, we need to include it in the return object
+                        // (similar to how argument variant branches handle this at line 1070-1072)
+                        const hasNestedContent = validNestedContent.length > 0;
+                        let funcReturnContents;
+                        if (hasNestedContent && levelContentItems.length > 1) {
+                            // Include both spread and nested content in the return
+                            funcReturnContents = `{\n${indent(levelContents)}\n}`;
+                        }
+                        else {
+                            funcReturnContents = returnValueContents;
+                        }
+                        const funcContents = `return ${funcReturnContents}`;
+                        content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
                     }
-                    const funcContents = `return ${funcReturnContents}`;
-                    content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
                 }
             }
             else {
@@ -1900,6 +1998,20 @@ options) {
             returnValueSection = relevantPart;
         }
     }
+    // Post-processing: When the root functionCallReturnValue is typed as "function" but the
+    // return value also has nested properties (methods like .from(), .auth, etc.), it's actually
+    // an object, not a function to be called. Clear returnsFunctionArgs to prevent double-wrapping
+    // (adding an extra () => { return { ... } } wrapper and ["()"] data paths).
+    // This handles cases like Supabase's createClient() which returns an object with methods.
+    // Only applied to the root level - nested parts that are functions with methods (like
+    // useSearchParams()[1] which is a setter function with .set() and .delete()) should keep
+    // their returnsFunctionArgs since they genuinely ARE functions.
+    if (returnValueParts.returnsFunctionArgs &&
+        returnValueParts.returnsFunctionArgs.length === 0 &&
+        returnValueParts.nested &&
+        returnValueParts.nested.length > 0) {
+        returnValueParts.returnsFunctionArgs = undefined;
+    }
     const contents = constructReturnValueString(returnValueParts);
     if (mockNameParts.length > 1) {
         const originalLib = `${mockNameParts[0]}__cyOriginal`;
@@ -1961,15 +2073,24 @@ options) {
             const nameAssignment = isErrorSubclass
                 ? `this.name = '${baseMockName}';`
                 : '';
-            // Use the safe function name for the class definition
-            const className = mockNameIsCallSignature
-                ? derivedFunctionName
-                : baseMockName;
+            // Use the base class name for the class definition, not the call-signature-derived name.
+            // When mockName is "StatsCalculator(supabase)", baseMockName is "StatsCalculator"
+            // and derivedFunctionName would be "StatsCalculator_supabase" which is wrong.
+            // Classes are instantiated with `new ClassName(args)` so the name must match the original.
+            const className = baseMockName;
+            // Use the already-generated contents (which has proper function wrappers for methods)
+            // instead of raw scenarios().data() which would create non-callable string-keyed properties.
+            // For classes with methods like calculateStats(), the contents will have:
+            //   { calculateStats: (...args) => scenarios().data()?.["key"]?.["calculateStats(...)"], ... }
+            // which makes methods callable on the instance.
+            const classContents = enhancedContents.trim().startsWith('{')
+                ? enhancedContents
+                : `scenarios().data()?.${quotePropertyKey(dataKey)} || {}`;
             return `class ${className}${isErrorSubclass ? ' extends Error' : ''} {
   constructor(message) {
     ${superCall}
     ${nameAssignment}
-    Object.assign(this, scenarios().data()?.${quotePropertyKey(dataKey)} || {});
+    Object.assign(this, ${classContents});
   }
 }`;
         }
@@ -2047,7 +2168,19 @@ options) {
         const safeReturnValue = isSimpleDataPath
             ? `${returnValue} ?? {}`
             : returnValue;
-        return `${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}(...args) {\n${indent(`return ${safeReturnValue};`)}\n}`;
+        const refName = `_${safeFunctionName}Ref`;
+        const assignment = `${refName}.current = ${safeReturnValue};`;
+        const ifBlock = `if (!${refName}.current) {\n${indent(assignment)}\n}`;
+        const body = `${ifBlock}\nreturn ${refName}.current;`;
+        return [
+            `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)`,
+            `const ${refName} = {`,
+            `  current: null,`,
+            `};`,
+            `${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}(...args) {`,
+            indent(body),
+            `}`,
+        ].join('\n');
     }
     else {
         // Generate safe const name: