@codeyam/codeyam-cli 0.1.0-staging.8aea589 → 0.1.0-staging.bbe4da9

package/analyzer-template/project/writeMockDataTsx.ts

@@ -244,6 +244,24 @@ const jsonToCode = (
     } else {
       const keyStrings: string[] = [];
       const jsonObj = json as Record<string, unknown>;
+      // Track normalized function names to avoid duplicate keys in output
+      // e.g., submit({ a }) and submit({ b }) should both become "submit" once
+      const seenNormalizedFuncNames = new Set<string>();
+
+      // Pre-scan to identify plain keys that have function-call versions
+      // These plain keys should be skipped because the function-call version
+      // will be normalized to the same key name
+      // e.g., if both "push" and "push(`/path`)" exist, skip the plain "push"
+      const plainKeysWithFunctionCallVersions = new Set<string>();
+      for (const key of Object.keys(jsonObj)) {
+        if (key.includes('(') && key.endsWith(')')) {
+          const funcName = key.split('(')[0];
+          // Check if a plain key with this name exists
+          if (funcName in jsonObj && !funcName.includes('(')) {
+            plainKeysWithFunctionCallVersions.add(funcName);
+          }
+        }
+      }
 
       for (const key of Object.keys(jsonObj)) {
         if (jsonObj[key] === undefined || jsonObj[key] === null) continue;
@@ -252,6 +270,42 @@ const jsonToCode = (
           if (key === '~~codeyam-jsx~~') {
             return `<>${(jsonObj[key] as string[]).join('')}</>`;
           }
+
+          // Check if this is a nested function signature with array value
+          // e.g., "postMessage(message, '*')": ["mockMessageString", "*"]
+          // These need to be transformed into callable arrow functions
+          // Only apply at deeper nesting levels (level > 2) - top-level mock data keys
+          // (level 2) are return values that should preserve their data
+          // Skip when array contains objects (likely return data like getAll() returning [{name, value}])
+          const argsArray = jsonObj[key] as unknown[];
+          const isReturnData = argsArray.some(
+            (item) => item && typeof item === 'object' && !Array.isArray(item),
+          );
+          if (
+            key.includes('(') &&
+            key.endsWith(')') &&
+            level > 2 &&
+            !isReturnData
+          ) {
+            const funcName = key.split('(')[0];
+            // Skip if we've already added this normalized function name
+            if (seenNormalizedFuncNames.has(funcName)) {
+              continue;
+            }
+            seenNormalizedFuncNames.add(funcName);
+            const argsArray = jsonObj[key] as unknown[];
+            const argsString = argsArray
+              .map((_, i) => `arg${i + 1}`)
+              .join(', ');
+            console.log(
+              `CodeYam: Nested func transform (array): "${key}" -> "${funcName}"`,
+            );
+            keyStrings.push(
+              `${levelSpacing}"${safeString(funcName, level)}": (${argsString}) => {}`,
+            );
+            continue;
+          }
+
           const arrayString = jsonToCode(
             jsonObj[key],
             level + 1,
@@ -269,9 +323,38 @@ const jsonToCode = (
             );
           }
         } else if (typeof jsonObj[key] === 'object') {
-          // Check if this object has a "functionCallReturnValue" key - if so, unwrap it
           const objKeys = Object.keys(jsonObj[key] as object);
+
+          // Check if this is a nested function signature (e.g., "postMessage(message, targetOrigin)": { signature: [...] })
+          // These need to be transformed into callable arrow functions
+          // Only apply at deeper nesting levels (level > 2) - top-level mock data keys
+          // (level 2) are return values that should preserve their data
           if (
+            key.includes('(') &&
+            key.endsWith(')') &&
+            level > 2 &&
+            objKeys.includes('signature') &&
+            Array.isArray((jsonObj[key] as Record<string, unknown>).signature)
+          ) {
+            const funcName = key.split('(')[0];
+            // Skip if we've already added this normalized function name
+            if (seenNormalizedFuncNames.has(funcName)) {
+              continue;
+            }
+            seenNormalizedFuncNames.add(funcName);
+            const signature = (jsonObj[key] as Record<string, unknown>)
+              .signature as string[];
+            const argsString = signature
+              .map((_, i) => `arg${i + 1}`)
+              .join(', ');
+            console.log(
+              `CodeYam: Nested func transform (signature): "${key}" -> "${funcName}"`,
+            );
+            keyStrings.push(
+              `${levelSpacing}"${safeString(funcName, level)}": (${argsString}) => {}`,
+            );
+          } else if (
+            // Check if this object has a "functionCallReturnValue" key - if so, unwrap it
             objKeys.length === 1 &&
             objKeys[0] === 'functionCallReturnValue'
           ) {
@@ -341,10 +424,78 @@ const jsonToCode = (
           }
           return keyValue;
         } else if (typeof jsonObj[key] === 'string') {
-          keyStrings.push(
-            `${levelSpacing}"${safeString(key, level)}": "${safeString(jsonObj[key] as string, level)}"`,
-          );
+          const stringValue = jsonObj[key] as string;
+
+          // Check if this is a nested function signature with string value
+          // e.g., "postMessage(message, '*')": "() => { console.log('postMessage called'); }"
+          // These need to have the key normalized to just the function name
+          // Only apply at deeper nesting levels (level > 2)
+          if (key.includes('(') && key.endsWith(')') && level > 2) {
+            const funcName = key.split('(')[0];
+
+            // Skip if we've already added this normalized function name
+            if (seenNormalizedFuncNames.has(funcName)) {
+              continue;
+            }
+            seenNormalizedFuncNames.add(funcName);
+
+            // Check if the string value looks like a function expression
+            const looksLikeFunction =
+              stringValue.includes('=>') ||
+              stringValue.startsWith('function') ||
+              stringValue.startsWith('async');
+
+            // Handle special type indicators that need transformation
+            let outputValue: string;
+            if (stringValue === 'promise') {
+              outputValue = 'Promise.resolve()';
+              console.log(
+                `CodeYam: Nested func transform (string->Promise): "${key}" -> "${funcName}": Promise.resolve()`,
+              );
+            } else if (stringValue === 'function') {
+              outputValue = '() => {}';
+              console.log(
+                `CodeYam: Nested func transform (string->function): "${key}" -> "${funcName}": () => {}`,
+              );
+            } else if (looksLikeFunction) {
+              outputValue = stringValue;
+              console.log(
+                `CodeYam: Nested func transform (string): "${key}" -> "${funcName}": ${stringValue.substring(0, 30)}...`,
+              );
+            } else {
+              // Plain string value - must be quoted
+              outputValue = `"${safeString(stringValue, level)}"`;
+              console.log(
+                `CodeYam: Nested func transform (string->quoted): "${key}" -> "${funcName}": "${stringValue}"`,
+              );
+            }
+
+            keyStrings.push(
+              `${levelSpacing}"${safeString(funcName, level)}": ${outputValue}`,
+            );
+          } else {
+            // Skip plain keys that have function-call versions (at the same nesting level where
+            // function-call keys get normalized). The function-call version will be output instead.
+            // e.g., if both "push" and "push(`/path`)" exist, skip "push" - the other normalizes to "push"
+            if (level > 2 && plainKeysWithFunctionCallVersions.has(key)) {
+              console.log(
+                `CodeYam: Skipping plain key "${key}" (has function-call version that will be normalized)`,
+              );
+              continue;
+            }
+            keyStrings.push(
+              `${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`,
+            );
+          }
         } else {
+          // Skip plain keys that have function-call versions (at the same nesting level where
+          // function-call keys get normalized)
+          if (level > 2 && plainKeysWithFunctionCallVersions.has(key)) {
+            console.log(
+              `CodeYam: Skipping plain key "${key}" (has function-call version that will be normalized)`,
+            );
+            continue;
+          }
           keyStrings.push(
             `${levelSpacing}"${safeString(key, level)}": ${safeString(String(jsonObj[key]), level)}`,
           );
@@ -437,6 +588,7 @@ import React from 'react';
     const rawScenarioMockData = {
       ...(mockScenario.metadata.data?.mockData ?? {}),
     };
+
     // Reconcile scenario-specific mock data keys as well
     const scenarioMockData = reconcileMockDataKeys(
       rawScenarioMockData,
@@ -448,6 +600,7 @@ import React from 'react';
     });
 
     const mergedMockData = deepMerge(defaultMockData, scenarioMockData);
+
     // Normalize mock data to merge entries with same normalized function name
     const normalizedMockData = normalizeMockData(
       mergedMockData as Record<string, unknown>,
@@ -517,13 +670,44 @@ function serialize(obj) {
         
         // Handle functions
         if (typeof value === 'function') {
-            const fnStr = value.toString();
+            let fnStr;
+            try {
+                fnStr = value.toString();
+            } catch (toStringErr) {
+                console.warn('CodeYam: Function.toString() threw error:', toStringErr, 'function name:', value.name);
+                return {
+                    __type: TYPE_MARKERS.FUNCTION,
+                    value: '() => {}',
+                    name: value.name || 'anonymous'
+                };
+            }
+
+            // Defensive check: ensure fnStr is actually a string
+            if (typeof fnStr !== 'string') {
+                console.warn('CodeYam: Function.toString() returned non-string:', typeof fnStr, fnStr, 'function name:', value.name);
+                return {
+                    __type: TYPE_MARKERS.FUNCTION,
+                    value: '() => {}',
+                    name: value.name || 'anonymous'
+                };
+            }
+
             // Check if it's an arrow function
             if (fnStr.includes('=>')) {
+                const arrowIndex = fnStr.indexOf('=>');
+                // Extra safety: verify indexOf returned a valid index
+                if (arrowIndex === -1) {
+                    console.warn('CodeYam: Arrow function detection inconsistency - includes found => but indexOf returned -1. fnStr:', fnStr);
+                    return {
+                        __type: TYPE_MARKERS.FUNCTION,
+                        value: fnStr,
+                        name: value.name
+                    };
+                }
                 return {
                     __type: TYPE_MARKERS.ARROW_FUNCTION,
-                    params: fnStr.substring(0, fnStr.indexOf('=>')).trim(),
-                    body: fnStr.substring(fnStr.indexOf('=>') + 2).trim()
+                    params: fnStr.substring(0, arrowIndex).trim(),
+                    body: fnStr.substring(arrowIndex + 2).trim()
                 };
             }
             return {