@flowuent-org/diagramming-core 1.4.0 → 1.4.2

package/packages/diagrams/src/lib/utils/AutomationExecutionEngine.ts

@@ -0,0 +1,658 @@
+import { Node, Edge } from '@xyflow/react';
+import {
+  AutomationNodeForm,
+  AutomationStartNodeForm,
+  AutomationApiNodeForm,
+  AutomationFormattingNodeForm,
+  AutomationEndNodeForm,
+} from '../types/automation-node-data-types';
+
+export interface AutomationContext {
+  runId: string;
+  startTime: Date;
+  variables: Record<string, string | number | boolean | object | null>;
+  logs: AutomationLog[];
+}
+
+export interface AutomationLog {
+  timestamp: Date;
+  nodeId: string;
+  nodeType: string;
+  level: 'info' | 'warning' | 'error' | 'success';
+  message: string;
+  data?: string | number | boolean | object | null;
+}
+
+export interface AutomationResult {
+  success: boolean;
+  context: AutomationContext;
+  finalOutput?: string | number | boolean | object | null;
+  error?: string;
+}
+
+export class AutomationExecutionEngine {
+  private nodes: Node[];
+  private edges: Edge[];
+  private context: AutomationContext;
+  private onNodeUpdate?: (nodeId: string, updatedData: any) => void;
+  private onLog?: (log: AutomationLog) => void;
+
+  constructor(
+    nodes: Node[],
+    edges: Edge[],
+    onNodeUpdate?: (nodeId: string, updatedData: any) => void,
+    onLog?: (log: AutomationLog) => void,
+  ) {
+    this.nodes = nodes;
+    this.edges = edges;
+    this.onNodeUpdate = onNodeUpdate;
+    this.onLog = onLog;
+    this.context = {
+      runId: this.generateRunId(),
+      startTime: new Date(),
+      variables: {},
+      logs: [],
+    };
+  }
+
+  private generateRunId(): string {
+    return `run_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private storeExecutionResult(
+    nodeId: string,
+    result: string | number | boolean | object | null,
+    success: boolean = true,
+    error?: string,
+    executionTime?: number,
+  ): void {
+    const node = this.nodes.find((n) => n.id === nodeId);
+    if (!node) return;
+
+    const executionResult = {
+      success,
+      data: result,
+      timestamp: new Date().toISOString(),
+      error,
+      executionTime,
+    };
+
+    // Update the node's formData with execution result
+    if (node.data.formData) {
+      (node.data.formData as any).executionResult = executionResult;
+    } else {
+      (node.data as any).executionResult = executionResult;
+    }
+
+    // Notify the parent component about the node update
+    if (this.onNodeUpdate) {
+      // Create new object reference with deep clone of formData so React detects the change
+      const updatedData = {
+        ...node.data,
+        ...(node.data.formData ? { formData: { ...node.data.formData } } : {}),
+      };
+      this.onNodeUpdate(nodeId, updatedData);
+    }
+  }
+
+  private log(
+    level: AutomationLog['level'],
+    nodeId: string,
+    nodeType: string,
+    message: string,
+    data?: string | number | boolean | object | null,
+  ) {
+    const entry: AutomationLog = {
+      timestamp: new Date(),
+      nodeId,
+      nodeType,
+      level,
+      message,
+      data,
+    };
+    this.context.logs.push(entry);
+    if (this.onLog) {
+      try {
+        this.onLog(entry);
+      } catch {
+        // ignore UI callback errors
+      }
+    }
+  }
+
+  private getNextNodes(currentNodeId: string): Node[] {
+    const outgoingEdges = this.edges.filter(
+      (edge) => edge.source === currentNodeId,
+    );
+    const nextNodeIds = outgoingEdges.map((edge) => edge.target);
+    return this.nodes.filter((node) => nextNodeIds.includes(node.id));
+  }
+
+  private async executeStartNode(
+    node: Node,
+  ): Promise<{ runId: string; startTime: string }> {
+    const data = node.data;
+    this.log(
+      'info',
+      node.id,
+      'AutomationStartNode',
+      'Starting automation workflow',
+    );
+
+    // Set initial context variables
+    this.context.variables.runId = this.context.runId;
+    this.context.variables.startTime = this.context.startTime.toISOString();
+
+    const result = {
+      runId: this.context.runId,
+      startTime: this.context.startTime.toISOString(),
+    };
+
+    // Store the execution result in node data
+    this.storeExecutionResult(node.id, result, true);
+
+    return result;
+  }
+
+  private async executeApiNode(node: Node): Promise<object> {
+    const data = node.data;
+    const formData = (data.formData || data) as AutomationApiNodeForm;
+
+    this.log(
+      'info',
+      node.id,
+      'AutomationApiNode',
+      `Making ${formData.method} request to ${formData.url}`,
+    );
+
+    try {
+      const headers: Record<string, string> = {};
+      if (formData.headers && Array.isArray(formData.headers)) {
+        formData.headers.forEach((header) => {
+          if (header.enabled) {
+            headers[header.key] = header.value;
+          }
+        });
+      }
+
+      const queryParams = new URLSearchParams();
+      if (formData.queryParams && Array.isArray(formData.queryParams)) {
+        formData.queryParams.forEach((param) => {
+          if (param.enabled) {
+            queryParams.append(param.key, param.value);
+          }
+        });
+      }
+
+      const url = queryParams.toString()
+        ? `${formData.url}?${queryParams.toString()}`
+        : formData.url;
+
+      const requestOptions: RequestInit = {
+        method: formData.method,
+        headers,
+        signal: AbortSignal.timeout(formData.timeout || 30000),
+      };
+
+      if (
+        formData.body &&
+        (formData.method === 'POST' || formData.method === 'PUT')
+      ) {
+        requestOptions.body = formData.body;
+      }
+
+      const response = await fetch(url, requestOptions);
+
+      if (!response.ok) {
+        throw new Error(
+          `HTTP ${response.status}: ${response.statusText} - ${url}`,
+        );
+      }
+
+      const responseData = await response.json();
+      this.log(
+        'success',
+        node.id,
+        'AutomationApiNode',
+        'API call completed successfully',
+        responseData,
+      );
+
+      // Store the execution result in node data
+      this.storeExecutionResult(node.id, responseData, true);
+
+      return responseData;
+    } catch (error) {
+      let errorMessage = `API call failed: ${error}`;
+
+      if (error instanceof TypeError && error.message.includes('fetch')) {
+        errorMessage = `Network error: Unable to connect to ${formData.url}. This might be due to CORS restrictions or network connectivity issues.`;
+      }
+
+      this.log(
+        'error',
+        node.id,
+        'AutomationApiNode',
+        errorMessage,
+        error instanceof Error ? error.message : String(error),
+      );
+
+      // Store the error result in node data
+      this.storeExecutionResult(node.id, null, false, errorMessage);
+
+      throw new Error(errorMessage);
+    }
+  }
+
+  private async executeFormattingNode(
+    node: Node,
+    inputData: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    const data = node.data;
+    const formData = (data.formData || data) as AutomationFormattingNodeForm;
+
+    this.log(
+      'info',
+      node.id,
+      'AutomationFormattingNode',
+      'Starting data formatting',
+    );
+
+    try {
+      if (formData.formattingType === 'ai-powered' && formData.aiFormatting) {
+        // AI-powered formatting
+        this.log('info', node.id, 'AutomationFormattingNode', 'AI thinking...');
+        const aiResponse = await this.callAiApi(
+          formData.aiFormatting,
+          inputData,
+        );
+        this.log(
+          'success',
+          node.id,
+          'AutomationFormattingNode',
+          'AI formatting completed',
+          aiResponse,
+        );
+
+        // Store the execution result in node data
+        this.storeExecutionResult(node.id, aiResponse, true);
+
+        return aiResponse;
+      } else {
+        // Basic formatting
+        const formattedData = this.basicFormatting(inputData, formData);
+        this.log(
+          'success',
+          node.id,
+          'AutomationFormattingNode',
+          'Basic formatting completed',
+          formattedData,
+        );
+
+        // Store the execution result in node data
+        this.storeExecutionResult(node.id, formattedData, true);
+
+        return formattedData;
+      }
+    } catch (error) {
+      this.log(
+        'error',
+        node.id,
+        'AutomationFormattingNode',
+        `Formatting failed: ${error}`,
+        error instanceof Error ? error.message : String(error),
+      );
+
+      // Store the error result in node data
+      this.storeExecutionResult(
+        node.id,
+        null,
+        false,
+        error instanceof Error ? error.message : String(error),
+      );
+
+      throw error;
+    }
+  }
+
+  private async callAiApi(
+    aiConfig: NonNullable<AutomationFormattingNodeForm['aiFormatting']>,
+    inputData: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    // Validate API key is not a placeholder
+    if (
+      !aiConfig.apiKey ||
+      aiConfig.apiKey.includes('your-openai-api-key-here') ||
+      aiConfig.apiKey.length < 10
+    ) {
+      throw new Error('Invalid API key. Please provide a valid API key.');
+    }
+
+    // Additional validation for Gemini API key format
+    if (aiConfig.apiUrl.includes('generativelanguage.googleapis.com')) {
+      if (!aiConfig.apiKey.startsWith('AIza')) {
+        throw new Error(
+          'Invalid Gemini API key format. Gemini API keys should start with "AIza".',
+        );
+      }
+    }
+
+    const prompt = `${aiConfig.instruction}\n\nInput data: ${JSON.stringify(inputData)}`;
+
+    // Determine if this is Gemini API or OpenAI API based on URL
+    const isGeminiApi = aiConfig.apiUrl.includes(
+      'generativelanguage.googleapis.com',
+    );
+
+    let requestBody: any;
+    let headers: Record<string, string>;
+
+    if (isGeminiApi) {
+      // Gemini API format
+      headers = {
+        'Content-Type': 'application/json',
+        'X-goog-api-key': aiConfig.apiKey,
+      };
+
+      requestBody = {
+        contents: [
+          {
+            parts: [
+              {
+                text: `${aiConfig.systemPrompt || 'You are a data formatting assistant.'}\n\n${prompt}`,
+              },
+            ],
+          },
+        ],
+        generationConfig: {
+          temperature: aiConfig.temperature || 0.1,
+          maxOutputTokens: aiConfig.maxTokens || 1000,
+          responseMimeType: 'application/json',
+        },
+      };
+    } else {
+      // OpenAI API format
+      headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${aiConfig.apiKey}`,
+      };
+
+      requestBody = {
+        model: aiConfig.model,
+        messages: [
+          {
+            role: 'system',
+            content:
+              aiConfig.systemPrompt || 'You are a data formatting assistant.',
+          },
+          {
+            role: 'user',
+            content: prompt,
+          },
+        ],
+        temperature: aiConfig.temperature || 0.1,
+        max_tokens: aiConfig.maxTokens || 1000,
+      };
+    }
+
+    const response = await fetch(aiConfig.apiUrl, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `AI API call failed: ${response.status} ${response.statusText}. ${errorText}`,
+      );
+    }
+
+    const result = await response.json();
+
+    let content: string;
+
+    if (isGeminiApi) {
+      // Gemini API response format
+      if (
+        !result.candidates ||
+        !result.candidates[0] ||
+        !result.candidates[0].content ||
+        !result.candidates[0].content.parts
+      ) {
+        throw new Error('Invalid Gemini API response format');
+      }
+      content = result.candidates[0].content.parts[0].text;
+    } else {
+      // OpenAI API response format
+      if (!result.choices || !result.choices[0] || !result.choices[0].message) {
+        throw new Error('Invalid AI API response format');
+      }
+      content = result.choices[0].message.content;
+    }
+
+    // Try to parse as JSON, fallback to string if parsing fails
+    try {
+      return JSON.parse(content);
+    } catch {
+      return content;
+    }
+  }
+
+  private basicFormatting(
+    inputData: string | number | boolean | object | null,
+    config: AutomationFormattingNodeForm,
+  ): string | number | boolean | object | null {
+    // Basic data transformation logic
+    if (typeof inputData === 'string') {
+      return inputData.trim();
+    }
+
+    if (Array.isArray(inputData)) {
+      return inputData.map((item) => this.basicFormatting(item, config));
+    }
+
+    if (typeof inputData === 'object' && inputData !== null) {
+      const formatted: Record<string, unknown> = {};
+      Object.keys(inputData).forEach((key) => {
+        formatted[key] = this.basicFormatting(
+          (inputData as Record<string, unknown>)[key] as
+            | string
+            | number
+            | boolean
+            | object
+            | null,
+          config,
+        );
+      });
+      return formatted;
+    }
+
+    return inputData;
+  }
+
+  private async executeEndNode(
+    node: Node,
+    inputData: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    const data = node.data;
+    const formData = (data.formData || data) as AutomationEndNodeForm;
+
+    this.log(
+      'info',
+      node.id,
+      'AutomationEndNode',
+      'Workflow completed successfully',
+    );
+
+    // Handle different output types
+    switch (formData.outputType) {
+      case 'display':
+        this.log(
+          'info',
+          node.id,
+          'AutomationEndNode',
+          'Output displayed in UI',
+          inputData,
+        );
+        break;
+      case 'store':
+        this.log(
+          'info',
+          node.id,
+          'AutomationEndNode',
+          'Data stored to destination',
+          inputData,
+        );
+        break;
+      case 'send':
+        this.log(
+          'info',
+          node.id,
+          'AutomationEndNode',
+          'Data sent to destination',
+          inputData,
+        );
+        break;
+    }
+
+    // Store the execution result in node data
+    this.storeExecutionResult(node.id, inputData, true);
+
+    return inputData;
+  }
+
+  private async executeNode(
+    node: Node,
+    inputData?: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    const nodeType = node.type;
+
+    switch (nodeType) {
+      case 'AutomationStartNode':
+        return await this.executeStartNode(node);
+      case 'AutomationApiNode':
+        return await this.executeApiNode(node);
+      case 'AutomationFormattingNode':
+        return await this.executeFormattingNode(node, inputData || null);
+      case 'AutomationEndNode':
+        return await this.executeEndNode(node, inputData || null);
+      default:
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+  }
+
+  public async executeWorkflow(): Promise<AutomationResult> {
+    try {
+      // Find start node
+      const startNode = this.nodes.find(
+        (node) => node.type === 'AutomationStartNode',
+      );
+      if (!startNode) {
+        throw new Error('No start node found in workflow');
+      }
+
+      this.log('info', 'workflow', 'engine', 'Starting workflow execution');
+
+      // Execute nodes in sequence
+      let currentNode: Node | null = startNode;
+      let currentData: string | number | boolean | object | null = null;
+      const visitedNodes = new Set<string>();
+
+      while (currentNode) {
+        if (visitedNodes.has(currentNode.id)) {
+          throw new Error(
+            `Circular dependency detected: node ${currentNode.id} already visited`,
+          );
+        }
+
+        visitedNodes.add(currentNode.id);
+
+        // Announce node execution start
+        this.log(
+          'info',
+          currentNode.id,
+          String(currentNode.type || 'node'),
+          'Executing node...',
+        );
+
+        // Update node status to running
+        (currentNode.data as Record<string, unknown>).status = 'Running';
+        if (this.onNodeUpdate) {
+          // Create new object reference so React detects the change
+          this.onNodeUpdate(currentNode.id, { ...currentNode.data });
+        }
+
+        try {
+          currentData = await this.executeNode(currentNode, currentData);
+          (currentNode.data as Record<string, unknown>).status = 'Completed';
+          (currentNode.data as Record<string, unknown>).lastRun =
+            new Date().toISOString();
+          if (this.onNodeUpdate) {
+            // Create new object reference so React detects the change
+            this.onNodeUpdate(currentNode.id, { ...currentNode.data });
+          }
+        } catch (error) {
+          (currentNode.data as Record<string, unknown>).status = 'Error';
+          (currentNode.data as Record<string, unknown>).lastRun =
+            new Date().toISOString();
+          if (this.onNodeUpdate) {
+            // Create new object reference so React detects the change
+            this.onNodeUpdate(currentNode.id, { ...currentNode.data });
+          }
+          throw error;
+        }
+
+        // Find next node
+        const nextNodes = this.getNextNodes(currentNode.id);
+        if (nextNodes.length > 0) {
+          const next = nextNodes[0];
+          this.log(
+            'info',
+            next.id,
+            String(next.type || 'node'),
+            'Moving to next node',
+          );
+          currentNode = next;
+        } else {
+          this.log('info', 'workflow', 'engine', 'No next node. Ending.');
+          currentNode = null;
+        }
+      }
+
+      this.log(
+        'success',
+        'workflow',
+        'engine',
+        'Workflow execution completed successfully',
+      );
+
+      return {
+        success: true,
+        context: this.context,
+        finalOutput: currentData,
+      };
+    } catch (error) {
+      this.log(
+        'error',
+        'workflow',
+        'engine',
+        `Workflow execution failed: ${error}`,
+      );
+
+      return {
+        success: false,
+        context: this.context,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  public getLogs(): AutomationLog[] {
+    return this.context.logs;
+  }
+
+  public getContext(): AutomationContext {
+    return this.context;
+  }
+}

package/packages/diagrams/src/lib/utils/add-new-block.ts

@@ -0,0 +1,34 @@
+import { IBlock, ICardNode } from '../types/card-node';
+import { v4 as uuidv4 } from 'uuid';
+import { GenerateNewNodeProps } from './helpers.types';
+
+export function generateNewNodes({
+  title,
+  color,
+  data,
+  nodes,
+  type,
+}: GenerateNewNodeProps) {
+  const newBLock: IBlock = {
+    color,
+    id: uuidv4(),
+    title,
+    type,
+  };
+
+  const newNodes: ICardNode[] = nodes.map((node) => {
+    if (node.id === data.nodeId) {
+      return {
+        ...node,
+        data: {
+          ...node.data,
+          blocks: [...(node.data.blocks || []), newBLock],
+        },
+      };
+    } else {
+      return node;
+    }
+  });
+
+  return { newBLock, newNodes };
+}