@skyhook-io/k8s-ui 1.8.9 → 1.8.11

package/src/utils/index.ts

@@ -22,4 +22,6 @@ export * from './rbac-badges'
 export * from './git-provider-urls'
 export * from './applications'
 export * from './topology-neighborhood'
+export * from './application-topology'
 export * from './bulk-workload-actions'
+export * from './workflow-execution'

package/src/utils/navigation.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, afterEach } from 'vitest'
-import { kindToPlural, pluralToKind, refToSelectedResource, initNavigationMap, resetNavigationMap } from './navigation'
+import { kindToPlural, pluralToKind, refToSelectedResource, initNavigationMap, resetNavigationMap, laneId, laneResourceKey, groupQualifiesLaneId, parseLaneId } from './navigation'
 
 afterEach(() => {
   resetNavigationMap()
@@ -190,3 +190,34 @@ describe('refToSelectedResource', () => {
     })
   })
 })
+
+describe('lane identity helpers', () => {
+  test('groupQualifiesLaneId: only CRD groups qualify', () => {
+    expect(groupQualifiesLaneId('')).toBe(false)          // core
+    expect(groupQualifiesLaneId(undefined)).toBe(false)
+    expect(groupQualifiesLaneId('apps')).toBe(false)       // built-in
+    expect(groupQualifiesLaneId('batch')).toBe(false)
+    expect(groupQualifiesLaneId('networking.k8s.io')).toBe(false)
+    expect(groupQualifiesLaneId('postgresql.cnpg.io')).toBe(true)
+    expect(groupQualifiesLaneId('cluster.x-k8s.io')).toBe(true)
+  })
+
+  test('laneId: bare for core/built-in, qualified for CRD groups', () => {
+    expect(laneId('Pod', '', 'team-a', 'x')).toBe('Pod/team-a/x')
+    expect(laneId('Deployment', 'apps', 'ns', 'web')).toBe('Deployment/ns/web')
+    expect(laneId('Cluster', 'postgresql.cnpg.io', 'prod', 'main-db')).toBe('Cluster.postgresql.cnpg.io/prod/main-db')
+  })
+
+  test('laneResourceKey is always group-less', () => {
+    expect(laneResourceKey('Cluster', 'prod', 'main-db')).toBe('Cluster/prod/main-db')
+    expect(laneResourceKey('Pod', 'team-a', 'x')).toBe('Pod/team-a/x')
+  })
+
+  test('parseLaneId round-trips both bare and qualified ids', () => {
+    expect(parseLaneId('Pod/team-a/x')).toEqual({ kind: 'Pod', group: '', namespace: 'team-a', name: 'x' })
+    expect(parseLaneId('Cluster.postgresql.cnpg.io/prod/main-db')).toEqual({
+      kind: 'Cluster', group: 'postgresql.cnpg.io', namespace: 'prod', name: 'main-db',
+    })
+    expect(parseLaneId('bogus')).toBeNull()
+  })
+})

package/src/utils/navigation.ts

@@ -25,6 +25,10 @@ const BUILTIN_PLURAL_TO_KIND: Record<string, string> = {
   nodes: 'Node',
   jobs: 'Job',
   cronjobs: 'CronJob',
+  workflows: 'Workflow',
+  cronworkflows: 'CronWorkflow',
+  workflowtemplates: 'WorkflowTemplate',
+  clusterworkflowtemplates: 'ClusterWorkflowTemplate',
   horizontalpodautoscalers: 'HorizontalPodAutoscaler',
   persistentvolumeclaims: 'PersistentVolumeClaim',
   persistentvolumes: 'PersistentVolume',
@@ -158,3 +162,69 @@ export function apiVersionToGroup(apiVersion?: string | null): string {
   const i = apiVersion.indexOf('/')
   return i === -1 ? '' : apiVersion.slice(0, i)
 }
+
+// -----------------------------------------------------------------------------
+// Timeline lane identity. A lane's id includes the API group so two CRDs that
+// share a kind name across vendors (CAPI `Cluster` in cluster.x-k8s.io vs CNPG
+// `Cluster` in postgresql.cnpg.io) can never merge into one row. The group is an
+// INTERNAL identity component only — it never surfaces in the UI except the rare
+// on-screen collision chip (see collidingLaneKeys in resource-hierarchy).
+// -----------------------------------------------------------------------------
+
+// Built-in Kubernetes API groups. Their kind names are globally reserved and
+// never collide across vendors, so their lanes keep the bare `Kind/ns/name` id.
+// This keeps existing pins, ?event= URLs, and the applications byResource join
+// byte-stable for all core/built-in resources (Pod, Deployment, Job, …) — only
+// CRD-group lanes get a group-qualified id, so ONLY CRD pins are affected.
+const BUILTIN_API_GROUPS: ReadonlySet<string> = new Set([
+  '', // core (v1)
+  'apps', 'batch', 'autoscaling', 'policy',
+  'networking.k8s.io', 'storage.k8s.io', 'scheduling.k8s.io',
+  'coordination.k8s.io', 'node.k8s.io', 'discovery.k8s.io',
+  'rbac.authorization.k8s.io', 'admissionregistration.k8s.io',
+  'authentication.k8s.io', 'authorization.k8s.io', 'certificates.k8s.io',
+  'apiextensions.k8s.io', 'apiregistration.k8s.io', 'events.k8s.io',
+  'flowcontrol.apiserver.k8s.io',
+])
+
+/** Whether a resource's API group must appear in its lane id to prevent a
+ *  cross-group merge. Built-in groups never collide, so they stay bare. */
+export function groupQualifiesLaneId(group: string | undefined): boolean {
+  return !!group && !BUILTIN_API_GROUPS.has(group)
+}
+
+/** Canonical timeline lane id. Group-qualified only for CRD groups
+ *  (`Cluster.postgresql.cnpg.io/prod/db`); bare for built-in/core groups
+ *  (`Pod/team-a/x`, `Deployment/ns/web`) so those ids stay exactly as before. */
+export function laneId(kind: string, group: string | undefined, namespace: string, name: string): string {
+  const g = groupQualifiesLaneId(group) ? `.${group}` : ''
+  return `${kind}${g}/${namespace}/${name}`
+}
+
+/** The group-less resource key (`Kind/ns/name`) — the join key for group-less
+ *  server payloads (applications byResource, AppRow workloads) and group-less
+ *  references (owner refs, K8s-event involvedObject, topology node ids). For a
+ *  built-in-group lane this equals its id; for a CRD lane it's the id minus the
+ *  `.group` segment. */
+export function laneResourceKey(kind: string, namespace: string, name: string): string {
+  return `${kind}/${namespace}/${name}`
+}
+
+/** Recover {kind, group, namespace, name} from a lane id. The kind segment may
+ *  carry a `.group` suffix (CRD lanes). Kind names never contain '.', and a
+ *  qualifying group always does, so the first '.' in the kind segment splits
+ *  them; ns and name never contain '/', so the first two '/' bound the rest. */
+export function parseLaneId(id: string): { kind: string; group: string; namespace: string; name: string } | null {
+  const s1 = id.indexOf('/')
+  if (s1 < 0) return null
+  const s2 = id.indexOf('/', s1 + 1)
+  if (s2 < 0) return null
+  const kindSeg = id.slice(0, s1)
+  const dot = kindSeg.indexOf('.')
+  return {
+    kind: dot < 0 ? kindSeg : kindSeg.slice(0, dot),
+    group: dot < 0 ? '' : kindSeg.slice(dot + 1),
+    namespace: id.slice(s1 + 1, s2),
+    name: id.slice(s2 + 1),
+  }
+}