Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

[FE-3717] feat(studio): Multigres cluster topology diagram (#49298)

Alaister Young928049ce2c90
diff --git a/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx b/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx
index 7d05a6b9e60..7bfab5a8b1d 100644
--- a/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx
+++ b/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx
@@ -1,11 +1,14 @@
import { BaseEdge, EdgeLabelRenderer, getSmoothStepPath, type EdgeProps } from '@xyflow/react'
-import { useParams } from 'common'
-import { ArrowRight, Loader2, Square, X, type LucideIcon } from 'lucide-react'
+import { useParams, useReducedMotion } from 'common'
import { useMemo } from 'react'
-import { cn } from 'ui'
import { getStatusName } from '../Pipeline.utils'
import { STATUS_REFRESH_FREQUENCY_MS } from '../Replication.constants'
+import {
+ EdgeVisualChip,
+ getEdgeVisual,
+ type ReplicationState,
+} from '@/components/ui/ReactFlow/EdgeVisual'
import { useReplicationPipelineStatusQuery } from '@/data/replication/pipeline-status-query'
import { useReplicationPipelinesQuery } from '@/data/replication/pipelines-query'
import {
@@ -19,67 +22,6 @@ type EdgeData = {
shiftEdgeEnd: boolean
}
-interface ReplicationState {
- isComingUp: boolean
- isReplicating: boolean
- isFailed: boolean
-}
-
-interface EdgeVisual {
- Icon: LucideIcon
- // CSS color shared by the icon and the connecting line so they always match.
- color: string
- opacity: number
- dashArray: string
- shouldAnimate: boolean
- shouldSpin?: boolean
- isFilled?: boolean
- strokeWidth?: number
-}
-
-// Picks the icon + line appearance for a replication state. Both the icon and the line are derived
-// here from the same state so they always stay in sync. We deliberately don't surface lag: the line
-// just communicates whether data is moving, stopped, starting, or broken.
-const getEdgeVisual = ({ isComingUp, isReplicating, isFailed }: ReplicationState): EdgeVisual => {
- if (isFailed) {
- return {
- Icon: X,
- color: 'hsl(var(--destructive-default))',
- opacity: 1,
- dashArray: '5 5',
- shouldAnimate: false,
- strokeWidth: 4,
- }
- }
- if (isComingUp) {
- return {
- Icon: Loader2,
- color: 'var(--foreground-light)',
- opacity: 1,
- dashArray: '5',
- shouldAnimate: true,
- shouldSpin: true,
- }
- }
- if (isReplicating) {
- return {
- Icon: ArrowRight,
- color: 'hsl(var(--brand-default))',
- opacity: 1,
- dashArray: '5',
- shouldAnimate: true,
- }
- }
- return {
- Icon: Square,
- color: 'var(--foreground-lighter)',
- opacity: 0.5,
- dashArray: '5 5',
- shouldAnimate: false,
- isFilled: true,
- }
-}
-
export const SmoothstepEdge = ({
sourceX,
sourceY,
@@ -92,6 +34,7 @@ export const SmoothstepEdge = ({
data,
}: EdgeProps) => {
const { ref: projectRef = 'default' } = useParams()
+ const prefersReducedMotion = useReducedMotion()
const { identifier, shiftEdgeEnd } = (data || {}) as EdgeData
const { data: pipelinesData } = useReplicationPipelinesQuery({ projectRef })
@@ -126,16 +69,7 @@ export const SmoothstepEdge = ({
targetPosition,
})
- const {
- Icon,
- color,
- opacity,
- dashArray,
- shouldAnimate,
- shouldSpin,
- isFilled,
- strokeWidth = 2,
- } = getEdgeVisual(replicationState)
+ const visual = getEdgeVisual(replicationState)
return (
<>
@@ -144,11 +78,14 @@ export const SmoothstepEdge = ({
markerEnd={markerEnd}
style={{
...style,
- stroke: color,
- strokeWidth,
- opacity,
- strokeDasharray: dashArray,
- animation: shouldAnimate ? 'dashdraw 0.5s linear infinite' : undefined,
+ stroke: visual.color,
+ strokeWidth: visual.strokeWidth,
+ opacity: visual.opacity,
+ strokeDasharray: visual.dashArray,
+ animation:
+ visual.shouldAnimate && !prefersReducedMotion
+ ? 'dashdraw 0.5s linear infinite'
+ : undefined,
}}
/>
<EdgeLabelRenderer>
@@ -160,18 +97,7 @@ export const SmoothstepEdge = ({
}}
className="nodrag nopan"
>
- <div
- className={cn(
- 'w-6 h-6 rounded-full flex items-center justify-center border bg-surface-100'
- )}
- style={{ borderColor: color }}
- >
- <Icon
- size={14}
- className={cn(shouldSpin && 'animate-spin')}
- style={{ color, fill: isFilled ? color : undefined }}
- />
- </div>
+ <EdgeVisualChip visual={visual} />
</div>
</EdgeLabelRenderer>
</>
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx
new file mode 100644
index 00000000000..4ca4b8d3b43
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx
@@ -0,0 +1,81 @@
+import { useParams } from 'common'
+import Link from 'next/link'
+import { Tooltip, TooltipContent, TooltipTrigger } from 'ui'
+
+import { metricColor } from './InstanceNode.utils'
+import { useComputeMetrics } from '@/hooks/analytics/useComputeMetrics'
+
+/**
+ * Compute metrics row at the bottom of a primary database node card, linking
+ * to the database report. Metrics are project-scoped, which reports the
+ * primary on both standard and High Availability projects.
+ */
+export const ComputeMetricsFooter = ({ showConnections = true }: { showConnections?: boolean }) => {
+ const { ref } = useParams()
+
+ const {
+ cpu,
+ disk,
+ memory,
+ connections,
+ isLoading: isMetricsLoading,
+ isError: isMetricsError,
+ } = useComputeMetrics({
+ projectRef: ref,
+ })
+
+ const observabilityUrl = `/project/${ref}/observability/database`
+
+ return (
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <Link
+ href={observabilityUrl}
+ className="border-t px-3 py-2 hover:bg-surface-200 transition flex items-center gap-x-3 text-xs"
+ >
+ {/* Stable live region: announces loading/failure, never the polled values */}
+ <span role="status" className="sr-only">
+ {isMetricsLoading && 'Loading metrics'}
+ {!isMetricsLoading && isMetricsError && 'Metrics unavailable'}
+ </span>
+ {/* h-4 matches the text-xs line height so the card doesn't shift when metrics load */}
+ {isMetricsLoading && (
+ <div
+ aria-hidden="true"
+ className="h-4 w-44 rounded-sm bg-surface-300 motion-safe:animate-pulse"
+ />
+ )}
+ {!isMetricsLoading && isMetricsError && (
+ <span aria-hidden="true" className="text-foreground-lighter">
+ Metrics unavailable
+ </span>
+ )}
+ {!isMetricsLoading && !isMetricsError && (
+ <>
+ <span>
+ CPU <span className={metricColor(cpu)}>{cpu.toFixed(0)}%</span>
+ </span>
+ <span className="text-foreground-lighter">·</span>
+ <span>
+ Disk <span className={metricColor(disk)}>{disk.toFixed(0)}%</span>
+ </span>
+ <span className="text-foreground-lighter">·</span>
+ <span>
+ RAM <span className={metricColor(memory)}>{memory.toFixed(0)}%</span>
+ </span>
+ {showConnections && connections.max > 0 && (
+ <>
+ <span className="text-foreground-lighter">·</span>
+ <span className="text-foreground-light">
+ {connections.peak}/{connections.max} conns
+ </span>
+ </>
+ )}
+ </>
+ )}
+ </Link>
+ </TooltipTrigger>
+ <TooltipContent side="bottom">Go to Database Report</TooltipContent>
+ </Tooltip>
+ )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/DiagramFlow.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/DiagramFlow.tsx
new file mode 100644
index 00000000000..4dd20536df8
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/DiagramFlow.tsx
@@ -0,0 +1,132 @@
+import {
+ Background,
+ ColorMode,
+ Edge,
+ EdgeTypes,
+ Node,
+ NodeTypes,
+ ReactFlow,
+ useNodesInitialized,
+ useReactFlow,
+} from '@xyflow/react'
+import { useTheme } from 'next-themes'
+import { useEffect, useEffectEvent, useState } from 'react'
+
+import '@xyflow/react/dist/style.css'
+
+import { cn } from 'ui'
+
+import { getDagreGraphLayout } from './InstanceConfiguration.utils'
+import { timeout } from '@/lib/helpers'
+
+interface DiagramFlowProps {
+ nodes: Node[]
+ edges: Edge[]
+ nodeTypes: NodeTypes
+ edgeTypes: EdgeTypes
+ /** Prepends background group nodes (regions, shards) after the dagre layout runs */
+ addGroupNodes: (nodes: Node[], edges: Edge[]) => { nodes: Node[]; edges: Edge[] }
+ ranksep?: number
+}
+
+/**
+ * Shared React Flow canvas for the infrastructure diagrams, laid out with a
+ * two-pass measured dagre layout: the first pass uses fallback heights while
+ * the diagram is held invisible, then `useNodesInitialized` triggers a second
+ * pass that re-runs dagre with the real measured node heights before fading
+ * the diagram in. Must be rendered inside a `ReactFlowProvider`.
+ */
+export const DiagramFlow = ({
+ nodes,
+ edges,
+ nodeTypes,
+ edgeTypes,
+ addGroupNodes,
+ ranksep,
+}: DiagramFlowProps) => {
+ const reactFlow = useReactFlow()
+ const { resolvedTheme } = useTheme()
+ const nodesInitialized = useNodesInitialized()
+ const [hasMeasuredLayout, setHasMeasuredLayout] = useState(false)
+
+ const backgroundPatternColor =
+ resolvedTheme === 'dark' ? 'rgba(255, 255, 255, 0.3)' : 'rgba(0, 0, 0, 0.4)'
+
+ const setReactFlow = useEffectEvent(async ({ isMeasuredPass }: { isMeasuredPass: boolean }) => {
+ // Merge in React Flow's measured dimensions (if any) so dagre can use real
+ // heights instead of the first-paint fallbacks.
+ const measuredNodes = nodes.map((node) => {
+ const existing = reactFlow.getNode(node.id)
+ return existing?.measured ? { ...node, measured: existing.measured } : node
+ })
+ const graph = getDagreGraphLayout(measuredNodes, edges, { ranksep })
+ const { nodes: groupedNodes } = addGroupNodes(graph.nodes, graph.edges)
+ // Re-attach known measurements to the freshly created group nodes too —
+ // handing setNodes an unmeasured node resets the store's nodesInitialized
+ // flag, which would re-trigger the measured pass below on every re-measure
+ // and loop forever (each iteration re-running fitView, so the diagram
+ // snaps back to center and can't be panned).
+ const updatedNodes = groupedNodes.map((node) => {
+ if (node.measured !== undefined) return node
+ const existing = reactFlow.getNode(node.id)
+ return existing?.measured ? { ...node, measured: existing.measured } : node
+ })
+ reactFlow.setNodes(updatedNodes)
+ reactFlow.setEdges(graph.edges)
+
+ // [Joshen] Odd fix to ensure that react flow snaps back to center when adding nodes
+ await timeout(1)
+ reactFlow.fitView({ maxZoom: 0.9, minZoom: 0.9 })
+ if (isMeasuredPass) setHasMeasuredLayout(true)
+ })
+
+ // First pass: lay out using fallback heights for any not-yet-measured nodes.
+ // The diagram is kept invisible until the measured pass below has run, so the
+ // user never sees the fallback positions.
+ useEffect(() => {
+ if (nodes.length > 0) {
+ setReactFlow({ isMeasuredPass: false })
+ }
+ }, [nodes, edges])
+
+ // Second pass: once React Flow has measured the nodes, re-run the layout so
+ // dagre uses real heights. Only `nodesInitialized` going true should trigger
+ // this — the first-pass effect above handles node changes.
+ const runMeasuredLayout = useEffectEvent(() => {
+ if (nodesInitialized && nodes.length > 0) {
+ setReactFlow({ isMeasuredPass: true })
+ }
+ })
+ useEffect(() => {
+ runMeasuredLayout()
+ }, [nodesInitialized])
+
+ return (
+ <ReactFlow
+ // FIXME: https://github.com/xyflow/xyflow/issues/4876
+ colorMode={'' as unknown as ColorMode}
+ fitView
+ fitViewOptions={{ minZoom: 0.9, maxZoom: 0.9 }}
+ // Keep the diagram invisible (but laid out, so nodes can be measured)
+ // until the measured-height layout pass has run.
+ className={cn(
+ 'instance-configuration transition-opacity duration-150',
+ hasMeasuredLayout ? 'opacity-100' : 'opacity-0'
+ )}
+ zoomOnPinch={false}
+ zoomOnScroll={false}
+ nodesDraggable={false}
+ nodesConnectable={false}
+ zoomOnDoubleClick={false}
+ edgesFocusable={false}
+ edgesReconnectable={false}
+ defaultNodes={[]}
+ defaultEdges={[]}
+ nodeTypes={nodeTypes}
+ edgeTypes={edgeTypes}
+ proOptions={{ hideAttribution: true }}
+ >
+ <Background color={backgroundPatternColor} />
+ </ReactFlow>
+ )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.tsx
new file mode 100644
index 00000000000..0a5c0681998
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.tsx
@@ -0,0 +1,113 @@
+import { useQuery } from '@tanstack/react-query'
+import { useParams } from 'common'
+import { Loader2 } from 'lucide-react'
+import { useMemo } from 'react'
+
+import { DiagramFlow } from './DiagramFlow'
+import { addShardNodes, generateHaNodesAndEdges } from './HaInstanceConfiguration.utils'
+import { HaPrimaryNode, HaReplicaNode, HaShardNode, MultigatewayNode } from './HaInstanceNode'
+import { buildHaTopology, selectTopologyPoolers } from './HaTopology.utils'
+import { HA_RANKSEP } from './InstanceConfiguration.constants'
+import { AlertError } from '@/components/ui/AlertError'
+import { HighAvailabilityDisabledEmptyState } from '@/components/ui/HighAvailability/HighAvailabilityDisabledEmptyState'
+import { haClusterGatewaysQueryOptions } from '@/data/ha-admin/ha-cluster-gateways-query'
+import { haClusterPoolersQueryOptions } from '@/data/ha-admin/ha-cluster-poolers-query'
+
+const nodeTypes = {
+ HA_GATEWAY: MultigatewayNode,
+ HA_PRIMARY: HaPrimaryNode,
+ HA_REPLICA: HaReplicaNode,
+ HA_SHARD: HaShardNode,
+}
+
+// The gateway and replication edges both use React Flow's built-in smoothstep.
+const edgeTypes = {}
+
+const POOLER_STATUS_REFRESH_MS = 30_000
+
+/**
+ * Cluster topology diagram for High Availability (Multigres) projects:
+ * gateway tier → shard group → primary + read replicas, driven by the
+ * read-only multiadmin `/ha-admin` passthrough.
+ */
+export const HaInstanceConfiguration = () => {
+ const { ref: projectRef } = useParams()
+
+ // Gateways poll on the same interval as poolers so the gateway count and
+ // gateway→primary edge track cluster changes while the page stays open.
+ const {
+ data: gatewaysData,
+ error: gatewaysError,
+ isPending: isPendingGateways,
+ isError: isErrorGateways,
+ } = useQuery({
+ ...haClusterGatewaysQueryOptions({ projectRef }),
+ refetchInterval: POOLER_STATUS_REFRESH_MS,
+ })
+
+ const {
+ data: poolers,
+ error: poolersError,
+ isPending: isPendingPoolers,
+ isError: isErrorPoolers,
+ } = useQuery({
+ ...haClusterPoolersQueryOptions({ projectRef }),
+ refetchInterval: POOLER_STATUS_REFRESH_MS,
+ select: selectTopologyPoolers,
+ })
+
+ const gateways = gatewaysData?.gateways
+
+ const { nodes, edges } = useMemo(
+ () =>
+ generateHaNodesAndEdges(
+ buildHaTopology({ gateways: gateways ?? [], poolers: poolers ?? [] })
+ ),
+ [gateways, poolers]
+ )
+
+ const isPending = isPendingGateways || isPendingPoolers
+ const isError = isErrorGateways || isErrorPoolers
+ const error = gatewaysError ?? poolersError
+
+ if (isPending) {
+ return (
+ <div role="status" className="h-full w-full flex items-center justify-center">
+ <span className="sr-only">Loading cluster topology...</span>
+ <Loader2 aria-hidden="true" className="motion-safe:animate-spin text-foreground-light" />
+ </div>
+ )
+ }
+
+ if (isError) {
+ return (
+ <div className="h-full w-full flex items-center justify-center px-28">
+ <AlertError error={error} subject="Failed to retrieve cluster topology" />
+ </div>
+ )
+ }
+
+ if ((poolers ?? []).length === 0) {
+ return (
+ <div className="h-full w-full flex items-center justify-center p-6">
+ <HighAvailabilityDisabledEmptyState
+ title="Cluster topology unavailable"
+ description="Topology data for this project is not available yet. Contact support if this persists."
+ />
+ </div>
+ )
+ }
+
+ return (
+ <div className="nowheel h-full w-full relative">
+ <DiagramFlow
+ nodes={nodes}
+ edges={edges}
+ nodeTypes={nodeTypes}
+ edgeTypes={edgeTypes}
+ addGroupNodes={addShardNodes}
+ ranksep={HA_RANKSEP}
+ />
+ </div>
+ )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.test.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.test.ts
new file mode 100644
index 00000000000..bb8dc47848d
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+
+import { generateHaNodesAndEdges } from './HaInstanceConfiguration.utils'
+import { buildHaTopology } from './HaTopology.utils'
+
+describe('generateHaNodesAndEdges', () => {
+ it('gives every pooler a unique node id even when identities are omitted', () => {
+ const topology = buildHaTopology({
+ gateways: [],
+ poolers: [
+ {
+ id: { cell: 'cell-1', name: 'p-1' },
+ shardKey: { shard: '0' },
+ routingState: { role: 'ROUTING_ROLE_PRIMARY' },
+ },
+ { shardKey: { shard: '0' }, routingState: { role: 'ROUTING_ROLE_REPLICA' } },
+ { shardKey: { shard: '0' }, routingState: { role: 'ROUTING_ROLE_REPLICA' } },
+ ],
+ })
+
+ const { nodes, edges } = generateHaNodesAndEdges(topology)
+ const poolerNodeIds = nodes
+ .filter((node) => node.type === 'HA_PRIMARY' || node.type === 'HA_REPLICA')
+ .map((node) => node.id)
+
+ expect(poolerNodeIds).toHaveLength(3)
+ expect(new Set(poolerNodeIds).size).toBe(3)
+ // Each replica still gets its own edge from the primary.
+ expect(edges).toHaveLength(2)
+ expect(new Set(edges.map((edge) => edge.id)).size).toBe(2)
+ })
+})
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.ts
new file mode 100644
index 00000000000..8521ddea287
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.ts
@@ -0,0 +1,154 @@
+import { Edge, Node } from '@xyflow/react'
+import { groupBy } from 'lodash'
+
+import { getPoolerKey, hasPoolerIdentity, HaTopology } from './HaTopology.utils'
+import {
+ NODE_CARD_WIDTH,
+ SHARD_HEADER_HEIGHT,
+ SHARD_NODE_PADDING,
+} from './InstanceConfiguration.constants'
+import { getDagreNodeHeight } from './InstanceConfiguration.utils'
+
+export type MultigatewayNodeData = {
+ numGateways: number
+}
+
+export type HaPoolerNodeData = {
+ cell?: string
+ name?: string
+ shardId: string
+ shardName: string
+ // Only set on primary nodes; hides the unused top handle when no gateway exists.
+ hasGateway?: boolean
+}
+
+export type HaShardNodeData = {
+ name: string
+}
+
+// Records without a complete identity fall back to a positional id so two of
+// them never collide on the same React Flow node id (which would drop a card).
+const getPoolerNodeId = (pooler: Parameters<typeof getPoolerKey>[0], fallbackId: string) =>
+ hasPoolerIdentity(pooler) ? `pooler-${getPoolerKey(pooler)}` : `pooler-${fallbackId}`
+
+export const generateHaNodesAndEdges = (topology: HaTopology): { nodes: Node[]; edges: Edge[] } => {
+ const position = { x: 0, y: 0 }
+ const nodes: Node[] = []
+ const edges: Edge[] = []
+
+ // The alpha runs one multigateway per cell; the diagram collapses them into a
+ // single gateway node with a count rather than rendering one card per cell.
+ const hasGateway = topology.gateways.length > 0
+ if (hasGateway) {
+ nodes.push({
+ position,
+ id: 'multigateway',
+ type: 'HA_GATEWAY',
+ data: { numGateways: topology.gateways.length } satisfies MultigatewayNodeData,
+ })
+ }
+
+ topology.shards.forEach((shard) => {
+ let primaryId: string | undefined
+
+ if (shard.primary !== undefined) {
+ primaryId = getPoolerNodeId(shard.primary, `${shard.id}-primary`)
+ nodes.push({
+ position,
+ id: primaryId,
+ type: 'HA_PRIMARY',
+ data: {
+ cell: shard.primary.id?.cell,
+ name: shard.primary.id?.name,
+ shardId: shard.id,
+ shardName: shard.name,
+ hasGateway,
+ } satisfies HaPoolerNodeData,
+ })
+
+ if (hasGateway) {
+ edges.push({
+ id: `multigateway-${primaryId}`,
+ source: 'multigateway',
+ target: primaryId,
+ type: 'smoothstep',
+ className: 'cursor-default!',
+ })
+ }
+ }
+
+ shard.replicas.forEach((replica, replicaIndex) => {
+ const replicaId = getPoolerNodeId(replica, `${shard.id}-replica-${replicaIndex}`)
+ nodes.push({
+ position,
+ id: replicaId,
+ type: 'HA_REPLICA',
+ data: {
+ cell: replica.id?.cell,
+ name: replica.id?.name,
+ shardId: shard.id,
+ shardName: shard.name,
+ } satisfies HaPoolerNodeData,
+ })
+
+ if (primaryId !== undefined) {
+ edges.push({
+ id: `${primaryId}-${replicaId}`,
+ source: primaryId,
+ target: replicaId,
+ type: 'smoothstep',
+ animated: true,
+ className: 'cursor-default!',
+ })
+ }
+ })
+ })
+
+ return { nodes, edges }
+}
+
+const getNodeWidth = (node: Node) => node.measured?.width ?? NODE_CARD_WIDTH
+
+/**
+ * Prepends a background group node per shard wrapping its primary + replicas,
+ * using the same fake-subflow trick as `addRegionNodes` (dagre has no subflow
+ * support, so the box is sized from the laid-out children's bounding box).
+ */
+export const addShardNodes = (nodes: Node[], edges: Edge[]) => {
+ const shardNodes: Node[] = []
+ const poolerNodes = nodes.filter(
+ (node) => node.type === 'HA_PRIMARY' || node.type === 'HA_REPLICA'
+ ) as Node<HaPoolerNodeData>[]
+
+ const nodesByShard = groupBy(poolerNodes, (node) => node.data.shardId)
+ Object.entries(nodesByShard).forEach(([shardId, children]) => {
+ const minX = Math.min(...children.map((node) => node.position.x))
+ const maxX = Math.max(...children.map((node) => node.position.x + getNodeWidth(node)))
+ const minY = Math.min(...children.map((node) => node.position.y))
+ const maxY = Math.max(...children.map((node) => node.position.y + getDagreNodeHeight(node)))
+
+ shardNodes.push({
+ id: `shard-${shardId}`,
+ position: {
+ x: minX - SHARD_NODE_PADDING,
+ y: minY - SHARD_HEADER_HEIGHT - SHARD_NODE_PADDING,
+ },
+ // Explicit dimensions so React Flow renders the node immediately —
+ // without them a node stays `visibility: hidden` until a measurement
+ // pass that this post-layout background node never gets.
+ width: maxX - minX + SHARD_NODE_PADDING * 2,
+ height: maxY - minY + SHARD_HEADER_HEIGHT + SHARD_NODE_PADDING * 2,
+ // The box covers most of the canvas; making it non-interactive lets
+ // React Flow drop its pointer events so drag-to-pan passes through to
+ // the pane. The header pill re-enables pointer events for its tooltip.
+ selectable: false,
+ focusable: false,
+ type: 'HA_SHARD',
+ data: {
+ name: children[0].data.shardName,
+ } satisfies HaShardNodeData,
+ })
+ })
+
+ return { nodes: [...shardNodes, ...nodes], edges }
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceNode.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceNode.tsx
new file mode 100644
index 00000000000..7c439e4de59
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceNode.tsx
@@ -0,0 +1,190 @@
+import { Handle, Node, NodeProps, Position } from '@xyflow/react'
+import { Database, DatabaseBackup, HelpCircle, Layers, Loader2, Network } from 'lucide-react'
+import { Badge, cn, Tooltip, TooltipContent, TooltipTrigger } from 'ui'
+
+import { ComputeMetricsFooter } from './ComputeMetricsFooter'
+import {
+ HaPoolerNodeData,
+ HaShardNodeData,
+ MultigatewayNodeData,
+} from './HaInstanceConfiguration.utils'
+import { HA_POOLER_STATUS_LABELS, HaPoolerStatus } from './HaTopology.utils'
+import { NODE_CARD_WIDTH } from './InstanceConfiguration.constants'
+import { useHaPoolerCard } from './useHaPooler'
+import { BASE_PATH } from '@/lib/constants'
+
+const STATUS_BADGE_VARIANTS: Record<HaPoolerStatus, 'success' | 'warning' | 'default'> = {
+ healthy: 'success',
+ coming_up: 'default',
+ going_down: 'default',
+ unhealthy: 'warning',
+}
+
+const PoolerStatusBadge = ({ status }: { status: HaPoolerStatus }) => (
+ <Badge variant={STATUS_BADGE_VARIANTS[status]}>{HA_POOLER_STATUS_LABELS[status]}</Badge>
+)
+
+const PoolerCardSubtitle = ({
+ availabilityZone,
+ computeSize,
+}: {
+ availabilityZone?: string
+ computeSize?: string
+}) => (
+ <p className="flex items-center gap-x-1 text-sm text-foreground-light">
+ {availabilityZone !== undefined && <span>{availabilityZone}</span>}
+ {availabilityZone !== undefined && !!computeSize && (
+ <span className="text-foreground-lighter">·</span>
+ )}
+ {!!computeSize && <span>{computeSize}</span>}
+ </p>
+)
+
+export const MultigatewayNode = ({ data }: NodeProps<Node<MultigatewayNodeData>>) => {
+ const { numGateways } = data
+
+ return (
+ <>
+ <div className="flex flex-col rounded-sm bg-surface-100 border border-default">
+ <div className="flex items-start p-3 gap-x-4" style={{ width: NODE_CARD_WIDTH }}>
+ <div className="flex gap-x-3">
+ <div className="min-w-8 h-8 bg-blue-600 border border-blue-800 rounded-md flex items-center justify-center">
+ <Network aria-hidden="true" size={16} />
+ </div>
+ <div className="flex flex-col gap-y-0.5">
+ <p className="text-sm">Multigateway</p>
+ <p className="flex items-center gap-x-1 text-sm text-foreground-light">
+ <span>Load balancer</span>
+ {numGateways > 1 && (
+ <>
+ <span className="text-foreground-lighter">·</span>
+ <span>{numGateways} instances</span>
+ </>
+ )}
+ </p>
+ </div>
+ </div>
+ </div>
+ </div>
+ <Handle type="source" position={Position.Bottom} style={{ background: 'transparent' }} />
+ </>
+ )
+}
+
+export const HaPrimaryNode = ({ data }: NodeProps<Node<HaPoolerNodeData>>) => {
+ // [Joshen] Just FYI Handles cannot be conditionally rendered
+ const { cell, name, hasGateway } = data
+ const { status, availabilityZone, computeSize, primaryRegion } = useHaPoolerCard({ cell, name })
+
+ return (
+ <>
+ <Handle
+ type="target"
+ position={Position.Top}
+ className={!hasGateway ? 'opacity-0' : ''}
+ style={{ background: 'transparent' }}
+ />
+ <div className="flex flex-col rounded-sm bg-surface-100 border border-default">
+ <div className="flex items-start justify-between p-3" style={{ width: NODE_CARD_WIDTH }}>
+ <div className="flex gap-x-3">
+ <div className="w-8 h-8 bg-brand-500 border border-brand-600 rounded-md flex items-center justify-center">
+ <Database aria-hidden="true" size={16} />
+ </div>
+ <div className="flex flex-col gap-y-0.5">
+ <div className="flex items-center gap-x-2">
+ <p className="text-sm">Primary Database</p>
+ {/* Stable live region so polled status changes are announced */}
+ <span role="status">
+ {status !== undefined && <PoolerStatusBadge status={status} />}
+ </span>
+ </div>
+ {primaryRegion !== undefined && (
+ <p className="text-sm text-foreground-light">{primaryRegion.name}</p>
+ )}
+ <PoolerCardSubtitle availabilityZone={availabilityZone} computeSize={computeSize} />
+ </div>
+ </div>
+ {primaryRegion !== undefined && (
+ // Decorative — the visible text next to it already names the region
+ <img
+ alt=""
+ aria-hidden="true"
+ className="w-8 rounded-xs mt-0.5"
+ src={`${BASE_PATH}/img/regions/${primaryRegion.region}.svg`}
+ />
+ )}
+ </div>
+ {/* Whether connection metrics are meaningful through the multigateway
+ is unconfirmed, so they're left off for HA projects. */}
+ <ComputeMetricsFooter showConnections={false} />
+ </div>
+ <Handle type="source" position={Position.Bottom} style={{ background: 'transparent' }} />
+ </>
+ )
+}
+
+export const HaReplicaNode = ({ data }: NodeProps<Node<HaPoolerNodeData>>) => {
+ const { cell, name } = data
+ const { status, availabilityZone, computeSize } = useHaPoolerCard({ cell, name })
+
+ return (
+ <>
+ <Handle type="target" position={Position.Top} style={{ background: 'transparent' }} />
+ <div
+ className="flex items-start rounded-sm bg-surface-100 border border-default p-3"
+ style={{ width: NODE_CARD_WIDTH }}
+ >
+ <div className="flex gap-x-3">
+ <div
+ className={cn(
+ 'w-8 h-8 border rounded-md flex items-center justify-center',
+ status === 'healthy'
+ ? 'bg-brand-400 border-brand-500'
+ : 'bg-surface-100 border-foreground/20'
+ )}
+ >
+ {status === 'coming_up' ? (
+ <Loader2 aria-hidden="true" className="motion-safe:animate-spin" size={16} />
+ ) : (
+ <DatabaseBackup aria-hidden="true" size={16} />
+ )}
+ </div>
+ <div className="flex flex-col gap-y-0.5">
+ <div className="flex items-center gap-x-2">
+ <p className="text-sm">Read Replica</p>
+ {/* Stable live region so polled status changes are announced */}
+ <span role="status">
+ {status !== undefined && <PoolerStatusBadge status={status} />}
+ </span>
+ </div>
+ <PoolerCardSubtitle availabilityZone={availabilityZone} computeSize={computeSize} />
+ </div>
+ </div>
+ </div>
+ </>
+ )
+}
+
+export const HaShardNode = ({ data }: NodeProps<Node<HaShardNodeData>>) => {
+ const { name } = data
+
+ return (
+ <div className="relative h-full w-full rounded-md border border-default bg-surface-100/25">
+ <div className="pointer-events-auto absolute top-3 left-3 flex items-center gap-x-2 rounded-full border border-default bg-surface-100 pl-3 pr-2 py-1">
+ <Layers aria-hidden="true" size={14} className="text-foreground-light" />
+ <p className="text-sm">{name}</p>
+ <Tooltip>
+ {/* Renders a button so the explanation is keyboard reachable */}
+ <TooltipTrigger className="flex items-center gap-x-1 text-sm text-foreground-light">
+ Automatic failover
+ <HelpCircle aria-hidden="true" size={14} />
+ </TooltipTrigger>
+ <TooltipContent side="bottom" className="max-w-72 text-center">
+ If the primary database fails, a replica in this shard is automatically promoted to take
+ its place.
+ </TooltipContent>
+ </Tooltip>
+ </div>
+ </div>
+ )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.test.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.test.ts
new file mode 100644
index 00000000000..6e8d77ba78d
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.test.ts
@@ -0,0 +1,292 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+ buildHaTopology,
+ formatCellAsAvailabilityZone,
+ getPoolerStatus,
+ isPrimaryPooler,
+ selectTopologyPoolers,
+} from './HaTopology.utils'
+import type { Multipooler } from '@/data/ha-admin/ha-cluster-poolers-query'
+
+const primaryPooler = (overrides: Partial<Multipooler> = {}): Multipooler => ({
+ id: { cell: 'eu-central-1a', name: 'pooler-1' },
+ shardKey: { database: 'postgres', shard: '0' },
+ routingState: { role: 'ROUTING_ROLE_PRIMARY' },
+ ...overrides,
+})
+
+const replicaPooler = (overrides: Partial<Multipooler> = {}): Multipooler => ({
+ id: { cell: 'eu-central-1b', name: 'pooler-2' },
+ shardKey: { database: 'postgres', shard: '0' },
+ routingState: { role: 'ROUTING_ROLE_REPLICA' },
+ ...overrides,
+})
+
+describe('isPrimaryPooler', () => {
+ it('uses routingState.role as the authoritative signal', () => {
+ expect(isPrimaryPooler(primaryPooler())).toBe(true)
+ expect(isPrimaryPooler(replicaPooler())).toBe(false)
+ })
+
+ it('prefers routingState.role over the deprecated type field', () => {
+ expect(isPrimaryPooler(replicaPooler({ type: 'PRIMARY' }))).toBe(false)
+ })
+
+ it('falls back to the deprecated type field when routingState is omitted', () => {
+ expect(isPrimaryPooler({ type: 'PRIMARY' })).toBe(true)
+ expect(isPrimaryPooler({ type: 'REPLICA' })).toBe(false)
+ })
+
+ it('treats a pooler with every field omitted as a replica', () => {
+ expect(isPrimaryPooler({})).toBe(false)
+ })
+})
+
+describe('getPoolerStatus', () => {
+ it('treats a pooler with every field omitted as healthy (proto3 zero values mean SERVING)', () => {
+ expect(getPoolerStatus({})).toBe('healthy')
+ })
+
+ it('maps lifecycle states with or without the proto enum prefix', () => {
+ expect(getPoolerStatus({ lifecycleStatus: { status: 'STARTING' } })).toBe('coming_up')
+ expect(getPoolerStatus({ lifecycleStatus: { status: 'LIFECYCLE_STARTING' } })).toBe('coming_up')
+ expect(getPoolerStatus({ lifecycleStatus: { status: 'STOPPING' } })).toBe('going_down')
+ expect(getPoolerStatus({ lifecycleStatus: { status: 'SHUTDOWN' } })).toBe('unhealthy')
+ expect(getPoolerStatus({ lifecycleStatus: { status: 'QUARANTINED' } })).toBe('unhealthy')
+ })
+
+ it('falls back to serving status when the lifecycle is active', () => {
+ const active = { lifecycleStatus: { status: 'ACTIVE' } }
+ expect(getPoolerStatus({ ...active })).toBe('healthy')
+ expect(getPoolerStatus({ ...active, servingStatus: 'DRAINING' })).toBe('going_down')
+ expect(getPoolerStatus({ ...active, servingStatus: 'DISABLED' })).toBe('unhealthy')
+ expect(getPoolerStatus({ ...active, servingStatus: 'SERVING' })).toBe('healthy')
+ })
+
+ it('prioritizes a terminal lifecycle over the serving status', () => {
+ expect(
+ getPoolerStatus({ lifecycleStatus: { status: 'QUARANTINED' }, servingStatus: 'SERVING' })
+ ).toBe('unhealthy')
+ })
+})
+
+describe('formatCellAsAvailabilityZone', () => {
+ it('returns an AZ-shaped cell as is', () => {
+ expect(formatCellAsAvailabilityZone('eu-central-1a')).toBe('eu-central-1a')
+ })
+
+ it('extracts an AZ-shaped substring from a longer cell name', () => {
+ expect(formatCellAsAvailabilityZone('cell-eu-central-1a')).toBe('eu-central-1a')
+ expect(formatCellAsAvailabilityZone('ap-southeast-2c-0')).toBe('ap-southeast-2c')
+ })
+
+ it('falls back to the raw cell name when no AZ shape is found', () => {
+ expect(formatCellAsAvailabilityZone('cell-1')).toBe('cell-1')
+ })
+
+ it('returns undefined for an omitted cell', () => {
+ expect(formatCellAsAvailabilityZone(undefined)).toBeUndefined()
+ expect(formatCellAsAvailabilityZone('')).toBeUndefined()
+ })
+})
+
+describe('selectTopologyPoolers', () => {
+ it('projects poolers down to identity, shard, and routing role', () => {
+ const projected = selectTopologyPoolers({
+ poolers: [
+ {
+ id: { cell: 'cell-1', name: 'p-1' },
+ shardKey: { database: 'postgres', tableGroup: 'default', shard: '0-inf' },
+ type: 'PRIMARY',
+ hostname: 'some-host',
+ servingStatus: 'DRAINING',
+ lifecycleStatus: { status: 'LIFECYCLE_ACTIVE' },
+ routingState: {
+ role: 'ROUTING_ROLE_PRIMARY',
+ rule: { coordinatorTerm: '2', leaderSubterm: '1' },
+ },
+ },
+ ],
+ })
+
+ // Volatile fields (lifecycle, serving status, hostname) are dropped so the
+ // projection stays deep-equal across polls when the topology is unchanged.
+ // The routing rule is kept — it decides the primary during failover.
+ expect(projected).toEqual([
+ {
+ id: { cell: 'cell-1', name: 'p-1' },
+ shardKey: { database: 'postgres', tableGroup: 'default', shard: '0-inf' },
+ routingState: {
+ role: 'ROUTING_ROLE_PRIMARY',
+ rule: { coordinatorTerm: '2', leaderSubterm: '1' },
+ },
+ type: 'PRIMARY',
+ },
+ ])
+ })
+
+ it('preserves omitted fields as undefined and handles an empty response', () => {
+ expect(selectTopologyPoolers({})).toEqual([])
+ expect(selectTopologyPoolers({ poolers: [{}] })).toEqual([
+ { id: undefined, shardKey: undefined, routingState: undefined, type: undefined },
+ ])
+ })
+})
+
+describe('buildHaTopology', () => {
+ it('groups poolers into a shard with a primary and replicas', () => {
+ const primary = primaryPooler()
+ const replicaB = replicaPooler()
+ const replicaC = replicaPooler({ id: { cell: 'eu-central-1c', name: 'pooler-3' } })
+
+ const topology = buildHaTopology({
+ gateways: [{ id: { cell: 'eu-central-1a', name: 'gateway-1' } }],
+ poolers: [replicaC, primary, replicaB],
+ })
+
+ expect(topology.gateways).toHaveLength(1)
+ expect(topology.shards).toHaveLength(1)
+ expect(topology.shards[0].name).toBe('Shard 1')
+ expect(topology.shards[0].primary).toEqual(primary)
+ // Replicas are sorted by cell/name for a stable layout.
+ expect(topology.shards[0].replicas).toEqual([replicaB, replicaC])
+ })
+
+ it('splits poolers with different shard keys into separate shards', () => {
+ const topology = buildHaTopology({
+ gateways: [],
+ poolers: [
+ primaryPooler({ shardKey: { database: 'postgres', shard: '1' } }),
+ primaryPooler({
+ id: { cell: 'eu-central-1b', name: 'pooler-9' },
+ shardKey: { database: 'postgres', shard: '0' },
+ }),
+ ],
+ })
+
+ expect(topology.shards).toHaveLength(2)
+ expect(topology.shards.map((shard) => shard.name)).toEqual(['Shard 1', 'Shard 2'])
+ expect(topology.shards[0].primary?.shardKey?.shard).toBe('0')
+ expect(topology.shards[1].primary?.shardKey?.shard).toBe('1')
+ })
+
+ it('groups poolers with omitted shard keys into a single shard', () => {
+ const topology = buildHaTopology({
+ gateways: [],
+ poolers: [primaryPooler({ shardKey: undefined }), replicaPooler({ shardKey: undefined })],
+ })
+
+ expect(topology.shards).toHaveLength(1)
+ expect(topology.shards[0].replicas).toHaveLength(1)
+ })
+
+ it('keeps extra primaries as replicas instead of dropping them (tie keeps sort order)', () => {
+ const first = primaryPooler()
+ const second = primaryPooler({ id: { cell: 'eu-central-1b', name: 'pooler-2' } })
+
+ const topology = buildHaTopology({ gateways: [], poolers: [second, first] })
+
+ expect(topology.shards[0].primary).toEqual(first)
+ expect(topology.shards[0].replicas).toEqual([second])
+ })
+
+ it('elects the primary claimant with the highest coordinator term during failover', () => {
+ // '9' vs '10' also guards against lexicographic string comparison.
+ const outgoing = primaryPooler({
+ routingState: { role: 'ROUTING_ROLE_PRIMARY', rule: { coordinatorTerm: '9' } },
+ })
+ const incoming = primaryPooler({
+ id: { cell: 'eu-central-1b', name: 'pooler-2' },
+ routingState: { role: 'ROUTING_ROLE_PRIMARY', rule: { coordinatorTerm: '10' } },
+ })
+
+ const topology = buildHaTopology({ gateways: [], poolers: [outgoing, incoming] })
+
+ expect(topology.shards[0].primary).toEqual(incoming)
+ expect(topology.shards[0].replicas).toEqual([outgoing])
+ })
+
+ it('breaks coordinator-term ties on leader subterm', () => {
+ const lower = primaryPooler({
+ routingState: {
+ role: 'ROUTING_ROLE_PRIMARY',
+ rule: { coordinatorTerm: '2', leaderSubterm: '1' },
+ },
+ })
+ const higher = primaryPooler({
+ id: { cell: 'eu-central-1b', name: 'pooler-2' },
+ routingState: {
+ role: 'ROUTING_ROLE_PRIMARY',
+ rule: { coordinatorTerm: '2', leaderSubterm: '2' },
+ },
+ })
+
+ const topology = buildHaTopology({ gateways: [], poolers: [lower, higher] })
+
+ expect(topology.shards[0].primary).toEqual(higher)
+ })
+
+ it('prefers a claimant with a routing rule over one without (omitted terms are zero)', () => {
+ const withoutRule = primaryPooler()
+ const withRule = primaryPooler({
+ id: { cell: 'eu-central-1b', name: 'pooler-2' },
+ routingState: { role: 'ROUTING_ROLE_PRIMARY', rule: { coordinatorTerm: '1' } },
+ })
+
+ const topology = buildHaTopology({ gateways: [], poolers: [withoutRule, withRule] })
+
+ expect(topology.shards[0].primary).toEqual(withRule)
+ expect(topology.shards[0].replicas).toEqual([withoutRule])
+ })
+
+ it('handles a shard with no primary', () => {
+ const topology = buildHaTopology({ gateways: [], poolers: [replicaPooler()] })
+
+ expect(topology.shards[0].primary).toBeUndefined()
+ expect(topology.shards[0].replicas).toHaveLength(1)
+ })
+
+ it('dedupes repeated records by id (the passthrough returns one copy per cell)', () => {
+ const gateway = { id: { cell: 'cell-1', name: 'gw-1' } }
+ const primary = primaryPooler({
+ id: { cell: 'cell-1', name: 'p-1' },
+ lifecycleStatus: { status: 'LIFECYCLE_ACTIVE' },
+ })
+ const replica = replicaPooler({ id: { cell: 'cell-2', name: 'p-2' } })
+
+ const topology = buildHaTopology({
+ gateways: [gateway, gateway, gateway],
+ poolers: [primary, replica, primary, replica, primary, replica],
+ })
+
+ expect(topology.gateways).toEqual([gateway])
+ expect(topology.shards).toHaveLength(1)
+ // Duplicate copies of the primary must not be demoted to replicas.
+ expect(topology.shards[0].primary).toEqual(primary)
+ expect(topology.shards[0].replicas).toEqual([replica])
+ })
+
+ it('never dedupes records with omitted identity', () => {
+ const identityless = (overrides: Partial<Multipooler> = {}): Multipooler => ({
+ shardKey: { database: 'postgres', shard: '0' },
+ routingState: { role: 'ROUTING_ROLE_REPLICA' },
+ ...overrides,
+ })
+
+ const topology = buildHaTopology({
+ gateways: [{}, {}],
+ poolers: [primaryPooler(), identityless(), identityless()],
+ })
+
+ expect(topology.gateways).toHaveLength(2)
+ expect(topology.shards[0].replicas).toHaveLength(2)
+ })
+
+ it('returns an empty topology for empty responses', () => {
+ const topology = buildHaTopology({ gateways: [], poolers: [] })
+
+ expect(topology.gateways).toEqual([])
+ expect(topology.shards).toEqual([])
+ })
+})
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.ts
new file mode 100644
index 00000000000..1624caf53b2
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.ts
@@ -0,0 +1,192 @@
+import { groupBy, partition, uniqBy } from 'lodash'
+
+import type { Multigateway } from '@/data/ha-admin/ha-cluster-gateways-query'
+import type { HaClusterPoolersData, Multipooler } from '@/data/ha-admin/ha-cluster-poolers-query'
+
+/**
+ * Pure helpers mapping the multiadmin cluster state (gateways + poolers) onto
+ * the shapes the High Availability infrastructure diagram renders. Every field
+ * on the multiadmin responses is optional because proto3 JSON omits zero
+ * values — an absent field means "the default", not "missing data".
+ */
+
+export type HaPoolerStatus = 'healthy' | 'coming_up' | 'going_down' | 'unhealthy'
+
+export interface HaShard {
+ id: string
+ name: string
+ primary?: Multipooler
+ replicas: Multipooler[]
+}
+
+export interface HaTopology {
+ gateways: Multigateway[]
+ shards: HaShard[]
+}
+
+export const getPoolerKey = (pooler: Pick<Multipooler, 'id'>) =>
+ `${pooler.id?.cell ?? 'unknown'}-${pooler.id?.name ?? 'unknown'}`
+
+export const hasPoolerIdentity = (pooler: Pick<Multipooler, 'id'>) =>
+ pooler.id?.cell !== undefined && pooler.id?.name !== undefined
+
+/**
+ * `routingState.role` is the authoritative writable signal; the deprecated
+ * `type` field is derived and only used as a fallback when the routing state is
+ * missing. The role is omitted entirely when it is ROUTING_ROLE_UNKNOWN
+ * (proto3 zero value).
+ */
+export const isPrimaryPooler = (pooler: Multipooler) => {
+ const role = pooler.routingState?.role
+ if (role !== undefined) return role === 'ROUTING_ROLE_PRIMARY'
+ return pooler.type === 'PRIMARY'
+}
+
+/**
+ * Health as reported by the pooler's topology record — not a live probe: a
+ * pooler that crashes without publishing STOPPING/SHUTDOWN can leave an
+ * ACTIVE/SERVING record behind until the topology evicts it, and "healthy"
+ * says nothing about replication progress. Live signals (WAL receiver state,
+ * replay position) exist on `GET /poolers/{cell}/{name}/status` but require a
+ * per-pooler fanout.
+ */
+export const getPoolerStatus = (pooler: Multipooler): HaPoolerStatus => {
+ // Lifecycle values may arrive with or without the proto enum prefix.
+ const lifecycle = (pooler.lifecycleStatus?.status ?? '').replace(/^LIFECYCLE_/, '')
+
+ if (lifecycle === 'QUARANTINED' || lifecycle === 'SHUTDOWN') return 'unhealthy'
+ if (lifecycle === 'STARTING') return 'coming_up'
+ if (lifecycle === 'STOPPING') return 'going_down'
+
+ // Lifecycle is ACTIVE or unknown: fall back to the serving status. An absent
+ // servingStatus means SERVING (proto3 zero value), i.e. the node is taking
+ // traffic, so the default reads as healthy.
+ if (pooler.servingStatus === 'DRAINING') return 'going_down'
+ if (pooler.servingStatus === 'DISABLED') return 'unhealthy'
+ return 'healthy'
+}
+
+// Matches the status vocabulary of the read replica surfaces (getStatusLabel).
+export const HA_POOLER_STATUS_LABELS: Record<HaPoolerStatus, string> = {
+ healthy: 'Healthy',
+ coming_up: 'Coming up',
+ going_down: 'Going down',
+ unhealthy: 'Unhealthy',
+}
+
+const AWS_AZ_REGEX = /\b[a-z]{2}(?:-[a-z]+)+-\d[a-z]\b/
+
+/**
+ * Cells map 1:1 to availability zones in the alpha, but the exact cell naming
+ * format is unconfirmed — extract an AZ-shaped substring when there is one and
+ * fall back to the raw cell name otherwise.
+ */
+export const formatCellAsAvailabilityZone = (cell: string | undefined) => {
+ if (!cell) return undefined
+ return AWS_AZ_REGEX.exec(cell)?.[0] ?? cell
+}
+
+// Routing-rule terms are proto int64s, serialized as strings in JSON and
+// omitted when zero. Failover counts stay far below Number's safe range.
+const parseTerm = (value: string | undefined) => {
+ const parsed = Number(value ?? 0)
+ return Number.isFinite(parsed) ? parsed : 0
+}
+
+// Orders two primary claimants by routing rule: (coordinator term, leader
+// subterm), greatest wins.
+const compareRoutingRules = (a: Multipooler, b: Multipooler) => {
+ const ruleA = a.routingState?.rule
+ const ruleB = b.routingState?.rule
+ return (
+ parseTerm(ruleA?.coordinatorTerm) - parseTerm(ruleB?.coordinatorTerm) ||
+ parseTerm(ruleA?.leaderSubterm) - parseTerm(ruleB?.leaderSubterm)
+ )
+}
+
+export const buildHaTopology = ({
+ gateways,
+ poolers,
+}: {
+ gateways: Multigateway[]
+ poolers: Multipooler[]
+}): HaTopology => {
+ // The /ha-admin passthrough can return the same record multiple times (one
+ // copy per cell it fans out to), so both lists must be deduped by id —
+ // duplicate poolers would otherwise produce duplicate React Flow node ids,
+ // and extra copies of the primary would render as replicas. Records without
+ // a complete identity can't be told apart, so they are never deduped (keying
+ // by the record itself keeps each one unique).
+ const uniqueGateways = uniqBy(gateways, (gateway) =>
+ hasPoolerIdentity(gateway) ? getPoolerKey(gateway) : gateway
+ )
+ const uniquePoolers = uniqBy(poolers, (pooler) =>
+ hasPoolerIdentity(pooler) ? getPoolerKey(pooler) : pooler
+ )
+
+ const sortedPoolers = [...uniquePoolers].sort((a, b) =>
+ getPoolerKey(a).localeCompare(getPoolerKey(b))
+ )
+ const poolersByShard = groupBy(
+ sortedPoolers,
+ (pooler) =>
+ `${pooler.shardKey?.database ?? ''}/${pooler.shardKey?.tableGroup ?? ''}/${pooler.shardKey?.shard ?? ''}`
+ )
+
+ const shards = Object.entries(poolersByShard)
+ .sort(([a], [b]) => a.localeCompare(b))
+ .map(([id, shardPoolers], index) => {
+ const [primaries, replicas] = partition(shardPoolers, isPrimaryPooler)
+ // During a failover the outgoing and incoming primary can briefly both
+ // claim ROUTING_ROLE_PRIMARY — the highest routing rule wins, matching
+ // the multigateway's election. Losing claimants render as replicas
+ // rather than being dropped; ties keep the first in sorted order so the
+ // result stays deterministic.
+ const primary = primaries.reduce<Multipooler | undefined>(
+ (best, candidate) =>
+ best === undefined || compareRoutingRules(candidate, best) > 0 ? candidate : best,
+ undefined
+ )
+ return {
+ id,
+ name: `Shard ${index + 1}`,
+ primary,
+ replicas: [...primaries.filter((pooler) => pooler !== primary), ...replicas],
+ }
+ })
+
+ return { gateways: uniqueGateways, shards }
+}
+
+/**
+ * Query `select` projecting poolers down to the fields the topology depends on
+ * (identity, shard, routing role) — live status is self-fetched by the
+ * individual nodes and edges. React Query's structural sharing then keeps the
+ * result referentially stable across polls, so refetches only re-run
+ * layout/fitView when the topology actually changes (volatile fields like
+ * lifecycle timestamps would otherwise churn the data identity on every poll).
+ */
+const projectRoutingRule = (rule: NonNullable<Multipooler['routingState']>['rule']) =>
+ rule === undefined
+ ? undefined
+ : { coordinatorTerm: rule.coordinatorTerm, leaderSubterm: rule.leaderSubterm }
+
+const projectRoutingState = (routingState: Multipooler['routingState']) =>
+ routingState === undefined
+ ? undefined
+ : { role: routingState.role, rule: projectRoutingRule(routingState.rule) }
+
+export const selectTopologyPoolers = (data: HaClusterPoolersData): Multipooler[] =>
+ (data.poolers ?? []).map((pooler) => ({
+ id: pooler.id === undefined ? undefined : { cell: pooler.id.cell, name: pooler.id.name },
+ shardKey:
+ pooler.shardKey === undefined
+ ? undefined
+ : {
+ database: pooler.shardKey.database,
+ tableGroup: pooler.shardKey.tableGroup,
+ shard: pooler.shardKey.shard,
+ },
+ routingState: projectRoutingState(pooler.routingState),
+ type: pooler.type,
+ }))
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts
index 2d49e4739cc..7f8f2b2b6db 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts
@@ -44,9 +44,22 @@ export type EdgeData = {
export const NODE_WIDTH = 660
export const NODE_SEP = 20
+// Rendered width of the node cards; dagre lays out with NODE_WIDTH / 2 so
+// cards get a little breathing room between columns.
+export const NODE_CARD_WIDTH = NODE_WIDTH / 2 - 10
+
// The region wrapper is a static, non-measured sibling node with a fixed size.
export const REGION_NODE_HEIGHT = 162
+// The shard wrapper is a static, non-measured background node sized around its
+// children, with room reserved above them for the group header pill.
+export const SHARD_NODE_PADDING = 16
+export const SHARD_HEADER_HEIGHT = 42
+
+// dagre rank separation for the High Availability layout — leaves room for the
+// shard group header between the gateway row and the primary row.
+export const HA_RANKSEP = 96
+
// First-paint fallback heights for the dagre layout, only used before React
// Flow has measured the real nodes. Subsequent layouts use node.measured.height.
export const NODE_HEIGHT_FALLBACKS: Record<string, number> = {
@@ -54,6 +67,9 @@ export const NODE_HEIGHT_FALLBACKS: Record<string, number> = {
PRIMARY: 140,
READ_REPLICA: 140,
REGION: REGION_NODE_HEIGHT,
+ HA_GATEWAY: 64,
+ HA_PRIMARY: 150,
+ HA_REPLICA: 90,
}
// [Joshen] Coordinates from https://github.com/tobilg/aws-edge-locations/blob/main/data/aws-edge-locations.json
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx
index c49a7416010..7b4b4732259 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx
@@ -1,24 +1,14 @@
-import {
- Background,
- ColorMode,
- Edge,
- ReactFlow,
- ReactFlowProvider,
- useNodesInitialized,
- useReactFlow,
-} from '@xyflow/react'
+import { Edge, ReactFlowProvider } from '@xyflow/react'
+import { useParams } from 'common'
import { partition } from 'lodash'
import { Globe2, Loader2, Network } from 'lucide-react'
-import { useTheme } from 'next-themes'
-import { useEffect, useEffectEvent, useMemo, useState } from 'react'
-
-import '@xyflow/react/dist/style.css'
-
-import { useParams } from 'common'
-import { Button, cn } from 'ui'
+import { useEffect, useMemo, useState } from 'react'
+import { Button } from 'ui'
+import { DiagramFlow } from './DiagramFlow'
import { SmoothstepEdge } from './Edge'
-import { addRegionNodes, generateNodes, getDagreGraphLayout } from './InstanceConfiguration.utils'
+import { HaInstanceConfiguration } from './HaInstanceConfiguration'
+import { addRegionNodes, generateNodes } from './InstanceConfiguration.utils'
import { LoadBalancerNode, PrimaryNode, RegionNode, ReplicaNode } from './InstanceNode'
import MapView from './MapView'
import { REPLICA_STATUS } from '@/components/interfaces/Settings/Infrastructure/ReadReplicas/ReadReplicas.constants'
@@ -29,13 +19,22 @@ import {
ReplicaInitializationStatus,
useReadReplicasStatusesQuery,
} from '@/data/read-replicas/replicas-status-query'
+import { useHighAvailability } from '@/hooks/misc/useHighAvailability'
import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
import { useIsAwsCloudProvider, useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
-import { timeout } from '@/lib/helpers'
+
+const nodeTypes = {
+ PRIMARY: PrimaryNode,
+ READ_REPLICA: ReplicaNode,
+ REGION: RegionNode,
+ LOAD_BALANCER: LoadBalancerNode,
+}
+
+const edgeTypes = {
+ smoothstep: SmoothstepEdge,
+}
const InstanceConfigurationUI = () => {
- const reactFlow = useReactFlow()
- const { resolvedTheme } = useTheme()
const { ref: projectRef } = useParams()
const { isPending: isLoadingProject } = useSelectedProjectQuery()
@@ -109,9 +108,6 @@ const InstanceConfigurationUI = () => {
replicasStatuses,
])
- const backgroundPatternColor =
- resolvedTheme === 'dark' ? 'rgba(255, 255, 255, 0.3)' : 'rgba(0, 0, 0, 0.4)'
-
const nodes = useMemo(
() =>
isSuccessReplicas && isSuccessLoadBalancers && primary !== undefined
@@ -135,7 +131,8 @@ const InstanceConfigurationUI = () => {
source: 'load-balancer',
target: primary.identifier,
type: 'smoothstep',
- animated: true,
+ // Static: no data flows between the load balancer and the
+ // database — the line only indicates a relation.
className: 'cursor-default!',
},
]
@@ -160,76 +157,21 @@ const InstanceConfigurationUI = () => {
[isSuccessLoadBalancers, isSuccessReplicas, loadBalancers, primary?.identifier, replicas]
)
- const nodeTypes = useMemo(
- () => ({
- PRIMARY: PrimaryNode,
- READ_REPLICA: ReplicaNode,
- REGION: RegionNode,
- LOAD_BALANCER: LoadBalancerNode,
- }),
- []
- )
-
- const edgeTypes = useMemo(
- () => ({
- smoothstep: SmoothstepEdge,
- }),
- []
- )
-
- const nodesInitialized = useNodesInitialized()
- const [hasMeasuredLayout, setHasMeasuredLayout] = useState(false)
-
- const setReactFlow = async ({ measured }: { measured: boolean }) => {
- // Merge in React Flow's measured dimensions (if any) so dagre can use real
- // heights instead of the first-paint fallbacks.
- const measuredNodes = nodes.map((node) => {
- const existing = reactFlow.getNode(node.id)
- return existing?.measured ? { ...node, measured: existing.measured } : node
- })
- const graph = getDagreGraphLayout(measuredNodes, edges)
- const { nodes: updatedNodes } = addRegionNodes(graph.nodes, graph.edges)
- reactFlow.setNodes(updatedNodes)
- reactFlow.setEdges(graph.edges)
-
- // [Joshen] Odd fix to ensure that react flow snaps back to center when adding nodes
- await timeout(1)
- reactFlow.fitView({ maxZoom: 0.9, minZoom: 0.9 })
- if (measured) setHasMeasuredLayout(true)
- }
-
- // First pass: lay out using fallback heights for any not-yet-measured nodes.
- // The diagram is kept invisible until the measured pass below has run, so the
- // user never sees the fallback positions.
- // [Joshen] Just FYI this block is oddly triggering whenever we refocus on the viewport
- // even if I change the dependency array to just data. Not blocker, just an area to optimize
- useEffect(() => {
- if (isSuccessReplicas && isSuccessLoadBalancers && nodes.length > 0 && view === 'flow') {
- setReactFlow({ measured: false })
- }
- }, [isSuccessReplicas, isSuccessLoadBalancers, nodes, edges, view])
-
- // Second pass: once React Flow has measured the nodes, re-run the layout so
- // dagre uses real heights. Only `nodesInitialized` going true should trigger
- // this — the first-pass effect above handles node/view changes.
- const runMeasuredLayout = useEffectEvent(() => {
- if (nodesInitialized && nodes.length > 0 && view === 'flow') {
- setReactFlow({ measured: true })
- }
- })
- useEffect(() => {
- runMeasuredLayout()
- }, [nodesInitialized])
-
return (
- <div className={cn('nowheel h-full')}>
+ <div className="nowheel h-full">
<div
className={`h-full w-full relative ${
isSuccessReplicas && !isLoadingProject ? '' : 'flex items-center justify-center px-28'
}`}
>
{(isLoading || isLoadingProject) && (
- <Loader2 className="animate-spin text-foreground-light" />
+ <div role="status">
+ <span className="sr-only">Loading infrastructure...</span>
+ <Loader2
+ aria-hidden="true"
+ className="motion-safe:animate-spin text-foreground-light"
+ />
+ </div>
)}
{isError && <AlertError error={error} subject="Failed to retrieve replicas" />}
{isSuccessReplicas && !isLoadingProject && (
@@ -259,32 +201,13 @@ const InstanceConfigurationUI = () => {
</div>
)}
{view === 'flow' ? (
- <ReactFlow
- // FIXME: https://github.com/xyflow/xyflow/issues/4876
- colorMode={'' as unknown as ColorMode}
- fitView
- fitViewOptions={{ minZoom: 0.9, maxZoom: 0.9 }}
- // Keep the diagram invisible (but laid out, so nodes can be
- // measured) until the measured-height layout pass has run.
- className={cn(
- 'instance-configuration transition-opacity duration-150',
- hasMeasuredLayout ? 'opacity-100' : 'opacity-0'
- )}
- zoomOnPinch={false}
- zoomOnScroll={false}
- nodesDraggable={false}
- nodesConnectable={false}
- zoomOnDoubleClick={false}
- edgesFocusable={false}
- edgesReconnectable={false}
- defaultNodes={[]}
- defaultEdges={[]}
+ <DiagramFlow
+ nodes={nodes}
+ edges={edges}
nodeTypes={nodeTypes}
edgeTypes={edgeTypes}
- proOptions={{ hideAttribution: true }}
- >
- <Background color={backgroundPatternColor} />
- </ReactFlow>
+ addGroupNodes={addRegionNodes}
+ />
) : (
<MapView />
)}
@@ -296,9 +219,22 @@ const InstanceConfigurationUI = () => {
}
export const InstanceConfiguration = () => {
+ const { isHighAvailability, isPending } = useHighAvailability()
+
+ // Wait for the project record so an HA project never briefly mounts the
+ // standard diagram (and fires its queries) before swapping.
+ if (isPending) {
+ return (
+ <div role="status" className="h-full w-full flex items-center justify-center">
+ <span className="sr-only">Loading infrastructure...</span>
+ <Loader2 aria-hidden="true" className="motion-safe:animate-spin text-foreground-light" />
+ </div>
+ )
+ }
+
return (
<ReactFlowProvider>
- <InstanceConfigurationUI />
+ {isHighAvailability ? <HaInstanceConfiguration /> : <InstanceConfigurationUI />}
</ReactFlowProvider>
)
}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.test.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.test.ts
new file mode 100644
index 00000000000..8a9f75fa4d3
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.test.ts
@@ -0,0 +1,28 @@
+import { Edge, Node } from '@xyflow/react'
+import { describe, expect, it } from 'vitest'
+
+import { NODE_HEIGHT_FALLBACKS } from './InstanceConfiguration.constants'
+import { getDagreGraphLayout } from './InstanceConfiguration.utils'
+
+const makeNodes = (): Node[] => [
+ { id: 'primary', position: { x: 0, y: 0 }, data: {}, type: 'PRIMARY' },
+ { id: 'replica', position: { x: 0, y: 0 }, data: {}, type: 'READ_REPLICA' },
+]
+
+const edges: Edge[] = [{ id: 'primary-replica', source: 'primary', target: 'replica' }]
+
+// Vertical gap between a node's bottom edge and the next rank's top edge.
+const getRankGap = (nodes: Node[]) =>
+ nodes[1].position.y - (nodes[0].position.y + NODE_HEIGHT_FALLBACKS.PRIMARY)
+
+describe('getDagreGraphLayout', () => {
+ it('separates ranks by the default ranksep', () => {
+ const { nodes } = getDagreGraphLayout(makeNodes(), edges)
+ expect(getRankGap(nodes)).toBe(60)
+ })
+
+ it('separates ranks by a custom ranksep', () => {
+ const { nodes } = getDagreGraphLayout(makeNodes(), edges, { ranksep: 96 })
+ expect(getRankGap(nodes)).toBe(96)
+ })
+})
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts
index 81e89e5ae2b..c4a2489f3db 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts
@@ -114,15 +114,19 @@ export const generateNodes = ({
]
}
-const getDagreNodeHeight = (node: Node) => {
+export const getDagreNodeHeight = (node: Node) => {
if (node.measured?.height) return node.measured.height
return NODE_HEIGHT_FALLBACKS[node.type ?? ''] ?? 100
}
-export const getDagreGraphLayout = (nodes: Node[], edges: Edge[]) => {
+export const getDagreGraphLayout = (
+ nodes: Node[],
+ edges: Edge[],
+ { ranksep = 60 }: { ranksep?: number } = {}
+) => {
const dagreGraph = new dagre.graphlib.Graph()
dagreGraph.setDefaultEdgeLabel(() => ({}))
- dagreGraph.setGraph({ rankdir: 'TB', ranksep: 60, nodesep: NODE_SEP })
+ dagreGraph.setGraph({ rankdir: 'TB', ranksep, nodesep: NODE_SEP })
nodes.forEach((node) => {
dagreGraph.setNode(node.id, {
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx
index 9689483c179..f01884557e4 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx
@@ -21,6 +21,7 @@ import {
} from 'ui'
import { TimestampInfo } from 'ui-patterns/TimestampInfo'
+import { ComputeMetricsFooter } from './ComputeMetricsFooter'
import {
ERROR_STATES,
INIT_PROGRESS,
@@ -32,7 +33,6 @@ import {
ReplicaNodeData,
} from './InstanceConfiguration.constants'
import { formatSeconds } from './InstanceConfiguration.utils'
-import { metricColor } from './InstanceNode.utils'
import { getReadReplicaPath } from '@/components/interfaces/Settings/Infrastructure/Infrastructure.utils'
import { REPLICA_STATUS } from '@/components/interfaces/Settings/Infrastructure/ReadReplicas/ReadReplicas.constants'
import { RegionFlag } from '@/components/ui/RegionFlag'
@@ -43,7 +43,6 @@ import {
useReadReplicasStatusesQuery,
} from '@/data/read-replicas/replicas-status-query'
import { formatDatabaseID } from '@/data/read-replicas/replicas.utils'
-import { useComputeMetrics } from '@/hooks/analytics/useComputeMetrics'
import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
import { useDatabaseSelectorStateSnapshot } from '@/state/database-selector'
@@ -92,25 +91,11 @@ export const LoadBalancerNode = ({ data }: NodeProps<Node<LoadBalancerData>>) =>
export const PrimaryNode = ({ data }: NodeProps<Node<PrimaryNodeData>>) => {
// [Joshen] Just FYI Handles cannot be conditionally rendered
const { region, computeSize, numReplicas, numRegions, hasLoadBalancer } = data
- const { ref } = useParams()
const { projectHomepageShowInstanceSize } = useIsFeatureEnabled([
'project_homepage:show_instance_size',
])
- const {
- cpu,
- disk,
- memory,
- connections,
- isLoading: metricsLoading,
- isError: metricsError,
- } = useComputeMetrics({
- projectRef: ref,
- })
-
- const observabilityUrl = `/project/${ref}/observability/database`
-
return (
<>
<Handle
@@ -171,43 +156,7 @@ export const PrimaryNode = ({ data }: NodeProps<Node<PrimaryNodeData>>) => {
</p>
</div>
)}
- <Tooltip>
- <TooltipTrigger asChild>
- <Link
- href={observabilityUrl}
- className="border-t px-3 py-2 hover:bg-surface-200 transition flex items-center gap-x-3 text-xs"
- >
- {metricsLoading ? (
- <div className="h-3 w-44 rounded-sm bg-surface-300 animate-pulse" />
- ) : metricsError ? (
- <span className="text-foreground-lighter">Metrics unavailable</span>
- ) : (
- <>
- <span>
- CPU <span className={metricColor(cpu)}>{cpu.toFixed(0)}%</span>
- </span>
- <span className="text-foreground-lighter">·</span>
- <span>
- Disk <span className={metricColor(disk)}>{disk.toFixed(0)}%</span>
- </span>
- <span className="text-foreground-lighter">·</span>
- <span>
- RAM <span className={metricColor(memory)}>{memory.toFixed(0)}%</span>
- </span>
- {connections.max > 0 && (
- <>
- <span className="text-foreground-lighter">·</span>
- <span className="text-foreground-light">
- {connections.peak}/{connections.max} conns
- </span>
- </>
- )}
- </>
- )}
- </Link>
- </TooltipTrigger>
- <TooltipContent side="bottom">Go to Database Report</TooltipContent>
- </Tooltip>
+ <ComputeMetricsFooter />
</div>
<Handle
type="source"
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/useHaPooler.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/useHaPooler.ts
new file mode 100644
index 00000000000..af64b7301b8
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/useHaPooler.ts
@@ -0,0 +1,45 @@
+import { useQuery } from '@tanstack/react-query'
+import { useParams } from 'common'
+
+import { formatCellAsAvailabilityZone, getPoolerStatus } from './HaTopology.utils'
+import { AVAILABLE_REPLICA_REGIONS } from './InstanceConfiguration.constants'
+import { haClusterPoolersQueryOptions } from '@/data/ha-admin/ha-cluster-poolers-query'
+import { usePrimaryDatabase } from '@/data/read-replicas/replicas-query'
+import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
+
+/**
+ * Subscribes to a single pooler's live state from the shared poolers query, so
+ * each node/edge updates on its own without re-laying-out the whole diagram.
+ */
+export const useHaPooler = ({ cell, name }: { cell?: string; name?: string }) => {
+ const { ref: projectRef } = useParams()
+
+ return useQuery({
+ ...haClusterPoolersQueryOptions({ projectRef }),
+ select: (data) =>
+ (data.poolers ?? []).find((pooler) => pooler.id?.cell === cell && pooler.id?.name === name),
+ })
+}
+
+/**
+ * Everything a pooler node card displays. Region and compute size aren't in
+ * multiadmin — they come from the primary database row. HA locks compute to
+ * one project-level size, so the primary's size is correct for every node in
+ * the cluster.
+ */
+export const useHaPoolerCard = ({ cell, name }: { cell?: string; name?: string }) => {
+ const { ref: projectRef } = useParams()
+ const { projectHomepageShowInstanceSize } = useIsFeatureEnabled([
+ 'project_homepage:show_instance_size',
+ ])
+
+ const { database: primary } = usePrimaryDatabase({ projectRef })
+ const { data: pooler } = useHaPooler({ cell, name })
+
+ return {
+ status: pooler !== undefined ? getPoolerStatus(pooler) : undefined,
+ availabilityZone: formatCellAsAvailabilityZone(cell),
+ computeSize: projectHomepageShowInstanceSize ? primary?.size : undefined,
+ primaryRegion: AVAILABLE_REPLICA_REGIONS.find((r) => primary?.region.includes(r.region)),
+ }
+}
diff --git a/apps/studio/components/ui/ReactFlow/EdgeVisual.tsx b/apps/studio/components/ui/ReactFlow/EdgeVisual.tsx
new file mode 100644
index 00000000000..88c56574656
--- /dev/null
+++ b/apps/studio/components/ui/ReactFlow/EdgeVisual.tsx
@@ -0,0 +1,88 @@
+import { ArrowRight, Loader2, Square, X, type LucideIcon } from 'lucide-react'
+import { cn } from 'ui'
+
+export interface ReplicationState {
+ isComingUp: boolean
+ isReplicating: boolean
+ isFailed: boolean
+}
+
+export interface EdgeVisual {
+ Icon: LucideIcon
+ // CSS color shared by the icon and the connecting line so they always match.
+ color: string
+ opacity: number
+ dashArray: string
+ strokeWidth: number
+ shouldAnimate: boolean
+ shouldSpin?: boolean
+ isFilled?: boolean
+}
+
+// Picks the icon + line appearance for a replication state. Both the icon and the line are derived
+// here from the same state so they always stay in sync. We deliberately don't surface lag: the line
+// just communicates whether data is moving, stopped, starting, or broken.
+export const getEdgeVisual = ({
+ isComingUp,
+ isReplicating,
+ isFailed,
+}: ReplicationState): EdgeVisual => {
+ if (isFailed) {
+ return {
+ Icon: X,
+ color: 'hsl(var(--destructive-default))',
+ opacity: 1,
+ dashArray: '5 5',
+ shouldAnimate: false,
+ strokeWidth: 4,
+ }
+ }
+ if (isComingUp) {
+ return {
+ Icon: Loader2,
+ color: 'var(--foreground-light)',
+ opacity: 1,
+ dashArray: '5',
+ strokeWidth: 2,
+ shouldAnimate: true,
+ shouldSpin: true,
+ }
+ }
+ if (isReplicating) {
+ return {
+ Icon: ArrowRight,
+ color: 'hsl(var(--brand-default))',
+ opacity: 1,
+ dashArray: '5',
+ strokeWidth: 2,
+ shouldAnimate: true,
+ }
+ }
+ return {
+ Icon: Square,
+ color: 'var(--foreground-lighter)',
+ opacity: 0.5,
+ dashArray: '5 5',
+ strokeWidth: 2,
+ shouldAnimate: false,
+ isFilled: true,
+ }
+}
+
+/** The round icon chip rendered mid-edge, bordered in the edge's color. */
+export const EdgeVisualChip = ({ visual }: { visual: EdgeVisual }) => {
+ const { Icon, color, shouldSpin, isFilled } = visual
+
+ return (
+ <div
+ className="w-6 h-6 rounded-full flex items-center justify-center border bg-surface-100"
+ style={{ borderColor: color }}
+ >
+ <Icon
+ size={14}
+ className={cn(shouldSpin && 'motion-safe:animate-spin')}
+ style={{ color, fill: isFilled ? color : undefined }}
+ />
+ </div>
+ )
+}
diff --git a/apps/studio/data/ha-admin/get-ha-admin.ts b/apps/studio/data/ha-admin/get-ha-admin.ts
new file mode 100644
index 00000000000..53b205fcbd8
--- /dev/null
+++ b/apps/studio/data/ha-admin/get-ha-admin.ts
@@ -0,0 +1,41 @@
+import { z } from 'zod'
+
+import { get, handleError } from '@/data/fetchers'
+
+/**
+ * Read-only slices of the multiadmin API, surfaced through the mgmt-api
+ * `/ha-admin` GET passthrough. The passthrough is a catch-all proxy, so these
+ * paths aren't in Studio's generated OpenAPI types — each resource validates
+ * the response against its own zod schema instead.
+ *
+ * mgmt-api forwards `/ha-admin/v1/<x>` → `/multiadmin/v1/<x>`, which the
+ * project edge gateway rewrites to multiadmin's `/api/v1/<x>`.
+ */
+export async function getHaAdmin(
+ projectRef: string | undefined,
+ subPath: string,
+ signal?: AbortSignal
+): Promise<unknown> {
+ if (!projectRef) throw new Error('projectRef is required')
+
+ const { data, error } = await get(
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any -- off-schema passthrough path
+ `/platform/projects/${projectRef}/ha-admin/v1/${subPath}` as any,
+ { signal }
+ )
+
+ if (error) handleError(error)
+ return data
+}
+
+/**
+ * Validates a passthrough response, surfacing a readable error (which lands in
+ * the diagram's AlertError fallback) instead of a raw zod issue dump.
+ */
+export function parseHaAdminResponse<T extends z.ZodTypeAny>(schema: T, data: unknown): z.infer<T> {
+ const parsed = schema.safeParse(data)
+ if (!parsed.success) {
+ throw new Error('Received an unexpected response from the cluster admin API')
+ }
+ return parsed.data
+}
diff --git a/apps/studio/data/ha-admin/ha-cluster-cells-query.ts b/apps/studio/data/ha-admin/ha-cluster-cells-query.ts
new file mode 100644
index 00000000000..d5571f502c3
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-cells-query.ts
@@ -0,0 +1,27 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterCellsVariables = { projectRef?: string }
+export type HaClusterCellsError = ResponseError
+
+// Every field is optional because proto3 JSON omits zero values.
+const haClusterCellsResponseSchema = z.object({ names: z.array(z.string()).optional() })
+
+async function getHaClusterCells({ projectRef }: HaClusterCellsVariables, signal?: AbortSignal) {
+ const data = await getHaAdmin(projectRef, 'cells', signal)
+ return parseHaAdminResponse(haClusterCellsResponseSchema, data)
+}
+
+export type HaClusterCellsData = Awaited<ReturnType<typeof getHaClusterCells>>
+
+export const haClusterCellsQueryOptions = ({ projectRef }: HaClusterCellsVariables) =>
+ queryOptions({
+ queryKey: haAdminKeys.cells(projectRef),
+ queryFn: ({ signal }) => getHaClusterCells({ projectRef }, signal),
+ enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+ })
diff --git a/apps/studio/data/ha-admin/ha-cluster-databases-query.ts b/apps/studio/data/ha-admin/ha-cluster-databases-query.ts
new file mode 100644
index 00000000000..15cfd3adfb1
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-databases-query.ts
@@ -0,0 +1,30 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterDatabasesVariables = { projectRef?: string }
+export type HaClusterDatabasesError = ResponseError
+
+// Every field is optional because proto3 JSON omits zero values.
+const haClusterDatabasesResponseSchema = z.object({ names: z.array(z.string()).optional() })
+
+async function getHaClusterDatabases(
+ { projectRef }: HaClusterDatabasesVariables,
+ signal?: AbortSignal
+) {
+ const data = await getHaAdmin(projectRef, 'databases', signal)
+ return parseHaAdminResponse(haClusterDatabasesResponseSchema, data)
+}
+
+export type HaClusterDatabasesData = Awaited<ReturnType<typeof getHaClusterDatabases>>
+
+export const haClusterDatabasesQueryOptions = ({ projectRef }: HaClusterDatabasesVariables) =>
+ queryOptions({
+ queryKey: haAdminKeys.databases(projectRef),
+ queryFn: ({ signal }) => getHaClusterDatabases({ projectRef }, signal),
+ enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+ })
diff --git a/apps/studio/data/ha-admin/ha-cluster-gateways-query.ts b/apps/studio/data/ha-admin/ha-cluster-gateways-query.ts
new file mode 100644
index 00000000000..b8e8037b3aa
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-gateways-query.ts
@@ -0,0 +1,39 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterGatewaysVariables = { projectRef?: string }
+export type HaClusterGatewaysError = ResponseError
+
+// Every field is optional because proto3 JSON omits zero values.
+const multigatewaySchema = z.object({
+ id: z.object({ cell: z.string().optional(), name: z.string().optional() }).optional(),
+ hostname: z.string().optional(),
+})
+
+const haClusterGatewaysResponseSchema = z.object({
+ gateways: z.array(multigatewaySchema).optional(),
+})
+
+export type Multigateway = z.infer<typeof multigatewaySchema>
+
+async function getHaClusterGateways(
+ { projectRef }: HaClusterGatewaysVariables,
+ signal?: AbortSignal
+) {
+ const data = await getHaAdmin(projectRef, 'gateways', signal)
+ return parseHaAdminResponse(haClusterGatewaysResponseSchema, data)
+}
+
+export type HaClusterGatewaysData = Awaited<ReturnType<typeof getHaClusterGateways>>
+
+export const haClusterGatewaysQueryOptions = ({ projectRef }: HaClusterGatewaysVariables) =>
+ queryOptions({
+ queryKey: haAdminKeys.gateways(projectRef),
+ queryFn: ({ signal }) => getHaClusterGateways({ projectRef }, signal),
+ enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+ })
diff --git a/apps/studio/data/ha-admin/ha-cluster-poolers-query.ts b/apps/studio/data/ha-admin/ha-cluster-poolers-query.ts
new file mode 100644
index 00000000000..b88b12cbc14
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-poolers-query.ts
@@ -0,0 +1,64 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterPoolersVariables = { projectRef?: string }
+export type HaClusterPoolersError = ResponseError
+
+// Hand-modelled subset of multiadmin's OpenAPI spec. Every field is optional
+// because proto3 JSON omits zero values, and enum-shaped fields stay plain
+// strings (expected values in comments) so new proto values degrade gracefully
+// instead of failing the whole parse.
+const multipoolerSchema = z.object({
+ id: z.object({ cell: z.string().optional(), name: z.string().optional() }).optional(),
+ shardKey: z
+ .object({
+ database: z.string().optional(),
+ tableGroup: z.string().optional(),
+ shard: z.string().optional(),
+ })
+ .optional(),
+ // 'UNKNOWN' | 'PRIMARY' | 'REPLICA' | 'DRAINED' — deprecated (derived, not
+ // authoritative), prefer `routingState.role`
+ type: z.string().optional(),
+ // 'SERVING' | 'DISABLED' | 'DRAINING'
+ servingStatus: z.string().optional(),
+ hostname: z.string().optional(),
+ lifecycleStatus: z.object({ status: z.string().optional() }).optional(),
+ routingState: z
+ .object({
+ role: z.string().optional(),
+ // proto int64s, serialized as strings in JSON
+ rule: z
+ .object({ coordinatorTerm: z.string().optional(), leaderSubterm: z.string().optional() })
+ .optional(),
+ })
+ .optional(),
+})
+
+const haClusterPoolersResponseSchema = z.object({
+ poolers: z.array(multipoolerSchema).optional(),
+})
+
+export type Multipooler = z.infer<typeof multipoolerSchema>
+
+async function getHaClusterPoolers(
+ { projectRef }: HaClusterPoolersVariables,
+ signal?: AbortSignal
+) {
+ const data = await getHaAdmin(projectRef, 'poolers', signal)
+ return parseHaAdminResponse(haClusterPoolersResponseSchema, data)
+}
+
+export type HaClusterPoolersData = Awaited<ReturnType<typeof getHaClusterPoolers>>
+
+export const haClusterPoolersQueryOptions = ({ projectRef }: HaClusterPoolersVariables) =>
+ queryOptions({
+ queryKey: haAdminKeys.poolers(projectRef),
+ queryFn: ({ signal }) => getHaClusterPoolers({ projectRef }, signal),
+ enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+ })
diff --git a/apps/studio/data/ha-admin/keys.ts b/apps/studio/data/ha-admin/keys.ts
new file mode 100644
index 00000000000..3193018650a
--- /dev/null
+++ b/apps/studio/data/ha-admin/keys.ts
@@ -0,0 +1,9 @@
+export const haAdminKeys = {
+ cells: (projectRef: string | undefined) => ['projects', projectRef, 'ha-admin', 'cells'] as const,
+ databases: (projectRef: string | undefined) =>
+ ['projects', projectRef, 'ha-admin', 'databases'] as const,
+ poolers: (projectRef: string | undefined) =>
+ ['projects', projectRef, 'ha-admin', 'poolers'] as const,
+ gateways: (projectRef: string | undefined) =>
+ ['projects', projectRef, 'ha-admin', 'gateways'] as const,
+}
diff --git a/apps/studio/pages/project/[ref]/database/replication/index.tsx b/apps/studio/pages/project/[ref]/database/replication/index.tsx
index 296fcd4f3e2..e444bbad613 100644
--- a/apps/studio/pages/project/[ref]/database/replication/index.tsx
+++ b/apps/studio/pages/project/[ref]/database/replication/index.tsx
@@ -12,9 +12,9 @@ import { GenericSkeletonLoader } from 'ui-patterns/ShimmeringLoader'
import { ReadReplicasMovedCallout } from '@/components/interfaces/Database/Replication/DestinationPanel/ReadReplicasMovedCallout'
import { Destinations } from '@/components/interfaces/Database/Replication/Destinations'
import { ReplicationDiagram } from '@/components/interfaces/Database/Replication/ReplicationDiagram'
+import { InstanceConfiguration } from '@/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration'
import DatabaseLayout from '@/components/layouts/DatabaseLayout/DatabaseLayout'
import { DefaultLayout } from '@/components/layouts/DefaultLayout'
-import { HighAvailabilityDisabledEmptyState } from '@/components/ui/HighAvailability/HighAvailabilityDisabledEmptyState'
import { UnknownInterface } from '@/components/ui/UnknownInterface'
import { useHighAvailability } from '@/hooks/misc/useHighAvailability'
import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
@@ -33,12 +33,26 @@ const DatabaseReplicationPage: NextPageWithLayout = () => {
if (isHighAvailability) {
return (
- <div className="flex h-full w-full items-center justify-center p-6">
- <HighAvailabilityDisabledEmptyState
- title="Replication unavailable on High Availability projects"
- description="We're working to bring replication to High Availability projects. Contact support if this is blocking your work."
- />
- </div>
+ <>
+ <PageHeader size="large">
+ <PageHeaderMeta>
+ <PageHeaderSummary>
+ <PageHeaderTitle>Replication</PageHeaderTitle>
+ <PageHeaderDescription>High Availability cluster topology</PageHeaderDescription>
+ </PageHeaderSummary>
+ </PageHeaderMeta>
+ </PageHeader>
+
+ <PageContainer size="large">
+ <PageSection>
+ <PageSectionContent>
+ <div className="relative h-[500px] w-full overflow-hidden rounded-md border border-muted">
+ <InstanceConfiguration />
+ </div>
+ </PageSectionContent>
+ </PageSection>
+ </PageContainer>
+ </>
)
}
diff --git a/apps/studio/styles/reactflow.css b/apps/studio/styles/reactflow.css
index 62e1a494528..89eb05a4758 100644
--- a/apps/studio/styles/reactflow.css
+++ b/apps/studio/styles/reactflow.css
@@ -9,6 +9,12 @@
}
}
+@media (prefers-reduced-motion: reduce) {
+ .react-flow__edge.animated path {
+ animation: none;
+ }
+}
+
.map-path {
animation: dash 8s linear infinite;
}