fix(console): reattach backup dropdown options from CRD annotations

apps/console/src/lib/crd-option-sources.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest"
+import { graftOptionSources } from "./crd-option-sources.ts"
+
+interface SchemaNode {
+  type?: string
+  properties?: Record<string, SchemaNode>
+  "x-cozystack-options"?: { source: string }
+}
+
+describe("graftOptionSources", () => {
+  it("grafts a source onto a nested field (applicationRef.kind)", () => {
+    const spec: SchemaNode = {
+      type: "object",
+      properties: {
+        applicationRef: {
+          type: "object",
+          properties: {
+            kind: { type: "string" },
+            name: { type: "string" },
+          },
+        },
+      },
+    }
+
+    const out = graftOptionSources(spec, {
+      "options.cozystack.io/source.applicationRef.kind": "appkind",
+    }) as SchemaNode
+
+    expect(out.properties?.applicationRef?.properties?.kind?.["x-cozystack-options"]).toEqual({
+      source: "appkind",
+    })
+    // Sibling left untouched.
+    expect(
+      out.properties?.applicationRef?.properties?.name?.["x-cozystack-options"],
+    ).toBeUndefined()
+  })
+
+  it("grafts a source onto a top-level spec field (backupClassName)", () => {
+    const spec: SchemaNode = {
+      type: "object",
+      properties: { backupClassName: { type: "string" } },
+    }
+
+    const out = graftOptionSources(spec, {
+      "options.cozystack.io/source.backupClassName": "backupclass",
+    }) as SchemaNode
+
+    expect(out.properties?.backupClassName?.["x-cozystack-options"]).toEqual({
+      source: "backupclass",
+    })
+  })
+
+  it("applies every source annotation on a CRD (BackupJob shape)", () => {
+    const spec: SchemaNode = {
+      type: "object",
+      properties: {
+        applicationRef: { type: "object", properties: { kind: { type: "string" } } },
+        planRef: { type: "object", properties: { name: { type: "string" } } },
+        backupClassName: { type: "string" },
+      },
+    }
+
+    const out = graftOptionSources(spec, {
+      "controller-gen.kubebuilder.io/version": "v0.16.4",
+      "options.cozystack.io/source.applicationRef.kind": "appkind",
+      "options.cozystack.io/source.planRef.name": "plan",
+      "options.cozystack.io/source.backupClassName": "backupclass",
+    }) as SchemaNode
+
+    expect(out.properties?.applicationRef?.properties?.kind?.["x-cozystack-options"]).toEqual({
+      source: "appkind",
+    })
+    expect(out.properties?.planRef?.properties?.name?.["x-cozystack-options"]).toEqual({
+      source: "plan",
+    })
+    expect(out.properties?.backupClassName?.["x-cozystack-options"]).toEqual({
+      source: "backupclass",
+    })
+  })
+
+  it("ignores annotations without the option-source prefix", () => {
+    const spec: SchemaNode = {
+      type: "object",
+      properties: { backupClassName: { type: "string" } },
+    }
+
+    const out = graftOptionSources(spec, {
+      "controller-gen.kubebuilder.io/version": "v0.16.4",
+      "options.cozystack.io/other": "noise",
+    }) as SchemaNode
+
+    expect(out.properties?.backupClassName?.["x-cozystack-options"]).toBeUndefined()
+  })
+
+  it("is a no-op for a path that does not exist in the schema", () => {
+    const spec: SchemaNode = {
+      type: "object",
+      properties: { backupClassName: { type: "string" } },
+    }
+
+    expect(() =>
+      graftOptionSources(spec, {
+        "options.cozystack.io/source.missing.field": "appkind",
+      }),
+    ).not.toThrow()
+  })
+
+  it("does not mutate the input schema, including nested nodes", () => {
+    const spec: SchemaNode = {
+      type: "object",
+      properties: {
+        backupClassName: { type: "string" },
+        applicationRef: { type: "object", properties: { kind: { type: "string" } } },
+      },
+    }
+
+    graftOptionSources(spec, {
+      "options.cozystack.io/source.backupClassName": "backupclass",
+      "options.cozystack.io/source.applicationRef.kind": "appkind",
+    })
+
+    // Both a top-level field and a nested one must be left untouched, so a
+    // future shallow/partial clone that corrupts deep nodes can't slip through.
+    expect(spec.properties?.backupClassName?.["x-cozystack-options"]).toBeUndefined()
+    expect(spec.properties?.applicationRef?.properties?.kind?.["x-cozystack-options"]).toBeUndefined()
+  })
+
+  it("returns the schema unchanged when there are no annotations", () => {
+    const spec: SchemaNode = {
+      type: "object",
+      properties: { backupClassName: { type: "string" } },
+    }
+
+    expect(graftOptionSources(spec, undefined)).toBe(spec)
+    expect(graftOptionSources(spec, {})).toEqual(spec)
+  })
+})

apps/console/src/lib/crd-option-sources.ts

@@ -0,0 +1,56 @@
+/**
+ * Graft the `x-cozystack-options` vendor keyword back onto a CRD's spec schema
+ * from its metadata annotations.
+ *
+ * The backups.cozystack.io CRDs cannot carry `x-cozystack-options` in their
+ * OpenAPI schema: apiextensions `JSONSchemaProps` is a closed struct that only
+ * preserves `x-kubernetes-*` extensions, and server-side apply rejects any
+ * other `x-` key outright. The field→source mapping the dropdowns need is
+ * therefore stored in CRD metadata annotations (which the apiserver does
+ * preserve) and reattached client-side here, so DynamicOptionsWidget — which
+ * reads `x-cozystack-options.source` off the schema node — keeps working.
+ *
+ * Annotation contract (emitted by kubebuilder markers on the Go types):
+ *   options.cozystack.io/source.<dotted spec-relative path> = <option source>
+ * e.g. `options.cozystack.io/source.applicationRef.kind: appkind`.
+ */
+
+const SOURCE_ANNOTATION_PREFIX = "options.cozystack.io/source."
+
+/**
+ * Return a copy of `specSchema` with `x-cozystack-options: { source }` set on
+ * every field named by a matching annotation. The input is not mutated. Paths
+ * that do not resolve in the schema are skipped silently.
+ */
+export function graftOptionSources(
+  specSchema: unknown,
+  annotations: Record<string, string> | undefined | null,
+): unknown {
+  if (!specSchema || typeof specSchema !== "object" || !annotations) {
+    return specSchema
+  }
+
+  const cloned = structuredClone(specSchema)
+
+  for (const [key, source] of Object.entries(annotations)) {
+    if (!source || !key.startsWith(SOURCE_ANNOTATION_PREFIX)) continue
+    const path = key.slice(SOURCE_ANNOTATION_PREFIX.length).split(".")
+    applySource(cloned, path, source)
+  }
+
+  return cloned
+}
+
+function applySource(specSchema: unknown, path: string[], source: string): void {
+  let node = specSchema
+  for (const segment of path) {
+    const properties = (node as { properties?: Record<string, unknown> })?.properties
+    if (!properties || typeof properties !== "object" || !(segment in properties)) {
+      return
+    }
+    node = properties[segment]
+  }
+  if (node && typeof node === "object") {
+    ;(node as Record<string, unknown>)["x-cozystack-options"] = { source }
+  }
+}

apps/console/src/lib/use-crd-schema.ts

@@ -1,12 +1,13 @@
 import { useK8sGet } from "@cozystack/k8s-client"
+import { graftOptionSources } from "./crd-option-sources.ts"
 
 interface CRDVersion {
   name: string
   storage?: boolean
   schema?: {
     openAPIV3Schema?: {
       properties?: {
-        spec?: any
+        spec?: unknown
       }
     }
   }
@@ -17,6 +18,7 @@ interface CRD {
   kind: string
   metadata: {
     name: string
+    annotations?: Record<string, string>
   }
   spec: {
     group: string
@@ -40,7 +42,11 @@ export function useCRDSchema(crdName: string) {
 
   // Use the storage version (authoritative) or fall back to the first listed version
   const version = crd?.spec?.versions?.find((v) => v.storage) ?? crd?.spec?.versions?.[0]
-  const schema = version?.schema?.openAPIV3Schema?.properties?.spec
+  const specSchema = version?.schema?.openAPIV3Schema?.properties?.spec
+
+  // Reattach the x-cozystack-options dropdown hints the apiserver strips from
+  // the CRD schema; they are carried in metadata annotations instead.
+  const schema = graftOptionSources(specSchema, crd?.metadata?.annotations)
 
   return {
     schema: schema ? JSON.stringify(schema) : null,