Function convertCreateClause

packages/graph/src/astToSteps.ts:633–712

* Convert a CREATE clause into a CreateStep. * Handles both simple node patterns and chain patterns (with relationships). * * Chain patterns like: (t)-[:Contains]->(:Attr {props})-[:IsA]->(s) * Are processed to extract all nodes that need to be created and all edges, * respecting the order so t

(createClause: CreateClause)

 * respecting the order so that variables created earlier can be referenced later.
 */
function convertCreateClause(createClause: CreateClause): CreateStep {
  const vertices: CreateVertexConfig[] = [];
  const edges: CreateEdgeConfig[] = [];

  // Track variables assigned to nodes (including generated ones for anonymous nodes)
  // Maps from the node object reference to the assigned variable name
  const nodeVariables = new Map<CreateNodePattern | CreateVariableRef, string>();

  // Counter for generating unique anonymous variable names
  let anonCounter = 0;

  for (const pattern of createClause.patterns) {
    if (pattern.type === "CreateNodePattern") {
      // Simple standalone node creation
      const nodePattern = pattern as CreateNodePattern;
      vertices.push({
        variable: nodePattern.variable,
        label: nodePattern.labels[0] || "Node",
        properties: convertPropertyMap(nodePattern.properties),
      });
    } else if (pattern.type === "CreateChainPattern") {
      // Chain pattern: process nodes and edges in sequence
      const chain = pattern as CreateChainPattern;
      const elements = chain.elements;

      // First pass: assign variables to all nodes and collect nodes to create
      // We need to create nodes before edges so that edge endpoints can reference them
      for (let i = 0; i < elements.length; i += 2) {
        const nodeElement = elements[i] as CreateNodePattern | CreateVariableRef;

        if (nodeElement.type === "CreateVariableRef") {
          // Reference to existing node - use its variable
          nodeVariables.set(nodeElement, nodeElement.variable);
        } else {
          // CreateNodePattern - new node to create (with or without labels)
          const nodePattern = nodeElement as CreateNodePattern;
          // New node to create - assign variable (use existing or generate)
          const variable = nodePattern.variable || `__anon_${anonCounter++}`;
          nodeVariables.set(nodeElement, variable);
          vertices.push({
            variable,
            // Use first label if provided, otherwise use empty string for unlabeled nodes
            label: nodePattern.labels[0] || "",
            properties: convertPropertyMap(nodePattern.properties),
          });
        }
      }

      // Second pass: collect all edges using assigned variables
      for (let i = 1; i < elements.length; i += 2) {
        const edgeElement = elements[i] as CreateEdgePattern;
        const prevNode = elements[i - 1] as CreateNodePattern | CreateVariableRef;
        const nextNode = elements[i + 1] as CreateNodePattern | CreateVariableRef;

        const startVariable = nodeVariables.get(prevNode);
        const endVariable = nodeVariables.get(nextNode);

        if (!startVariable || !endVariable) {