@skyhook-io/radar-app 1.17.0 → 1.17.1

package/src/components/cnpg/shared.tsx

@@ -1,18 +1,23 @@
 import type { ReactNode } from 'react'
 import type { UseQueryResult } from '@tanstack/react-query'
-import { clsx } from 'clsx'
-import { Database, X } from 'lucide-react'
+import { Database } from 'lucide-react'
 import {
   CNPG_KIND_BY_KEY,
+  FoldSection,
+  coverageReadable,
   PaneLoader,
+  RadarUpgradeAction,
+  getRadarUpgradeRequirement,
+  radarUpgradeDetail,
+  radarUpgradeHeadline,
   type CNPGFleet,
   type CNPGKindCoverage,
   type CNPGWorkspaceResponse,
+  type CNPGWorkspaceKey,
 } from '@skyhook-io/k8s-ui'
 import type { SelectedResource } from '../../types'
 import { useConnection } from '../../context/ConnectionContext'
-import { EmptyState, Notice, ROW_HOVER, TABLE_HEAD, TABLE_WRAP, TBODY, TD, TH } from '../capacity/shared'
-import { sameResource } from './routes'
+import { Notice, RefreshFailedNotice, ScreenEmptyState } from '../workspace/layout'
 
 export interface CNPGScreenProps {
   data: CNPGWorkspaceResponse
@@ -23,25 +28,33 @@ export interface CNPGScreenProps {
   onInspect: (resource: SelectedResource) => void
   inspected: SelectedResource | null
   onClearNamespaces: () => void
+  /** Opens the create dialog for this screen's kind (the Clusters view's Create). */
+  onCreate?: () => void
 }
 
 const COVERAGE_LABEL: Record<string, string> = {
   denied: 'no access',
-  partial: 'no access in some namespaces',
+  partial: 'not read in some namespaces',
+  uncached: 'not cached by Radar',
   syncing: 'still loading',
   error: 'could not be read',
 }
 
+// The workspace name sits on the title line, as on the CloudNativePG detail
+// pages; it is not a link, since on Clusters it would lead to itself.
 export function CNPGWorkspaceHeader({ title, subtitle, actions }: { title: string; subtitle?: ReactNode; actions?: ReactNode }) {
   return (
     <div className="px-5 pt-4 xl:px-7">
-      <div className="flex items-center gap-2 text-xs text-theme-text-tertiary">
-        <Database className="h-3.5 w-3.5" />
-        <span>CloudNativePG</span>
-      </div>
-      <div className="mt-1 flex flex-wrap items-end justify-between gap-x-4 gap-y-2">
+      <div className="flex flex-wrap items-end justify-between gap-x-4 gap-y-2">
         <div className="min-w-0">
-          <h1 className="text-lg font-semibold text-theme-text-primary">{title}</h1>
+          <div className="flex flex-wrap items-center gap-x-2">
+            <span className="flex items-center gap-1.5 text-sm text-theme-text-tertiary">
+              <Database className="h-3.5 w-3.5" />
+              CloudNativePG
+              <span>/</span>
+            </span>
+            <h1 className="text-lg font-semibold text-theme-text-primary">{title}</h1>
+          </div>
           {subtitle && <div className="mt-0.5 text-sm text-theme-text-secondary">{subtitle}</div>}
         </div>
         {actions}
@@ -50,16 +63,52 @@ export function CNPGWorkspaceHeader({ title, subtitle, actions }: { title: strin
   )
 }
 
-export function CoverageNotice({ fleet, data }: { fleet: CNPGFleet; data: CNPGWorkspaceResponse }) {
-  if (fleet.incompleteKinds.length === 0) return null
-  const parts = fleet.incompleteKinds.map((k) => {
-    const cov = data.coverage[k]
-    const label = COVERAGE_LABEL[cov?.state ?? ''] ?? cov?.state
-    return `${CNPG_KIND_BY_KEY[k].kind} (${label})`
-  })
+// The causes the server named for the namespaces it left unread. A partial or
+// uncached read can name both kinds of namespace at once.
+function namedCauses(cov: CNPGKindCoverage | undefined, uncachedNoun: string): { denied?: string; uncached?: string } {
+  return {
+    denied: cov?.deniedNamespaces?.length ? cov.deniedNamespaces.join(', ') : undefined,
+    uncached: cov?.uncachedNamespaces?.length ? `${uncachedNoun} in ${cov.uncachedNamespaces.join(', ')}` : undefined,
+  }
+}
+
+/** How much of a kind was read, in a few words ("not cached by Radar in pg"). */
+export function coverageLabel(cov: CNPGKindCoverage | undefined): string {
+  if (!cov) return 'not read by this Radar'
+  const { denied, uncached } = namedCauses(cov, 'not cached by Radar')
+  const named = [denied && `no access in ${denied}`, uncached].filter(Boolean)
+  if (named.length > 0) return named.join('; ')
+  return COVERAGE_LABEL[cov?.state ?? ''] ?? cov?.state ?? 'unknown'
+}
+
+const INCOMPLETE_STATES = new Set(['partial', 'denied', 'syncing', 'error', 'uncached'])
+
+/**
+ * The incomplete kinds grouped by what was left unread, each reason said once.
+ * Jobs count when their coverage is incomplete: a Cluster's initdb, join and
+ * restore Job Pods are read only where they are.
+ */
+export function incompleteKindsText(kinds: CNPGFleet['incompleteKinds'], coverage: CNPGWorkspaceResponse['coverage'], jobCoverage?: CNPGKindCoverage): string {
+  const byLabel = new Map<string, string[]>()
+  const add = (kind: string, cov: CNPGKindCoverage | undefined) => {
+    const label = coverageLabel(cov)
+    byLabel.set(label, [...(byLabel.get(label) ?? []), kind])
+  }
+  for (const k of kinds) add(CNPG_KIND_BY_KEY[k].kind, coverage[k])
+  if (jobCoverage && INCOMPLETE_STATES.has(jobCoverage.state)) add('Job', jobCoverage)
+  return [...byLabel].map(([label, names]) => `${names.join(', ')} (${label})`).join('; ')
+}
+
+export function CoverageNotice({ fleet, data, kinds, namespace, includeJobs = false }: { fleet: CNPGFleet; data: CNPGWorkspaceResponse; kinds: readonly CNPGWorkspaceKey[]; namespace?: string; includeJobs?: boolean }) {
+  const incomplete = fleet.incompleteKinds.filter((k) => { const coverage = data.coverage[k]; return kinds.includes(k) && (!coverage || !coverageReadable(coverage, namespace)) })
+  const jobsIncomplete = includeJobs && !!data.jobCoverage && INCOMPLETE_STATES.has(data.jobCoverage.state) && !coverageReadable(data.jobCoverage, namespace)
+  if (incomplete.length === 0 && !jobsIncomplete) return null
   return (
     <Notice>
-      Some CloudNativePG data is not readable: {parts.join(', ')}. Facts built on it read “No access” or “unknown” rather than none, and counts are lower bounds.
+      Some data used on this screen was not read.
+      <FoldSection title="Coverage details" summary="Kinds and reasons" attention={false}>
+        {incompleteKindsText(incomplete, data.coverage, jobsIncomplete ? data.jobCoverage : undefined)}. Counts over incomplete data are lower bounds.
+      </FoldSection>
     </Notice>
   )
 }
@@ -81,172 +130,44 @@ export function CNPGScreenGate({
   const data = query.data
   if (!data && query.isLoading) return <PaneLoader label="Loading CloudNativePG…" className="flex-1" />
   if (!data) {
+    const upgrade = getRadarUpgradeRequirement(query.error)
+    if (upgrade) {
+      return (
+        <ScreenEmptyState
+          icon={Database}
+          title={radarUpgradeHeadline('CloudNativePG')}
+          detail={radarUpgradeDetail(upgrade)}
+          action={
+            <div className="mt-3 text-sm">
+              <RadarUpgradeAction requirement={upgrade} />
+            </div>
+          }
+        />
+      )
+    }
     return (
-      <EmptyState
+      <ScreenEmptyState
         icon={Database}
-        title="CloudNativePG workspace unavailable"
-        detail={query.error instanceof Error ? query.error.message : 'The workspace could not be loaded.'}
+        title="CloudNativePG data unavailable"
+        detail={query.error instanceof Error ? query.error.message : 'Radar could not load the CloudNativePG data.'}
+        action={
+          <button type="button" onClick={() => void query.refetch()} disabled={query.isFetching} className="btn-secondary mt-3 px-3 py-1.5 text-sm">
+            {query.isFetching ? 'Retrying…' : 'Retry'}
+          </button>
+        }
       />
     )
   }
   if (!data.installed || !fleet) {
     return (
-      <EmptyState
+      <ScreenEmptyState
         icon={Database}
         title="CloudNativePG is not installed"
         detail={`No postgresql.cnpg.io resources are served in ${connection.context || 'this cluster'}.`}
       />
     )
   }
-  return <>{children(data, fleet)}</>
-}
-
-export function ScreenBody({ children }: { children: ReactNode }) {
-  return (
-    <div className="min-h-0 flex-1 overflow-y-auto [scrollbar-gutter:stable]">
-      <div className="space-y-5 px-5 pb-6 pt-3 xl:px-7">{children}</div>
-    </div>
-  )
-}
-
-export function FilterChips({ chips }: { chips: { label: string; onClear: () => void }[] }) {
-  if (chips.length === 0) return null
-  return (
-    <div className="flex flex-wrap gap-1.5">
-      {chips.map((c) => (
-        <span key={c.label} className="inline-flex items-center gap-1 rounded-full bg-theme-elevated px-2.5 py-0.5 text-xs text-theme-text-secondary">
-          {c.label}
-          <button type="button" onClick={c.onClear} aria-label={`Remove ${c.label}`} className="rounded-full p-0.5 hover:bg-theme-hover">
-            <X className="h-3 w-3" />
-          </button>
-        </span>
-      ))}
-    </div>
-  )
-}
-
-export function namespaceChip(namespaces: string[], onClear: () => void) {
-  return namespaces.length > 0 ? [{ label: `Namespace: ${namespaces.join(', ')}`, onClear }] : []
-}
-
-export function Segments<T extends string>({
-  value,
-  options,
-  onChange,
-  label,
-}: {
-  value: T
-  options: { id: T; label: string; count?: number }[]
-  onChange: (id: T) => void
-  label: string
-}) {
-  return (
-    <div role="tablist" aria-label={label} className="inline-flex rounded-lg bg-theme-elevated p-0.5">
-      {options.map((o) => {
-        const on = o.id === value
-        return (
-          <button
-            key={o.id}
-            type="button"
-            role="tab"
-            aria-selected={on}
-            onClick={() => onChange(o.id)}
-            className={clsx(
-              'inline-flex items-center gap-1.5 rounded-md px-3 py-1 text-sm font-medium transition-colors',
-              on ? 'bg-theme-surface text-theme-text-primary shadow-theme-sm' : 'text-theme-text-secondary hover:text-theme-text-primary',
-            )}
-          >
-            {o.label}
-            {o.count !== undefined && <span className="font-mono text-xs text-theme-text-tertiary">{o.count}</span>}
-          </button>
-        )
-      })}
-    </div>
-  )
-}
-
-export interface TableColumn<T> {
-  header: ReactNode
-  width?: string
-  cell: (row: T) => ReactNode
-  className?: string
-}
-
-/** A workspace table. Rows inspect in the drawer; the inspected row is highlighted. */
-export function SectionTable<T>({
-  title,
-  subtitle,
-  columns,
-  rows,
-  rowKey,
-  rowResource,
-  onInspect,
-  inspected,
-  empty,
-  minWidth = 760,
-  footer,
-}: {
-  title: ReactNode
-  subtitle?: ReactNode
-  columns: TableColumn<T>[]
-  rows: T[]
-  rowKey: (row: T) => string
-  rowResource?: (row: T) => SelectedResource | null
-  onInspect?: (resource: SelectedResource) => void
-  inspected?: SelectedResource | null
-  empty: ReactNode
-  minWidth?: number
-  footer?: ReactNode
-}) {
-  return (
-    <section>
-      <div className="mb-2 flex flex-wrap items-baseline gap-x-2.5 gap-y-1">
-        <h2 className="text-sm font-semibold text-theme-text-primary">{title}</h2>
-        {subtitle && <span className="text-xs text-theme-text-tertiary">{subtitle}</span>}
-      </div>
-      <div className="overflow-hidden rounded-xl border border-theme-border bg-theme-surface shadow-theme-sm">
-        {rows.length === 0 ? (
-          <div className="px-4 py-5 text-sm text-theme-text-tertiary">{empty}</div>
-        ) : (
-          <div className={TABLE_WRAP}>
-            <table className="w-full table-fixed" style={{ minWidth }}>
-              <colgroup>
-                {columns.map((c, i) => (
-                  <col key={i} style={c.width ? { width: c.width } : undefined} />
-                ))}
-              </colgroup>
-              <thead className={TABLE_HEAD}>
-                <tr>
-                  {columns.map((c, i) => (
-                    <th key={i} className={TH}>{c.header}</th>
-                  ))}
-                </tr>
-              </thead>
-              <tbody className={TBODY}>
-                {rows.map((row) => {
-                  const res = rowResource?.(row) ?? null
-                  const active = !!res && sameResource(inspected, res)
-                  return (
-                    <tr
-                      key={rowKey(row)}
-                      onClick={res && onInspect ? () => onInspect(res) : undefined}
-                      className={clsx(res && onInspect && 'cursor-pointer', ROW_HOVER, active && 'selection')}
-                      aria-selected={res ? active : undefined}
-                    >
-                      {columns.map((c, i) => (
-                        <td key={i} className={clsx(TD, c.className)}>{c.cell(row)}</td>
-                      ))}
-                    </tr>
-                  )
-                })}
-              </tbody>
-            </table>
-          </div>
-        )}
-      </div>
-      {footer && <div className="mt-1.5 text-xs text-theme-text-tertiary">{footer}</div>}
-    </section>
-  )
+  return <><RefreshFailedNotice queries={[query]} className="px-5 pt-3 xl:px-7" />{children(data, fleet)}</>
 }
 
 /** Empty-state text for a collection, derived from how much of it was readable. */
@@ -255,7 +176,12 @@ export function coverageEmpty(cov: CNPGKindCoverage | undefined, noun: string):
     case 'full':
       return `No ${noun} in this scope.`
     case 'partial':
-      return `No ${noun} visible. Some namespaces are not readable with your access.`
+    case 'uncached': {
+      const { denied, uncached } = namedCauses(cov, `Radar does not cache ${noun}`)
+      const causes = [denied && `no access in ${denied}`, uncached].filter(Boolean)
+      if (causes.length > 0) return `No ${noun} visible: ${causes.join('; ')}.`
+      return cov.state === 'uncached' ? `Radar does not cache ${noun} in this scope.` : `No ${noun} visible. Some namespaces were not read.`
+    }
     case 'denied':
       return `No access to ${noun}.`
     case 'syncing':
@@ -269,18 +195,10 @@ export function coverageEmpty(cov: CNPGKindCoverage | undefined, noun: string):
 
 /** The less complete of two coverages, for collections built from several kinds. */
 export function worstCoverage(...covs: (CNPGKindCoverage | undefined)[]): CNPGKindCoverage | undefined {
-  const rank: Record<string, number> = { error: 0, denied: 1, syncing: 2, partial: 3, full: 4, notInstalled: 5 }
+  const rank: Record<string, number> = { error: 0, denied: 1, uncached: 2, syncing: 3, partial: 4, full: 5, notInstalled: 6 }
   return covs.filter(Boolean).sort((a, b) => (rank[a!.state] ?? 9) - (rank[b!.state] ?? 9))[0]
 }
 
-export function Mono({ children }: { children: ReactNode }) {
-  return <span className="font-mono text-[12.5px] break-all">{children}</span>
-}
-
-export function Sub({ children }: { children: ReactNode }) {
-  return <div className="mt-0.5 text-xs text-theme-text-tertiary break-words">{children}</div>
-}
-
 export function clusterResource(namespace: string, name: string): SelectedResource {
   return { kind: 'clusters', group: 'postgresql.cnpg.io', namespace, name }
 }

package/src/components/cnpg/storageModel.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest'
+import { buildResizeManifest, cnpgFloorTone, cnpgInstanceDiskTone, cnpgSharedExpansionGap, cnpgSlotRetentionText, cnpgWALUsageFloor } from './storageModel'
+import type { CNPGStorageVolume, CNPGStorageWAL } from '../../api/cnpg-storage'
+
+const cluster = {
+  metadata: { name: 'pg', namespace: 'db' },
+  spec: {
+    storage: { size: '10Gi', storageClass: 'fast' },
+    tablespaces: [
+      { name: 'hot', storage: { size: '5Gi' }, owner: { name: 'app' } },
+      { name: 'cold', storage: { pvcTemplate: { resources: { requests: { storage: '50Gi' } }, storageClassName: 'slow' } } },
+    ],
+  },
+}
+
+describe('buildResizeManifest', () => {
+  it('applies only the data size', () => {
+    const m = buildResizeManifest(cluster, { role: 'PG_DATA', field: 'spec.storage.size', declared: '10Gi' }, '20Gi')
+    expect(m).toEqual({ apiVersion: 'postgresql.cnpg.io/v1', kind: 'Cluster', metadata: { name: 'pg', namespace: 'db' }, spec: { storage: { size: '20Gi' } } })
+  })
+
+  it('writes WAL sizes under walStorage, following a pvcTemplate', () => {
+    const m = buildResizeManifest(cluster, { role: 'PG_WAL', field: 'spec.walStorage.pvcTemplate.resources.requests.storage' }, '4Gi')
+    expect(m.spec).toEqual({ walStorage: { pvcTemplate: { resources: { requests: { storage: '4Gi' } } } } })
+  })
+
+  it('sends every tablespace, changing only the one named', () => {
+    const m = buildResizeManifest(cluster, { role: 'PG_TABLESPACE', tablespace: 'cold', field: 'spec.tablespaces[name=cold].storage.pvcTemplate.resources.requests.storage' }, '80Gi')
+    expect(m.spec.tablespaces[0]).toEqual(cluster.spec.tablespaces[0])
+    expect(m.spec.tablespaces[1].storage).toEqual({ pvcTemplate: { resources: { requests: { storage: '80Gi' } }, storageClassName: 'slow' } })
+    expect(cluster.spec.tablespaces[1]!.storage.pvcTemplate?.resources.requests.storage).toBe('50Gi')
+  })
+})
+
+describe('cnpgSlotRetentionText', () => {
+  it('shows the largest slot, never a sum, and 0 B when nothing is held', () => {
+    expect(cnpgSlotRetentionText([])).toBe('No slots')
+    expect(cnpgSlotRetentionText([{ name: 'a', retainedBytes: 0 }])).toBe('0 B')
+    expect(cnpgSlotRetentionText([{ name: 'a', retainedBytes: 1024 }])).toBe('1.0 KiB')
+    const two = cnpgSlotRetentionText([{ name: 'a', retainedBytes: 10 * 1024 * 1024 }, { name: 'b', retainedBytes: 2 * 1024 * 1024 }])
+    expect(two).toBe('10 MiB (largest slot)')
+    expect(two).not.toContain('up to')
+  })
+})
+
+describe('cnpgSharedExpansionGap', () => {
+  const vol = (reason?: string, allow?: boolean) => ({ storageClass: { name: 'standard', allowVolumeExpansion: allow, reason } })
+  it('names one shared reason for every unknown volume, so the page says it once', () => {
+    expect(cnpgSharedExpansionGap([vol('cannot list StorageClasses'), vol('cannot list StorageClasses')])).toBe('cannot list StorageClasses')
+    expect(cnpgSharedExpansionGap([vol('a'), vol('b')])).toBeUndefined()
+    expect(cnpgSharedExpansionGap([vol('a')])).toBeUndefined()
+    expect(cnpgSharedExpansionGap([vol(undefined, true), vol(undefined, true)])).toBeUndefined()
+  })
+})
+
+describe('cnpgWALUsageFloor', () => {
+  const vol = (state: string, claim = 'pg-1') => ({ claim, role: 'PG_DATA', capacity: '1Gi', capacityBytes: 1024 ** 3, storageClass: {}, resize: {}, usage: { state } }) as CNPGStorageVolume
+  const wal = (sizeBytes: number, volume = 'pg-1') => ({ status: { state: 'ok' }, metrics: { state: 'ok' }, volume, sizeBytes }) as CNPGStorageWAL
+  it('is the WAL size on the claim that holds it, only when kubelet did not measure', () => {
+    expect(cnpgWALUsageFloor(vol('noSeries'), wal(512 * 1024 ** 2))).toEqual({ bytes: 512 * 1024 ** 2, ratio: 0.5 })
+    expect(cnpgWALUsageFloor(vol('ok'), wal(512 * 1024 ** 2))).toBeUndefined()
+    expect(cnpgWALUsageFloor(vol('noSeries', 'pg-1-wal'), wal(512 * 1024 ** 2))).toBeUndefined()
+    expect(cnpgWALUsageFloor(vol('noSeries'), { ...wal(1), metrics: { state: 'denied' } } as CNPGStorageWAL)).toBeUndefined()
+  })
+})
+
+describe('cnpgFloorTone', () => {
+  it('never reads a lower bound below the warning line as healthy', () => {
+    expect(cnpgFloorTone(0.5)).toBe('unknown')
+    expect(cnpgFloorTone(0.85)).toBe('degraded')
+    expect(cnpgFloorTone(3.3)).toBe('unhealthy')
+    expect(cnpgFloorTone(undefined)).toBe('unknown')
+  })
+})
+
+describe('cnpgInstanceDiskTone', () => {
+  const measured = (ratio: number, claim = 'pg-1') => ({ claim, role: 'PG_DATA', capacity: '1Gi', capacityBytes: 1024 ** 3, storageClass: {}, resize: {}, usage: { state: 'ok', ratio } }) as CNPGStorageVolume
+  const unmeasured = (claim: string) => ({ claim, role: 'PG_WAL', capacity: '1Gi', capacityBytes: 1024 ** 3, storageClass: {}, resize: {}, usage: { state: 'noSeries' } }) as CNPGStorageVolume
+  const wal = (sizeBytes: number, volume: string) => ({ status: { state: 'ok' }, metrics: { state: 'ok' }, volume, sizeBytes }) as CNPGStorageWAL
+  it('lets a dangerous WAL bound on one volume outrank a calm measurement on another', () => {
+    expect(cnpgInstanceDiskTone([measured(0.2), unmeasured('pg-1-wal')], wal(0.95 * 1024 ** 3, 'pg-1-wal'))).toBe('unhealthy')
+  })
+  it('stays unknown, not healthy, while any volume is unmeasured', () => {
+    expect(cnpgInstanceDiskTone([measured(0.2), unmeasured('pg-1-wal')], wal(0.1 * 1024 ** 3, 'pg-1-wal'))).toBe('unknown')
+    expect(cnpgInstanceDiskTone([measured(0.2)], undefined)).toBe('healthy')
+  })
+})
+
+it('does not infer slot absence from absent byte readings', () => {
+  expect(cnpgSlotRetentionText(undefined)).toBe('Slot inventory not read')
+  expect(cnpgSlotRetentionText(null)).toBe('Slot inventory not read')
+  expect(cnpgSlotRetentionText([], false)).toBe('Slot inventory partly read')
+  expect(cnpgSlotRetentionText([{ name: 'a', active: false }], false)).toBe('≥1 inactive slot; retained WAL not reported')
+  expect(cnpgSlotRetentionText([{ name: '_cnpg_orders_2', active: false }])).toBe('1 inactive slot; retained WAL not reported')
+  expect(cnpgSlotRetentionText([{ name: 'a', retainedBytes: 10 }, { name: 'b' }])).toContain('≥10 B reported; some slots unmeasured')
+})
+
+it('keeps measured retained WAL when slot inventory is unavailable', () => {
+  expect(cnpgSlotRetentionText(null, true, [{ slot: 'a', bytes: 2048 }])).toBe('≥2.0 KiB retained WAL reported; slot inventory not read')
+})
+
+it('can separate an unmeasured retention note from slot counts without changing the default', () => {
+  const slots = [{ name: '_cnpg_orders_2', active: false }]
+  expect(cnpgSlotRetentionText(slots, true, [], { separateMissingBytes: true })).toBe('1 inactive slot')
+  expect(cnpgSlotRetentionText(slots, false, [], { separateMissingBytes: true })).toBe('≥1 inactive slot')
+  expect(cnpgSlotRetentionText(slots)).toBe('1 inactive slot; retained WAL not reported')
+})

package/src/components/cnpg/storageModel.ts

@@ -0,0 +1,101 @@
+import { formatBytes } from './lsn'
+import { cnpgDiskTone, type HealthLevel } from '@skyhook-io/k8s-ui'
+import type { CNPGStorageTarget, CNPGStorageVolume, CNPGStorageWAL } from '../../api/cnpg-storage'
+
+function setPath(obj: Record<string, any>, path: string[], value: unknown) {
+  let cur = obj
+  for (const p of path.slice(0, -1)) {
+    cur[p] = cur[p] && typeof cur[p] === 'object' ? { ...cur[p] } : {}
+    cur = cur[p]
+  }
+  cur[path[path.length - 1]] = value
+}
+
+// Where the size lives under the storage block the target names.
+function sizePath(t: CNPGStorageTarget): string[] {
+  return t.field.endsWith('.pvcTemplate.resources.requests.storage') ? ['pvcTemplate', 'resources', 'requests', 'storage'] : ['size']
+}
+
+/**
+ * The manifest server-side applies only the size. Tablespaces are a list the
+ * CRD does not merge by key, so the whole list is sent with one size changed.
+ */
+export function buildResizeManifest(cluster: any, target: CNPGStorageTarget, size: string): Record<string, any> {
+  const spec: Record<string, any> = {}
+  if (target.role === 'PG_TABLESPACE') {
+    spec.tablespaces = (cluster?.spec?.tablespaces ?? []).map((ts: any) => {
+      if (ts?.name !== target.tablespace) return ts
+      const storage = { ...(ts.storage ?? {}) }
+      setPath(storage, sizePath(target), size)
+      return { ...ts, storage }
+    })
+  } else {
+    const block: Record<string, any> = {}
+    setPath(block, sizePath(target), size)
+    spec[target.role === 'PG_WAL' ? 'walStorage' : 'storage'] = block
+  }
+  return {
+    apiVersion: 'postgresql.cnpg.io/v1',
+    kind: 'Cluster',
+    metadata: { name: cluster?.metadata?.name, namespace: cluster?.metadata?.namespace },
+    spec,
+  }
+}
+
+/**
+ * WAL held by replication slots on one instance. Slots overlap (they can
+ * hold the same segments), so the figure is the largest slot, never a sum.
+ */
+export function cnpgSlotRetentionText(slots: { name: string; active?: boolean; retainedBytes?: number }[] | null | undefined, complete = true, retained: { slot: string; bytes: number }[] = [], options: { separateMissingBytes?: boolean } = {}): string {
+  if (!slots) return retained.length ? `≥${formatBytes(Math.max(...retained.map((s) => s.bytes)))} retained WAL reported; slot inventory not read` : 'Slot inventory not read'
+  if (slots.length === 0) return complete ? 'No slots' : 'Slot inventory partly read'
+  const measured = slots.filter((s) => s.retainedBytes !== undefined)
+  if (measured.length < slots.length) {
+    const inactive = slots.filter((s) => s.active === false).length
+    const count = inactive === slots.length ? `${inactive} inactive slot${inactive === 1 ? '' : 's'}` : `${slots.length} slot${slots.length === 1 ? '' : 's'}`
+    if (options.separateMissingBytes && measured.length === 0) return `${complete ? '' : '≥'}${count}`
+    return `${complete ? '' : '≥'}${count}; retained WAL ${measured.length ? `≥${formatBytes(Math.max(...measured.map((s) => s.retainedBytes!)))} reported; some slots unmeasured` : 'not reported'}`
+  }
+  const max = Math.max(...measured.map((s) => s.retainedBytes!))
+  return !complete ? `${formatBytes(max)} (largest reported slot)` : max === 0 || slots.length === 1 ? formatBytes(max) : `${formatBytes(max)} (largest slot)`
+}
+
+/**
+ * Why StorageClass expansion is unknown, when it is the same reason for
+ * every volume whose class could not be read (and more than one), so it can be
+ * said once for the page instead of under each volume.
+ */
+export function cnpgSharedExpansionGap(volumes: { storageClass: { name?: string; allowVolumeExpansion?: boolean; reason?: string } }[]): string | undefined {
+  const unknown = volumes.filter((v) => v.storageClass.name && v.storageClass.allowVolumeExpansion === undefined)
+  if (unknown.length < 2) return undefined
+  const reasons = new Set(unknown.map((v) => v.storageClass.reason ?? ''))
+  return reasons.size === 1 ? [...reasons][0] || undefined : undefined
+}
+
+/**
+ * A lower bound on a volume's used space when kubelet didn't measure it: the
+ * WAL the instance reports lives on this claim, so at least that much is used.
+ */
+export function cnpgWALUsageFloor(v: CNPGStorageVolume, wal: CNPGStorageWAL | undefined): { bytes: number; ratio?: number } | undefined {
+  if (v.usage.state === 'ok' || !wal || wal.metrics.state !== 'ok' || wal.sizeBytes === undefined || wal.volume !== v.claim) return undefined
+  return { bytes: wal.sizeBytes, ratio: v.capacityBytes ? wal.sizeBytes / v.capacityBytes : undefined }
+}
+
+/** A lower bound can prove a volume is filling, never that it's fine. */
+export function cnpgFloorTone(ratio: number | undefined): HealthLevel {
+  if (ratio === undefined) return 'unknown'
+  const tone = cnpgDiskTone(ratio)
+  return tone === 'healthy' ? 'unknown' : tone
+}
+
+/**
+ * An instance's disk tone across its volumes: the worst measured or bounded
+ * reading that crosses a line, otherwise healthy only when every volume was
+ * measured below it. One unmeasured volume leaves a calm verdict unknown.
+ */
+export function cnpgInstanceDiskTone(volumes: CNPGStorageVolume[], wal: CNPGStorageWAL | undefined): HealthLevel {
+  const rank: Record<string, number> = { unhealthy: 3, degraded: 2, unknown: 1, healthy: 0 }
+  const tones = volumes.map((v) => (v.usage.ratio !== undefined ? cnpgDiskTone(v.usage.ratio) : cnpgFloorTone(cnpgWALUsageFloor(v, wal)?.ratio)))
+  if (tones.length === 0) return 'unknown'
+  return tones.reduce((a, b) => ((rank[b] ?? 1) > (rank[a] ?? 1) ? b : a))
+}