Method traverse

packages/graph/src/Steps.ts:6686–6847

(
    source: GraphSource<any>,
    input: Iterable<TraversalPath<any, any, any>>,
    context?: QueryContext,
  )

  }

  public *traverse(
    source: GraphSource<any>,
    input: Iterable<TraversalPath<any, any, any>>,
    context?: QueryContext,
  ): IterableIterator<TraversalPath<any, any, any>> {
    const { distinct, items, orderBy, skip, limit, whereCondition } = this.config;

    // Collect all input paths for potential aggregation
    const paths = [...input];
    this.traversed += paths.length;

    // Check if we have any aggregate items
    const hasAggregate = items.some((item) => item.type === "aggregate");

    // Get non-aggregate items for grouping
    const nonAggregateItems = items.filter((item) => item.type !== "aggregate");

    let results: TraversalPath<any, any, any>[];

    if (hasAggregate) {
      if (nonAggregateItems.length > 0) {
        // Grouped aggregation mode: group by non-aggregate items, compute aggregates per group
        // This implements Cypher semantics: WITH n.name AS name, collect(n) AS nodes
        // groups results by name and collects nodes within each group
        const groups = new Map<string, TraversalPath<any, any, any>[]>();

        for (const path of paths) {
          // Compute group key from non-aggregate items
          const keyParts: string[] = [];
          for (const item of nonAggregateItems) {
            let value: any;
            switch (item.type) {
              case "variable": {
                const pathNode = path.get(item.sourceVariable);
                value = pathNode?.value ?? null;
                break;
              }
              case "property": {
                const pathNode = path.get(item.sourceVariable);
                value = pathNode?.property(item.property as never) ?? null;
                break;
              }
              case "functionCall": {
                const resolvedArgs = item.args.map((arg) =>
                  resolveConditionValue(path, arg, context),
                );
                value = evaluateFunction(item.functionName, resolvedArgs, path, item.distinct);
                break;
              }
            }
            if (value && typeof value === "object" && "id" in value) {
              keyParts.push(String(value.id));
            } else {
              keyParts.push(JSON.stringify(value));
            }
          }
          const groupKey = keyParts.join("|");