Function buildNode

src/ui-server/api/node.ts:77–227

(cg: CodeGraph, projectRoot: string, nodeId: string)

}

export async function buildNode(cg: CodeGraph, projectRoot: string, nodeId: string): Promise<unknown> {
  const node = cg.getNode(nodeId);
  if (!node) {
    throw notFound(
      'No symbol with that id is in this index.',
      'Symbol ids change whenever the file is re-indexed — search for the symbol by ' +
        'name instead of reusing an id from an older session.'
    );
  }

  const incomingAll = cg.getIncomingEdges(nodeId);
  const outgoingAll = cg.getOutgoingEdges(nodeId);

  // `contains` is structure, not dependency: upward it is the parent (already in
  // `ancestors`), downward it is the members outline. Leaving it in the rails
  // would put a symbol's own class in its caller list.
  const incoming = incomingAll.filter((e) => e.kind !== 'contains');
  const outgoingRest: Edge[] = [];
  const containsOut: Edge[] = [];
  for (const edge of outgoingAll) {
    if (edge.kind === 'contains') containsOut.push(edge);
    else outgoingRest.push(edge);
  }

  const ancestors = cg.getAncestors(nodeId);

  // ---------------------------------------------------------------------------
  // One batched resolve for every endpoint this payload names.
  // ---------------------------------------------------------------------------
  const endpointIds = new Set<string>();
  for (const edge of incoming) endpointIds.add(edge.source);
  for (const edge of outgoingRest) endpointIds.add(edge.target);
  for (const edge of containsOut) endpointIds.add(edge.target);
  const endpoints = cg.getNodesByIds([...endpointIds]);

  // A `references` edge into a type is "uses type X", not "calls X" — the
  // header shows those as chips rather than as callee rows. Split at the EDGE
  // level so a class that is both instantiated and named as a type appears in
  // both places, which is what the source actually says.
  const calleeEdges: Edge[] = [];
  const typeRefs: Edge[] = [];
  for (const edge of outgoingRest) {
    const target = endpoints.get(edge.target);
    if (edge.kind === 'references' && target && TYPE_KINDS.has(target.kind)) typeRefs.push(edge);
    else calleeEdges.push(edge);
  }

  // ---------------------------------------------------------------------------
  // Rails
  // ---------------------------------------------------------------------------
  const focalFile = toPosixPath(node.filePath);

  const incomingGroups = groupRelations(incoming, (e) => e.source, endpoints);
  incomingGroups.sort((a, b) => {
    // The symbol's own file first ("same file" in the left rail), then
    // production code, then tests — so a cap trims the least useful end.
    const aSame = a.node.file === focalFile ? 0 : 1;
    const bSame = b.node.file === focalFile ? 0 : 1;