@adminide-stack/form-builder-core 5.1.4-alpha.49 → 5.1.4-alpha.58

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.1.4-alpha.58](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.57...v5.1.4-alpha.58) (2025-10-06)
+
+**Note:** Version bump only for package @adminide-stack/form-builder-core
+
+## [5.1.4-alpha.57](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.56...v5.1.4-alpha.57) (2025-10-03)
+
+**Note:** Version bump only for package @adminide-stack/form-builder-core
+
 ## [5.1.4-alpha.49](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.48...v5.1.4-alpha.49) (2025-09-24)
 
 **Note:** Version bump only for package @adminide-stack/form-builder-core

package/lib/inngest/generateFunctionCode.js

@@ -54,8 +54,8 @@ ${indent(body, 4)}
 // New: return only the handler body that backend executes and editor displays
 function generateHandlerBody(def) {
   const stepBlocks = def.steps.map((step, index) => generateStepBlock(step, index + 1)).join('\n');
-  const footer = `return {\n  functionId: '${def.id}',\n  steps: ${def.steps.length},\n  timestamp: new Date().toISOString()\n};`;
-  return `${stepBlocks}\n${footer}`;
+  // Footer removed: callers should append their own consolidated return as needed
+  return `${stepBlocks}`;
 }
 // Generate Inngest function from database-extracted functions
 function generateStepFunctionsFromDB(functionId, events, extractedFunctions) {

package/lib/inngest/stepGenerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stepGenerator.d.ts","sourceRoot":"","sources":["../../src/inngest/stepGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;GAGG;AAGH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAGD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG9D;AAGD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA4FrF;AAGD,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,WAAW,GAAG,iBAAiB,EACrC,KAAK,EAAE,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAYnC;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0C/D;AAGD,wBAAgB,yBAAyB,CACrC,YAAY,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAC/C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAClB,MAAM,CAsER;AAGD,wBAAgB,gCAAgC,CAC5C,aAAa,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvF,MAAM,CAgCR;AAGD,wBAAgB,8BAA8B,CAAC,kBAAkB,EAAE,iBAAiB,EAAE,GAAG,MAAM,CAoB9F"}
+{"version":3,"file":"stepGenerator.d.ts","sourceRoot":"","sources":["../../src/inngest/stepGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;GAGG;AAGH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAGD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG9D;AAGD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA4FrF;AAGD,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,WAAW,GAAG,iBAAiB,EACrC,KAAK,EAAE,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAYnC;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0E/D;AAED,wBAAgB,yBAAyB,CACrC,YAAY,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAC/C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAClB,MAAM,CAsER;AAGD,wBAAgB,gCAAgC,CAC5C,aAAa,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvF,MAAM,CAgCR;AAGD,wBAAgB,8BAA8B,CAAC,kBAAkB,EAAE,iBAAiB,EAAE,GAAG,MAAM,CA6B9F"}

package/lib/inngest/stepGenerator.js

@@ -11,105 +11,6 @@ function extractStepVarName(code) {
   const match = code.match(/const\s+(\w+)\s*=/);
   return match ? match[1] : null;
 }
-// Generate default step function for different step types
-function generateDefaultStepFunction(stepVar, stepType) {
-  switch (stepType) {
-    case 'sleep':
-      return `const ${stepVar} = async (event, step) => {
-  // Sleep for specified duration
-  const sleepResult = await step.sleep('${stepVar}', '5s');
-  
-  console.log('Sleep completed:', sleepResult);
-  
-  return { success: true, duration: '5s', result: sleepResult };
-};`;
-    case 'sendEvent':
-      return `const ${stepVar} = async (event, step) => {
-  // Send an event to trigger other functions
-  const eventResult = await step.sendEvent('${stepVar}', {
-    name: 'my.custom.event',
-    data: {
-      source: '${stepVar}',
-      timestamp: new Date().toISOString(),
-      payload: event.data
-    }
-  });
-  
-  console.log('Event sent:', eventResult);
-  
-  return { success: true, eventSent: true, result: eventResult };
-};`;
-    case 'waitForEvent':
-      return `const ${stepVar} = async (event, step) => {
-  // Wait for a specific event before continuing
-  const waitResult = await step.waitForEvent('${stepVar}', {
-    event: 'my.waited.event',
-    timeout: '60s'
-  });
-  
-  console.log('Event received:', waitResult);
-  
-  return { success: true, eventReceived: true, result: waitResult };
-};`;
-    case 'retrieveData':
-      return `const ${stepVar} = async (event, step) => {
-  // Data retrieval implementation
-  const formData = event.data.formData || {};
-  
-  // Process and retrieve data
-  const retrievedData = {
-    ...formData,
-    processedAt: new Date().toISOString()
-  };
-  
-  return { success: true, data: retrievedData };
-};`;
-    case 'validateForm':
-      return `const ${stepVar} = async (event, step) => {
-  // Validate form data
-  const formData = event.data.formData || {};
-  const errors = [];
-  
-  // Add validation logic here
-  if (!formData.email) {
-    errors.push('Email is required');
-  }
-  
-  return { 
-    success: errors.length === 0, 
-    errors,
-    validated: errors.length === 0 
-  };
-};`;
-    case 'parallel':
-      return `const ${stepVar} = async (event, step) => {
-  // Execute parallel operations
-  const results = await Promise.all([
-    // Add parallel operations here
-    Promise.resolve({ task: 'task1', result: 'completed' }),
-    Promise.resolve({ task: 'task2', result: 'completed' })
-  ]);
-  
-  return { success: true, results };
-};`;
-    default:
-      return `const ${stepVar} = async (event, step) => {
-  // Default step implementation
-  return { success: true };
-};`;
-  }
-}
-// Generate a step function in editor format (const step_xxx = async (event, step) => {...})
-function generateStepFunction(step, index) {
-  // Extract or generate step variable name
-  const varName = extractStepVarName(step.code || '') || step.originalStepName || step.id || `step_${index}`;
-  // If step has code, use it; otherwise generate default
-  const code = step.code || generateDefaultStepFunction(varName, step.type || 'run');
-  return {
-    code: cleanStepCode(code),
-    varName
-  };
-}
 // Extract function body from step function code
 function extractFunctionBody(code) {
   // Find the opening brace after the arrow or function keyword
@@ -129,15 +30,40 @@ function extractFunctionBody(code) {
       startIndex = openBraceIndex + 1;
     }
   }
-  if (startIndex === -1) return null;
+  if (startIndex === -1) {
+    // FALLBACK: If we can't find function wrapper, return the whole code
+    console.warn('Could not extract function body, returning full code');
+    return code;
+  }
   // Find the matching closing brace by counting braces
   let braceCount = 1;
   let endIndex = startIndex;
+  let inString = false;
+  let stringChar = '';
+  let inTemplate = false;
   while (endIndex < code.length && braceCount > 0) {
-    if (code[endIndex] === '{') {
-      braceCount++;
-    } else if (code[endIndex] === '}') {
-      braceCount--;
+    const char = code[endIndex];
+    const prevChar = endIndex > 0 ? code[endIndex - 1] : '';
+    // Handle string literals
+    if ((char === '"' || char === "'") && prevChar !== '\\') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+    }
+    // Handle template literals
+    if (char === '`' && prevChar !== '\\') {
+      inTemplate = !inTemplate;
+    }
+    // Only count braces outside of strings
+    if (!inString && !inTemplate) {
+      if (char === '{') {
+        braceCount++;
+      } else if (char === '}') {
+        braceCount--;
+      }
     }
     if (braceCount > 0) {
       endIndex++;
@@ -146,107 +72,34 @@ function extractFunctionBody(code) {
   if (braceCount === 0) {
     return code.substring(startIndex, endIndex).trim();
   }
-  return null;
+  // FALLBACK: Return full code if brace matching fails
+  console.warn('Brace matching failed, returning full code');
+  return code;
 }
-// Transform a step function for execution inside Inngest wrapper
-function transformStepForExecution(stepFunction, stepType, stepLabel) {
-  const functionBody = extractFunctionBody(stepFunction.code);
-  if (!functionBody) {
-    return `// ${stepLabel}\nconst ${stepFunction.varName}_result = { success: false, error: 'Invalid function format' };`;
+// Convert ExtractedFunction array to step functions and generate Inngest function
+function generateFromExtractedFunctions(extractedFunctions) {
+  if (extractedFunctions.length === 0) {
+    return 'return { success: false, error: "No functions to execute" };';
   }
-  const cleanedBody = cleanStepCode(functionBody);
-  // For these step types, execute the body directly (they contain step.* calls)
-  if (stepType === 'sleep' || stepType === 'sendEvent' || stepType === 'waitForEvent') {
-    // Transform the body to ensure result is captured
-    let transformedBody = cleanedBody;
-    // Replace step method calls to ensure result variable is created
-    transformedBody = transformedBody.replace(/(const\s+\w+\s*=\s*)?await\s+step\.(sleep|sendEvent|waitForEvent)/g, (match, constPart, method) => {
-      if (constPart) {
-        // Already has assignment, replace variable name
-        return `const ${stepFunction.varName}_result = await step.${method}`;
-      }
-      // No assignment, add one
-      return `const ${stepFunction.varName}_result = await step.${method}`;
-    });
-    // Find the original variable name from the step assignment
-    const originalVarMatch = transformedBody.match(/const\s+(\w+)\s*=\s*await\s+step\./);
-    let originalVarName = null;
-    // Also try to find variable from the original code before transformation
-    if (!originalVarMatch) {
-      const [, codeVarName] = cleanedBody.match(/const\s+(\w+)\s*=\s*await\s+step\./) || [];
-      if (codeVarName) {
-        originalVarName = codeVarName;
-      }
-    }
-    // Replace variable references (like eventResult, sleepResult, waitResult)
-    // Common patterns: eventResult, sleepResult, waitResult, or any variable used in console.log/return
-    if (originalVarName) {
-      // Replace all references to the original variable with the new result variable
-      const varPattern = new RegExp(`\\b${originalVarName}\\b`, 'g');
-      transformedBody = transformedBody.replace(varPattern, `${stepFunction.varName}_result`);
+  // For functions that are complete workflow steps (like step_416),
+  // just return the code body directly without extraction
+  const func = extractedFunctions[0];
+  // Check if this is a complete function (has async function signature)
+  if (func.code && func.code.includes('async function')) {
+    // Extract just the body, preserving all helper functions and logic
+    const bodyMatch = func.code.match(/async function[^{]*\{([\s\S]*)\}[\s]*$/);
+    if (bodyMatch) {
+      return bodyMatch[1].trim();
     }
-    // Also replace common result variable names that might not have been caught
-    transformedBody = transformedBody.replace(/\beventResult\b/g, `${stepFunction.varName}_result`).replace(/\bsleepResult\b/g, `${stepFunction.varName}_result`).replace(/\bwaitResult\b/g, `${stepFunction.varName}_result`);
-    // Remove return statements (since we'll add our own unified return)
-    transformedBody = transformedBody.split('\n').filter(line => {
-      const trimmed = line.trim();
-      // Remove lines that start with 'return'
-      return !trimmed.match(/^return\s/);
-    }).join('\n');
-    return `// ${stepLabel}\n        ${transformedBody}`;
   }
-  // For other step types, wrap in step.run()
-  return `// ${stepLabel}
-        const ${stepFunction.varName}_result = await step.run('${stepFunction.varName}', async (event, step) => {
-            ${cleanedBody}
-        });`;
-}
-// Generate complete Inngest function from step functions
-function generateInngestFunctionFromSteps(stepFunctions) {
-  // Transform each step for execution
-  const stepBlocks = [];
-  const resultVars = [];
-  stepFunctions.forEach((stepFunc, index) => {
-    const stepType = stepFunc.type || 'run';
-    const stepLabel = stepFunc.label || `Step ${index + 1}`;
-    const executionCode = transformStepForExecution(stepFunc, stepType, stepLabel);
-    stepBlocks.push(executionCode);
-    // Determine result variable name
-    if (executionCode.includes(`${stepFunc.varName}_result`)) {
-      resultVars.push(`${stepFunc.varName}_result`);
-    } else {
-      // For direct execution without result assignment
-      resultVars.push(stepFunc.varName);
+  // Check if code has arrow function format: const x = async (event, step) => { ... }
+  if (func.code && func.code.includes('async') && func.code.includes('=>')) {
+    const arrowBodyMatch = func.code.match(/=>\s*\{([\s\S]*)\}[\s]*;?[\s]*$/);
+    if (arrowBodyMatch) {
+      return arrowBodyMatch[1].trim();
     }
-  });
-  // Generate function body without async wrapper
-  const code = `${stepBlocks.join('\n\n')}
-
-        return {
-            steps: ${stepFunctions.length},
-            results: {
-${resultVars.map((v, i) => `                ${stepFunctions[i].varName}: ${v}`).join(',\n')}
-            }
-        };`;
-  return code;
-}
-// Convert ExtractedFunction array to step functions and generate Inngest function
-function generateFromExtractedFunctions(extractedFunctions) {
-  // Convert extracted functions to step function format
-  const stepFunctions = extractedFunctions.map((func, index) => {
-    const {
-      code,
-      varName
-    } = generateStepFunction(func, index + 1);
-    // Detect step type from the code
-    let type = 'run';
-    if (code.includes('step.sleep(')) type = 'sleep';else if (code.includes('step.sendEvent(')) type = 'sendEvent';else if (code.includes('step.waitForEvent(')) type = 'waitForEvent';
-    return {
-      code,
-      varName,
-      type,
-      label: func.name || `Step ${index + 1}`
-    };
-  });
-  return generateInngestFunctionFromSteps(stepFunctions);
-}export{cleanStepCode,extractFunctionBody,extractStepVarName,generateDefaultStepFunction,generateFromExtractedFunctions,generateInngestFunctionFromSteps,generateStepFunction,transformStepForExecution};//# sourceMappingURL=stepGenerator.js.map
+  }
+  // Fallback: return the code as-is if we can't parse it
+  console.warn('Could not parse function format, returning code as-is');
+  return func.code || 'return { success: false, error: "No code available" };';
+}export{cleanStepCode,extractFunctionBody,extractStepVarName,generateFromExtractedFunctions};//# sourceMappingURL=stepGenerator.js.map

package/lib/inngest/stepGenerator.js.map

@@ -1 +1 @@
-{"version":3,"file":"stepGenerator.js","sources":["../../src/inngest/stepGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAGA;AAEA;;;AAGG,SAAA,aAAA,CAAA,IAAA,EAAA;AAGH,EAAA,OAAA,IAAA;AAKA;AAMA;AA+FA,SAAA,kBAAgB,CAAA,IAAA,EAAA;QAGP,QAAQ,IAAC,CAAA,KAAA,CAAA,mBAAA,CAAA;SAAC,aAAe,CAAA,CAAA,CAAA,GAAA,IAAA;;AAelC;AA6CA,SAAA,2BAAgB,CAAA,OACZ,EAAA,QAAA,EAAY;UAAU,QAAO;IAAC,KAAA;MAC9B,OAAU,CAAA,MAAM,UACP;AA0Eb;wCACwC,EAAA,OAAA,CAAA;;;;;AAoCxC,EAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"stepGenerator.js","sources":["../../src/inngest/stepGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AAGA;AAEA;;;AAGG,SAAA,aAAA,CAAA,IAAA,EAAA;AAGH,EAAA,OAAA,IAAA;AAKA;AAMA;AA+FA,SAAA,kBAAgB,CAAA,IAAA,EAAA;QAGP,QAAQ,IAAC,CAAA,KAAA,CAAA,mBAAA,CAAA;SAAC,aAAe,CAAA,CAAA,CAAA,GAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@adminide-stack/form-builder-core",
-    "version": "5.1.4-alpha.49",
+    "version": "5.1.4-alpha.58",
     "sideEffects": false,
     "type": "module",
     "main": "lib/index.js",
@@ -24,5 +24,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "4fc9dbe45e8754f40077dc927b64be811d2e1562"
+    "gitHead": "4ddce5652e314ce3408435942885de210e49a6af"
 }

package/src/inngest/generateFunctionCode.ts

@@ -89,8 +89,8 @@ ${indent(body, 4)}
 // New: return only the handler body that backend executes and editor displays
 export function generateHandlerBody(def: InngestFunctionDef): string {
     const stepBlocks = def.steps.map((step, index) => generateStepBlock(step, index + 1)).join('\n');
-    const footer = `return {\n  functionId: '${def.id}',\n  steps: ${def.steps.length},\n  timestamp: new Date().toISOString()\n};`;
-    return `${stepBlocks}\n${footer}`;
+    // Footer removed: callers should append their own consolidated return as needed
+    return `${stepBlocks}`;
 }
 
 // Generate Inngest function from database-extracted functions

package/src/inngest/stepGenerator.ts

@@ -154,17 +154,47 @@ export function extractFunctionBody(code: string): string | null {
         }
     }
 
-    if (startIndex === -1) return null;
+    if (startIndex === -1) {
+        // FALLBACK: If we can't find function wrapper, return the whole code
+        console.warn('Could not extract function body, returning full code');
+        return code;
+    }
 
     // Find the matching closing brace by counting braces
     let braceCount = 1;
     let endIndex = startIndex;
+    let inString = false;
+    let stringChar = '';
+    let inTemplate = false;
+
     while (endIndex < code.length && braceCount > 0) {
-        if (code[endIndex] === '{') {
-            braceCount++;
-        } else if (code[endIndex] === '}') {
-            braceCount--;
+        const char = code[endIndex];
+        const prevChar = endIndex > 0 ? code[endIndex - 1] : '';
+
+        // Handle string literals
+        if ((char === '"' || char === "'") && prevChar !== '\\') {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            } else if (char === stringChar) {
+                inString = false;
+            }
+        }
+
+        // Handle template literals
+        if (char === '`' && prevChar !== '\\') {
+            inTemplate = !inTemplate;
         }
+
+        // Only count braces outside of strings
+        if (!inString && !inTemplate) {
+            if (char === '{') {
+                braceCount++;
+            } else if (char === '}') {
+                braceCount--;
+            }
+        }
+
         if (braceCount > 0) {
             endIndex++;
         }
@@ -174,9 +204,10 @@ export function extractFunctionBody(code: string): string | null {
         return code.substring(startIndex, endIndex).trim();
     }
 
-    return null;
+    // FALLBACK: Return full code if brace matching fails
+    console.warn('Brace matching failed, returning full code');
+    return code;
 }
-
 // Transform a step function for execution inside Inngest wrapper
 export function transformStepForExecution(
     stepFunction: { code: string; varName: string },
@@ -293,23 +324,32 @@ ${resultVars.map((v, i) => `                ${stepFunctions[i].varName}: ${v}`).
 
 // Convert ExtractedFunction array to step functions and generate Inngest function
 export function generateFromExtractedFunctions(extractedFunctions: ExtractedFunction[]): string {
-    // Convert extracted functions to step function format
-    const stepFunctions = extractedFunctions.map((func, index) => {
-        const { code, varName } = generateStepFunction(func, index + 1);
+    if (extractedFunctions.length === 0) {
+        return 'return { success: false, error: "No functions to execute" };';
+    }
 
-        // Detect step type from the code
-        let type = 'run';
-        if (code.includes('step.sleep(')) type = 'sleep';
-        else if (code.includes('step.sendEvent(')) type = 'sendEvent';
-        else if (code.includes('step.waitForEvent(')) type = 'waitForEvent';
+    // For functions that are complete workflow steps (like step_416),
+    // just return the code body directly without extraction
+    const func = extractedFunctions[0];
 
-        return {
-            code,
-            varName,
-            type,
-            label: func.name || `Step ${index + 1}`,
-        };
-    });
+    // Check if this is a complete function (has async function signature)
+    if (func.code && func.code.includes('async function')) {
+        // Extract just the body, preserving all helper functions and logic
+        const bodyMatch = func.code.match(/async function[^{]*\{([\s\S]*)\}[\s]*$/);
+        if (bodyMatch) {
+            return bodyMatch[1].trim();
+        }
+    }
+
+    // Check if code has arrow function format: const x = async (event, step) => { ... }
+    if (func.code && func.code.includes('async') && func.code.includes('=>')) {
+        const arrowBodyMatch = func.code.match(/=>\s*\{([\s\S]*)\}[\s]*;?[\s]*$/);
+        if (arrowBodyMatch) {
+            return arrowBodyMatch[1].trim();
+        }
+    }
 
-    return generateInngestFunctionFromSteps(stepFunctions);
+    // Fallback: return the code as-is if we can't parse it
+    console.warn('Could not parse function format, returning code as-is');
+    return func.code || 'return { success: false, error: "No code available" };';
 }