Self-hosted homelab infrastructure visualizer — interactive network diagram with live status monitoring
TypeScript diagramhomelabhomelab-infrastructure-observabilitynetworkproxmox-veself-hostedzigbeezwavezwave-js
fix: improve auto-layout peer alignment and edge direction
Pouzor8affcda09dae
diff --git a/frontend/src/utils/__tests__/layout.test.ts b/frontend/src/utils/__tests__/layout.test.tsnew file mode 100644index 0000000..6948f35--- /dev/null+++ b/frontend/src/utils/__tests__/layout.test.ts@@ -0,0 +1,122 @@+import { describe, it, expect } from 'vitest'+import { applyDagreLayout } from '../layout'+import type { Node, Edge } from '@xyflow/react'+import type { NodeData, EdgeData } from '@/types'++function makeNode(id: string, type: string, parentId?: string): Node<NodeData> {+ return {+ id,+ type,+ position: { x: 0, y: 0 },+ data: { type, label: id } as unknown as NodeData,+ ...(parentId ? { parentId } : {}),+ }+}++function makeEdge(source: string, target: string, sourceHandle?: string): Edge<EdgeData> {+ return { id: `${source}-${target}`, source, target, sourceHandle, data: {} as EdgeData }+}++describe('applyDagreLayout', () => {+ it('places two proxmox nodes connected to each other at the same Y', () => {+ const nodes = [+ makeNode('router', 'router'),+ makeNode('pve1', 'proxmox'),+ makeNode('pve2', 'proxmox'),+ ]+ const edges = [+ makeEdge('router', 'pve1'),+ makeEdge('router', 'pve2'),+ makeEdge('pve1', 'pve2'),+ ]++ const result = applyDagreLayout(nodes, edges)+ const pve1 = result.find((n) => n.id === 'pve1')!+ const pve2 = result.find((n) => n.id === 'pve2')!++ expect(pve1.position.y).toBe(pve2.position.y)+ })++ it('orders peer nodes left-to-right by chain: endpoint first, middle last', () => {+ // pve-left -- pve-center -- pve-right (chain)+ // router connects to all three+ const nodes = [+ makeNode('router', 'router'),+ makeNode('pve-left', 'proxmox'),+ makeNode('pve-center', 'proxmox'),+ makeNode('pve-right', 'proxmox'),+ ]+ const edges = [+ makeEdge('router', 'pve-left'),+ makeEdge('router', 'pve-center'),+ makeEdge('router', 'pve-right'),+ makeEdge('pve-left', 'pve-center'),+ makeEdge('pve-center', 'pve-right'),+ ]++ const result = applyDagreLayout(nodes, edges)+ const left = result.find((n) => n.id === 'pve-left')!+ const center = result.find((n) => n.id === 'pve-center')!+ const right = result.find((n) => n.id === 'pve-right')!++ // All at same Y+ expect(left.position.y).toBe(center.position.y)+ expect(center.position.y).toBe(right.position.y)++ // X order: endpoint (left or right) < center (middle has 2 peer connections)+ // The BFS starts from an endpoint, so we just verify the middle is not at the extremes+ const xs = [left.position.x, center.position.x, right.position.x].sort((a, b) => a - b)+ expect(center.position.x).toBe(xs[1]) // pve-center must be in the middle+ })++ it('keeps child nodes (parentId set) in place', () => {+ const nodes = [+ makeNode('router', 'router'),+ makeNode('pve1', 'proxmox'),+ makeNode('vm1', 'vm', 'pve1'),+ ]+ const edges = [makeEdge('router', 'pve1')]++ const result = applyDagreLayout(nodes, edges)+ const vm1 = result.find((n) => n.id === 'vm1')!+ expect(vm1.position).toEqual({ x: 0, y: 0 })+ })++ it('places a node below its parent when the edge exits from the top handle (upward edge)', () => {+ // Frigate connects UP to Proxmox via its top handle (source=Frigate, sourceHandle='top')+ // Dagre must place Frigate BELOW Proxmox, not above.+ const nodes = [+ makeNode('router', 'router'),+ makeNode('proxmox', 'proxmox'),+ makeNode('frigate', 'server'),+ ]+ const edges = [+ makeEdge('router', 'proxmox'),+ makeEdge('frigate', 'proxmox', 'top'), // upward edge: frigate → proxmox via top handle+ ]++ const result = applyDagreLayout(nodes, edges)+ const proxmox = result.find((n) => n.id === 'proxmox')!+ const frigate = result.find((n) => n.id === 'frigate')!++ expect(frigate.position.y).toBeGreaterThan(proxmox.position.y)+ })++ it('places two switch nodes connected to each other at the same Y', () => {+ const nodes = [+ makeNode('router', 'router'),+ makeNode('sw1', 'switch'),+ makeNode('sw2', 'switch'),+ ]+ const edges = [+ makeEdge('router', 'sw1'),+ makeEdge('router', 'sw2'),+ makeEdge('sw1', 'sw2'),+ ]++ const result = applyDagreLayout(nodes, edges)+ const sw1 = result.find((n) => n.id === 'sw1')!+ const sw2 = result.find((n) => n.id === 'sw2')!+ expect(sw1.position.y).toBe(sw2.position.y)+ })+})diff --git a/frontend/src/utils/layout.ts b/frontend/src/utils/layout.tsindex 309aa40..fc0771d 100644--- a/frontend/src/utils/layout.ts+++ b/frontend/src/utils/layout.ts@@ -5,46 +5,149 @@ import type { NodeData, EdgeData } from '@/types'const NODE_WIDTH = 180const NODE_HEIGHT = 52+const PEER_TYPES = new Set(['proxmox', 'switch'])++/**+ * Find groups of peer nodes (same type, directly connected to each other)+ * using union-find. Returns a map: nodeId → groupId (the minimum nodeId in the group).+ */+function buildPeerGroups(+ topLevel: Node<NodeData>[],+ edges: Edge<EdgeData>[],+): Map<string, string> {+ const parent = new Map<string, string>(topLevel.map((n) => [n.id, n.id]))++ function find(id: string): string {+ if (parent.get(id) !== id) parent.set(id, find(parent.get(id)!))+ return parent.get(id)!+ }+ function union(a: string, b: string) {+ const ra = find(a), rb = find(b)+ if (ra !== rb) parent.set(ra, rb)+ }++ const topLevelIds = new Set(topLevel.map((n) => n.id))+ const peerIds = new Set(topLevel.filter((n) => PEER_TYPES.has(n.type ?? '')).map((n) => n.id))++ for (const edge of edges) {+ const { source: s, target: t } = edge+ if (topLevelIds.has(s) && topLevelIds.has(t) && peerIds.has(s) && peerIds.has(t)) {+ // Only merge if both nodes share the same type (proxmox↔proxmox, switch↔switch)+ const srcNode = topLevel.find((n) => n.id === s)!+ const tgtNode = topLevel.find((n) => n.id === t)!+ if (srcNode.type === tgtNode.type) union(s, t)+ }+ }++ // Resolve all to canonical group ids+ const result = new Map<string, string>()+ for (const n of topLevel) result.set(n.id, find(n.id))+ return result+}+/*** Apply Dagre hierarchical (top-to-bottom) layout to nodes and edges.* Child nodes (parentId set) keep their relative position inside the parent — only* top-level nodes are repositioned by Dagre.+ *+ * Post-pass: peer nodes of the same type (proxmox, switch) connected to each other+ * are snapped to the same Y rank so they appear on the same horizontal level.*/export function applyDagreLayout(nodes: Node<NodeData>[],edges: Edge<EdgeData>[],): Node<NodeData>[] {+ const topLevel = nodes.filter((n) => !n.parentId)+ const topLevelIds = new Set(topLevel.map((n) => n.id))++ // Capture original X positions before Dagre — used to preserve left-to-right+ // ordering of peer groups as the user set them.+ const originalX = new Map<string, number>(topLevel.map((n) => [n.id, n.position.x]))++ // Identify peer groups before running Dagre so we can exclude peer edges+ const peerGroups = buildPeerGroups(topLevel, edges)+ const isPeerEdge = (e: Edge<EdgeData>) => {+ const sg = peerGroups.get(e.source)+ const tg = peerGroups.get(e.target)+ return sg !== undefined && tg !== undefined && sg === tg+ }+const g = new dagre.graphlib.Graph()g.setDefaultEdgeLabel(() => ({}))g.setGraph({ rankdir: 'TB', nodesep: 60, ranksep: 80 })- const topLevel = nodes.filter((n) => !n.parentId)-for (const node of topLevel) {const w = node.type === 'proxmox' ? (node.width ?? 300) : NODE_WIDTHconst h = node.type === 'proxmox' ? (node.height ?? 200) : NODE_HEIGHTg.setNode(node.id, { width: w, height: h })}for (const edge of edges) {- // Only add edges between top-level nodes- const srcTop = topLevel.some((n) => n.id === edge.source)- const tgtTop = topLevel.some((n) => n.id === edge.target)- if (srcTop && tgtTop) g.setEdge(edge.source, edge.target)+ const srcTop = topLevelIds.has(edge.source)+ const tgtTop = topLevelIds.has(edge.target)+ // Exclude peer-to-peer edges — they confuse Dagre's rank assignment+ if (!srcTop || !tgtTop || isPeerEdge(edge)) continue+ // If the edge exits from the TOP handle of the source, the connection goes+ // upward — meaning the source node is visually below the target. Reverse+ // the edge direction for Dagre so it places the source below the target.+ const upward = (edge as { sourceHandle?: string | null }).sourceHandle === 'top'+ if (upward) {+ g.setEdge(edge.target, edge.source)+ } else {+ g.setEdge(edge.source, edge.target)+ }}dagre.layout(g)- return nodes.map((node) => {- if (node.parentId) return node // keep children in place+ // Build initial positions from Dagre+ const positions = new Map<string, { x: number; y: number; w: number; h: number }>()+ for (const node of topLevel) {const pos = g.node(node.id)const w = node.type === 'proxmox' ? (node.width ?? 300) : NODE_WIDTHconst h = node.type === 'proxmox' ? (node.height ?? 200) : NODE_HEIGHT- return {- ...node,- position: {- x: pos.x - w / 2,- y: pos.y - h / 2,- },+ positions.set(node.id, { x: pos.x - w / 2, y: pos.y - h / 2, w, h })+ }++ // Post-pass: fix peer groups (same-type nodes directly connected to each other)+ // Collect members per group+ const groupMembers = new Map<string, string[]>()+ for (const [id, groupId] of peerGroups) {+ if (!groupMembers.has(groupId)) groupMembers.set(groupId, [])+ groupMembers.get(groupId)!.push(id)+ }++ for (const [, members] of groupMembers) {+ if (members.length < 2) continue++ // --- Y: snap all to average Y of the group ---+ const avgY = members.reduce((sum, id) => sum + positions.get(id)!.y, 0) / members.length+ for (const id of members) positions.set(id, { ...positions.get(id)!, y: avgY })++ // --- X: sort by original (pre-layout) X to preserve the user's intended+ // left-to-right order. Fall back to Dagre X if all nodes share the+ // same original X (e.g. freshly created canvas with no positions yet). ---+ const GAP = 60+ const origXs = members.map((id) => originalX.get(id) ?? 0)+ const allSameOrigX = origXs.every((x) => x === origXs[0])+ const ordered = members.slice().sort((a, b) =>+ allSameOrigX+ ? positions.get(a)!.x - positions.get(b)!.x // fall back to Dagre X+ : (originalX.get(a) ?? 0) - (originalX.get(b) ?? 0), // preserve user order+ )+ const totalWidth = ordered.reduce((sum, id) => sum + positions.get(id)!.w, 0) + GAP * (ordered.length - 1)+ const centerX = members.reduce((sum, id) => sum + positions.get(id)!.x + positions.get(id)!.w / 2, 0) / members.length++ let curX = centerX - totalWidth / 2+ for (const id of ordered) {+ const p = positions.get(id)!+ positions.set(id, { ...p, x: curX })+ curX += p.w + GAP}+ }++ return nodes.map((node) => {+ if (node.parentId) return node+ const p = positions.get(node.id)!+ return { ...node, position: { x: p.x, y: p.y } }})}