Function convertParenthesizedPathPattern

packages/graph/src/astToSteps.ts:1773–1834

* Convert a parenthesized path pattern to steps. * Handles optional inline WHERE condition and quantifiers. * * Parenthesized path patterns allow grouping patterns with inline conditions: * - ((a)-[r]->(b) WHERE r.weight > 10) - pattern with inline condition * - ((a)-[r]->(b))+ - quantified pat

(parenthesized: ParenthesizedPathPattern)

 * - ((a)-[r]->(b) WHERE r.weight > 10){2,5} - with condition and quantifier
 */
function convertParenthesizedPathPattern(parenthesized: ParenthesizedPathPattern): Step<any>[] {
  // Convert the inner pattern to steps WITHOUT the WHERE clause
  // The WHERE will be added after the pattern traversal
  const patternSteps = convertPattern(
    parenthesized.pattern,
    undefined, // Don't pass WHERE here, we'll add it manually
    true,
  );

  // Build the complete inner steps array
  const innerSteps: Step<any>[] = [...patternSteps];

  // Add inline WHERE condition as a filter at the end of the inner pattern
  // This ensures the condition is checked after each traversal iteration
  if (parenthesized.where) {
    innerSteps.push(
      new FilterElementsStep({
        condition: convertCondition(parenthesized.where),
      }),
    );
  }

  // If there's a quantifier, wrap in RepeatStep
  if (parenthesized.quantifier) {
    const { min, max } = parenthesized.quantifier;

    // Extract the last variable from the pattern for step labels
    const lastElement = parenthesized.pattern.elements[parenthesized.pattern.elements.length - 1];
    const stepLabels =
      lastElement?.type === "NodePattern" && lastElement.variable
        ? [lastElement.variable]
        : undefined;

    // Handle zero-min case
    const emitInput = min === 0;
    const effectiveMin = min ?? 1;
    const emitStart = effectiveMin > 0 ? effectiveMin : 1;

    // Exact count
    if (max !== undefined && effectiveMin === max) {
      if (emitInput) {
        return [new RepeatStep({ times: max, stepLabels, emitInput }, innerSteps)];
      }
      return [new RepeatStep({ times: max, stepLabels }, innerSteps)];
    }

    // Range
    if (max !== undefined) {
      return [
        new RepeatStep({ times: max, emit: true, emitStart, emitInput, stepLabels }, innerSteps),
      ];
    }

    // Open-ended
    return [
      new RepeatStep({ times: 100, emit: true, emitStart, emitInput, stepLabels }, innerSteps),
    ];
  }