@flowuent-org/diagramming-core 1.3.10 → 1.4.1

package/packages/diagrams/src/lib/utils/automation-flow-processor.ts

@@ -1,619 +1,556 @@
-import {
-  AutomationNodeForm,
-  AutomationWorkflowData,
-  AutomationStartNodeForm,
-  AutomationApiNodeForm,
-  AutomationFormattingNodeForm,
-  AutomationSheetsNodeForm,
-  AutomationEndNodeForm,
-} from '../types/automation-node-data-types';
-import { Node, Edge } from '@xyflow/react';
-
-export interface AutomationExecutionContext {
-  variables: Record<string, string | number | boolean | object | null>;
-  logs: Array<{
-    timestamp: string;
-    level: 'info' | 'warn' | 'error' | 'debug';
-    nodeId: string;
-    message: string;
-    data?: string | number | boolean | object | null;
-  }>;
-  errors: Array<{
-    timestamp: string;
-    nodeId: string;
-    error: string;
-    stack?: string;
-  }>;
-}
-
-export class AutomationFlowProcessor {
-  private context: AutomationExecutionContext;
-  private nodes: Node[];
-  private edges: Edge[];
-
-  constructor(nodes: Node[], edges: Edge[]) {
-    this.nodes = nodes;
-    this.edges = edges;
-    this.context = {
-      variables: {},
-      logs: [],
-      errors: [],
-    };
-  }
-
-  /**
-   * Process automation workflow data similar to workflow system
-   */
-  public processWorkflowData(): AutomationWorkflowData {
-    const workflowData: AutomationWorkflowData = {
-      id: `automation-workflow-${Date.now()}`,
-      name: 'Automation Workflow',
-      description: 'Generated automation workflow',
-      version: '1.0.0',
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      nodes: [],
-      edges: [],
-      variables: [],
-      settings: {
-        timeout: 300000, // 5 minutes
-        retryPolicy: {
-          maxRetries: 3,
-          retryDelay: 1000,
-          backoffMultiplier: 2,
-        },
-        logging: {
-          level: 'info',
-          destination: 'console',
-        },
-      },
-    };
-
-    // Process nodes
-    this.nodes.forEach((node) => {
-      if (node.data.formData) {
-        const formData = node.data.formData as AutomationNodeForm;
-
-        workflowData.nodes.push({
-          id: node.id,
-          type: node.type || 'unknown',
-          position: node.position,
-          data: formData,
-        });
-
-        // Extract variables from form data
-        this.extractVariablesFromNode(formData, workflowData.variables!);
-      }
-    });
-
-    // Process edges
-    this.edges.forEach((edge) => {
-      workflowData.edges.push({
-        id: edge.id,
-        source: edge.source,
-        target: edge.target,
-        sourceHandle: edge.sourceHandle || undefined,
-        targetHandle: edge.targetHandle || undefined,
-        data: edge.data || undefined,
-      });
-    });
-
-    return workflowData;
-  }
-
-  /**
-   * Extract variables from node form data
-   */
-  private extractVariablesFromNode(
-    formData: AutomationNodeForm,
-    variables: NonNullable<AutomationWorkflowData['variables']>,
-  ): void {
-    switch (formData.type) {
-      case 'start':
-        // Extract initial variables
-        if (formData.initialVariables) {
-          formData.initialVariables.forEach((variable) => {
-            if (!variables.find((v) => v.name === variable.name)) {
-              variables.push({
-                name: variable.name,
-                type: variable.type,
-                defaultValue: variable.value,
-                description: `Initial variable from ${formData.title}`,
-              });
-            }
-          });
-        }
-        break;
-
-      case 'api':
-        // Extract response variable
-        if (formData.responseVariable) {
-          if (!variables.find((v) => v.name === formData.responseVariable)) {
-            variables.push({
-              name: formData.responseVariable,
-              type: formData.responseDataType.toLowerCase() as any,
-              defaultValue: null,
-              description: `API response from ${formData.title}`,
-            });
-          }
-        }
-        break;
-
-      case 'formatting':
-        // Extract input and output variables
-        if (formData.inputVariable) {
-          if (!variables.find((v) => v.name === formData.inputVariable)) {
-            variables.push({
-              name: formData.inputVariable,
-              type: 'object',
-              defaultValue: null,
-              description: `Input data for ${formData.title}`,
-            });
-          }
-        }
-        if (formData.outputVariable) {
-          if (!variables.find((v) => v.name === formData.outputVariable)) {
-            variables.push({
-              name: formData.outputVariable,
-              type: formData.outputDataType.toLowerCase() as any,
-              defaultValue: null,
-              description: `Formatted output from ${formData.title}`,
-            });
-          }
-        }
-        break;
-
-      case 'end':
-        // End node doesn't create new variables
-        break;
-    }
-  }
-
-  /**
-   * Generate JavaScript code from automation workflow
-   */
-  public generateJavaScriptCode(): string {
-    const workflowData = this.processWorkflowData();
-    let code = `// Generated Automation Workflow Code
-// Workflow ID: ${workflowData.id}
-// Generated at: ${new Date().toISOString()}
-
-async function executeAutomationWorkflow() {
-  const context = {
-    variables: {},
-    logs: [],
-    errors: [],
-  };
-
-  // Initialize variables
-${
-  workflowData.variables
-    ?.map(
-      (variable) =>
-        `  context.variables['${variable.name}'] = ${JSON.stringify(variable.defaultValue)};`,
-    )
-    .join('\n') || ''
-}
-
-  try {
-`;
-
-    // Generate code for each node
-    workflowData.nodes.forEach((node) => {
-      code += this.generateNodeCode(node.data);
-    });
-
-    code += `
-    return {
-      success: true,
-      context,
-      finalOutput: context.variables,
-    };
-  } catch (error) {
-    context.errors.push({
-      timestamp: new Date().toISOString(),
-      nodeId: 'unknown',
-      error: error.message,
-      stack: error.stack,
-    });
-    
-    return {
-      success: false,
-      context,
-      error: error.message,
-    };
-  }
-}
-
-// Export for use
-module.exports = { executeAutomationWorkflow };
-`;
-
-    return code;
-  }
-
-  /**
-   * Generate JavaScript code for a specific node
-   */
-  private generateNodeCode(formData: AutomationNodeForm): string {
-    let code = `\n    // ${formData.title} (${formData.type})\n`;
-
-    switch (formData.type) {
-      case 'start':
-        code += this.generateStartNodeCode(formData as AutomationStartNodeForm);
-        break;
-      case 'api':
-        code += this.generateApiNodeCode(formData as AutomationApiNodeForm);
-        break;
-      case 'formatting':
-        code += this.generateFormattingNodeCode(
-          formData as AutomationFormattingNodeForm,
-        );
-        break;
-      case 'sheets':
-        code += this.generateSheetsNodeCode(
-          formData as AutomationSheetsNodeForm,
-        );
-        break;
-      case 'end':
-        code += this.generateEndNodeCode(formData as AutomationEndNodeForm);
-        break;
-    }
-
-    return code;
-  }
-
-  private generateStartNodeCode(formData: AutomationStartNodeForm): string {
-    return `    // Start Node: ${formData.title}
-    context.logs.push({
-      timestamp: new Date().toISOString(),
-      level: 'info',
-      nodeId: '${formData.nodeId}',
-      message: 'Starting automation workflow',
-    });
-
-    // Initialize workflow context
-    ${
-      formData.initialVariables
-        ?.map(
-          (variable) =>
-            `context.variables['${variable.name}'] = ${JSON.stringify(variable.value)};`,
-        )
-        .join('\n    ') || ''
-    }
-
-    context.variables['${formData.outputVariable || 'workflowContext'}'] = {
-      runId: context.variables['runId'] || Date.now().toString(),
-      startTime: context.variables['startTime'] || new Date().toISOString(),
-      triggerType: '${formData.triggerType}',
-    };
-`;
-  }
-
-  private generateApiNodeCode(formData: AutomationApiNodeForm): string {
-    return `    // API Node: ${formData.title}
-    try {
-      context.logs.push({
-        timestamp: new Date().toISOString(),
-        level: 'info',
-        nodeId: '${formData.nodeId}',
-        message: 'Making API call to ${formData.url}',
-      });
-
-      const headers = {
-        ${
-          formData.headers
-            ?.filter((h) => h.enabled)
-            .map((header) => `'${header.key}': '${header.value}',`)
-            .join('\n        ') || ''
-        }
-      };
-
-      const queryParams = new URLSearchParams({
-        ${
-          formData.queryParams
-            ?.filter((p) => p.enabled)
-            .map((param) => `'${param.key}': '${param.value}',`)
-            .join('\n        ') || ''
-        }
-      });
-
-      const url = '${formData.url}' + (queryParams.toString() ? '?' + queryParams.toString() : '');
-      
-      const response = await fetch(url, {
-        method: '${formData.method}',
-        headers,
-        ${formData.body ? `body: ${formData.bodyType === 'json' ? 'JSON.stringify(' + formData.body + ')' : formData.body},` : ''}
-        timeout: ${formData.timeout},
-      });
-
-      if (!response.ok) {
-        throw new Error(\`API call failed: \${response.status} \${response.statusText}\`);
-      }
-
-      const data = await response.json();
-      context.variables['${formData.responseVariable}'] = data;
-      
-      context.logs.push({
-        timestamp: new Date().toISOString(),
-        level: 'info',
-        nodeId: '${formData.nodeId}',
-        message: 'API call completed successfully',
-        data: data,
-      });
-    } catch (error) {
-      context.errors.push({
-        timestamp: new Date().toISOString(),
-        nodeId: '${formData.nodeId}',
-        error: error.message,
-      });
-      ${
-        formData.errorHandling?.onError === 'continue'
-          ? `context.variables['${formData.responseVariable}'] = ${JSON.stringify(formData.errorHandling.fallbackValue)};`
-          : 'throw error;'
-      }
-    }
-`;
-  }
-
-  private generateFormattingNodeCode(
-    formData: AutomationFormattingNodeForm,
-  ): string {
-    return `    // Formatting Node: ${formData.title}
-    try {
-      context.logs.push({
-        timestamp: new Date().toISOString(),
-        level: 'info',
-        nodeId: '${formData.nodeId}',
-        message: 'Processing data formatting',
-      });
-
-      const inputData = context.variables['${formData.inputVariable}'];
-      
-      let formattedData;
-      
-      if ('${formData.formattingType}' === 'ai-powered') {
-        // AI-powered formatting
-        // Validate API key is not a placeholder
-        if (!'${formData.aiFormatting?.apiKey}' || '${formData.aiFormatting?.apiKey}'.includes('your-openai-api-key-here') || '${formData.aiFormatting?.apiKey}'.length < 10) {
-          throw new Error('Invalid API key. Please provide a valid API key.');
-        }
-        
-        // Determine if this is Gemini API or OpenAI API based on URL
-        const isGeminiApi = '${formData.aiFormatting?.apiUrl}'.includes('generativelanguage.googleapis.com');
-        
-        let requestBody;
-        let headers;
-        
-        if (isGeminiApi) {
-          // Gemini API format
-          headers = {
-            'Content-Type': 'application/json',
-            'X-goog-api-key': '${formData.aiFormatting?.apiKey}',
-          };
-          
-          requestBody = {
-            contents: [
-              {
-                parts: [
-                  {
-                    text: \`${formData.aiFormatting?.systemPrompt || 'You are a data formatting assistant.'}\\n\\n${formData.aiFormatting?.instruction}\\n\\nData: \${JSON.stringify(inputData)}\`,
-                  },
-                ],
-              },
-            ],
-            generationConfig: {
-              temperature: ${formData.aiFormatting?.temperature},
-              maxOutputTokens: ${formData.aiFormatting?.maxTokens || 1000},
-              responseMimeType: 'application/json',
-            },
-          };
-        } else {
-          // OpenAI API format
-          headers = {
-            'Content-Type': 'application/json',
-            'Authorization': 'Bearer ${formData.aiFormatting?.apiKey}',
-          };
-          
-          requestBody = {
-            model: '${formData.aiFormatting?.model}',
-            messages: [
-              {
-                role: 'system',
-                content: '${formData.aiFormatting?.systemPrompt || 'You are a data formatting assistant.'}',
-              },
-              {
-                role: 'user',
-                content: \`${formData.aiFormatting?.instruction}\\n\\nData: \${JSON.stringify(inputData)}\`,
-              },
-            ],
-            temperature: ${formData.aiFormatting?.temperature},
-            max_tokens: ${formData.aiFormatting?.maxTokens || 1000},
-          };
-        }
-        
-        const aiResponse = await fetch('${formData.aiFormatting?.apiUrl}', {
-          method: 'POST',
-          headers,
-          body: JSON.stringify(requestBody),
-        });
-
-        if (!aiResponse.ok) {
-          const errorText = await aiResponse.text();
-          throw new Error(\`AI API call failed: \${aiResponse.status} \${aiResponse.statusText}. \${errorText}\`);
-        }
-
-        const aiResult = await aiResponse.json();
-        
-        let content;
-        
-        if (isGeminiApi) {
-          // Gemini API response format
-          if (!aiResult.candidates || !aiResult.candidates[0] || !aiResult.candidates[0].content || !aiResult.candidates[0].content.parts) {
-            throw new Error('Invalid Gemini API response format');
-          }
-          content = aiResult.candidates[0].content.parts[0].text;
-        } else {
-          // OpenAI API response format
-          if (!aiResult.choices || !aiResult.choices[0] || !aiResult.choices[0].message) {
-            throw new Error('Invalid AI API response format');
-          }
-          content = aiResult.choices[0].message.content;
-        }
-        
-        // Try to parse as JSON, fallback to string if parsing fails
-        try {
-          formattedData = JSON.parse(content);
-        } catch {
-          formattedData = content;
-        }
-      } else if ('${formData.formattingType}' === 'template') {
-        // Template-based formatting
-        let template = \`${formData.templateFormatting?.template}\`;
-        ${
-          formData.templateFormatting?.variables
-            ?.map(
-              (variable) =>
-                `template = template.replace(/{{${variable.name}}}/g, context.variables['${variable.source}'] || '');`,
-            )
-            .join('\n        ') || ''
-        }
-        formattedData = JSON.parse(template);
-      } else {
-        // Basic formatting
-        formattedData = inputData;
-        ${
-          formData.basicFormatting?.operations
-            ?.map((operation) => {
-              switch (operation.type) {
-                case 'trim':
-                  return `// Trim fields: ${(operation.config as { fields: string[] }).fields.join(', ')}`;
-                case 'rename':
-                  return `// Rename fields: ${(operation.config as { mappings: Array<{ from: string; to: string }> }).mappings.map((m) => `${m.from} -> ${m.to}`).join(', ')}`;
-                default:
-                  return `// ${operation.type} operation`;
-              }
-            })
-            .join('\n        ') || ''
-        }
-      }
-
-      context.variables['${formData.outputVariable}'] = formattedData;
-      
-      context.logs.push({
-        timestamp: new Date().toISOString(),
-        level: 'info',
-        nodeId: '${formData.nodeId}',
-        message: 'Data formatting completed',
-        data: formattedData,
-      });
-    } catch (error) {
-      context.errors.push({
-        timestamp: new Date().toISOString(),
-        nodeId: '${formData.nodeId}',
-        error: error.message,
-      });
-      throw error;
-    }
-`;
-  }
-
-  private generateSheetsNodeCode(formData: AutomationSheetsNodeForm): string {
-    return `    // Google Sheets Node: ${formData.title}
-    try {
-      const inputData = context.variables['${formData.inputVariable}'];
-      
-      if (!inputData) {
-        throw new Error('Input data not found: ${formData.inputVariable}');
-      }
-
-      // Prepare data for Google Sheets export
-      let exportData = Array.isArray(inputData) ? inputData : [inputData];
-      
-      // Map data according to configuration
-      const mappedData = exportData.map((item) => {
-        const row = {};
-        ${formData.dataMapping.headers
-          .map(
-            (header) =>
-              `row['${header.column}'] = item['${header.sourceField}'];`,
-          )
-          .join('\n        ')}
-        return row;
-      });
-
-      // Simulate Google Sheets API call
-      const sheetsResponse = {
-        spreadsheetId: '${formData.sheetsConfig.spreadsheetId}',
-        sheetName: '${formData.sheetsConfig.sheetName}',
-        range: '${formData.sheetsConfig.range}',
-        rowsAdded: mappedData.length,
-        columnsMapped: ${formData.dataMapping.headers.length},
-        data: mappedData,
-        exportTime: new Date().toISOString(),
-        success: true,
-      };
-
-      // Store the response in context
-      context.variables['${formData.outputVariable}'] = sheetsResponse;
-      
-      context.logs.push({
-        timestamp: new Date().toISOString(),
-        level: 'info',
-        nodeId: '${formData.nodeId}',
-        message: 'Google Sheets export completed successfully',
-        data: sheetsResponse,
-      });
-    } catch (error) {
-      context.errors.push({
-        timestamp: new Date().toISOString(),
-        nodeId: '${formData.nodeId}',
-        error: error.message,
-      });
-      throw error;
-    }
-`;
-  }
-
-  private generateEndNodeCode(formData: AutomationEndNodeForm): string {
-    return `    // End Node: ${formData.title}
-    context.logs.push({
-      timestamp: new Date().toISOString(),
-      level: 'info',
-      nodeId: '${formData.nodeId}',
-      message: 'Automation workflow completed',
-    });
-
-    // Handle output based on configuration
-    const finalData = context.variables;
-    
-    if ('${formData.outputType}' === 'display') {
-      console.log('Automation Results:', finalData);
-    } else if ('${formData.outputType}' === 'store') {
-      // Store results (implementation depends on storage type)
-      console.log('Storing results to ${formData.storeConfig?.destination}');
-    } else if ('${formData.outputType}' === 'send') {
-      // Send results (implementation depends on send method)
-      console.log('Sending results via ${formData.sendConfig?.method}');
-    } else if ('${formData.outputType}' === 'webhook') {
-      // Send to webhook
-      console.log('Sending results to webhook: ${formData.webhookConfig?.url}');
-    }
-`;
-  }
-
-  /**
-   * Export workflow data as JSON
-   */
-  public exportAsJSON(): string {
-    const workflowData = this.processWorkflowData();
-    return JSON.stringify(workflowData, null, 2);
-  }
-
-  /**
-   * Import workflow data from JSON
-   */
-  public static importFromJSON(jsonString: string): AutomationWorkflowData {
-    return JSON.parse(jsonString) as AutomationWorkflowData;
-  }
-}
+import {
+  AutomationNodeForm,
+  AutomationWorkflowData,
+  AutomationStartNodeForm,
+  AutomationApiNodeForm,
+  AutomationFormattingNodeForm,
+  AutomationEndNodeForm,
+} from '../types/automation-node-data-types';
+import { Node, Edge } from '@xyflow/react';
+
+export interface AutomationExecutionContext {
+  variables: Record<string, string | number | boolean | object | null>;
+  logs: Array<{
+    timestamp: string;
+    level: 'info' | 'warn' | 'error' | 'debug';
+    nodeId: string;
+    message: string;
+    data?: string | number | boolean | object | null;
+  }>;
+  errors: Array<{
+    timestamp: string;
+    nodeId: string;
+    error: string;
+    stack?: string;
+  }>;
+}
+
+export class AutomationFlowProcessor {
+  private context: AutomationExecutionContext;
+  private nodes: Node[];
+  private edges: Edge[];
+
+  constructor(nodes: Node[], edges: Edge[]) {
+    this.nodes = nodes;
+    this.edges = edges;
+    this.context = {
+      variables: {},
+      logs: [],
+      errors: [],
+    };
+  }
+
+  /**
+   * Process automation workflow data similar to workflow system
+   */
+  public processWorkflowData(): AutomationWorkflowData {
+    const workflowData: AutomationWorkflowData = {
+      id: `automation-workflow-${Date.now()}`,
+      name: 'Automation Workflow',
+      description: 'Generated automation workflow',
+      version: '1.0.0',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      nodes: [],
+      edges: [],
+      variables: [],
+      settings: {
+        timeout: 300000, // 5 minutes
+        retryPolicy: {
+          maxRetries: 3,
+          retryDelay: 1000,
+          backoffMultiplier: 2,
+        },
+        logging: {
+          level: 'info',
+          destination: 'console',
+        },
+      },
+    };
+
+    // Process nodes
+    this.nodes.forEach((node) => {
+      if (node.data.formData) {
+        const formData = node.data.formData as AutomationNodeForm;
+
+        workflowData.nodes.push({
+          id: node.id,
+          type: node.type || 'unknown',
+          position: node.position,
+          data: formData,
+        });
+
+        // Extract variables from form data
+        this.extractVariablesFromNode(formData, workflowData.variables!);
+      }
+    });
+
+    // Process edges
+    this.edges.forEach((edge) => {
+      workflowData.edges.push({
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+        sourceHandle: edge.sourceHandle || undefined,
+        targetHandle: edge.targetHandle || undefined,
+        data: edge.data || undefined,
+      });
+    });
+
+    return workflowData;
+  }
+
+  /**
+   * Extract variables from node form data
+   */
+  private extractVariablesFromNode(
+    formData: AutomationNodeForm,
+    variables: NonNullable<AutomationWorkflowData['variables']>,
+  ): void {
+    switch (formData.type) {
+      case 'start':
+        // Extract initial variables
+        if (formData.initialVariables) {
+          formData.initialVariables.forEach((variable) => {
+            if (!variables.find((v) => v.name === variable.name)) {
+              variables.push({
+                name: variable.name,
+                type: variable.type,
+                defaultValue: variable.value,
+                description: `Initial variable from ${formData.title}`,
+              });
+            }
+          });
+        }
+        break;
+
+      case 'api':
+        // Extract response variable
+        if (formData.responseVariable) {
+          if (!variables.find((v) => v.name === formData.responseVariable)) {
+            variables.push({
+              name: formData.responseVariable,
+              type: formData.responseDataType.toLowerCase() as any,
+              defaultValue: null,
+              description: `API response from ${formData.title}`,
+            });
+          }
+        }
+        break;
+
+      case 'formatting':
+        // Extract input and output variables
+        if (formData.inputVariable) {
+          if (!variables.find((v) => v.name === formData.inputVariable)) {
+            variables.push({
+              name: formData.inputVariable,
+              type: 'object',
+              defaultValue: null,
+              description: `Input data for ${formData.title}`,
+            });
+          }
+        }
+        if (formData.outputVariable) {
+          if (!variables.find((v) => v.name === formData.outputVariable)) {
+            variables.push({
+              name: formData.outputVariable,
+              type: formData.outputDataType.toLowerCase() as any,
+              defaultValue: null,
+              description: `Formatted output from ${formData.title}`,
+            });
+          }
+        }
+        break;
+
+      case 'end':
+        // End node doesn't create new variables
+        break;
+    }
+  }
+
+  /**
+   * Generate JavaScript code from automation workflow
+   */
+  public generateJavaScriptCode(): string {
+    const workflowData = this.processWorkflowData();
+    let code = `// Generated Automation Workflow Code
+// Workflow ID: ${workflowData.id}
+// Generated at: ${new Date().toISOString()}
+
+async function executeAutomationWorkflow() {
+  const context = {
+    variables: {},
+    logs: [],
+    errors: [],
+  };
+
+  // Initialize variables
+${
+  workflowData.variables
+    ?.map(
+      (variable) =>
+        `  context.variables['${variable.name}'] = ${JSON.stringify(variable.defaultValue)};`,
+    )
+    .join('\n') || ''
+}
+
+  try {
+`;
+
+    // Generate code for each node
+    workflowData.nodes.forEach((node) => {
+      code += this.generateNodeCode(node.data);
+    });
+
+    code += `
+    return {
+      success: true,
+      context,
+      finalOutput: context.variables,
+    };
+  } catch (error) {
+    context.errors.push({
+      timestamp: new Date().toISOString(),
+      nodeId: 'unknown',
+      error: error.message,
+      stack: error.stack,
+    });
+    
+    return {
+      success: false,
+      context,
+      error: error.message,
+    };
+  }
+}
+
+// Export for use
+module.exports = { executeAutomationWorkflow };
+`;
+
+    return code;
+  }
+
+  /**
+   * Generate JavaScript code for a specific node
+   */
+  private generateNodeCode(formData: AutomationNodeForm): string {
+    let code = `\n    // ${formData.title} (${formData.type})\n`;
+
+    switch (formData.type) {
+      case 'start':
+        code += this.generateStartNodeCode(formData as AutomationStartNodeForm);
+        break;
+      case 'api':
+        code += this.generateApiNodeCode(formData as AutomationApiNodeForm);
+        break;
+      case 'formatting':
+        code += this.generateFormattingNodeCode(
+          formData as AutomationFormattingNodeForm,
+        );
+        break;
+      case 'end':
+        code += this.generateEndNodeCode(formData as AutomationEndNodeForm);
+        break;
+    }
+
+    return code;
+  }
+
+  private generateStartNodeCode(formData: AutomationStartNodeForm): string {
+    return `    // Start Node: ${formData.title}
+    context.logs.push({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      nodeId: '${formData.nodeId}',
+      message: 'Starting automation workflow',
+    });
+
+    // Initialize workflow context
+    ${
+      formData.initialVariables
+        ?.map(
+          (variable) =>
+            `context.variables['${variable.name}'] = ${JSON.stringify(variable.value)};`,
+        )
+        .join('\n    ') || ''
+    }
+
+    context.variables['${formData.outputVariable || 'workflowContext'}'] = {
+      runId: context.variables['runId'] || Date.now().toString(),
+      startTime: context.variables['startTime'] || new Date().toISOString(),
+      triggerType: '${formData.triggerType}',
+    };
+`;
+  }
+
+  private generateApiNodeCode(formData: AutomationApiNodeForm): string {
+    return `    // API Node: ${formData.title}
+    try {
+      context.logs.push({
+        timestamp: new Date().toISOString(),
+        level: 'info',
+        nodeId: '${formData.nodeId}',
+        message: 'Making API call to ${formData.url}',
+      });
+
+      const headers = {
+        ${
+          formData.headers
+            ?.filter((h) => h.enabled)
+            .map((header) => `'${header.key}': '${header.value}',`)
+            .join('\n        ') || ''
+        }
+      };
+
+      const queryParams = new URLSearchParams({
+        ${
+          formData.queryParams
+            ?.filter((p) => p.enabled)
+            .map((param) => `'${param.key}': '${param.value}',`)
+            .join('\n        ') || ''
+        }
+      });
+
+      const url = '${formData.url}' + (queryParams.toString() ? '?' + queryParams.toString() : '');
+      
+      const response = await fetch(url, {
+        method: '${formData.method}',
+        headers,
+        ${formData.body ? `body: ${formData.bodyType === 'json' ? 'JSON.stringify(' + formData.body + ')' : formData.body},` : ''}
+        timeout: ${formData.timeout},
+      });
+
+      if (!response.ok) {
+        throw new Error(\`API call failed: \${response.status} \${response.statusText}\`);
+      }
+
+      const data = await response.json();
+      context.variables['${formData.responseVariable}'] = data;
+      
+      context.logs.push({
+        timestamp: new Date().toISOString(),
+        level: 'info',
+        nodeId: '${formData.nodeId}',
+        message: 'API call completed successfully',
+        data: data,
+      });
+    } catch (error) {
+      context.errors.push({
+        timestamp: new Date().toISOString(),
+        nodeId: '${formData.nodeId}',
+        error: error.message,
+      });
+      ${
+        formData.errorHandling?.onError === 'continue'
+          ? `context.variables['${formData.responseVariable}'] = ${JSON.stringify(formData.errorHandling.fallbackValue)};`
+          : 'throw error;'
+      }
+    }
+`;
+  }
+
+  private generateFormattingNodeCode(
+    formData: AutomationFormattingNodeForm,
+  ): string {
+    return `    // Formatting Node: ${formData.title}
+    try {
+      context.logs.push({
+        timestamp: new Date().toISOString(),
+        level: 'info',
+        nodeId: '${formData.nodeId}',
+        message: 'Processing data formatting',
+      });
+
+      const inputData = context.variables['${formData.inputVariable}'];
+      
+      let formattedData;
+      
+      if ('${formData.formattingType}' === 'ai-powered') {
+        // AI-powered formatting
+        // Validate API key is not a placeholder
+        if (!'${formData.aiFormatting?.apiKey}' || '${formData.aiFormatting?.apiKey}'.includes('your-openai-api-key-here') || '${formData.aiFormatting?.apiKey}'.length < 10) {
+          throw new Error('Invalid API key. Please provide a valid API key.');
+        }
+        
+        // Determine if this is Gemini API or OpenAI API based on URL
+        const isGeminiApi = '${formData.aiFormatting?.apiUrl}'.includes('generativelanguage.googleapis.com');
+        
+        let requestBody;
+        let headers;
+        
+        if (isGeminiApi) {
+          // Gemini API format
+          headers = {
+            'Content-Type': 'application/json',
+            'X-goog-api-key': '${formData.aiFormatting?.apiKey}',
+          };
+          
+          requestBody = {
+            contents: [
+              {
+                parts: [
+                  {
+                    text: \`${formData.aiFormatting?.systemPrompt || 'You are a data formatting assistant.'}\\n\\n${formData.aiFormatting?.instruction}\\n\\nData: \${JSON.stringify(inputData)}\`,
+                  },
+                ],
+              },
+            ],
+            generationConfig: {
+              temperature: ${formData.aiFormatting?.temperature},
+              maxOutputTokens: ${formData.aiFormatting?.maxTokens || 1000},
+              responseMimeType: 'application/json',
+            },
+          };
+        } else {
+          // OpenAI API format
+          headers = {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ${formData.aiFormatting?.apiKey}',
+          };
+          
+          requestBody = {
+            model: '${formData.aiFormatting?.model}',
+            messages: [
+              {
+                role: 'system',
+                content: '${formData.aiFormatting?.systemPrompt || 'You are a data formatting assistant.'}',
+              },
+              {
+                role: 'user',
+                content: \`${formData.aiFormatting?.instruction}\\n\\nData: \${JSON.stringify(inputData)}\`,
+              },
+            ],
+            temperature: ${formData.aiFormatting?.temperature},
+            max_tokens: ${formData.aiFormatting?.maxTokens || 1000},
+          };
+        }
+        
+        const aiResponse = await fetch('${formData.aiFormatting?.apiUrl}', {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(requestBody),
+        });
+
+        if (!aiResponse.ok) {
+          const errorText = await aiResponse.text();
+          throw new Error(\`AI API call failed: \${aiResponse.status} \${aiResponse.statusText}. \${errorText}\`);
+        }
+
+        const aiResult = await aiResponse.json();
+        
+        let content;
+        
+        if (isGeminiApi) {
+          // Gemini API response format
+          if (!aiResult.candidates || !aiResult.candidates[0] || !aiResult.candidates[0].content || !aiResult.candidates[0].content.parts) {
+            throw new Error('Invalid Gemini API response format');
+          }
+          content = aiResult.candidates[0].content.parts[0].text;
+        } else {
+          // OpenAI API response format
+          if (!aiResult.choices || !aiResult.choices[0] || !aiResult.choices[0].message) {
+            throw new Error('Invalid AI API response format');
+          }
+          content = aiResult.choices[0].message.content;
+        }
+        
+        // Try to parse as JSON, fallback to string if parsing fails
+        try {
+          formattedData = JSON.parse(content);
+        } catch {
+          formattedData = content;
+        }
+      } else if ('${formData.formattingType}' === 'template') {
+        // Template-based formatting
+        let template = \`${formData.templateFormatting?.template}\`;
+        ${
+          formData.templateFormatting?.variables
+            ?.map(
+              (variable) =>
+                `template = template.replace(/{{${variable.name}}}/g, context.variables['${variable.source}'] || '');`,
+            )
+            .join('\n        ') || ''
+        }
+        formattedData = JSON.parse(template);
+      } else {
+        // Basic formatting
+        formattedData = inputData;
+        ${
+          formData.basicFormatting?.operations
+            ?.map((operation) => {
+              switch (operation.type) {
+                case 'trim':
+                  return `// Trim fields: ${(operation.config as { fields: string[] }).fields.join(', ')}`;
+                case 'rename':
+                  return `// Rename fields: ${(operation.config as { mappings: Array<{ from: string; to: string }> }).mappings.map((m) => `${m.from} -> ${m.to}`).join(', ')}`;
+                default:
+                  return `// ${operation.type} operation`;
+              }
+            })
+            .join('\n        ') || ''
+        }
+      }
+
+      context.variables['${formData.outputVariable}'] = formattedData;
+      
+      context.logs.push({
+        timestamp: new Date().toISOString(),
+        level: 'info',
+        nodeId: '${formData.nodeId}',
+        message: 'Data formatting completed',
+        data: formattedData,
+      });
+    } catch (error) {
+      context.errors.push({
+        timestamp: new Date().toISOString(),
+        nodeId: '${formData.nodeId}',
+        error: error.message,
+      });
+      throw error;
+    }
+`;
+  }
+
+  private generateEndNodeCode(formData: AutomationEndNodeForm): string {
+    return `    // End Node: ${formData.title}
+    context.logs.push({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      nodeId: '${formData.nodeId}',
+      message: 'Automation workflow completed',
+    });
+
+    // Handle output based on configuration
+    const finalData = context.variables;
+    
+    if ('${formData.outputType}' === 'display') {
+      console.log('Automation Results:', finalData);
+    } else if ('${formData.outputType}' === 'store') {
+      // Store results (implementation depends on storage type)
+      console.log('Storing results to ${formData.storeConfig?.destination}');
+    } else if ('${formData.outputType}' === 'send') {
+      // Send results (implementation depends on send method)
+      console.log('Sending results via ${formData.sendConfig?.method}');
+    } else if ('${formData.outputType}' === 'webhook') {
+      // Send to webhook
+      console.log('Sending results to webhook: ${formData.webhookConfig?.url}');
+    }
+`;
+  }
+
+  /**
+   * Export workflow data as JSON
+   */
+  public exportAsJSON(): string {
+    const workflowData = this.processWorkflowData();
+    return JSON.stringify(workflowData, null, 2);
+  }
+
+  /**
+   * Import workflow data from JSON
+   */
+  public static importFromJSON(jsonString: string): AutomationWorkflowData {
+    return JSON.parse(jsonString) as AutomationWorkflowData;
+  }
+}