Function processLegacyQuery

packages/graph/src/astToSteps.ts:326–469

* Process a query using the legacy flat structure (backward compatibility).

(query: Query, steps: Step<any>[])

 * Process a query using the legacy flat structure (backward compatibility).
 */
function processLegacyQuery(query: Query, steps: Step<any>[]): void {
  // 1. Convert MATCH clauses patterns to steps
  // Process regular MATCH clauses first, then OPTIONAL MATCH clauses
  // If the first MATCH is OPTIONAL, we need a StartStep to provide an initial path
  // so that OptionalMatchStep has an input to extend with null bindings
  const firstMatchIsOptional = query.matches.length > 0 && query.matches[0]!.optional;
  if (firstMatchIsOptional) {
    steps.push(new StartStep({}));
  }

  let hasSeenPreviousMatch = false;
  for (const matchClause of query.matches) {
    // Convert the pattern to steps
    let patternSteps: Step<any>[];

    if (matchClause.pattern.type === "ShortestPathPattern") {
      patternSteps = convertShortestPathPattern(
        matchClause.pattern as ShortestPathPattern,
        matchClause.where,
      );
    } else if (matchClause.pattern.type === "MultiPattern") {
      // Handle comma-separated patterns like MATCH (a), (b)
      patternSteps = convertMultiPattern(matchClause.pattern as MultiPattern, matchClause.where);
    } else {
      // For OPTIONAL MATCH after a previous MATCH, the first node may reference
      // a previously bound variable. We enable anchor detection (anchoredToInput: true)
      // when there are previous steps in the query that may have bound variables.
      // The anchor heuristic will only trigger if the first node has no labels.
      const isAnchoredContext = matchClause.optional && hasSeenPreviousMatch;
      patternSteps = convertPattern(
        matchClause.pattern as Pattern,
        matchClause.where,
        isAnchoredContext,
      );
    }

    if (matchClause.optional) {
      // Wrap in OptionalMatchStep for OPTIONAL MATCH
      // skipAnchor: Only skip anchor if there was a previous MATCH that bound variables
      const skipAnchor = hasSeenPreviousMatch;
      const variables = extractPatternVariables(matchClause.pattern, skipAnchor);
      steps.push(new OptionalMatchStep({ variables }, patternSteps as Step<any>[]));
    } else {
      steps.push(...patternSteps);
    }
    hasSeenPreviousMatch = true;
  }

  // 1b. If no MATCH clauses but there are mutations or list operations, add a StartStep
  // to provide an initial empty path for CREATE/MERGE/UNWIND to work with
  const hasMutations =
    (query.merge && query.merge.length > 0) ||
    query.create ||
    query.set ||
    query.remove ||
    query.delete ||
    (query.foreach && query.foreach.length > 0);