@flowuent-org/diagramming-core 1.3.9 → 1.4.0

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

@@ -1,1465 +0,0 @@
-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: '' };
-};