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

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.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
+
+## [5.1.4-alpha.48](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.47...v5.1.4-alpha.48) (2025-09-23)
+
+**Note:** Version bump only for package @adminide-stack/form-builder-core
+
 ## [5.1.4-alpha.47](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.46...v5.1.4-alpha.47) (2025-09-23)
 
 **Note:** Version bump only for package @adminide-stack/form-builder-core

package/lib/index.js

@@ -1,3 +1 @@
-export * from './inngest/interfaces/types';
-export * from './inngest/generateFunctionCode';
-export { generateFromExtractedFunctions } from './inngest/stepGenerator';
+export{generateFunctionCode,generateHandlerBody,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction}from'./inngest/generateFunctionCode.js';export{cleanStepCode,extractStepVarName,generateFromExtractedFunctions}from'./inngest/stepGenerator.js';//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/inngest/generateFunctionCode.js

@@ -1,59 +1,49 @@
-import { cleanStepCode, extractStepVarName, generateFromExtractedFunctions, extractFunctionBody, } from './stepGenerator';
-// Re-export utilities for backward compatibility
-export { cleanStepCode, extractStepVarName } from './stepGenerator';
-// Check if code contains direct step operations (sleep, sendEvent, etc)
+import {generateFromExtractedFunctions,extractStepVarName,extractFunctionBody,cleanStepCode}from'./stepGenerator.js';// Check if code contains direct step operations (sleep, sendEvent, etc)
 function hasDirectStepOperations(code) {
-    return /step\.(sleep|sendEvent|waitForEvent|run)\s*\(/.test(code);
+  return /step\.(sleep|sendEvent|waitForEvent|run)\s*\(/.test(code);
 }
 function getDefaultDirectBody(type, id, label) {
-    switch (type) {
-        case 'sleep':
-            return `const ${id}_result = await step.sleep('${id}', '5s');`;
-        case 'sendEvent':
-            return `const ${id}_result = await step.sendEvent('${id}', { name: 'my.custom.event', data: { source: '${label || id}', ts: new Date().toISOString() } });`;
-        case 'waitForEvent':
-            return `const ${id}_result = await step.waitForEvent('${id}', { event: 'my.waited.event', timeout: '60s' });`;
-        default:
-            return `// not supported`;
-    }
+  switch (type) {
+    case 'sleep':
+      return `const ${id}_result = await step.sleep('${id}', '5s');`;
+    case 'sendEvent':
+      return `const ${id}_result = await step.sendEvent('${id}', { name: 'my.custom.event', data: { source: '${label || id}', ts: new Date().toISOString() } });`;
+    case 'waitForEvent':
+      return `const ${id}_result = await step.waitForEvent('${id}', { event: 'my.waited.event', timeout: '60s' });`;
+    default:
+      return `// not supported`;
+  }
 }
 function indent(s, spaces) {
-    const pad = ' '.repeat(spaces);
-    return s
-        .split('\n')
-        .map((l) => (l ? pad + l : l))
-        .join('\n');
+  const pad = ' '.repeat(spaces);
+  return s.split('\n').map(l => l ? pad + l : l).join('\n');
 }
 // Simple code formatter
 function formatCode(code) {
-    // Basic formatting - in production, you'd use a proper formatter
-    return code
-        .split('\n')
-        .map((line) => line.trimEnd())
-        .join('\n')
-        .replace(/\n{3,}/g, '\n\n'); // Remove excessive blank lines
+  // Basic formatting - in production, you'd use a proper formatter
+  return code.split('\n').map(line => line.trimEnd()).join('\n').replace(/\n{3,}/g, '\n\n'); // Remove excessive blank lines
 }
 function generateStepBlock(step, position) {
-    const stepVar = (step.code || '').match(/const\s+(\w+)\s*=/)?.[1] || `step_${position}`;
-    // If caller supplied code, embed it inside step.run wrapper by default for consistency
-    if (step.type === 'sleep' || step.type === 'sendEvent' || step.type === 'waitForEvent') {
-        // Execute directly (these typically call step.* helpers)
-        const body = extractFunctionBody(step.code || '') || getDefaultDirectBody(step.type, stepVar, step.name);
-        return `// ${step.description || step.name || `Step ${position}`}
-${body}`;
-    }
-    const inner = extractFunctionBody(step.code || '') || 'return { success: true };';
+  const stepVar = (step.code || '').match(/const\s+(\w+)\s*=/)?.[1] || `step_${position}`;
+  // If caller supplied code, embed it inside step.run wrapper by default for consistency
+  if (step.type === 'sleep' || step.type === 'sendEvent' || step.type === 'waitForEvent') {
+    // Execute directly (these typically call step.* helpers)
+    const body = extractFunctionBody(step.code || '') || getDefaultDirectBody(step.type, stepVar, step.name);
     return `// ${step.description || step.name || `Step ${position}`}
+${body}`;
+  }
+  const inner = extractFunctionBody(step.code || '') || 'return { success: true };';
+  return `// ${step.description || step.name || `Step ${position}`}
 const ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {
 ${indent(inner, 2)}
 });`;
 }
 // Minimal shared generator. Replace internals by moving editor logic here incrementally.
-export function generateFunctionCode(def) {
-    const eventsString = def.events.length > 0 ? def.events.map((e) => `'${e}'`).join(', ') : `'app.event'`;
-    const safeId = def.id.replace(/[^a-zA-Z0-9]/g, '') || 'function';
-    const body = generateHandlerBody(def);
-    return `const ${safeId}Function = inngest.createFunction(
+function generateFunctionCode(def) {
+  const eventsString = def.events.length > 0 ? def.events.map(e => `'${e}'`).join(', ') : `'app.event'`;
+  const safeId = def.id.replace(/[^a-zA-Z0-9]/g, '') || 'function';
+  const body = generateHandlerBody(def);
+  return `const ${safeId}Function = inngest.createFunction(
   { id: '${def.id}' },
   { event: [${eventsString}] },
   async ({ event, step }) => {
@@ -62,46 +52,46 @@ ${indent(body, 4)}
 );`;
 }
 // New: return only the handler body that backend executes and editor displays
-export 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}`;
+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}`;
 }
 // Generate Inngest function from database-extracted functions
-export function generateStepFunctionsFromDB(functionId, events, extractedFunctions) {
-    if (!extractedFunctions || extractedFunctions.length === 0) {
-        throw new Error('No functions provided to generate');
-    }
-    // Use the new unified generator
-    const code = generateFromExtractedFunctions(extractedFunctions);
-    return {
-        code: formatCode(code),
-        functionId,
-        stepCount: extractedFunctions.length,
-    };
+function generateStepFunctionsFromDB(functionId, events, extractedFunctions) {
+  if (!extractedFunctions || extractedFunctions.length === 0) {
+    throw new Error('No functions provided to generate');
+  }
+  // Use the new unified generator
+  const code = generateFromExtractedFunctions(extractedFunctions);
+  return {
+    code: formatCode(code),
+    functionId,
+    stepCount: extractedFunctions.length
+  };
 }
 // Wrap multiple step functions in a single Inngest function
-export function wrapStepsInInngestFunction(functionDef, stepFunctions) {
-    const extractedFunctions = stepFunctions.map((sf) => ({
-        id: sf.id,
-        name: sf.name,
-        code: sf.code,
-        description: sf.description,
-    }));
-    const result = generateStepFunctionsFromDB(functionDef.id, functionDef.events, extractedFunctions);
-    return result.code;
+function wrapStepsInInngestFunction(functionDef, stepFunctions) {
+  const extractedFunctions = stepFunctions.map(sf => ({
+    id: sf.id,
+    name: sf.name,
+    code: sf.code,
+    description: sf.description
+  }));
+  const result = generateStepFunctionsFromDB(functionDef.id, functionDef.events, extractedFunctions);
+  return result.code;
 }
 // Generate a single step from an extracted function
-export function generateStepFromFunction(stepFunction, index) {
-    const stepVar = extractStepVarName(stepFunction.code) || `step_${index}`;
-    const functionBody = extractFunctionBody(stepFunction.code);
-    if (!functionBody) {
-        return `// ${stepFunction.name || `Step ${index}`}\nconst ${stepVar}_result = { success: false, error: 'Invalid function format' };`;
-    }
-    const hasDirectOps = hasDirectStepOperations(stepFunction.code);
-    const cleanedBody = cleanStepCode(functionBody);
-    if (hasDirectOps) {
-        return `// ${stepFunction.name || `Step ${index}`}\n${cleanedBody}`;
-    }
-    return `// ${stepFunction.name || `Step ${index}`}\nconst ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {\n${indent(cleanedBody, 2)}\n});`;
-}
+function generateStepFromFunction(stepFunction, index) {
+  const stepVar = extractStepVarName(stepFunction.code) || `step_${index}`;
+  const functionBody = extractFunctionBody(stepFunction.code);
+  if (!functionBody) {
+    return `// ${stepFunction.name || `Step ${index}`}\nconst ${stepVar}_result = { success: false, error: 'Invalid function format' };`;
+  }
+  const hasDirectOps = hasDirectStepOperations(stepFunction.code);
+  const cleanedBody = cleanStepCode(functionBody);
+  if (hasDirectOps) {
+    return `// ${stepFunction.name || `Step ${index}`}\n${cleanedBody}`;
+  }
+  return `// ${stepFunction.name || `Step ${index}`}\nconst ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {\n${indent(cleanedBody, 2)}\n});`;
+}export{cleanStepCode,extractStepVarName,generateFunctionCode,generateHandlerBody,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction};//# sourceMappingURL=generateFunctionCode.js.map

package/lib/inngest/generateFunctionCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFunctionCode.js","sources":["../../src/inngest/generateFunctionCode.ts"],"sourcesContent":[null],"names":[],"mappings":"qHAyFA;AAOA,SAAA;AAoBA,EAAA,OAAA,+CAA2C,CAAA,IAAA,CAAW,IAAE,CAAA;AAcxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/inngest/stepGenerator.js

@@ -3,19 +3,19 @@
  * Used by both browser editor and server execution
  */
 // Pass through code without any cleaning/validation
-export function cleanStepCode(code) {
-    return code;
+function cleanStepCode(code) {
+  return code;
 }
 // Extract step variable name from code
-export function extractStepVarName(code) {
-    const match = code.match(/const\s+(\w+)\s*=/);
-    return match ? match[1] : null;
+function extractStepVarName(code) {
+  const match = code.match(/const\s+(\w+)\s*=/);
+  return match ? match[1] : null;
 }
 // Generate default step function for different step types
-export function generateDefaultStepFunction(stepVar, stepType) {
-    switch (stepType) {
-        case 'sleep':
-            return `const ${stepVar} = async (event, step) => {
+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');
   
@@ -23,8 +23,8 @@ export function generateDefaultStepFunction(stepVar, stepType) {
   
   return { success: true, duration: '5s', result: sleepResult };
 };`;
-        case 'sendEvent':
-            return `const ${stepVar} = async (event, step) => {
+    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',
@@ -39,8 +39,8 @@ export function generateDefaultStepFunction(stepVar, stepType) {
   
   return { success: true, eventSent: true, result: eventResult };
 };`;
-        case 'waitForEvent':
-            return `const ${stepVar} = async (event, step) => {
+    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',
@@ -51,8 +51,8 @@ export function generateDefaultStepFunction(stepVar, stepType) {
   
   return { success: true, eventReceived: true, result: waitResult };
 };`;
-        case 'retrieveData':
-            return `const ${stepVar} = async (event, step) => {
+    case 'retrieveData':
+      return `const ${stepVar} = async (event, step) => {
   // Data retrieval implementation
   const formData = event.data.formData || {};
   
@@ -64,8 +64,8 @@ export function generateDefaultStepFunction(stepVar, stepType) {
   
   return { success: true, data: retrievedData };
 };`;
-        case 'validateForm':
-            return `const ${stepVar} = async (event, step) => {
+    case 'validateForm':
+      return `const ${stepVar} = async (event, step) => {
   // Validate form data
   const formData = event.data.formData || {};
   const errors = [];
@@ -81,8 +81,8 @@ export function generateDefaultStepFunction(stepVar, stepType) {
     validated: errors.length === 0 
   };
 };`;
-        case 'parallel':
-            return `const ${stepVar} = async (event, step) => {
+    case 'parallel':
+      return `const ${stepVar} = async (event, step) => {
   // Execute parallel operations
   const results = await Promise.all([
     // Add parallel operations here
@@ -92,145 +92,135 @@ export function generateDefaultStepFunction(stepVar, stepType) {
   
   return { success: true, results };
 };`;
-        default:
-            return `const ${stepVar} = async (event, step) => {
+    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) => {...})
-export 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 };
+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
-export function extractFunctionBody(code) {
-    // Find the opening brace after the arrow or function keyword
-    const arrowIndex = code.indexOf('=>');
-    const functionIndex = code.indexOf('function');
-    let startIndex = -1;
-    if (arrowIndex !== -1) {
-        // Find opening brace after =>
-        const openBraceIndex = code.indexOf('{', arrowIndex);
-        if (openBraceIndex !== -1) {
-            startIndex = openBraceIndex + 1;
-        }
+function extractFunctionBody(code) {
+  // Find the opening brace after the arrow or function keyword
+  const arrowIndex = code.indexOf('=>');
+  const functionIndex = code.indexOf('function');
+  let startIndex = -1;
+  if (arrowIndex !== -1) {
+    // Find opening brace after =>
+    const openBraceIndex = code.indexOf('{', arrowIndex);
+    if (openBraceIndex !== -1) {
+      startIndex = openBraceIndex + 1;
     }
-    else if (functionIndex !== -1) {
-        // Find opening brace after function declaration
-        const openBraceIndex = code.indexOf('{', functionIndex);
-        if (openBraceIndex !== -1) {
-            startIndex = openBraceIndex + 1;
-        }
+  } else if (functionIndex !== -1) {
+    // Find opening brace after function declaration
+    const openBraceIndex = code.indexOf('{', functionIndex);
+    if (openBraceIndex !== -1) {
+      startIndex = openBraceIndex + 1;
     }
-    if (startIndex === -1)
-        return null;
-    // Find the matching closing brace by counting braces
-    let braceCount = 1;
-    let endIndex = startIndex;
-    while (endIndex < code.length && braceCount > 0) {
-        if (code[endIndex] === '{') {
-            braceCount++;
-        }
-        else if (code[endIndex] === '}') {
-            braceCount--;
-        }
-        if (braceCount > 0) {
-            endIndex++;
-        }
+  }
+  if (startIndex === -1) return null;
+  // Find the matching closing brace by counting braces
+  let braceCount = 1;
+  let endIndex = startIndex;
+  while (endIndex < code.length && braceCount > 0) {
+    if (code[endIndex] === '{') {
+      braceCount++;
+    } else if (code[endIndex] === '}') {
+      braceCount--;
     }
-    if (braceCount === 0) {
-        return code.substring(startIndex, endIndex).trim();
+    if (braceCount > 0) {
+      endIndex++;
     }
-    return null;
+  }
+  if (braceCount === 0) {
+    return code.substring(startIndex, endIndex).trim();
+  }
+  return null;
 }
 // Transform a step function for execution inside Inngest wrapper
-export function transformStepForExecution(stepFunction, stepType, stepLabel) {
-    const functionBody = extractFunctionBody(stepFunction.code);
-    if (!functionBody) {
-        return `// ${stepLabel}\nconst ${stepFunction.varName}_result = { success: false, error: 'Invalid function format' };`;
+function transformStepForExecution(stepFunction, stepType, stepLabel) {
+  const functionBody = extractFunctionBody(stepFunction.code);
+  if (!functionBody) {
+    return `// ${stepLabel}\nconst ${stepFunction.varName}_result = { success: false, error: 'Invalid function format' };`;
+  }
+  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;
+      }
     }
-    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`);
-        }
-        // 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}`;
+    // 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 other step types, wrap in step.run()
-    return `// ${stepLabel}
+    // 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
-export 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);
-        }
-    });
-    // Generate function body without async wrapper
-    const code = `${stepBlocks.join('\n\n')}
+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);
+    }
+  });
+  // Generate function body without async wrapper
+  const code = `${stepBlocks.join('\n\n')}
 
         return {
             steps: ${stepFunctions.length},
@@ -238,27 +228,25 @@ export function generateInngestFunctionFromSteps(stepFunctions) {
 ${resultVars.map((v, i) => `                ${stepFunctions[i].varName}: ${v}`).join(',\n')}
             }
         };`;
-    return code;
+  return code;
 }
 // Convert ExtractedFunction array to step functions and generate Inngest function
-export 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);
-}
+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

package/lib/inngest/stepGenerator.js.map

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,14 +1,22 @@
 {
     "name": "@adminide-stack/form-builder-core",
-    "version": "5.1.4-alpha.47",
+    "version": "5.1.4-alpha.49",
     "sideEffects": false,
     "type": "module",
     "main": "lib/index.js",
     "module": "lib/index.js",
     "types": "lib/index.d.ts",
     "scripts": {
-        "build": "tsc",
-        "clean": "rimraf lib"
+        "build": "npm run build:clean && npm run build:lib",
+        "build:clean": "rimraf lib",
+        "build:lib": "rollup -c rollup.config.mjs",
+        "build:lib:watch": "npm run build:lib -- --watch",
+        "jest": "./node_modules/.bin/jest",
+        "prepublish": "npm run build",
+        "test": "cross-env ENV_FILE=../../../config/test/test.env jest",
+        "test:debug": "npm test -- --runInBand",
+        "test:watch": "npm test -- --watch",
+        "watch": "npm run build:lib:watch"
     },
     "devDependencies": {
         "typescript": "^5.4.0"
@@ -16,5 +24,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "0ab3c879bace1cbf771c99c2422366628ddd8483"
+    "gitHead": "4fc9dbe45e8754f40077dc927b64be811d2e1562"
 }

package/rollup.config.mjs

@@ -0,0 +1,33 @@
+import { createRollupConfig } from '../../../rollup.config.base.mjs';
+
+// Define any additional plugins specific to this bundle
+const additionalPlugins = [];
+
+// Use the createRollupConfig function to merge the base and specific configurations
+export default (commandLineArgs) => {
+    const isWatchMode = commandLineArgs.watch;
+    return [
+        createRollupConfig(
+            {
+                input: ['src/index.ts'],
+                plugins: [
+                    // Spread in additional plugins specific to this config
+                    ...additionalPlugins,
+                ],
+                output: [
+                    {
+                        dir: 'lib',
+                        format: 'es',
+                        name: 'form-stack-server',
+                        compact: true,
+                        exports: 'named',
+                        sourcemap: true,
+                        preserveModules: true,
+                        chunkFileNames: '[name]-[hash].[format].js',
+                    },
+                ],
+            },
+            isWatchMode,
+        ),
+    ];
+};

package/lib/inngest/interfaces/index.js

@@ -1 +0,0 @@
-export * from './types';

package/lib/inngest/interfaces/types.js

@@ -1 +0,0 @@
-export {};

package/lib/inngest/types.d.ts

@@ -1,47 +0,0 @@
-export type InngestStepType = 'run' | 'sleep' | 'sendEvent' | 'waitForEvent' | 'retrieveData' | 'parallel' | 'validateForm';
-export interface InngestStep {
-    id: string;
-    name: string;
-    type: InngestStepType;
-    code?: string;
-    description?: string;
-    [key: string]: unknown;
-}
-export interface InngestFunctionDef {
-    id: string;
-    name: string;
-    description?: string;
-    events: string[];
-    steps: InngestStep[];
-    concurrency?: number;
-    retries?: number;
-    timeout?: string | number;
-    [key: string]: unknown;
-}
-export interface ExtractedFunction {
-    id: string;
-    name: string;
-    code?: string;
-    extensionId?: string;
-    extensionName?: string;
-    generatedCode?: string;
-    steps?: StepDefinition[];
-    originalStepName?: string;
-}
-export interface StepFunction {
-    id: string;
-    name: string;
-    code: string;
-    type?: InngestStepType;
-    description?: string;
-}
-export interface StepDefinition {
-    id: string;
-    name: string;
-    code: string;
-}
-export interface GeneratedFunctionResult {
-    code: string;
-    functionId: string;
-    stepCount: number;
-}

package/lib/inngest/types.js

@@ -1 +0,0 @@
-export {};