Function createPostprocessor

packages/graph/src/index.ts:177–261

* Creates a function which takes the array of values returned by the graph traversal * and returns an object with the values mapped to the variable names in the RETURN clause. * * When multiple properties from the same variable are returned (e.g., `RETURN c.name, c.description`), * they are grou

(
  ast: Query | UnionQuery | MultiStatement,
)

 * @param ast The AST of the query (Query, UnionQuery, or MultiStatement).
 */
function createPostprocessor(
  ast: Query | UnionQuery | MultiStatement,
): (row: readonly unknown[]) => Record<string, unknown> {
  // For multi-statement queries, pass through results as-is
  // (each statement has different schema, results include _statementIndex)
  if (ast.type === "MultiStatement") {
    return (row) => {
      if (row && typeof row === "object" && !Array.isArray(row)) {
        return row as unknown as Record<string, unknown>;
      }
      return { _value: row };
    };
  }

  // For union queries, use the first query's RETURN clause for variable names
  // (all queries in a UNION must return the same columns)
  const query = ast.type === "UnionQuery" ? ast.queries[0]! : ast;

  // For mutation-only queries without RETURN, return empty object
  if (!query.return) {
    return () => ({});
  }

  const items = query.return.items;

  // Build a map of output key -> list of {index, property}
  // This groups properties that should be merged under the same key
  const keyMapping = new Map<string, Array<{ index: number; property: string | undefined }>>();

  for (let i = 0; i < items.length; i++) {
    const item = items[i]!;
    // Use alias if present, otherwise use variable name, or generate a key for expressions
    let key: string;
    if (item.alias) {
      key = item.alias;
    } else if (item.variable) {
      key = item.variable;
    } else if (item.expression) {
      // For expression-based items without alias, generate a key
      key = `expr_${i}`;
    } else {
      key = `item_${i}`;
    }
    if (!keyMapping.has(key)) {
      keyMapping.set(key, []);
    }
    keyMapping.get(key)!.push({ index: i, property: item.property });
  }

  return (row) => {
    // Normalize row to array for aggregate-only queries that yield raw values
    // (e.g., COUNT yields a number, not an array)
    const normalizedRow = Array.isArray(row) ? row : [row];
    const result: Record<string, unknown> = {};

    for (const [key, mappings] of keyMapping) {
      if (mappings.length === 1) {
        // Single mapping for this key - return value directly