@skyhook-io/radar-app 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyhook-io/radar-app",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Radar's full web UI as a reusable React component. Used by Radar's own binary and by external consumers like Radar Cloud.",
   "repository": {
     "type": "git",

package/src/App.tsx

@@ -948,22 +948,30 @@ function AppInner() {
     const navigatingToHelm = mainView === 'helm' && prevMainView.current !== 'helm'
     prevMainView.current = mainView
 
-    // Don't clear selectedResource when navigating TO resources view (deep link from Helm)
-    if (!navigatingToResources) {
+    // The URL is the source of truth for what's selected. A deep link
+    // (?resource=, ?release=) seeds the selection on mount; the effects that
+    // run during that same mount must not wipe a selection the URL still
+    // asserts. (On a real view switch the URL no longer carries the param, so
+    // the clear proceeds.) Without this, deep-linking straight to a Helm
+    // release lands on the release list with no drawer.
+    const params = new URLSearchParams(window.location.search)
+    if (!navigatingToResources && !params.has('resource')) {
       setSelectedResource(null)
     }
-    // Don't clear helm release when navigating TO helm (back button restores from URL)
-    if (!navigatingToHelm) {
+    if (!navigatingToHelm && !params.has('release')) {
       setSelectedHelmRelease(null)
     }
     setDrawerExpanded(false)
   }, [mainView])
 
-  // Clear resource selection when namespaces change
+  // Clear resource selection when namespaces change — but keep a selection the
+  // URL still asserts (deep link, or a release/resource the user is viewing
+  // while they adjust the namespace scope filter).
   useEffect(() => {
-    setSelectedResource(null)
+    const params = new URLSearchParams(window.location.search)
+    if (!params.has('resource')) setSelectedResource(null)
+    if (!params.has('release')) setSelectedHelmRelease(null)
     setDrawerExpanded(false)
-    setSelectedHelmRelease(null)
   }, [namespacesKey])
 
   // Filter topology based on visible kinds (uses displayedTopology which respects pause)

package/src/api/client.ts

@@ -1609,8 +1609,24 @@ export function useUpdateResource() {
       errorMessage: 'Failed to update resource',
       successMessage: 'Resource updated',
     },
-    onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['resource', variables.kind, variables.namespace, variables.name] })
+    onSuccess: (updated: any, variables) => {
+      // The PUT goes straight to the apiserver and returns the authoritative
+      // object, but the GET behind this query reads Radar's informer cache,
+      // which lags a write by one watch round-trip. Seed the detail cache with
+      // the PUT response so the edit shows immediately. Invalidating here
+      // instead would trigger a refetch that races the seed and re-reads the
+      // lagging cache — the change appears not to have taken effect.
+      if (updated && typeof updated === 'object' && updated.metadata) {
+        queryClient.setQueriesData(
+          { queryKey: ['resource', variables.kind, variables.namespace, variables.name] },
+          (old: any) =>
+            old && typeof old === 'object' && 'resource' in old
+              ? { ...old, resource: updated }
+              : { resource: updated }
+        )
+      } else {
+        queryClient.invalidateQueries({ queryKey: ['resource', variables.kind, variables.namespace, variables.name] })
+      }
       queryClient.invalidateQueries({ queryKey: ['resources', variables.kind] })
       queryClient.invalidateQueries({ queryKey: ['topology'] })
     },

package/src/api/quotas.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query'
+import { fetchJSON } from './client'
+
+// useNamespaceQuotas fetches a namespace's ResourceQuota objects via
+// /api/resources/resourcequotas?namespace=<ns> (a bare array). Backs the
+// NamespaceRenderer quota-usage section — quota saturation is otherwise
+// surfaced nowhere in the UI, yet it's exactly why a namespace stops
+// admitting new pods.
+export function useNamespaceQuotas(namespace: string, enabled = true) {
+  return useQuery<any[]>({
+    queryKey: ['resourcequotas', namespace],
+    queryFn: () => fetchJSON<any[]>(`/resources/resourcequotas?namespace=${encodeURIComponent(namespace)}`),
+    enabled: enabled && !!namespace,
+    staleTime: 15000,
+  })
+}

package/src/components/resources/renderers/NamespaceRenderer.tsx

@@ -1,6 +1,8 @@
 import { NamespaceRenderer as BaseNamespaceRenderer } from '@skyhook-io/k8s-ui/components/resources/renderers/NamespaceRenderer'
 import type { ResourceRef } from '@skyhook-io/k8s-ui'
 import { useRBACNamespace } from '../../../api/rbac'
+import { useNamespaceQuotas } from '../../../api/quotas'
+import { isForbiddenError } from '../../../api/client'
 
 interface NamespaceRendererProps {
   data: any
@@ -10,12 +12,19 @@ interface NamespaceRendererProps {
 export function NamespaceRenderer({ data, onNavigate }: NamespaceRendererProps) {
   const name = data?.metadata?.name ?? ''
   const { data: rbacData, isLoading, error } = useRBACNamespace(name, !!name)
+  const { data: quotaData, error: quotaError } = useNamespaceQuotas(name, !!name)
+  // 403 → the user can't see quotas; hide the section (same posture as the
+  // RBAC sections). Surface other errors (500/503) so a quota-constrained
+  // namespace doesn't silently render as quota-free.
+  const quotaErr = quotaError && !isForbiddenError(quotaError) ? (quotaError as Error) : null
   return (
     <BaseNamespaceRenderer
       data={data}
       rbacData={rbacData ?? null}
       rbacLoading={isLoading}
       rbacError={error as Error | null}
+      quotaData={quotaData}
+      quotaError={quotaErr}
       onNavigate={onNavigate}
     />
   )

package/src/index.ts

@@ -22,3 +22,12 @@ export { ShortcutHelpOverlay } from './components/ui/ShortcutHelpOverlay';
 // kubeconfig ContextSwitcher without taking a direct dep on k8s-ui internals.
 export { ClusterSwitcher } from '@skyhook-io/k8s-ui';
 export type { ClusterSwitcherProps, ClusterSwitcherItem } from '@skyhook-io/k8s-ui';
+
+// Deep-link builders — so consumers (Radar Hub) construct deep links into a
+// cluster view without hand-rolling Radar's internal URL format, which drifts
+// silently when Radar re-routes. `resourcePath` opens the detail drawer for any
+// kind incl. cluster-scoped; `buildWorkloadPath` is the namespaced-workload
+// full-page view. Both return basename-relative paths; embedders prepend their
+// cluster prefix (e.g. /c/:id).
+export { resourcePath, buildWorkloadPath } from './utils/navigation';
+export type { SelectedResource } from '@skyhook-io/k8s-ui/types/core';

package/src/utils/navigation.ts

@@ -1,4 +1,5 @@
 import { apiUrl, getAuthHeaders, getCredentialsMode } from '../api/config'
+import { kindToPlural } from '@skyhook-io/k8s-ui/utils/navigation'
 import type { SelectedResource } from '@skyhook-io/k8s-ui/types/core'
 
 // Re-export shared navigation utilities from @skyhook-io/k8s-ui.
@@ -8,6 +9,8 @@ export type { NavigateToResource } from '@skyhook-io/k8s-ui/utils/navigation'
 /**
  * Build a /workload/:kind/:namespace/:name URL, preserving the API group as a
  * query param so the WorkloadView can resolve CRDs with colliding kind names.
+ * Namespaced workloads only — WorkloadView requires a namespace. For arbitrary
+ * kinds (including cluster-scoped) use resourcePath.
  */
 export function buildWorkloadPath(resource: SelectedResource): string {
   const kind = encodeURIComponent(resource.kind)
@@ -17,6 +20,30 @@ export function buildWorkloadPath(resource: SelectedResource): string {
   return resource.group ? `${base}?apiGroup=${encodeURIComponent(resource.group)}` : base
 }
 
+/**
+ * Build a /resources/:plural?resource=:namespace/:name URL — the deep link that
+ * opens a resource's detail drawer in the resources view. Cluster-scoped
+ * resources use ?resource=:name (no slash); the API group rides in ?apiGroup=
+ * to disambiguate CRD/core kind collisions. This is the exact form the
+ * ResourcesView mount effect parses (the `?resource=` reader in
+ * packages/k8s-ui/src/components/resources/ResourcesView.tsx) — keep the two in
+ * lockstep.
+ *
+ * Unlike buildWorkloadPath, this opens the detail drawer for ANY kind,
+ * including cluster-scoped resources. Returns a basename-relative path;
+ * embedders (Radar Hub) prepend their cluster prefix (e.g. /c/:id).
+ */
+export function resourcePath(resource: SelectedResource): string {
+  const params = new URLSearchParams()
+  // No name → nothing to open; the kind list is the sane fallback.
+  if (resource.name) {
+    params.set('resource', resource.namespace ? `${resource.namespace}/${resource.name}` : resource.name)
+  }
+  if (resource.group) params.set('apiGroup', resource.group)
+  const query = params.toString()
+  return `/resources/${kindToPlural(resource.kind)}${query ? `?${query}` : ''}`
+}
+
 // radar-specific: open URL in system browser (desktop app support)
 export function openExternal(url: string): void {
   fetch(apiUrl('/desktop/open-url'), {