Function processQuerySegments

packages/graph/src/astToSteps.ts:180–321

* Process query segments in order for flexible clause ordering. * Each segment can contain MATCH, mutations, and a WITH clause that transitions to the next segment.

(segments: QuerySegment[], steps: Step<any>[])

 * Each segment can contain MATCH, mutations, and a WITH clause that transitions to the next segment.
 */
function processQuerySegments(segments: QuerySegment[], steps: Step<any>[]): void {
  let isFirstSegment = true;
  let hasSeenNonOptionalMatch = false;
  let hasSeenWithClause = false;

  for (const segment of segments) {
    // Check if this segment has any content (MATCH, mutations, or list operations)
    const hasMatches = segment.matches && segment.matches.length > 0;
    const hasMutations = segment.mutations && segment.mutations.length > 0;
    const hasUnwind = segment.unwind && segment.unwind.length > 0;
    const hasCall = segment.call && segment.call.length > 0;
    const hasForeach = segment.foreach && segment.foreach.length > 0;
    const hasSet = segment.set;
    const hasRemove = segment.remove;
    const hasDelete = segment.delete;
    const hasWithClause = segment.with && segment.with.length > 0;

    const hasContent =
      hasMatches ||
      hasMutations ||
      hasUnwind ||
      hasCall ||
      hasForeach ||
      hasSet ||
      hasRemove ||
      hasDelete ||
      hasWithClause;

    // Check if the first MATCH in this segment is OPTIONAL
    const firstMatchIsOptional = hasMatches && segment.matches![0]!.optional === true;

    // For the first segment with no MATCH but mutations/list ops/WITH, add StartStep
    // Also add StartStep if the first MATCH is OPTIONAL (needs input path for null bindings)
    if (isFirstSegment && ((!hasMatches && hasContent) || firstMatchIsOptional)) {
      steps.push(new StartStep({}));
    }
    isFirstSegment = false;

    // Process MATCH clauses for this segment
    if (hasMatches) {
      for (const matchClause of segment.matches!) {
        let patternSteps: Step<any>[];

        if (matchClause.pattern.type === "ShortestPathPattern") {
          patternSteps = convertShortestPathPattern(
            matchClause.pattern as ShortestPathPattern,
            matchClause.where,
          );
        } else if (matchClause.pattern.type === "MultiPattern") {
          patternSteps = convertMultiPattern(
            matchClause.pattern as MultiPattern,
            matchClause.where,
            hasSeenWithClause, // Preserve bindings from prior WITH clause
          );
        } else {
          // After a WITH clause or non-optional MATCH, MATCH can reference variables
          const isAnchoredContext = matchClause.optional && hasSeenNonOptionalMatch;
          patternSteps = convertPattern(