@adminide-stack/form-builder-core 5.1.4-alpha.43

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Change Log
+
+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.43](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.42...v5.1.4-alpha.43) (2025-09-23)
+
+**Note:** Version bump only for package @adminide-stack/form-builder-core

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2017 CDMBase LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './inngest/types';
+export * from './inngest/generateFunctionCode';
+export * from './inngest/stepGenerator';

package/lib/index.js

@@ -0,0 +1,3 @@
+export * from './inngest/types';
+export * from './inngest/generateFunctionCode';
+export * from './inngest/stepGenerator';

package/lib/inngest/generateFunctionCode.d.ts

@@ -0,0 +1,7 @@
+import type { InngestFunctionDef, ExtractedFunction, StepFunction, GeneratedFunctionResult } from './types';
+export { cleanStepCode, extractStepVarName } from './stepGenerator';
+export declare function generateFunctionCode(def: InngestFunctionDef): string;
+export declare function generateHandlerBody(def: InngestFunctionDef): string;
+export declare function generateStepFunctionsFromDB(functionId: string, events: string[], extractedFunctions: ExtractedFunction[]): GeneratedFunctionResult;
+export declare function wrapStepsInInngestFunction(functionDef: InngestFunctionDef, stepFunctions: StepFunction[]): string;
+export declare function generateStepFromFunction(stepFunction: StepFunction, index: number): string;

package/lib/inngest/generateFunctionCode.js

@@ -0,0 +1,108 @@
+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)
+function hasDirectStepOperations(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`;
+    }
+}
+function indent(s, spaces) {
+    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
+}
+function generateStepBlock(step, position) {
+    var _a;
+    const stepVar = ((_a = (step.code || '').match(/const\s+(\w+)\s*=/)) === null || _a === void 0 ? void 0 : _a[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(
+  { id: '${def.id}' },
+  { event: [${eventsString}] },
+  async ({ event, step }) => {
+${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}`;
+}
+// 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,
+    };
+}
+// 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;
+}
+// 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});`;
+}

package/lib/inngest/stepGenerator.d.ts

@@ -0,0 +1,25 @@
+import type { InngestStep, ExtractedFunction } from './types';
+export type { ExtractedFunction } from './types';
+/**
+ * Step function generation utilities for unified code generation
+ * Used by both browser editor and server execution
+ */
+export declare function cleanStepCode(code: string): string;
+export declare function extractStepVarName(code: string): string | null;
+export declare function generateDefaultStepFunction(stepVar: string, stepType: string): string;
+export declare function generateStepFunction(step: InngestStep | ExtractedFunction, index: number): {
+    code: string;
+    varName: string;
+};
+export declare function extractFunctionBody(code: string): string | null;
+export declare function transformStepForExecution(stepFunction: {
+    code: string;
+    varName: string;
+}, stepType: string, stepLabel: string): string;
+export declare function generateInngestFunctionFromSteps(stepFunctions: Array<{
+    code: string;
+    varName: string;
+    type?: string;
+    label?: string;
+}>): string;
+export declare function generateFromExtractedFunctions(extractedFunctions: ExtractedFunction[]): string;

package/lib/inngest/stepGenerator.js

@@ -0,0 +1,266 @@
+/**
+ * Step function generation utilities for unified code generation
+ * Used by both browser editor and server execution
+ */
+// Pass through code without any cleaning/validation
+export 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;
+}
+// Generate default step function for different step types
+export 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) => {...})
+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 };
+}
+// 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;
+        }
+    }
+    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 (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' };`;
+    }
+    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}`;
+            }
+            else {
+                // 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}`;
+    }
+    // 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')}
+
+        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
+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);
+}

package/lib/inngest/types.d.ts

@@ -0,0 +1,47 @@
+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

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

package/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "@adminide-stack/form-builder-core",
+    "version": "5.1.4-alpha.43",
+    "sideEffects": false,
+    "main": "lib/index.js",
+    "module": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "scripts": {
+        "build": "tsc -b",
+        "clean": "rimraf lib"
+    },
+    "devDependencies": {
+        "typescript": "^5.4.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "gitHead": "e1bb514cf466e95100493832754f4fc2be6675d8"
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './inngest/types';
+export * from './inngest/generateFunctionCode';
+export * from './inngest/stepGenerator';

package/src/inngest/generateFunctionCode.ts

@@ -0,0 +1,150 @@
+import type {
+    InngestFunctionDef,
+    InngestStep,
+    ExtractedFunction,
+    StepFunction,
+    GeneratedFunctionResult,
+} from './types';
+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)
+function hasDirectStepOperations(code: string): boolean {
+    return /step\.(sleep|sendEvent|waitForEvent|run)\s*\(/.test(code);
+}
+
+function getDefaultDirectBody(type: string, id: string, label?: string): string {
+    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: string, spaces: number): string {
+    const pad = ' '.repeat(spaces);
+    return s
+        .split('\n')
+        .map((l) => (l ? pad + l : l))
+        .join('\n');
+}
+
+// Simple code formatter
+function formatCode(code: string): string {
+    // 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: InngestStep, position: number): string {
+    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: InngestFunctionDef): string {
+    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 }) => {
+${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}`;
+}
+
+// Generate Inngest function from database-extracted functions
+export function generateStepFunctionsFromDB(
+    functionId: string,
+    events: string[],
+    extractedFunctions: ExtractedFunction[],
+): GeneratedFunctionResult {
+    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: InngestFunctionDef, stepFunctions: StepFunction[]): string {
+    const extractedFunctions: ExtractedFunction[] = 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: StepFunction, index: number): string {
+    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});`;
+}

package/src/inngest/stepGenerator.ts

@@ -0,0 +1,316 @@
+import type { InngestStep, ExtractedFunction } from './types';
+
+// Re-export for convenience
+export type { ExtractedFunction } from './types';
+
+/**
+ * Step function generation utilities for unified code generation
+ * Used by both browser editor and server execution
+ */
+
+// Pass through code without any cleaning/validation
+export function cleanStepCode(code: string): string {
+    return code;
+}
+
+// Extract step variable name from code
+export function extractStepVarName(code: string): string | null {
+    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: string, stepType: string): string {
+    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) => {...})
+export function generateStepFunction(
+    step: InngestStep | ExtractedFunction,
+    index: number,
+): { code: string; varName: string } {
+    // Extract or generate step variable name
+    const varName =
+        extractStepVarName(step.code || '') ||
+        (step as ExtractedFunction).originalStepName ||
+        step.id ||
+        `step_${index}`;
+
+    // If step has code, use it; otherwise generate default
+    const code = step.code || generateDefaultStepFunction(varName, (step as InngestStep).type || 'run');
+
+    return { code: cleanStepCode(code), varName };
+}
+
+// Extract function body from step function code
+export function extractFunctionBody(code: string): string | null {
+    // 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;
+        }
+    }
+
+    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 (braceCount === 0) {
+        return code.substring(startIndex, endIndex).trim();
+    }
+
+    return null;
+}
+
+// Transform a step function for execution inside Inngest wrapper
+export function transformStepForExecution(
+    stepFunction: { code: string; varName: string },
+    stepType: string,
+    stepLabel: string,
+): string {
+    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}`;
+                } else {
+                    // 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}`;
+    }
+
+    // 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: Array<{ code: string; varName: string; type?: string; label?: string }>,
+): string {
+    // Transform each step for execution
+    const stepBlocks: string[] = [];
+    const resultVars: string[] = [];
+
+    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},
+            results: {
+${resultVars.map((v, i) => `                ${stepFunctions[i].varName}: ${v}`).join(',\n')}
+            }
+        };`;
+
+    return code;
+}
+
+// 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);
+
+        // 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);
+}

package/src/inngest/types.ts

@@ -0,0 +1,63 @@
+export type InngestStepType =
+    | 'run'
+    | 'sleep'
+    | 'sendEvent'
+    | 'waitForEvent'
+    | 'retrieveData'
+    | 'parallel'
+    | 'validateForm';
+
+export interface InngestStep {
+    id: string;
+    name: string;
+    type: InngestStepType;
+    code?: string;
+    description?: string;
+    // Loose optional fields to avoid coupling; extend in callers as needed
+    [key: string]: unknown;
+}
+
+export interface InngestFunctionDef {
+    id: string;
+    name: string;
+    description?: string;
+    events: string[];
+    steps: InngestStep[];
+    concurrency?: number;
+    retries?: number;
+    timeout?: string | number;
+    // Extra passthrough metadata
+    [key: string]: unknown;
+}
+
+// New interfaces for database-extracted functions
+export interface ExtractedFunction {
+    id: string;
+    name: string;
+    code?: string; // The complete async function code
+    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/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "target": "ES2019",
+        "module": "ES2020",
+        "declaration": true,
+        "outDir": "lib",
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true
+    },
+    "include": ["src"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/inngest/generatefunctioncode.ts","./src/inngest/stepgenerator.ts","./src/inngest/types.ts"],"version":"5.9.2"}