schema-agnostic approaches with working tests

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

Author: grokspawn

cmd/catalogd/main.go

@@ -381,10 +381,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

go.mod

@@ -17,6 +17,7 @@ require (
 	github.com/google/go-containerregistry v0.21.3
 	github.com/google/renameio/v2 v2.0.2
 	github.com/gorilla/handlers v1.5.2
+	github.com/graphql-go/graphql v0.8.1
 	github.com/klauspost/compress v1.18.5
 	github.com/opencontainers/go-digest v1.0.0
 	github.com/opencontainers/image-spec v1.1.1
@@ -142,7 +143,6 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/mux v1.8.1 // indirect
 	github.com/gosuri/uitable v0.0.4 // indirect
-	github.com/graphql-go/graphql v0.8.1 // indirect
 	github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.7 // indirect
 	github.com/h2non/filetype v1.1.3 // indirect

helm/experimental.yaml

@@ -23,5 +23,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/README.md

@@ -92,11 +92,11 @@ curl -X POST http://localhost:8080/my-catalog/api/v1/graphql \
 
 ## Integration
 
-The GraphQL functionality is integrated into the `LocalDirV1` storage handler in `internal/catalogd/storage/localdir.go`:
+The GraphQL functionality is integrated across multiple packages:
 
-- `handleV1GraphQL()`: Handles POST requests to the GraphQL endpoint
-- `createCatalogFS()`: Creates filesystem interface for catalog data
-- `buildCatalogGraphQLSchema()`: Builds dynamic GraphQL schema for specific catalogs
+- `internal/catalogd/server/handlers.go`: `CatalogHandlers.handleV1GraphQL()` handles POST requests to the GraphQL endpoint
+- `internal/catalogd/storage/localdir.go`: `LocalDirV1.GetCatalogFS()` creates filesystem interface for catalog data
+- `internal/catalogd/service/graphql_service.go`: `GraphQLService.GetSchema()` and `buildSchemaFromFS()` build dynamic GraphQL schemas for specific catalogs
 
 ## Technical Details
 

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
@@ -178,7 +169,7 @@ func TestFieldNameRemapping_EdgeCases(t *testing.T) {
 		{"operators.operatorframework.io/bundle.channels.v1", "operatorsOperatorframeworkIoBundleChannelsV1"},
 		{"---", "field_"},
 		{"123", "field_123"},
-		{"field@#$%", "fieldField"},
+		{"field@#$%", "field"},
 	}
 
 	for _, tc := range testCases {
@@ -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)
 		}
 	}