Method computeAggregates

packages/graph/src/Steps.ts:6899–6956

(
    paths: readonly TraversalPath<any, any, any>[],
    items: readonly WithItemConfig[],
    context?: QueryContext,
  )

  }

  protected computeAggregates(
    paths: readonly TraversalPath<any, any, any>[],
    items: readonly WithItemConfig[],
    context?: QueryContext,
  ): { firstValue: any; bindings: [string, any][] } {
    const bindings: [string, any][] = [];
    let firstValue: any = null;
    let isFirst = true;

    for (const item of items) {
      let value: any;

      switch (item.type) {
        case "variable": {
          // For non-aggregate items in an aggregate context, use the first path's value
          const pathNode = paths[0]?.get(item.sourceVariable);
          value = pathNode?.value ?? null;
          break;
        }
        case "property": {
          const pathNode = paths[0]?.get(item.sourceVariable);
          value = pathNode?.property(item.property as never) ?? null;
          break;
        }
        case "aggregate": {
          value = this.computeSingleAggregate(paths, item);
          break;
        }
        case "functionCall": {
          // Evaluate function call using first path
          const firstPath = paths[0];
          if (firstPath) {
            const resolvedArgs = item.args.map((arg) =>
              resolveConditionValue(firstPath, arg, context),
            );
            value = evaluateFunction(item.functionName, resolvedArgs, firstPath, item.distinct);
          } else {
            value = null;
          }
          break;
        }
        case "expression": {
          // Evaluate arbitrary expression using first path
          const firstPath = paths[0];
          value = firstPath ? resolveConditionValue(firstPath, item.value, context) : null;
          break;
        }
      }

      if (isFirst) {
        firstValue = value;
        isFirst = false;
      }
      bindings.push([item.alias, value]);
    }

    return { firstValue, bindings };
  }