@flowuent-org/diagramming-core 1.1.0 → 1.1.2

package/packages/diagrams/src/lib/utils/flow-to-js.ts

@@ -0,0 +1,1465 @@
+import { Edge } from '@xyflow/react';
+import { ICardNode as _ICardNode } from '../types/card-node';
+import { FunctionParameter } from '../templates/node-forms/FunctionForm';
+import {
+  Expression,
+  OperationExpression,
+} from '../types/workflow-node-data-types';
+import { CallFormData } from '../types/function-execution';
+import { RuleGroup } from '../types/condition-builder';
+
+type ICardNode = _ICardNode;
+
+export interface MiddleSchema {
+  id?: string;
+  true?: (MiddleSchema | undefined)[];
+  false?: (MiddleSchema | undefined)[];
+  body?: (MiddleSchema | undefined)[];
+  type: string;
+  variable?: Expression;
+  value?: Expression;
+  condition?: Expression;
+  conditions?: RuleGroup; // Add support for multiple conditions
+  parameters?: (string | FunctionParameter)[];
+  name?: string;
+  customCode?: string;
+  bindings?: [string, Expression][];
+  mode?: 'simple' | 'object' | 'code'; // Add mode for let node
+  objectDefinition?: any; // Add object definition for let node
+  catchBlock?: MiddleSchema;
+  init?: string;
+  update?: string;
+  switchValue?: string;
+  errorVar?: string;
+  title?: string;
+  dataType?: string;
+  valueDataType?: string;
+  conditionDataType?: string;
+  initDataType?: string;
+  updateDataType?: string;
+  // Add function call specific fields
+  functionName?: string;
+  args?: Array<{ name: string; value: string; dataType?: string }>;
+  returnValueName?: string;
+  returnValueDataType?: string;
+  // Add flag to identify function call nodes
+  isFunctionCall?: boolean;
+  // Add API node specific fields
+  method?: string;
+  url?: string;
+  headers?: Array<{ key: string; value: string; enabled: boolean }>;
+  queryParams?: Array<{ key: string; value: string; enabled: boolean }>;
+  requestBody?: string;
+  bodyType?: string;
+  responseVariable?: string;
+  responseDataType?: string;
+  // Add GraphQL node specific fields
+  graphqlMode?: string;
+  operationType?: string;
+  operationName?: string;
+  rootField?: string;
+  arguments?: Array<{ key: string; value: string }>;
+  fields?: Array<{ name: string; subFields?: Array<{ name: string }> }>;
+  variables?: Array<{ key: string; value: string; type: string }>;
+  customQuery?: string;
+}
+
+export const flowToCode = (json: { nodes: ICardNode[]; edges: Edge[] }) => {
+  const externalFunctions: string[] = [];
+  // Clone the JSON without processed flag
+  const clonedJson = {
+    nodes: json.nodes.map((node) => ({ ...node })),
+    edges: json.edges.map((edge) => ({ ...edge })),
+  };
+
+  // Track processed nodes to prevent duplicates
+  const processedNodes = new Set<string>();
+
+  // --- Move processNode and createBlockFlow above jsonToJavaScript for scope ---
+  const processNode = (
+    n: ICardNode,
+    visited: Set<string>,
+  ): MiddleSchema | undefined => {
+    if (!n || visited.has(n.id) || processedNodes.has(n.id)) return;
+    visited.add(n.id);
+    processedNodes.add(n.id);
+
+    // Determine the node type based on data structure
+    let nodeType = n.data.formData?.type || n.data.type || 'emptyNode';
+
+    // Check if this is a function call node based on data structure
+    let isFunctionCall = false;
+    if (
+      n.data.formData &&
+      ('functionName' in n.data.formData || 'args' in n.data.formData)
+    ) {
+      isFunctionCall = true;
+    }
+
+    const res: MiddleSchema = {
+      id: n.id,
+      type: nodeType,
+      title: n.data.title,
+      isFunctionCall,
+    };
+
+    // Debug type assignment for function nodes
+    if (n.data.formData?.type === 'function') {
+      console.log('Function node type assignment:', {
+        id: n.id,
+        title: n.data.title,
+        formDataType: n.data.formData?.type,
+        dataType: n.data.type,
+        assignedType: res.type,
+      });
+    }
+
+    // Add compatible properties from formData based on node type
+    if (n.data.formData) {
+      const formData = n.data.formData;
+
+      // Add properties that are directly compatible with MiddleSchema
+      if ('name' in formData) res.name = formData.name as string;
+      if ('parameters' in formData) {
+        // Handle both old string[] format and new FunctionParameter[] format
+        const params = formData.parameters;
+        if (Array.isArray(params)) {
+          if (params.length > 0 && typeof params[0] === 'string') {
+            // Old format: string[]
+            res.parameters = params as (string | FunctionParameter)[];
+          } else if (
+            params.length > 0 &&
+            typeof params[0] === 'object' &&
+            'name' in params[0]
+          ) {
+            // New format: FunctionParameter[]
+            res.parameters = params as (string | FunctionParameter)[];
+          }
+        }
+      }
+      if ('variable' in formData)
+        res.variable = formData.variable as Expression;
+      if ('value' in formData) res.value = formData.value as Expression;
+      if ('condition' in formData)
+        res.condition = formData.condition as Expression;
+      if ('bindings' in formData)
+        res.bindings = formData.bindings as [string, Expression][];
+      if ('mode' in formData)
+        res.mode = formData.mode as 'simple' | 'object' | 'code';
+      if ('objectDefinition' in formData)
+        res.objectDefinition = formData.objectDefinition as any;
+      if ('customCode' in formData) {
+        res.customCode = formData.customCode as string;
+        if (formData.type === 'function') {
+          console.log('Extracted custom code from function formData:', {
+            functionName: res.name,
+            customCode: res.customCode,
+            customCodeLength: res.customCode?.length,
+          });
+        }
+      }
+      if ('init' in formData) {
+        if (typeof formData.init === 'string') {
+          res.init = formData.init;
+        } else if (
+          typeof formData.init === 'object' &&
+          'operation' in formData.init
+        ) {
+          // Convert operation expression to string representation
+          const op = formData.init as { operation: string; operands: string[] };
+          // Handle special operators that need different formatting
+          switch (op.operation) {
+            case '=':
+              // Assignment operator - no parentheses needed
+              res.init =
+                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
+              break;
+            case '==':
+            case '!=':
+              // Equality operators - use parentheses for clarity
+              res.init =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+              break;
+            default:
+              // All other operators - use parentheses
+              res.init =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+          }
+        }
+      }
+      if ('update' in formData) {
+        if (typeof formData.update === 'string') {
+          res.update = formData.update;
+        } else if (
+          typeof formData.update === 'object' &&
+          'operation' in formData.update
+        ) {
+          // Convert operation expression to string representation
+          const op = formData.update as {
+            operation: string;
+            operands: string[];
+          };
+          // Handle special operators that need different formatting
+          switch (op.operation) {
+            case '=':
+              // Assignment operator - no parentheses needed
+              res.update =
+                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
+              break;
+            case '==':
+            case '!=':
+              // Equality operators - use parentheses for clarity
+              res.update =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+              break;
+            default:
+              // All other operators - use parentheses
+              res.update =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+          }
+        }
+      }
+      if ('switchValue' in formData) {
+        if (typeof formData.switchValue === 'string') {
+          res.switchValue = formData.switchValue;
+        } else if (
+          typeof formData.switchValue === 'object' &&
+          'operation' in formData.switchValue
+        ) {
+          // Convert operation expression to string representation
+          const op = formData.switchValue as {
+            operation: string;
+            operands: string[];
+          };
+          // Handle special operators that need different formatting
+          switch (op.operation) {
+            case '=':
+              // Assignment operator - no parentheses needed
+              res.switchValue =
+                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
+              break;
+            case '==':
+            case '!=':
+              // Equality operators - use parentheses for clarity
+              res.switchValue =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+              break;
+            default:
+              // All other operators - use parentheses
+              res.switchValue =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+          }
+        }
+      }
+      if ('errorVar' in formData) res.errorVar = formData.errorVar as string;
+      if ('dataType' in formData) res.dataType = formData.dataType as string;
+      if ('valueDataType' in formData)
+        res.valueDataType = formData.valueDataType as string;
+      if ('conditionDataType' in formData)
+        res.conditionDataType = formData.conditionDataType as string;
+      if ('initDataType' in formData)
+        res.initDataType = formData.initDataType as string;
+      if ('updateDataType' in formData)
+        res.updateDataType = formData.updateDataType as string;
+
+      // Handle function call specific properties
+      if ('functionName' in formData)
+        res.functionName = formData.functionName as string;
+      if ('args' in formData) {
+        res.args = (
+          formData.args as Array<{
+            name: string;
+            value: string | { operation: string; operands: string[] };
+            dataType?: string;
+          }>
+        ).map((arg) => ({
+          name: arg.name,
+          value:
+            typeof arg.value === 'string'
+              ? arg.value
+              : (() => {
+                  const op = arg.value as {
+                    operation: string;
+                    operands: string[];
+                  };
+                  // Handle special operators that need different formatting
+                  switch (op.operation) {
+                    case '=':
+                      // Assignment operator - no parentheses needed
+                      return `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
+                    case '==':
+                    case '!=':
+                      // Equality operators - use parentheses for clarity
+                      return `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+                    default:
+                      // All other operators - use parentheses
+                      return `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+                  }
+                })(),
+          dataType: arg.dataType,
+        }));
+      }
+      if ('returnValueName' in formData && formData.returnValueName) {
+        if (typeof formData.returnValueName === 'string') {
+          res.returnValueName = formData.returnValueName;
+        } else if (
+          typeof formData.returnValueName === 'object' &&
+          'operation' in formData.returnValueName
+        ) {
+          // Convert operation expression to string representation
+          const op = formData.returnValueName as {
+            operation: string;
+            operands: string[];
+          };
+          // Handle special operators that need different formatting
+          switch (op.operation) {
+            case '=':
+              // Assignment operator - no parentheses needed
+              res.returnValueName =
+                `${op.operands[0] || ''} = ${op.operands[1] || ''}`.trim();
+              break;
+            case '==':
+            case '!=':
+              // Equality operators - use parentheses for clarity
+              res.returnValueName =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+              break;
+            default:
+              // All other operators - use parentheses
+              res.returnValueName =
+                `(${op.operands[0] || ''} ${op.operation} ${op.operands[1] || ''})`.trim();
+          }
+        }
+      }
+      if ('returnValueDataType' in formData)
+        res.returnValueDataType = formData.returnValueDataType as string;
+
+      // Handle API node specific properties
+      if ('method' in formData) res.method = formData.method as string;
+      if ('url' in formData) res.url = formData.url as string;
+      if ('headers' in formData)
+        res.headers = formData.headers as Array<{
+          key: string;
+          value: string;
+          enabled: boolean;
+        }>;
+      if ('queryParams' in formData)
+        res.queryParams = formData.queryParams as Array<{
+          key: string;
+          value: string;
+          enabled: boolean;
+        }>;
+      if ('body' in formData) res.requestBody = formData.body as string;
+      if ('bodyType' in formData) res.bodyType = formData.bodyType as string;
+      if ('responseVariable' in formData)
+        res.responseVariable = formData.responseVariable as string;
+      if ('responseDataType' in formData)
+        res.responseDataType = formData.responseDataType as string;
+
+      // Handle GraphQL node specific properties
+      if ('mode' in formData) res.graphqlMode = formData.mode as string;
+      if ('operationType' in formData)
+        res.operationType = formData.operationType as string;
+      if ('operationName' in formData)
+        res.operationName = formData.operationName as string;
+      if ('rootField' in formData) res.rootField = formData.rootField as string;
+      if ('arguments' in formData)
+        res.arguments = formData.arguments as Array<{
+          key: string;
+          value: string;
+        }>;
+      if ('fields' in formData)
+        res.fields = formData.fields as Array<{
+          name: string;
+          subFields?: Array<{
+            name: string;
+          }>;
+        }>;
+      if ('variables' in formData)
+        res.variables = formData.variables as Array<{
+          key: string;
+          value: string;
+          type: string;
+        }>;
+      if ('customQuery' in formData)
+        res.customQuery = formData.customQuery as string;
+    }
+
+    // Handle conditions from node data (RuleGroup format)
+    if (n.data.conditions) {
+      res.conditions = n.data.conditions as RuleGroup;
+    }
+
+    // Handle branch nodes (true/false cases)
+    const isBranchRoot = n.data.branchRoot === n.id;
+    if (isBranchRoot) {
+      const trueCase = clonedJson.nodes.find(
+        (node: ICardNode) => n.data.trueCase === node.id,
+      );
+      if (trueCase) {
+        res.true = createBlockFlow(trueCase, visited);
+      }
+      const falseCase = clonedJson.nodes.find(
+        (node: ICardNode) => n.data.falseCase === node.id,
+      );
+      if (falseCase) {
+        res.false = createBlockFlow(falseCase, visited);
+      }
+    }
+
+    // Handle try/catch nodes
+    if (n.data.type === 'try') {
+      // Only process catch block via edges if we don't already have child nodes
+      // Child nodes are processed above in the general child node handling
+      if (!res.body || res.body.length === 0) {
+        // Outgoing edges: one to body, one to catch
+        const outgoingEdges = clonedJson.edges.filter(
+          (edge: Edge) => edge.source === n.id,
+        );
+
+        // Body edge: not to a catch node
+        const bodyEdge = outgoingEdges.find((edge: Edge) => {
+          const targetNode = clonedJson.nodes.find(
+            (node: ICardNode) => node.id === edge.target,
+          );
+          return targetNode && targetNode.data.type !== 'catch';
+        });
+        if (bodyEdge) {
+          const bodyNode = clonedJson.nodes.find(
+            (node: ICardNode) => node.id === bodyEdge.target,
+          );
+          if (bodyNode) {
+            res.body = createBlockFlow(bodyNode, visited);
+          }
+        }
+      }
+
+      // Catch edge: to a catch node
+      const catchEdge = clonedJson.edges.find((edge: Edge) => {
+        return (
+          edge.source === n.id &&
+          clonedJson.nodes.find(
+            (node: ICardNode) =>
+              node.id === edge.target && node.data.type === 'catch',
+          )
+        );
+      });
+      if (catchEdge) {
+        const catchNode = clonedJson.nodes.find(
+          (node: ICardNode) => node.id === catchEdge.target,
+        );
+        if (catchNode) {
+          // Create a new visited set for the catch node to avoid conflicts
+          const catchVisited = new Set(visited);
+          // Remove the catch node from visited set if it's already there
+          catchVisited.delete(catchNode.id);
+          res.catchBlock = processNode(catchNode, catchVisited);
+        }
+      }
+    }
+
+    // Handle switch/case nodes
+    if (n.data.type === 'switch' || n.data.formData?.type === 'switch') {
+      // All outgoing edges are to case or default nodes
+      const caseEdges = clonedJson.edges.filter(
+        (edge: Edge) => edge.source === n.id,
+      );
+
+      // Create case node schemas directly without calling processNode to avoid conflicts
+      res.body = caseEdges
+        .map((edge: Edge) => {
+          const caseNode = clonedJson.nodes.find(
+            (node: ICardNode) => edge.target === node.id,
+          );
+          if (caseNode) {
+            // Create case node schema directly
+            const caseSchema: MiddleSchema = {
+              id: caseNode.id,
+              type: 'case',
+              title: caseNode.data.title || '',
+            };
+
+            const caseChildNodes = clonedJson.nodes.filter(
+              (childNode: ICardNode) => {
+                return childNode.parentId === caseNode.id;
+              },
+            );
+
+            if (caseChildNodes.length > 0) {
+              // Process child nodes as body of the case
+              caseSchema.body = caseChildNodes
+                .map((childNode) => processNode(childNode, visited))
+                .filter(Boolean);
+            }
+
+            return caseSchema;
+          }
+          return undefined;
+        })
+        .filter(Boolean);
+    }
+
+    // Handle nodes that can have child nodes (nested scope)
+    // These are nodes that can contain other nodes within their scope
+    if (['forLoop', 'loop', 'catch', 'try'].includes(n.data.type || '')) {
+      // Find child nodes (nodes that have this node as parent)
+      const childNodes = clonedJson.nodes.filter((node: ICardNode) => {
+        return node.parentId === n.id;
+      });
+
+      if (childNodes.length > 0) {
+        // Process child nodes as body of this node
+        res.body = childNodes
+          .map((childNode) => processNode(childNode, visited))
+          .filter(Boolean);
+      }
+    }
+
+    return res;
+  };
+
+  const createBlockFlow = (
+    firstNode: ICardNode,
+    visited: Set<string>,
+    stopAtFunctions: boolean = false,
+  ): (MiddleSchema | undefined)[] => {
+    const flow: (MiddleSchema | undefined)[] = [];
+    let currentNode: ICardNode | undefined = firstNode;
+
+    while (currentNode) {
+      // Skip catch nodes in linear flow - they should only be processed by try nodes
+      if (currentNode.data.type === 'catch') {
+        break;
+      }
+
+      // Stop if we encounter another function node (when stopAtFunctions is true)
+      if (stopAtFunctions && currentNode.data.formData?.type === 'function') {
+        break;
+      }
+
+      // Skip if already processed
+      if (processedNodes.has(currentNode.id)) {
+        break;
+      }
+
+      const nodeResult = processNode(currentNode, visited);
+      if (!nodeResult) break;
+      flow.push(nodeResult);
+
+      // Find next node in the flow (edge-connected, same level)
+      let edgesNext = clonedJson.edges.filter(
+        (edge: Edge) => edge.source === currentNode?.id,
+      );
+
+      // Handle branch final node
+      const isBranchRoot: boolean =
+        currentNode.data.branchRoot === currentNode.id;
+      let finalNodeId: ICardNode | undefined =
+        isBranchRoot && currentNode.data.finalNodeId
+          ? clonedJson.nodes.find(
+              (n: ICardNode) => currentNode?.data.finalNodeId === n.id,
+            )
+          : undefined;
+
+      if (finalNodeId) {
+        currentNode = finalNodeId;
+        continue;
+      }
+
+      // Follow edge to next node (same level)
+      if (edgesNext.length === 1) {
+        const edge = edgesNext[0];
+        const nextNode = clonedJson.nodes.find(
+          (node: ICardNode) => edge.target === node.id,
+        );
+        if (nextNode) {
+          const previousEdgesOfNextNode = clonedJson.edges.filter(
+            (edge: Edge) => edge.target === nextNode?.id,
+          );
+          if (previousEdgesOfNextNode.length === 1) {
+            currentNode = nextNode;
+            continue;
+          }
+        }
+      }
+      break;
+    }
+    return flow;
+  };
+
+  // Helper function to find nodes that belong to a specific function
+  const findNodesBelongingToFunction = (
+    functionNode: ICardNode,
+    allNodes: ICardNode[],
+    allEdges: Edge[],
+    excludedFunctionIds: string[],
+  ): (MiddleSchema | undefined)[] => {
+    // Find the first node that's connected to this function
+    const firstConnectedNode = allEdges
+      .filter((edge) => edge.source === functionNode.id)
+      .map((edge) => allNodes.find((n) => n.id === edge.target))
+      .find((node) => node && node.data.formData?.type !== 'function');
+
+    if (!firstConnectedNode) {
+      return [];
+    }
+
+    // Use createBlockFlow to get the proper flow of nodes
+    // This will handle all the control structures and nested flows correctly
+    const visited = new Set<string>();
+    visited.add(functionNode.id); // Mark function node as visited to avoid processing it
+
+    const result = createBlockFlow(firstConnectedNode, visited, true); // Stop at functions to prevent overlap
+
+    return result;
+  };
+
+  function jsonToJavaScript(json: MiddleSchema) {
+    function parseNode(node: MiddleSchema): string {
+      switch (node.type) {
+        case 'emptyNode':
+          return '';
+        case 'function':
+          return parseFunction(node);
+        case 'call':
+          return parseCall(node);
+        case 'branch':
+          return parseBranch(node);
+        case 'let':
+          return parseLet(node);
+        case 'loop':
+          return parseLoop(node);
+        case 'forLoop':
+          return parseForLoop(node);
+        case 'set':
+          return parseSet(node);
+        case 'return':
+          return parseReturn(node);
+        case 'try':
+          return parseTry(node);
+        case 'catch':
+          return parseCatch(node);
+        case 'switch':
+          return parseSwitch(node);
+        case 'case':
+          return parseCaseNode(node);
+        case 'api':
+          return parseApi(node);
+        case 'graphql':
+          return parseGraphQL(node);
+        default:
+          // Check if this node has function call properties even if type is not 'call'
+          if (node.isFunctionCall || (node.functionName && node.args)) {
+            return parseCall(node);
+          }
+          throw new Error(`Unknown node type: ${node.type}`);
+      }
+    }
+
+    const parseCall = (node: MiddleSchema): string => {
+      // Extract function call data from the node
+      const functionName = node.functionName || 'unknownFunction';
+      const args = node.args || [];
+      const returnValueName = node.returnValueName || '';
+
+      // Extract arguments' values, providing a default empty string if value is undefined
+      const argValues = args.map(
+        (arg: { name: string; value: string; dataType?: string }) => {
+          // If the value is empty, use the name as a variable reference
+          if (arg.value && arg.value.trim() !== '') {
+            // Format the value based on data type
+            const value = arg.value.trim();
+            const dataType = arg.dataType || 'String';
+
+            switch (dataType) {
+              case 'String':
+              case 'STRING':
+              case 'CHAR':
+              case 'TEXT':
+                // For string types, always wrap in quotes unless it's already quoted
+                if (
+                  (value.startsWith('"') && value.endsWith('"')) ||
+                  (value.startsWith("'") && value.endsWith("'"))
+                ) {
+                  return value; // Already quoted
+                }
+                return `'${value}'`;
+              case 'Number':
+              case 'INT':
+              case 'FLOAT':
+                // For number types, ensure it's not quoted
+                return value;
+              case 'Boolean':
+              case 'BOOLEAN':
+                // For boolean types, ensure it's not quoted
+                return value;
+              case 'Object':
+                // For object type, try to parse as JSON or wrap in quotes if it's a string
+                try {
+                  JSON.parse(value);
+                  return value; // Valid JSON
+                } catch {
+                  return `'${value}'`; // Not valid JSON, treat as string
+                }
+              case 'Array':
+                // For array type, try to parse as JSON or wrap in quotes if it's a string
+                try {
+                  JSON.parse(value);
+                  return value; // Valid JSON
+                } catch {
+                  return `'${value}'`; // Not valid JSON, treat as string
+                }
+              case 'Date':
+              case 'DATE':
+              case 'TIME':
+              case 'DATETIME':
+                // For date types, wrap in quotes to preserve as string
+                if (
+                  (value.startsWith('"') && value.endsWith('"')) ||
+                  (value.startsWith("'") && value.endsWith("'"))
+                ) {
+                  return value; // Already quoted
+                }
+                return `'${value}'`;
+              case 'Map':
+              case 'Set':
+                // For Map and Set types, try to parse as JSON or wrap in quotes if it's a string
+                try {
+                  JSON.parse(value);
+                  return value; // Valid JSON
+                } catch {
+                  return `'${value}'`; // Not valid JSON, treat as string
+                }
+              default:
+                // For other types, default to string behavior
+                if (
+                  (value.startsWith('"') && value.endsWith('"')) ||
+                  (value.startsWith("'") && value.endsWith("'"))
+                ) {
+                  return value; // Already quoted
+                }
+                return `'${value}'`;
+            }
+          }
+          return arg.name;
+        },
+      );
+
+      // Format the function call
+      const functionCall = `${functionName}(${argValues.join(', ')})`;
+
+      // Return formatted code
+      return returnValueName
+        ? `const ${returnValueName} = ${functionCall};`
+        : `${functionCall};`;
+    };
+
+    function parseFunction(node: MiddleSchema): string {
+      console.log('Parsing function node:', {
+        name: node.name,
+        hasCustomCode: !!node.customCode,
+        customCodeLength: node.customCode?.length,
+        customCode: node.customCode,
+      });
+
+      const params = node.parameters
+        ?.map((param) => {
+          if (typeof param === 'string') {
+            return param;
+          } else if (
+            typeof param === 'object' &&
+            'name' in param &&
+            'type' in param
+          ) {
+            const { name, type } = param as FunctionParameter;
+            return `${name}: ${type}`;
+          }
+          return '';
+        })
+        .join(', ');
+
+      if (node.customCode) {
+        console.log('Using custom code for function:', node.name);
+        // Wrap the custom code in the function declaration
+        return `function ${node.name}(${params}) {\n  ${node.customCode}\n}`;
+      }
+
+      console.log('Generating function from body for:', node.name);
+      const body =
+        node.body
+          ?.filter((n): n is MiddleSchema => n !== undefined)
+          .map(parseNode)
+          .join('\n  ') || '';
+      return `function ${node.name}(${params}) {\n  ${body}\n}`;
+    }
+
+    // Helper function to parse RuleGroup to JavaScript expression
+    function parseRuleGroup(ruleGroup: RuleGroup): string {
+      if (ruleGroup.rules.length === 0) return 'true';
+
+      const ruleExpressions = ruleGroup.rules.map((rule) => {
+        if ('combinator' in rule) {
+          // Nested RuleGroup
+          return `(${parseRuleGroup(rule)})`;
+        } else {
+          // Single Rule
+          return parseRule(rule);
+        }
+      });
+
+      const operator = ruleGroup.combinator === 'and' ? '&&' : '||';
+      return ruleExpressions.join(` ${operator} `);
+    }
+
+    // Helper function to parse a single Rule to JavaScript expression
+    function parseRule(rule: any): string {
+      // Debug logging
+      console.log('Parsing rule:', rule);
+
+      // Handle field
+      let field: string;
+      if (rule.field?.rawValue) {
+        // Plain text input
+        field = rule.field.rawValue;
+      } else if (rule.field?.label && rule.field?.type) {
+        // Structured input with type and label
+        field = `{{${rule.field.type}.${rule.field.label}}}`;
+      } else {
+        // Fallback
+        field = rule.field?.label || '';
+      }
+
+      // Handle value
+      let value: string;
+      if (rule.value?.rawValue) {
+        // Plain text input
+        value = rule.value.rawValue;
+      } else if (rule.value?.label && rule.value?.type) {
+        // Structured input with type and label
+        value = `{{${rule.value.type}.${rule.value.label}}}`;
+      } else {
+        // Fallback
+        value = rule.value?.label || '';
+      }
+
+      console.log('Parsed field:', field, 'value:', value);
+
+      switch (rule.operator) {
+        case '=':
+          return `${field} === ${value}`;
+        case '!=':
+          return `${field} !== ${value}`;
+        case '>':
+          return `${field} > ${value}`;
+        case '<':
+          return `${field} < ${value}`;
+        case '>=':
+          return `${field} >= ${value}`;
+        case '<=':
+          return `${field} <= ${value}`;
+        default:
+          return `${field} === ${value}`;
+      }
+    }
+
+    function parseBranch(node: MiddleSchema): string {
+      let condition: string;
+
+      // Check if we have multiple conditions (RuleGroup) or single condition
+      if (node.conditions && node.conditions.rules.length > 0) {
+        condition = parseRuleGroup(node.conditions);
+      } else {
+        condition = parseExpression(node.condition || '');
+      }
+
+      const trueBranch =
+        node.true
+          ?.filter((n): n is MiddleSchema => n !== undefined)
+          .map(parseNode)
+          .join('\n  ') || '';
+      const falseBranch = node.false
+        ? node.false
+            .filter((n): n is MiddleSchema => n !== undefined)
+            .map(parseNode)
+            .join('\n  ')
+        : '';
+
+      return `if (${condition}) {\n  ${trueBranch}\n}${falseBranch ? ` else {\n  ${falseBranch}\n}` : ''}`;
+    }
+
+    function parseLet(node: MiddleSchema): string {
+      // Handle different modes
+      if (node.mode === 'code' && node.customCode) {
+        return node.customCode;
+      }
+
+      if (node.mode === 'object' && node.objectDefinition) {
+        return parseObjectDefinition(node.objectDefinition);
+      }
+
+      // Default to simple bindings mode
+      const bindings = node.bindings
+        ?.map(
+          ([name, value]) => `let ${name} = ${parseExpression(value || '')};`,
+        )
+        .join('\n');
+      return bindings || '';
+    }
+
+    // Helper function to parse object definition
+    function parseObjectDefinition(objectDef: any): string {
+      if (
+        !objectDef.variableName ||
+        !objectDef.properties ||
+        objectDef.properties.length === 0
+      ) {
+        return '';
+      }
+
+      const properties = objectDef.properties
+        .map((prop: any) => {
+          const key = prop.key;
+          const value = parseExpression(prop.value || '');
+          return `  ${key}: ${value}`;
+        })
+        .join(',\n');
+
+      return `let ${objectDef.variableName} = {\n${properties}\n};`;
+    }
+
+    function parseLoop(node: MiddleSchema): string {
+      let condition: string;
+
+      // Check if we have multiple conditions (RuleGroup) or single condition
+      if (node.conditions && node.conditions.rules.length > 0) {
+        condition = parseRuleGroup(node.conditions);
+      } else {
+        condition = parseExpression(node.condition || '');
+      }
+
+      const body =
+        node.body
+          ?.filter((n): n is MiddleSchema => n !== undefined)
+          .map(parseNode)
+          .join('\n  ') || '';
+
+      return `while (${condition}) {\n  ${body}\n}`;
+    }
+
+    function parseExpression(expr: Expression): string {
+      if (typeof expr === 'number') {
+        return expr.toString();
+      } else if (typeof expr === 'string' && !isNaN(Number(expr))) {
+        return expr;
+      } else if (typeof expr === 'string') {
+        return /^[a-zA-Z_$][a-zA-Z_$0-9]*$/.test(expr)
+          ? expr
+          : JSON.stringify(expr);
+      } else if (typeof expr === 'object' && expr.operation) {
+        const [left, right] = expr.operands.map(parseExpression);
+
+        // Handle special operators that need different formatting
+        switch (expr.operation) {
+          case '=':
+            // Assignment operator - no parentheses needed
+            return `${left} = ${right}`;
+          case '==':
+          case '!=':
+            // Equality operators - use parentheses for clarity
+            return `(${left} ${expr.operation} ${right})`;
+          default:
+            // All other operators - use parentheses
+            return `(${left} ${expr.operation} ${right})`;
+        }
+      } else {
+        return JSON.stringify(expr);
+      }
+    }
+
+    // --- New helper for forLoop ---
+    function parseForLoop(node: MiddleSchema): string {
+      // Format initialization with 'let' keyword
+      let init = node.init || '';
+      if (
+        init &&
+        !init.startsWith('let ') &&
+        !init.startsWith('const ') &&
+        !init.startsWith('var ')
+      ) {
+        // Check if it's an assignment expression (contains '=')
+        if (init.includes('=')) {
+          init = `let ${init}`;
+        }
+      }
+
+      // Parse expressions with proper data type handling
+      let condition: string;
+
+      // Check if we have multiple conditions (RuleGroup) or single condition
+      if (node.conditions && node.conditions.rules.length > 0) {
+        condition = parseRuleGroup(node.conditions);
+      } else {
+        condition = parseExpression(node.condition || '');
+      }
+      const update = parseExpression(node.update || '');
+
+      const body =
+        node.body
+          ?.filter(Boolean)
+          .map((n) => parseNode(n as MiddleSchema))
+          .join('\n  ') || '';
+
+      return `for (${init}; ${condition}; ${update}) {\n  ${body}\n}`;
+    }
+
+    // --- New helper for try/catch ---
+    function parseTry(node: MiddleSchema): string {
+      const body =
+        node.body
+          ?.filter(Boolean)
+          .map((n) => parseNode(n as MiddleSchema))
+          .join('\n  ') || '';
+      let catchBlock = '';
+      if (node.catchBlock) {
+        catchBlock = parseCatch(node.catchBlock);
+      } else {
+        console.log('No catch block found in try node:', node);
+      }
+      return `try {\n  ${body}\n}${catchBlock}`;
+    }
+
+    function parseCatch(node: MiddleSchema): string {
+      const errorVar = node.errorVar || 'e';
+      const body =
+        node.body
+          ?.filter(Boolean)
+          .map((n) => parseNode(n as MiddleSchema))
+          .join('\n  ') || '';
+      return ` catch (${errorVar}) {\n  ${body}\n}`;
+    }
+
+    function parseReturn(node: MiddleSchema): string {
+      const value = parseExpression(node.value || '');
+      return `return ${value};`;
+    }
+
+    function parseSet(node: MiddleSchema): string {
+      const variable = node.variable;
+      const value = parseExpression(node.value || '');
+      return `${variable} = ${value};`;
+    }
+
+    // --- New helper for switch/case ---
+    function parseSwitch(node: MiddleSchema): string {
+      const switchValue = node.switchValue || '';
+      const cases =
+        node.body
+          ?.filter(Boolean)
+          .map((n) => parseCaseNode(n as MiddleSchema))
+          .join('\n  ') || '';
+      return `switch (${switchValue}) {\n  ${cases}\n}`;
+    }
+
+    function parseCaseNode(node: MiddleSchema): string {
+      // Handle default case
+      if (node.title === 'Default') {
+        // For case nodes, we need to process their body if they have one
+        const body =
+          node.body
+            ?.filter(Boolean)
+            .map((n) => parseNode(n as MiddleSchema))
+            .join('\n    ') || '';
+        return `default:\n    ${body}\n    break;`;
+      } else {
+        // For case nodes, we need to process their body if they have one
+        // Use the title as the case value, or fallback to a generic case
+        const caseValue = node.title || 'value';
+        const body =
+          node.body
+            ?.filter(Boolean)
+            .map((n) => parseNode(n as MiddleSchema))
+            .join('\n    ') || '';
+        return `case '${caseValue}':\n    ${body}\n    break;`;
+      }
+    }
+
+    function parseApi(node: MiddleSchema): string {
+      // Extract API node properties
+      const method = (node as any).method || 'GET';
+      const url = (node as any).url || '';
+      const headers = (node as any).headers || [];
+      const queryParams = (node as any).queryParams || [];
+      const body = (node as any).requestBody || '';
+      const bodyType = (node as any).bodyType || 'json';
+      const responseVariable = (node as any).responseVariable || 'apiResponse';
+      const responseDataType = (node as any).responseDataType || 'Object';
+
+      // Generate headers object
+      const headersObj = headers
+        .filter((h: any) => h.key && h.value)
+        .reduce(
+          (acc: any, h: any) => {
+            acc[h.key] = h.value;
+            return acc;
+          },
+          {} as Record<string, string>,
+        );
+
+      // Generate query parameters
+      const queryString = queryParams
+        .filter((q: any) => q.key && q.value)
+        .map(
+          (q: any) =>
+            `${encodeURIComponent(q.key)}=${encodeURIComponent(q.value)}`,
+        )
+        .join('&');
+
+      const fullUrl = queryString ? `${url}?${queryString}` : url;
+
+      // Build the fetch options object manually for proper formatting
+      let fetchOptions = `{
+    method: "${method.toUpperCase()}"`;
+
+      // Add headers
+      if (Object.keys(headersObj).length > 0) {
+        fetchOptions += `,
+    headers: {
+      ${Object.entries(headersObj)
+        .map(([key, value]) => `"${key}": "${value}"`)
+        .join(',\n      ')}
+    }`;
+      }
+
+      // Add body for POST, PUT, PATCH
+      if (['POST', 'PUT', 'PATCH'].includes(method.toUpperCase()) && body) {
+        switch (bodyType) {
+          case 'json':
+            try {
+              // Parse the JSON string to validate it, then stringify it properly
+              const parsedBody = JSON.parse(body);
+              fetchOptions += `,
+    body: JSON.stringify(${JSON.stringify(parsedBody)})`;
+            } catch {
+              // If parsing fails, treat as raw string and stringify it
+              fetchOptions += `,
+    body: JSON.stringify("${body}")`;
+            }
+            break;
+          case 'form-data':
+            fetchOptions += `,
+    body: new FormData().append('data', '${body}')`;
+            break;
+          case 'x-www-form-urlencoded':
+            try {
+              const parsedBody = JSON.parse(body);
+              const formData = new URLSearchParams(parsedBody).toString();
+              fetchOptions += `,
+    body: "${formData}"`;
+            } catch {
+              const formData = new URLSearchParams(body).toString();
+              fetchOptions += `,
+    body: "${formData}"`;
+            }
+            break;
+          case 'raw':
+            fetchOptions += `,
+    body: "${body}"`;
+            break;
+        }
+      }
+
+      fetchOptions += '\n  }';
+
+      // Generate the complete API call code
+      const apiCall = `const response = await fetch('${fullUrl}', ${fetchOptions});
+
+if (!response.ok) {
+  throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+}
+
+const ${responseVariable} = await response.${responseDataType === 'String' ? 'text()' : 'json()'};`;
+
+      return apiCall;
+    }
+
+    function parseCustomGraphQLQuery(
+      node: MiddleSchema,
+      customQuery: string,
+      url: string,
+      headers: any[],
+      responseVariable: string,
+      responseDataType: string,
+    ): string {
+      // Generate headers object
+      const headersObj = headers
+        .filter((h: any) => h.key && h.value)
+        .reduce(
+          (acc: any, h: any) => {
+            acc[h.key] = h.value;
+            return acc;
+          },
+          {} as Record<string, string>,
+        );
+
+      // Build the fetch options object
+      let fetchOptions = `{
+    method: "POST"`;
+
+      // Add headers
+      if (Object.keys(headersObj).length > 0) {
+        fetchOptions += `,
+    headers: {
+      ${Object.entries(headersObj)
+        .map(([key, value]) => `"${key}": "${value}"`)
+        .join(',\n      ')}
+    }`;
+      } else {
+        // Default Content-Type for GraphQL
+        fetchOptions += `,
+    headers: {
+      "Content-Type": "application/json"
+    }`;
+      }
+
+      // Add body with custom GraphQL query
+      fetchOptions += `,
+    body: JSON.stringify({
+      query: \`${customQuery}\`,
+      variables: {}
+    })`;
+
+      fetchOptions += '\n  }';
+
+      // Generate unique variable names to avoid conflicts
+      const responseVarName = `response${Math.random().toString(36).substr(2, 9)}`;
+      const dataVarName = `data${Math.random().toString(36).substr(2, 9)}`;
+
+      // Generate the complete GraphQL call code
+      const responseMethod =
+        responseDataType === 'String' ? 'text()' : 'json()';
+      const responseAssignment =
+        responseDataType === 'String'
+          ? `const ${responseVariable} = await ${responseVarName}.${responseMethod};`
+          : `const { data: ${dataVarName} } = await ${responseVarName}.${responseMethod};
+const ${responseVariable} = ${dataVarName};`;
+
+      const graphqlCall = `const ${responseVarName} = await fetch('${url}', ${fetchOptions});
+
+if (!${responseVarName}.ok) {
+  throw new Error(\`HTTP \${${responseVarName}.status}: \${${responseVarName}.statusText}\`);
+}
+
+${responseAssignment}`;
+
+      return graphqlCall;
+    }
+
+    function parseGraphQL(node: MiddleSchema): string {
+      // Extract GraphQL node properties
+      const mode = (node as any).graphqlMode || 'normal';
+      const operationType = (node as any).operationType || 'query';
+      const operationName = (node as any).operationName || '';
+      const rootField = (node as any).rootField || 'field';
+      const url = (node as any).url || '';
+      const headers = (node as any).headers || [];
+      const nodeArguments = (node as any).arguments || [];
+      const fields = (node as any).fields || [];
+      const variables = (node as any).variables || [];
+      const responseVariable =
+        (node as any).responseVariable || 'graphqlResponse';
+      const responseDataType = (node as any).responseDataType || 'Object';
+      const customQuery = (node as any).customQuery || '';
+
+      // If in advanced mode and custom query is provided, use it directly
+      if (mode === 'advanced' && customQuery.trim()) {
+        return parseCustomGraphQLQuery(
+          node,
+          customQuery,
+          url,
+          headers,
+          responseVariable,
+          responseDataType,
+        );
+      }
+
+      // Generate headers object
+      const headersObj = headers
+        .filter((h: any) => h.key && h.value)
+        .reduce(
+          (acc: any, h: any) => {
+            acc[h.key] = h.value;
+            return acc;
+          },
+          {} as Record<string, string>,
+        );
+
+      // Generate variables object and variable declarations
+      const variablesObj = variables
+        .filter((v: any) => v.key && v.value)
+        .reduce(
+          (acc: any, v: any) => {
+            // Use variable name without $ prefix for the variables object
+            const varName = v.key.startsWith('$') ? v.key.slice(1) : v.key;
+            // Convert values to proper types based on GraphQL type
+            let value = v.value;
+            if (v.type === 'Int' || v.type === 'Float') {
+              value = parseFloat(v.value);
+            } else if (v.type === 'Boolean') {
+              value = v.value === 'true';
+            } else if (v.type === 'ID' && !isNaN(Number(v.value))) {
+              value = v.value; // Keep as string for ID
+            }
+            acc[varName] = value;
+            return acc;
+          },
+          {} as Record<string, any>,
+        );
+
+      // Generate variable declarations for the query
+      const variableDeclarations = variables
+        .filter((v: any) => v.key && v.type)
+        .map((v: any) => {
+          const varName = v.key.startsWith('$') ? v.key : `$${v.key}`;
+          return `${varName}: ${v.type}`;
+        })
+        .join(', ');
+      const variablesString = variableDeclarations
+        ? `(${variableDeclarations})`
+        : '';
+
+      // Generate arguments string - use variables if they exist, otherwise use direct values
+      const args = nodeArguments
+        .filter((arg: any) => arg.key && arg.value)
+        .map((arg: any) => {
+          // Check if the value is already a variable reference (starts with $)
+          if (arg.value.startsWith('$')) {
+            return `${arg.key}: ${arg.value}`;
+          }
+          // Check if there's a variable with the same key
+          const matchingVariable = variables.find(
+            (v: any) => v.key === arg.key,
+          );
+          if (matchingVariable) {
+            const varName = matchingVariable.key.startsWith('$')
+              ? matchingVariable.key
+              : `$${matchingVariable.key}`;
+            return `${arg.key}: ${varName}`;
+          }
+          return `${arg.key}: ${arg.value}`;
+        })
+        .join(', ');
+      const argsString = args ? `(${args})` : '';
+
+      // Generate fields string
+      const fieldsList = fields
+        .filter((field: any) => field.name)
+        .map((field: any) => field.name)
+        .join('\n    ');
+      const fieldsString = fieldsList ? ` {\n    ${fieldsList}\n  }` : '';
+
+      // Build the GraphQL query
+      const operationNameStr = operationName ? ` ${operationName}` : '';
+      const query = `${operationType}${operationNameStr}${variablesString} {\n  ${rootField}${argsString}${fieldsString}\n}`;
+
+      // Build the fetch options object
+      let fetchOptions = `{
+    method: "POST"`;
+
+      // Add headers
+      if (Object.keys(headersObj).length > 0) {
+        fetchOptions += `,
+    headers: {
+      ${Object.entries(headersObj)
+        .map(([key, value]) => `"${key}": "${value}"`)
+        .join(',\n      ')}
+    }`;
+      } else {
+        // Default Content-Type for GraphQL
+        fetchOptions += `,
+    headers: {
+      "Content-Type": "application/json"
+    }`;
+      }
+
+      // Add body with GraphQL query and variables
+      fetchOptions += `,
+    body: JSON.stringify({
+      query: \`${query}\`,
+      variables: ${JSON.stringify(variablesObj)}
+    })`;
+
+      fetchOptions += '\n  }';
+
+      // Generate unique variable names to avoid conflicts
+      const responseVarName = `response${Math.random().toString(36).substr(2, 9)}`;
+      const dataVarName = `data${Math.random().toString(36).substr(2, 9)}`;
+
+      // Generate the complete GraphQL call code
+      const responseMethod =
+        responseDataType === 'String' ? 'text()' : 'json()';
+      const responseAssignment =
+        responseDataType === 'String'
+          ? `const ${responseVariable} = await ${responseVarName}.${responseMethod};`
+          : `const { data: ${dataVarName} } = await ${responseVarName}.${responseMethod};
+const ${responseVariable} = ${dataVarName};`;
+
+      const graphqlCall = `const ${responseVarName} = await fetch('${url}', ${fetchOptions});
+
+if (!${responseVarName}.ok) {
+  throw new Error(\`HTTP \${${responseVarName}.status}: \${${responseVarName}.statusText}\`);
+}
+
+${responseAssignment}`;
+
+      return graphqlCall;
+    }
+
+    return parseNode(json);
+  }
+
+  // Only process root nodes (nodes with no parentId) at the top level
+  const rootNodes = clonedJson.nodes.filter((node) => !node.parentId);
+  const output = rootNodes
+    .map((node) => processNode(node, new Set<string>()))
+    .filter(Boolean) as MiddleSchema[];
+
+  // Find all function nodes instead of just one
+  const allFunctions = output.filter((n) => n.type === 'function');
+
+  if (allFunctions.length > 0) {
+    // Generate code for each function separately
+    const functionCodes = allFunctions.map((func) => {
+      // Reset processedNodes for each function to avoid conflicts
+      processedNodes.clear();
+
+      // Find the original function node to get its ID
+      const originalFunctionNode = rootNodes.find(
+        (node) => node.id === func.id,
+      );
+      if (!originalFunctionNode) return jsonToJavaScript(func as MiddleSchema);
+
+      // Find nodes that belong to this specific function by following edges
+      // and exclude nodes that belong to other functions
+      const functionBody = findNodesBelongingToFunction(
+        originalFunctionNode,
+        rootNodes,
+        clonedJson.edges,
+        allFunctions
+          .map((f) => f.id)
+          .filter((id): id is string => id !== undefined), // Filter out undefined and type guard
+      );
+
+      func.body = functionBody;
+      return jsonToJavaScript(func as MiddleSchema);
+    });
+
+    const mainCode = functionCodes.join('\n\n');
+
+    return {
+      externalFunctions: externalFunctions.join('\n'),
+      mainCode: mainCode,
+    };
+  }
+
+  return { externalFunctions: '', mainCode: '' };
+};