@adminide-stack/form-builder-core 5.1.4-alpha.81 → 6.0.1-alpha.0

package/src/inngest/stepGenerator.ts

@@ -1,538 +0,0 @@
-import type { InngestStep, ExtractedFunction } from './interfaces/types';
-
-// Re-export for convenience
-export type { ExtractedFunction } from './interfaces/types';
-
-/**
- * Step function generation utilities for unified code generation
- * Used by both browser editor and server execution
- *
- * Integrates with js-autocomplete-extension for intelligent code completion
- */
-
-/**
- * Get scope context for code completion in step functions
- * Returns available variables and their types for autocomplete
- */
-export function getStepCompletionScope(): string[] {
-    return [
-        'step',
-        'event',
-        'run',
-        'sleep',
-        'sendEvent',
-        'waitForEvent',
-        'Promise',
-        'console',
-        'Date',
-        'JSON',
-        'Array',
-        'Object',
-    ];
-}
-
-/**
- * Get type definitions for step function context
- * Used by Monaco editor for enhanced IntelliSense
- */
-export function getStepTypeDefinitions(): string {
-    return `
-// Inngest Step API
-declare const step: {
-    run<T>(id: string, fn: (event: any, step: any) => Promise<T> | T): Promise<T>;
-    sendEvent(id: string, input: { name: string; data?: any }): Promise<void>;
-    waitForEvent<T = any>(id: string, opts: { event: string; timeout?: string | number }): Promise<T>;
-    sleep(id: string, ms: string | number): Promise<void>;
-};
-
-// Event context
-declare const event: {
-    data: any;
-    id: string;
-    name: string;
-    ts: number;
-    user?: any;
-};
-
-// Common utilities available in step functions
-declare const console: {
-    log(...args: any[]): void;
-    error(...args: any[]): void;
-    warn(...args: any[]): void;
-    info(...args: any[]): void;
-};
-
-// Promise and async utilities
-declare class Promise<T> {
-    then<TResult>(onfulfilled?: (value: T) => TResult | Promise<TResult>): Promise<TResult>;
-    catch<TResult>(onrejected?: (reason: any) => TResult | Promise<TResult>): Promise<TResult>;
-    finally(onfinally?: () => void): Promise<T>;
-    static all<T>(promises: Promise<T>[]): Promise<T[]>;
-    static race<T>(promises: Promise<T>[]): Promise<T>;
-    static resolve<T>(value: T): Promise<T>;
-    static reject(reason?: any): Promise<never>;
-}
-
-// Date utilities
-declare class Date {
-    constructor();
-    constructor(value: number | string);
-    toISOString(): string;
-    getTime(): number;
-    static now(): number;
-}
-`;
-}
-
-/**
- * Get autocomplete suggestions for a specific step type
- * Returns context-specific completions based on step type
- */
-export function getStepTypeCompletions(stepType: string): Array<{ name: string; snippet: string; doc: string }> {
-    const completions: Record<string, Array<{ name: string; snippet: string; doc: string }>> = {
-        sleep: [
-            {
-                name: 'step.sleep',
-                snippet: "await step.sleep('${1:step-id}', '${2:5s}');",
-                doc: 'Sleep for a specified duration. Accepts time strings like "5s", "1m", "1h"',
-            },
-        ],
-        sendEvent: [
-            {
-                name: 'step.sendEvent',
-                snippet: `await step.sendEvent('\${1:step-id}', {
-  name: '\${2:event.name}',
-  data: {
-    \${3:key}: \${4:value}
-  }
-});`,
-                doc: 'Send an event to trigger other workflows',
-            },
-        ],
-        waitForEvent: [
-            {
-                name: 'step.waitForEvent',
-                snippet: `const \${1:result} = await step.waitForEvent('\${2:step-id}', {
-  event: '\${3:event.name}',
-  timeout: '\${4:60s}'
-});`,
-                doc: 'Wait for a specific event before continuing',
-            },
-        ],
-        run: [
-            {
-                name: 'step.run',
-                snippet: `const \${1:result} = await step.run('\${2:step-id}', async () => {
-  \${3:// Your logic here}
-  return { success: true };
-});`,
-                doc: 'Run a unit of work with automatic retries and error handling',
-            },
-        ],
-        parallel: [
-            {
-                name: 'Promise.all',
-                snippet: `const results = await Promise.all([
-  \${1:step.run('step-1', async () => { return 1; })},
-  \${2:step.run('step-2', async () => { return 2; })}
-]);`,
-                doc: 'Execute multiple steps in parallel',
-            },
-        ],
-    };
-
-    return completions[stepType] || completions.run;
-}
-
-/**
- * Extract variable names from step code for completion context
- * Returns all declared variables in the step function
- */
-export function extractVariablesFromCode(code: string): string[] {
-    const variables: string[] = [];
-
-    // Match const/let/var declarations
-    const declRegex = /(?:const|let|var)\s+(\w+)/g;
-    let match;
-
-    while ((match = declRegex.exec(code)) !== null) {
-        variables.push(match[1]);
-    }
-
-    // Match function parameters
-    const paramRegex = /(?:async\s+)?\(([^)]*)\)\s*=>/g;
-    while ((match = paramRegex.exec(code)) !== null) {
-        const params = match[1].split(',').map((p) => p.trim().split(/\s+/)[0]);
-        variables.push(...params.filter((p) => p && p !== ''));
-    }
-
-    return [...new Set(variables)]; // Remove duplicates
-}
-
-/**
- * Get completion context for a step at a specific position
- * Used by Monaco editor to provide context-aware completions
- */
-export interface CompletionContext {
-    scope: string[];
-    typeDefinitions: string;
-    snippets: Array<{ name: string; snippet: string; doc: string }>;
-    variables: string[];
-}
-
-export function getStepCompletionContext(step: InngestStep, code: string): CompletionContext {
-    const stepType = step.type || 'run';
-
-    return {
-        scope: getStepCompletionScope(),
-        typeDefinitions: getStepTypeDefinitions(),
-        snippets: getStepTypeCompletions(stepType),
-        variables: extractVariablesFromCode(code),
-    };
-}
-
-// 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) {
-        // 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) {
-        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++;
-        }
-    }
-
-    if (braceCount === 0) {
-        return code.substring(startIndex, endIndex).trim();
-    }
-
-    // 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 },
-    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}`;
-                }
-                // 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 {
-    if (extractedFunctions.length === 0) {
-        return 'return { success: false, error: "No functions to execute" };';
-    }
-
-    // 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();
-        }
-    }
-
-    // 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();
-        }
-    }
-
-    // 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" };';
-}

package/src/utils/json.ts

@@ -1,50 +0,0 @@
-export function flatten(obj: Record<string, unknown>, parentKey = '', res: Record<string, unknown> = {}) {
-    Object.entries(obj).forEach(([key, value]) => {
-        const newKey = parentKey ? `${parentKey}.${key}` : key;
-
-        if (Array.isArray(value)) {
-            value.forEach((item, index) => {
-                if (item !== null && typeof item === 'object') {
-                    flatten(item, `${newKey}.${index}`, res);
-                } else {
-                    res[`${newKey}.${index}`] = item;
-                }
-            });
-        } else if (value !== null && typeof value === 'object') {
-            flatten(value as Record<string, unknown>, newKey, res);
-        } else {
-            res[newKey] = value;
-        }
-    });
-
-    return res;
-}
-
-export function unflatten(obj: Record<string, unknown>) {
-    const result = {};
-    if (!obj || typeof obj !== 'object') return result;
-    for (const [flatKey, value] of Object.entries(obj)) {
-        const keys = flatKey.split('.');
-        keys.reduce((acc, cur, i) => {
-            const isLast = i === keys.length - 1;
-            const nextKey = keys[i + 1];
-            const curIsIndex = !Number.isNaN(Number(cur));
-            const nextIsIndex = !Number.isNaN(Number(nextKey));
-
-            // If current key is numeric, treat parent as an array
-            if (curIsIndex) {
-                if (!Array.isArray(acc)) return [];
-            }
-
-            if (isLast) {
-                acc[cur] = value;
-            } else if (acc[cur] == null) {
-                acc[cur] = nextIsIndex ? [] : {};
-            }
-
-            return acc[cur];
-        }, result);
-    }
-
-    return result;
-}

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-    "extends": "../../../tsconfig.json",
-    "compilerOptions": {
-        "resolveJsonModule": true,
-        "rootDir": "./src",
-        "outDir": "lib",
-        "sourceMap": false,
-        "declarationDir": "lib",
-        "declaration": true,
-        "declarationMap": true,
-        "skipLibCheck": true
-    },
-    "include": ["src"]
-}