@skyhook-io/radar-app 1.15.0 → 1.16.1

package/src/hooks/usePreviousIntegrationSettings.render.test.tsx

@@ -0,0 +1,62 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { afterEach, expect, it, vi } from 'vitest'
+import { usePreviousIntegrationSettings, previousIntegrationSettingsKey } from './usePreviousIntegrationSettings'
+
+const state = vi.hoisted(() => ({ context: 'first', switching: false, embedded: false, management: 'local', connected: true }))
+vi.mock('../context/ConnectionContext', () => ({ useConnection: () => ({ connection: { context: state.context, state: state.connected ? 'connected' : 'disconnected' } }) }))
+vi.mock('../context/ContextSwitchContext', () => ({ useContextSwitch: () => ({ isSwitching: state.switching }) }))
+vi.mock('../context/NavCustomization', () => ({ useNavCustomization: () => ({ embedded: state.embedded }) }))
+vi.mock('../contexts/CapabilitiesContext', () => ({ useCapabilitiesContext: () => ({ configManagement: state.management }) }))
+vi.mock('../api/client', () => ({ fetchJSON: vi.fn() }))
+import { fetchJSON } from '../api/client'
+
+vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true)
+const element = document.createElement('div')
+let root = createRoot(element)
+let client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+function Subject({ relevant = true }: { relevant?: boolean }) {
+  const offers = usePreviousIntegrationSettings(relevant)
+  return <span>{offers.metrics ? 'offer' : 'ordinary'}</span>
+}
+async function render(relevant = true) {
+  await act(async () => { root.render(<QueryClientProvider client={client}><Subject relevant={relevant} /></QueryClientProvider>) })
+}
+afterEach(async () => {
+  await act(async () => root.unmount())
+  client.clear()
+  client = new QueryClient()
+  root = createRoot(element)
+  Object.assign(state, { context: 'first', switching: false, embedded: false, management: 'local', connected: true })
+  vi.mocked(fetchJSON).mockReset()
+})
+
+it.each(['embedded', 'operator', 'cloud', 'loading', 'switching', 'disconnected', 'irrelevant'])('does not fetch or display cached offers when %s', async gate => {
+  if (gate === 'embedded') state.embedded = true
+  if (['operator', 'cloud', 'loading'].includes(gate)) state.management = gate === 'loading' ? '' : gate
+  if (gate === 'switching') state.switching = true
+  if (gate === 'disconnected') state.connected = false
+  client.setQueryData([previousIntegrationSettingsKey, '/api', 'first'], { metrics: 'previous' })
+  await render(gate !== 'irrelevant')
+  expect(element.textContent).toBe('ordinary')
+  expect(fetchJSON).not.toHaveBeenCalled()
+})
+
+it('drops a cached offer immediately while switching and aborts the old fetch', async () => {
+  const signals: AbortSignal[] = []
+  vi.mocked(fetchJSON).mockImplementation((_path, signal) => { signals.push(signal as AbortSignal); return new Promise(() => {}) })
+  client.setQueryData([previousIntegrationSettingsKey, '/api', 'first'], { metrics: 'previous' }, { updatedAt: 1 })
+  await render()
+  expect(element.textContent).toBe('offer')
+  state.switching = true
+  await render()
+  expect(element.textContent).toBe('ordinary')
+  state.context = 'second'
+  state.switching = false
+  await render()
+  expect(element.textContent).toBe('ordinary')
+  expect(signals[0].aborted).toBe(true)
+  expect(signals).toHaveLength(2)
+})

package/src/hooks/usePreviousIntegrationSettings.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+import { previousIntegrationOffers, type IntegrationSettingsResponse } from './usePreviousIntegrationSettings'
+import type { ConnectionResponse, IntegrationProfile, IntegrationProfiles } from '../components/settings/LocalConnectionSettings'
+
+function response(overrides: Partial<IntegrationProfile> = {}): IntegrationSettingsResponse {
+  const profile = { target: { context: 'development' }, state: 'auto', legacy: { url: 'https://backend.example', mode: 'auto' }, ...overrides } as IntegrationProfile
+  return { management: 'local', integrationProfiles: { metrics: profile, argocd: profile, cost: profile } as IntegrationProfiles }
+}
+
+describe('previous integration eligibility projection', () => {
+  it('keeps only eligibility and routing facts, never URLs or credentials', () => {
+    expect(previousIntegrationOffers(response(), 'development')).toEqual({ metrics: 'previous', argocd: 'previous', cost: 'previous', explicitCostBackend: true })
+  })
+  it.each(['operator', 'cloud'] as const)('rejects %s management', management => {
+    expect(Object.values(previousIntegrationOffers({ ...response(), management }, 'development')).some(Boolean)).toBe(false)
+  })
+  it.each(['saved', 'launch', 'target_changed', 'error'] as const)('rejects %s profiles', state => {
+    expect(previousIntegrationOffers(response({ state }), 'development').metrics).toBeUndefined()
+  })
+  it('rejects missing offers, wrong context and errored bundles', () => {
+    expect(previousIntegrationOffers(response({ legacy: undefined }), 'development').metrics).toBeUndefined()
+    expect(previousIntegrationOffers(response(), 'staging').metrics).toBeUndefined()
+    expect(previousIntegrationOffers(response(), '').metrics).toBeUndefined()
+    const data = response()
+    data.integrationProfiles!.metrics.legacy!.error = 'invalid credentials binding'
+    expect(previousIntegrationOffers(data, 'development').metrics).toBeUndefined()
+  })
+  it('offers another cluster\'s saved settings once no previous settings apply', () => {
+    const entry = { integration: 'metrics', binding: 'staging', url: 'https://mimir.example' } as ConnectionResponse['connections'][number]
+    const data = response({ legacy: undefined, target: { context: 'development', binding: 'development' } as IntegrationProfile['target'] })
+    expect(previousIntegrationOffers(data, 'development', [entry]).metrics).toBe('copy')
+    expect(previousIntegrationOffers(data, 'development', [{ ...entry, binding: 'development' }]).metrics).toBeUndefined()
+    expect(previousIntegrationOffers(data, 'development', [{ ...entry, url: '' }]).metrics).toBeUndefined()
+    expect(previousIntegrationOffers(data, 'development', [{ ...entry, error: 'invalid' }]).metrics).toBeUndefined()
+    expect(previousIntegrationOffers(response(), 'development', [entry]).metrics).toBe('previous')
+    expect(previousIntegrationOffers(response({ state: 'saved', legacy: undefined }), 'development', [entry]).metrics).toBeUndefined()
+  })
+  it('stops reminding after the notice is dismissed, falling back to copy offers', () => {
+    const entry = { integration: 'metrics', binding: 'staging', url: 'https://mimir.example' } as ConnectionResponse['connections'][number]
+    const data = response({ target: { context: 'development', binding: 'development' } as IntegrationProfile['target'] })
+    for (const kind of ['metrics', 'argocd', 'cost'] as const)
+      data.integrationProfiles![kind] = { ...data.integrationProfiles![kind], legacy: { ...data.integrationProfiles![kind].legacy!, noticeDismissed: true } }
+    expect(previousIntegrationOffers(data, 'development').metrics).toBeUndefined()
+    expect(previousIntegrationOffers(data, 'development', [entry]).metrics).toBe('copy')
+  })
+  it('never nudges Argo CD toward another cluster\'s server', () => {
+    const entry = { integration: 'argocd', binding: 'staging', url: 'https://argo.example' } as ConnectionResponse['connections'][number]
+    const data = response({ legacy: undefined, target: { context: 'development', binding: 'development' } as IntegrationProfile['target'] })
+    expect(previousIntegrationOffers(data, 'development', [entry]).argocd).toBeUndefined()
+  })
+  it.each([
+    ['auto', 'https://cost.example', true],
+    ['kubecost', 'https://cost.example', true],
+    ['prometheus', 'https://cost.example', false],
+    ['auto', '', false],
+    ['kubecost', '', false],
+  ])('identifies the independent Cost alternative for %s / %s', (mode, url, expected) => {
+    const data = response()
+    Object.assign(data.integrationProfiles!.cost.legacy!, { mode, url })
+    expect(previousIntegrationOffers(data, 'development').explicitCostBackend).toBe(expected)
+  })
+})

package/src/hooks/usePreviousIntegrationSettings.ts

@@ -0,0 +1,89 @@
+import { useQuery } from '@tanstack/react-query'
+import { fetchJSON } from '../api/client'
+import { getApiBase } from '../api/config'
+import { useConnection } from '../context/ConnectionContext'
+import { useContextSwitch } from '../context/ContextSwitchContext'
+import { useNavCustomization } from '../context/NavCustomization'
+import { useCapabilitiesContext } from '../contexts/CapabilitiesContext'
+import type { ConnectionResponse, IntegrationKind, IntegrationProfiles } from '../components/settings/LocalConnectionSettings'
+
+export interface IntegrationSettingsResponse {
+  management: 'local' | 'operator' | 'cloud'
+  integrationProfiles?: IntegrationProfiles
+}
+
+// 'previous' offers this context the old global settings; 'copy' points to
+// another cluster's saved settings once those are the way to reuse them.
+export type SettingsOffer = 'previous' | 'copy'
+
+export interface PreviousIntegrationSettings {
+  metrics?: SettingsOffer
+  argocd?: SettingsOffer
+  cost?: SettingsOffer
+  explicitCostBackend: boolean
+}
+
+const noOffers: PreviousIntegrationSettings = { explicitCostBackend: false }
+export const previousIntegrationSettingsKey = 'previous-integration-settings'
+
+export function previousIntegrationOffers(
+  response: IntegrationSettingsResponse,
+  context: string,
+  catalog?: ConnectionResponse['connections'],
+): PreviousIntegrationSettings {
+  if (response.management !== 'local' || !context) return noOffers
+  const offer = (kind: IntegrationKind): SettingsOffer | undefined => {
+    const profile = response.integrationProfiles?.[kind]
+    if (profile?.target.context !== context || profile.state !== 'auto') return undefined
+    if (profile.legacy && !profile.legacy.error && !profile.legacy.noticeDismissed) return 'previous'
+    // Another cluster's Argo CD server manages that cluster's Applications, so
+    // copying it is rarely the fix for this one; Settings still offers it.
+    if (kind === 'argocd') return undefined
+    return catalog?.some(entry => entry.integration === kind && !entry.error && entry.url && entry.binding !== profile.target.binding)
+      ? 'copy' : undefined
+  }
+  const cost = offer('cost')
+  const legacyCost = response.integrationProfiles?.cost.legacy
+  return {
+    metrics: offer('metrics'), argocd: offer('argocd'), cost,
+    explicitCostBackend: cost === 'copy' ||
+      (cost === 'previous' && !!legacyCost?.url && (legacyCost.mode === 'auto' || legacyCost.mode === 'kubecost')),
+  }
+}
+
+async function loadOffers(context: string, signal: AbortSignal): Promise<PreviousIntegrationSettings> {
+  const response = await fetchJSON<IntegrationSettingsResponse>('/config', signal)
+  const offers = previousIntegrationOffers(response, context)
+  const unoffered = (['metrics', 'argocd', 'cost'] as const).some(kind =>
+    !offers[kind] && response.integrationProfiles?.[kind]?.state === 'auto')
+  if (response.management !== 'local' || !unoffered) return offers
+  const catalog = await fetchJSON<ConnectionResponse>('/integrations/connections', signal)
+    .then(data => data.connections, () => undefined)
+  return previousIntegrationOffers(response, context, catalog)
+}
+
+export function usePreviousIntegrationSettings(relevant: boolean): PreviousIntegrationSettings {
+  const { connection } = useConnection()
+  const { isSwitching } = useContextSwitch()
+  const { embedded } = useNavCustomization()
+  const { configManagement } = useCapabilitiesContext()
+  const enabled = relevant && !embedded && configManagement === 'local' && connection.state === 'connected' && !isSwitching && !!connection.context
+  const query = useQuery({
+    queryKey: [previousIntegrationSettingsKey, getApiBase(), connection.context],
+    queryFn: ({ signal }) => loadOffers(connection.context, signal),
+    enabled,
+    retry: false,
+    staleTime: 30_000,
+  })
+  return enabled && !query.isError ? query.data ?? noOffers : noOffers
+}
+
+const settingsTabs: Record<IntegrationKind, string> = { metrics: 'Metrics', argocd: 'Argo CD', cost: 'Cost' }
+
+// Only a note: call sites keep their neutral action, because another cluster's
+// backend connects fine while showing the wrong cluster's data.
+export function previousSettingsNote(kind: IntegrationKind, offer: SettingsOffer): string {
+  return offer === 'copy'
+    ? 'Settings saved for another cluster are available to copy if that backend also serves this cluster.'
+    : `Connections are now saved per cluster. You can copy your previous settings in Settings → ${settingsTabs[kind]}.`
+}

package/src/index.ts

@@ -16,6 +16,7 @@ export {
   getCredentialsMode,
 } from './api/config';
 export type { NavCustomization, FleetTakeoverTarget } from './context/NavCustomization';
+export type { RadarUpgradeRequest } from './context/RadarUpgradeHost';
 // Timeline data-source selection — lets an embedder back the timeline with a
 // retained-history endpoint instead of Radar's local event store. Additive;
 // absent = local (standalone behavior).