schema-agnostic approaches with working tests

Signed-off-by: Jordan <jordan@nimblewidget.com>

Author: grokspawn

cmd/catalogd/main.go

@@ -365,10 +365,25 @@ func run(ctx context.Context) error {
 		return err
 	}
 
+	var metasMode storage.MetasHandlerMode
+	if features.CatalogdFeatureGate.Enabled(features.APIV1MetasHandler) {
+		metasMode = storage.MetasHandlerEnabled
+	} else {
+		metasMode = storage.MetasHandlerDisabled
+	}
+
+	var graphqlMode storage.GraphQLQueriesMode
+	if features.CatalogdFeatureGate.Enabled(features.GraphQLCatalogQueries) {
+		graphqlMode = storage.GraphQLQueriesEnabled
+	} else {
+		graphqlMode = storage.GraphQLQueriesDisabled
+	}
+
 	localStorage = storage.NewLocalDirV1(
 		storeDir,
 		baseStorageURL,
-		features.CatalogdFeatureGate.Enabled(features.APIV1MetasHandler),
+		metasMode,
+		graphqlMode,
 	)
 
 	// Config for the catalogd web server

helm/experimental.yaml

@@ -22,5 +22,6 @@ options:
     features:
       enabled:
         - APIV1MetasHandler
+        - GraphQLCatalogQueries
 # This can be one of: standard or experimental
   featureSet: experimental

internal/catalogd/features/features.go

@@ -9,13 +9,13 @@ import (
 )
 
 const (
-	APIV1MetasHandler = featuregate.Feature("APIV1MetasHandler")
+	APIV1MetasHandler     = featuregate.Feature("APIV1MetasHandler")
 	GraphQLCatalogQueries = featuregate.Feature("GraphQLCatalogQueries")
 )
 
 var catalogdFeatureGates = map[featuregate.Feature]featuregate.FeatureSpec{
-	APIV1MetasHandler: {Default: false, PreRelease: featuregate.Alpha},
-	GraphQLCatalogQueries: {Default: false, PreRelease: featuregate.Alpha},
+	APIV1MetasHandler:     {Default: false, PreRelease: featuregate.Alpha, LockToDefault: false},
+	GraphQLCatalogQueries: {Default: false, PreRelease: featuregate.Alpha, LockToDefault: false},
 }
 
 var CatalogdFeatureGate featuregate.MutableFeatureGate = featuregate.NewFeatureGate()

internal/catalogd/graphql/discovery_test.go

@@ -116,35 +116,26 @@ func TestDiscoverSchemaFromMetas_CoreLogic(t *testing.T) {
 			t.Errorf("Expected 1 bundle object, got %d", bundleSchema.TotalObjects)
 		}
 
-		// Check property types discovery
-		if len(bundleSchema.PropertyTypes) == 0 {
-			t.Error("No property types discovered for bundle schema")
+		// Check that properties field is discovered with nested structure
+		propertiesField, exists := bundleSchema.Fields[remapFieldName("properties")]
+		if !exists {
+			t.Error("properties field not discovered in bundle schema")
+		} else if !propertiesField.IsArray {
+			t.Error("properties field should be an array")
+		} else if propertiesField.NestedFields == nil || len(propertiesField.NestedFields) == 0 {
+			t.Error("properties field should have nested fields discovered")
 		}
 
-		// Check for specific property types
-		if olmPackage, exists := bundleSchema.PropertyTypes["olm.package"]; !exists {
-			t.Error("olm.package property type not discovered")
-		} else {
-			expectedPropertyFields := []string{"packageName", "version"}
-			for _, field := range expectedPropertyFields {
-				graphqlField := remapFieldName(field)
-				if _, exists := olmPackage[graphqlField]; !exists {
-					t.Errorf("Expected property field %s not found in olm.package", graphqlField)
+		// Check for typical property fields (type, value)
+		if propertiesField.NestedFields != nil {
+			expectedFields := []string{"type", "value"}
+			for _, field := range expectedFields {
+				if _, exists := propertiesField.NestedFields[remapFieldName(field)]; !exists {
+					t.Errorf("Expected nested field %s not found in properties", field)
 				}
 			}
 		}
 
-		if olmGvk, exists := bundleSchema.PropertyTypes["olm.gvk"]; !exists {
-			t.Error("olm.gvk property type not discovered")
-		} else {
-			expectedGvkFields := []string{"group", "version", "kind"}
-			for _, field := range expectedGvkFields {
-				graphqlField := remapFieldName(field)
-				if _, exists := olmGvk[graphqlField]; !exists {
-					t.Errorf("Expected GVK field %s not found in olm.gvk", graphqlField)
-				}
-			}
-		}
 	}
 
 	// Test channel schema
@@ -269,6 +260,7 @@ func TestAnalyzeJSONObject_FieldTypes(t *testing.T) {
 }
 
 func TestBundlePropertiesAnalysis_ComprehensiveTypes(t *testing.T) {
+	// Test that properties field is discovered with nested structure
 	bundleObj := map[string]interface{}{
 		"name":    "test-bundle",
 		"package": "test-package",
@@ -288,83 +280,40 @@ func TestBundlePropertiesAnalysis_ComprehensiveTypes(t *testing.T) {
 					"kind":    "TestResource",
 				},
 			},
-			map[string]interface{}{
-				"type": "olm.csv.metadata",
-				"value": map[string]interface{}{
-					"name":      "test-operator",
-					"namespace": "test-namespace",
-					"annotations": map[string]interface{}{
-						"description": "A test operator",
-					},
-				},
-			},
-			map[string]interface{}{
-				"type": "olm.bundle.object",
-				"value": map[string]interface{}{
-					"ref": "objects/test.yaml",
-					"data": map[string]interface{}{
-						"apiVersion": "v1",
-						"kind":       "ConfigMap",
-						"metadata": map[string]interface{}{
-							"name": "config",
-						},
-					},
-				},
-			},
 		},
 	}
 
 	info := &SchemaInfo{
-		PropertyTypes: make(map[string]map[string]*FieldInfo),
+		Fields: make(map[string]*FieldInfo),
 	}
 
-	analyzeBundleProperties(bundleObj, info)
-
-	// Check that property types were discovered
-	expectedPropertyTypes := []string{"olm.package", "olm.gvk", "olm.csv.metadata", "olm.bundle.object"}
-	for _, propType := range expectedPropertyTypes {
-		if _, exists := info.PropertyTypes[propType]; !exists {
-			t.Errorf("Property type %s not discovered", propType)
-		}
-	}
+	// Use the generic field analysis (not bundle-specific)
+	analyzeJSONObject(bundleObj, info)
 
-	// Check olm.package fields
-	if olmPackage, exists := info.PropertyTypes["olm.package"]; exists {
-		expectedFields := []string{"packageName", "version"}
-		for _, field := range expectedFields {
-			if _, exists := olmPackage[field]; !exists {
-				t.Errorf("Field %s not found in olm.package property type", field)
-			}
-		}
+	// Check that properties field was discovered
+	propertiesField, exists := info.Fields[remapFieldName("properties")]
+	if !exists {
+		t.Error("properties field not discovered")
+		return
 	}
 
-	// Check olm.gvk fields
-	if olmGvk, exists := info.PropertyTypes["olm.gvk"]; exists {
-		expectedFields := []string{"group", "version", "kind"}
-		for _, field := range expectedFields {
-			if _, exists := olmGvk[field]; !exists {
-				t.Errorf("Field %s not found in olm.gvk property type", field)
-			}
-		}
+	// Verify it's detected as an array
+	if !propertiesField.IsArray {
+		t.Error("properties field should be detected as an array")
 	}
 
-	// Check that nested objects are handled (annotations in csv.metadata)
-	if csvMetadata, exists := info.PropertyTypes["olm.csv.metadata"]; exists {
-		expectedFields := []string{"name", "namespace", "annotations"}
-		for _, field := range expectedFields {
-			if _, exists := csvMetadata[field]; !exists {
-				t.Errorf("Field %s not found in olm.csv.metadata property type", field)
-			}
-		}
+	// Verify nested fields were discovered
+	if propertiesField.NestedFields == nil {
+		t.Error("properties field should have nested fields discovered")
+		return
 	}
 
-	// Check bundle object type
-	if bundleObject, exists := info.PropertyTypes["olm.bundle.object"]; exists {
-		expectedFields := []string{"ref", "data"}
-		for _, field := range expectedFields {
-			if _, exists := bundleObject[field]; !exists {
-				t.Errorf("Field %s not found in olm.bundle.object property type", field)
-			}
+	// Check for common property fields (type, value)
+	expectedFields := []string{"type", "value"}
+	for _, field := range expectedFields {
+		fieldName := remapFieldName(field)
+		if _, exists := propertiesField.NestedFields[fieldName]; !exists {
+			t.Errorf("Expected nested field %s not found in properties", fieldName)
 		}
 	}
 }
@@ -458,22 +407,23 @@ func TestSchemaDiscovery_RealWorldExample(t *testing.T) {
 		t.Fatal("Bundle schema not found")
 	}
 
-	expectedPropertyTypes := map[string][]string{
-		"olm.package":          {"packageName", "version"},
-		"olm.gvk":              {"group", "kind", "version"},
-		"olm.bundle.mediatype": {}, // This is a string value, no nested fields
-	}
-
-	for propType, expectedFields := range expectedPropertyTypes {
-		if propFields, exists := bundleSchema.PropertyTypes[propType]; exists {
-			for _, expectedField := range expectedFields {
-				if _, fieldExists := propFields[expectedField]; !fieldExists {
-					t.Errorf("Expected field %s not found in property type %s", expectedField, propType)
+	// With the schema-agnostic approach, we verify the properties field has nested structure
+	propertiesField, exists := bundleSchema.Fields[remapFieldName("properties")]
+	if !exists {
+		t.Error("properties field not found in bundle schema")
+	} else {
+		if !propertiesField.IsArray {
+			t.Error("properties field should be an array")
+		}
+		if propertiesField.NestedFields == nil || len(propertiesField.NestedFields) == 0 {
+			t.Error("properties field should have nested fields")
+		} else {
+			// Verify common property fields
+			for _, field := range []string{"type", "value"} {
+				if _, exists := propertiesField.NestedFields[remapFieldName(field)]; !exists {
+					t.Errorf("Expected field %s not found in properties", field)
 				}
 			}
-		} else if len(expectedFields) > 0 {
-			// Only error if we expected fields (mediatype is a string, so no fields expected)
-			t.Errorf("Property type %s not discovered", propType)
 		}
 	}