✨ Add automated schema generation and validation for registry+v1 bundle configuration

Summary:

Implements Phase 1 of the variable configuration feature to achieve feature parity with
OLMv0's SubscriptionConfig for registry+v1 bundles.

RFC: https://docs.google.com/document/d/18O4qBvu5I4WIJgo5KU1opyUKcrfgk64xsI3tyXxmVEU/edit?tab=t.0#heading=h.x3tfh25grvnv

Details:

This PR adds infrastructure for JSON schema-based validation of registry+v1 bundle configuration
in ClusterExtension, including both `watchNamespace` and `deploymentConfig` fields:

- **Schema Generation Tool**: Parses SubscriptionConfig using AST to extract field names/types
  - Fetches Kubernetes OpenAPI v3 specs from GitHub releases
  - Maps fields to official Kubernetes schemas
  - Generates schema with `watchNamespace` (for operator scope) and `deploymentConfig` (for deployment customization)
  - Excludes `selector` field (unused in OLMv0)

- **Runtime Schema Customization**: The base schema is loaded and modified at runtime based on
operator install modes: `watchNamespace` validation rules are customized per operator's supported install modes

- **Validation Infrastructure**: Validation integrated into bundle config unmarshaling via `config.UnmarshalConfig()`

- **Regeneration Workflow**: Added `make update-registryv1-bundle-schema` target to regenerate schema when
upstream SubscriptionConfig changes.

When the upstream `v1alpha1.SubscriptionConfig` adds new fields (e.g., new k8s corev1 types), running the
regeneration target will automatically include them in the schema without manual updates.

Addresses OPRUN-4112 (Phase 1)

Future PRs will implement:
- Phase 2: Renderer integration to apply deploymentConfig to Deployments
- Phase 3: Provider integration to extract bundle configuration from bundles
- Phase 4: Documentation

Author: anik120

Makefile

@@ -222,6 +222,10 @@ fmt: $(YAMLFMT) #EXHELP Formats code
 update-tls-profiles: $(GOJQ) #EXHELP Update TLS profiles from the Mozilla wiki
 	env JQ=$(GOJQ) hack/tools/update-tls-profiles.sh
 
+.PHONY: update-registryv1-bundle-schema
+update-registryv1-bundle-schema: #EXHELP Update registry+v1 bundle configuration JSON schema
+	hack/tools/update-registryv1-bundle-schema.sh
+
 .PHONY: verify-crd-compatibility
 CRD_DIFF_ORIGINAL_REF := git://main?path=
 CRD_DIFF_UPDATED_REF := file://

hack/tools/schema-generator/main.go

@@ -0,0 +1,322 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	schemaID          = "https://operator-framework.io/schemas/registry-v1-bundle-config.json"
+	schemaDraft       = "http://json-schema.org/draft-07/schema#"
+	schemaTitle       = "Registry+v1 Bundle Configuration"
+	schemaDescription = "Configuration schema for registry+v1 bundles. Includes watchNamespace for controlling operator scope and deploymentConfig for customizing operator deployment (environment variables, resource scheduling, storage, and pod placement). The deploymentConfig follows the same structure and behavior as OLM v0's SubscriptionConfig. Note: The 'selector' field from v0's SubscriptionConfig is not included as it was never used."
+)
+
+// OpenAPISpec represents the structure of Kubernetes OpenAPI v3 spec
+type OpenAPISpec struct {
+	Components struct {
+		Schemas map[string]interface{} `json:"schemas"`
+	} `json:"components"`
+}
+
+// Schema represents a JSON Schema Draft 7 document
+type Schema struct {
+	Schema               string                 `json:"$schema"`
+	ID                   string                 `json:"$id"`
+	Title                string                 `json:"title"`
+	Description          string                 `json:"description"`
+	Type                 string                 `json:"type"`
+	Properties           map[string]interface{} `json:"properties"`
+	AdditionalProperties bool                   `json:"additionalProperties"`
+	Defs                 map[string]interface{} `json:"$defs,omitempty"`
+}
+
+// FieldInfo contains parsed information about a struct field
+type FieldInfo struct {
+	JSONName string
+	TypeName string
+	TypePkg  string
+	IsSlice  bool
+	IsPtr    bool
+	IsMap    bool
+}
+
+func main() {
+	if len(os.Args) != 4 {
+		fmt.Fprintf(os.Stderr, "Usage: %s <k8s-openapi-spec-url> <subscription-types-file> <output-file>\n", os.Args[0])
+		os.Exit(1)
+	}
+
+	k8sOpenAPISpecURL := os.Args[1]
+	subscriptionTypesFile := os.Args[2]
+	outputFile := os.Args[3]
+
+	fmt.Printf("Fetching Kubernetes OpenAPI spec from %s...\n", k8sOpenAPISpecURL)
+
+	// Fetch the Kubernetes OpenAPI spec
+	openAPISpec, err := fetchOpenAPISpec(k8sOpenAPISpecURL)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error fetching OpenAPI spec: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("Parsing SubscriptionConfig from %s...\n", subscriptionTypesFile)
+
+	// Parse SubscriptionConfig structure
+	fields, err := parseSubscriptionConfig(subscriptionTypesFile)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error parsing SubscriptionConfig: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("Generating registry+v1 bundle configuration schema...\n")
+
+	// Generate the schema
+	schema := generateBundleConfigSchema(openAPISpec, fields)
+
+	// Marshal to JSON with indentation
+	data, err := json.MarshalIndent(schema, "", "  ")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error marshaling schema: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Ensure output directory exists
+	dir := filepath.Dir(outputFile)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		fmt.Fprintf(os.Stderr, "Error creating output directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Write to file
+	if err := os.WriteFile(outputFile, data, 0644); err != nil {
+		fmt.Fprintf(os.Stderr, "Error writing schema file: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("Successfully generated schema at %s\n", outputFile)
+}
+
+func fetchOpenAPISpec(url string) (*OpenAPISpec, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch spec: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var spec OpenAPISpec
+	if err := json.Unmarshal(body, &spec); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal spec: %w", err)
+	}
+
+	return &spec, nil
+}
+
+func parseSubscriptionConfig(filepath string) ([]FieldInfo, error) {
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, filepath, nil, parser.ParseComments)
+	if err != nil {
+		return nil, err
+	}
+
+	var fields []FieldInfo
+
+	// Find the SubscriptionConfig struct
+	ast.Inspect(node, func(n ast.Node) bool {
+		typeSpec, ok := n.(*ast.TypeSpec)
+		if !ok || typeSpec.Name.Name != "SubscriptionConfig" {
+			return true
+		}
+
+		structType, ok := typeSpec.Type.(*ast.StructType)
+		if !ok {
+			return true
+		}
+
+		// Extract field information
+		for _, field := range structType.Fields.List {
+			if field.Names == nil {
+				continue
+			}
+
+			fieldName := field.Names[0].Name
+
+			// Skip Selector field
+			if fieldName == "Selector" {
+				continue
+			}
+
+			// Get JSON tag
+			jsonName := extractJSONTag(field.Tag)
+			if jsonName == "" || jsonName == "-" {
+				continue
+			}
+
+			// Parse the field type
+			fieldInfo := FieldInfo{
+				JSONName: jsonName,
+			}
+
+			parseFieldType(field.Type, &fieldInfo)
+
+			fields = append(fields, fieldInfo)
+		}
+
+		return false
+	})
+
+	return fields, nil
+}
+
+func extractJSONTag(tag *ast.BasicLit) string {
+	if tag == nil {
+		return ""
+	}
+
+	tagValue := strings.Trim(tag.Value, "`")
+	for _, part := range strings.Split(tagValue, " ") {
+		if strings.HasPrefix(part, "json:") {
+			jsonTag := strings.Trim(strings.TrimPrefix(part, "json:"), "\"")
+			return strings.Split(jsonTag, ",")[0]
+		}
+	}
+
+	return ""
+}
+
+func parseFieldType(expr ast.Expr, info *FieldInfo) {
+	switch t := expr.(type) {
+	case *ast.ArrayType:
+		info.IsSlice = true
+		parseFieldType(t.Elt, info)
+
+	case *ast.StarExpr:
+		info.IsPtr = true
+		parseFieldType(t.X, info)
+
+	case *ast.MapType:
+		info.IsMap = true
+		info.TypeName = "map[string]string" // Simplified for our use case
+
+	case *ast.Ident:
+		info.TypeName = t.Name
+
+	case *ast.SelectorExpr:
+		if pkg, ok := t.X.(*ast.Ident); ok {
+			info.TypePkg = pkg.Name
+			info.TypeName = t.Sel.Name
+		}
+	}
+}
+
+func generateBundleConfigSchema(openAPISpec *OpenAPISpec, fields []FieldInfo) *Schema {
+	schema := &Schema{
+		Schema:               schemaDraft,
+		ID:                   schemaID,
+		Title:                schemaTitle,
+		Description:          schemaDescription,
+		Type:                 "object",
+		Properties:           make(map[string]interface{}),
+		AdditionalProperties: false,
+		Defs:                 make(map[string]interface{}),
+	}
+
+	// Add watchNamespace property (base definition - will be modified at runtime)
+	schema.Properties["watchNamespace"] = map[string]interface{}{
+		"description": "The namespace that the operator should watch for custom resources. The meaning and validation of this field depends on the operator's install modes. This field may be optional or required, and may have format constraints, based on the operator's supported install modes.",
+		"anyOf": []interface{}{
+			map[string]string{"type": "null"},
+			map[string]string{"type": "string"},
+		},
+	}
+
+	// Create deploymentConfig property
+	deploymentConfigProp := map[string]interface{}{
+		"type":                 "object",
+		"description":          "Configuration for customizing operator deployment (environment variables, resources, volumes, etc.)",
+		"properties":           make(map[string]interface{}),
+		"additionalProperties": false,
+	}
+
+	// Build deploymentConfig properties from parsed fields
+	deploymentConfigProps := deploymentConfigProp["properties"].(map[string]interface{})
+
+	for _, field := range fields {
+		fieldSchema := mapFieldToOpenAPISchema(field, openAPISpec)
+		if fieldSchema != nil {
+			deploymentConfigProps[field.JSONName] = fieldSchema
+		}
+	}
+
+	schema.Properties["deploymentConfig"] = deploymentConfigProp
+
+	return schema
+}
+
+func mapFieldToOpenAPISchema(field FieldInfo, openAPISpec *OpenAPISpec) interface{} {
+	// Handle map types (nodeSelector, annotations)
+	if field.IsMap {
+		return map[string]interface{}{
+			"type": "object",
+			"additionalProperties": map[string]string{
+				"type": "string",
+			},
+		}
+	}
+
+	// Get the OpenAPI schema for the base type
+	openAPITypeName := getOpenAPITypeName(field)
+	if openAPITypeName == "" {
+		fmt.Fprintf(os.Stderr, "Warning: Could not map field %s (type: %s.%s) to OpenAPI schema\n",
+			field.JSONName, field.TypePkg, field.TypeName)
+		return nil
+	}
+
+	baseSchema, ok := openAPISpec.Components.Schemas[openAPITypeName]
+	if !ok {
+		fmt.Fprintf(os.Stderr, "Warning: Schema for %s not found in OpenAPI spec\n", openAPITypeName)
+		return nil
+	}
+
+	// Wrap in array if it's a slice field
+	if field.IsSlice {
+		return map[string]interface{}{
+			"type":  "array",
+			"items": baseSchema,
+		}
+	}
+
+	return baseSchema
+}
+
+func getOpenAPITypeName(field FieldInfo) string {
+	// Map package names to OpenAPI prefixes
+	pkgMap := map[string]string{
+		"corev1": "io.k8s.api.core.v1",
+		"v1":     "io.k8s.api.core.v1",
+	}
+
+	prefix, ok := pkgMap[field.TypePkg]
+	if !ok {
+		return ""
+	}
+
+	return fmt.Sprintf("%s.%s", prefix, field.TypeName)
+}