integration with existing http service endpoint

Signed-off-by: grokspawn <[email protected]>

Author: grokspawn

internal/catalogd/graphql/README.md

@@ -0,0 +1,106 @@
+# GraphQL Integration
+
+This package provides dynamic GraphQL schema generation for operator catalog data, integrated into the catalogd storage server.
+
+## Usage
+
+The GraphQL endpoint is now available as part of the catalogd storage server at:
+
+```
+{catalog}/api/v1/graphql
+```
+
+Where `{catalog}` is replaced by the actual catalog name at runtime.
+
+## Example Usage
+
+### Making a GraphQL Request
+
+```bash
+curl -X POST http://localhost:8080/my-catalog/api/v1/graphql \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "{ summary { totalSchemas schemas { name totalObjects totalFields } } }"
+  }'
+```
+
+### Sample Queries
+
+#### Get catalog summary:
+```graphql
+{
+  summary {
+    totalSchemas
+    schemas {
+      name
+      totalObjects
+      totalFields
+    }
+  }
+}
+```
+
+#### Get bundles with pagination:
+```graphql
+{
+  bundles(limit: 5, offset: 0) {
+    name
+    package
+    version
+  }
+}
+```
+
+#### Get packages:
+```graphql
+{
+  packages(limit: 10) {
+    name
+    description
+  }
+}
+```
+
+#### Get bundle properties (union types):
+```graphql
+{
+  bundles(limit: 5) {
+    name
+    properties {
+      type
+      value {
+        ... on PropertyValueFeaturesOperatorsOpenshiftIo {
+          disconnected
+          cnf
+          cni
+          csi
+          fips
+        }
+      }
+    }
+  }
+}
+```
+
+## Features
+
+- **Dynamic Schema Generation**: Automatically discovers schema structure from catalog metadata
+- **Union Types**: Supports complex bundle properties with variable structures
+- **Pagination**: Built-in limit/offset pagination for all queries
+- **Field Name Sanitization**: Converts JSON field names to valid GraphQL identifiers
+- **Catalog-Specific**: Each catalog gets its own dynamically generated schema
+
+## Integration
+
+The GraphQL functionality is integrated into the `LocalDirV1` storage handler in `internal/catalogd/storage/localdir.go`:
+
+- `handleV1GraphQL()`: Handles POST requests to the GraphQL endpoint
+- `createCatalogFS()`: Creates filesystem interface for catalog data
+- `buildCatalogGraphQLSchema()`: Builds dynamic GraphQL schema for specific catalogs
+
+## Technical Details
+
+- Uses `declcfg.WalkMetasFS` to discover schema structure
+- Generates GraphQL object types dynamically from discovered fields
+- Creates union types for bundle properties with variable structures
+- Supports all standard GraphQL features including introspection 

internal/catalogd/graphql/graphql.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/fs"
-	"net/http"
 	"reflect"
 	"regexp"
 	"strings"
@@ -14,8 +13,6 @@ import (
 	"github.com/operator-framework/operator-registry/alpha/declcfg"
 )
 
-var schema graphql.Schema
-
 // FieldInfo represents discovered field information
 type FieldInfo struct {
 	Name         string
@@ -565,7 +562,7 @@ func BuildDynamicGraphQLSchema(catalogSchema *CatalogSchema, metasBySchema map[s
 }
 
 // LoadAndSummarizeCatalogDynamic loads FBC using WalkMetasReader and builds dynamic GraphQL schema
-func LoadAndSummarizeCatalogDynamic(catalogFS fs.FS) error {
+func LoadAndSummarizeCatalogDynamic(catalogFS fs.FS) (*DynamicSchema, error) {
 	var metas []*declcfg.Meta
 
 	// Collect all metas from the filesystem
@@ -579,13 +576,13 @@ func LoadAndSummarizeCatalogDynamic(catalogFS fs.FS) error {
 		return nil
 	})
 	if err != nil {
-		return fmt.Errorf("error walking catalog metas: %w", err)
+		return nil, fmt.Errorf("error walking catalog metas: %w", err)
 	}
 
 	// Discover schema from collected metas
 	catalogSchema, err := DiscoverSchemaFromMetas(metas)
 	if err != nil {
-		return fmt.Errorf("error discovering schema: %w", err)
+		return nil, fmt.Errorf("error discovering schema: %w", err)
 	}
 
 	// Organize metas by schema for resolvers
@@ -599,11 +596,15 @@ func LoadAndSummarizeCatalogDynamic(catalogFS fs.FS) error {
 	// Build dynamic GraphQL schema
 	dynamicSchema, err := BuildDynamicGraphQLSchema(catalogSchema, metasBySchema)
 	if err != nil {
-		return fmt.Errorf("error building GraphQL schema: %w", err)
+		return nil, fmt.Errorf("error building GraphQL schema: %w", err)
 	}
 
-	// Set the global schema for serving
-	schema = dynamicSchema.Schema
+	return dynamicSchema, nil
+}
+
+// PrintCatalogSummary prints a comprehensive summary of the discovered schema
+func PrintCatalogSummary(dynamicSchema *DynamicSchema) {
+	catalogSchema := dynamicSchema.CatalogSchema
 
 	// Print comprehensive summary
 	fmt.Printf("Dynamic GraphQL schema generation complete.\n")
@@ -661,32 +662,4 @@ func LoadAndSummarizeCatalogDynamic(catalogFS fs.FS) error {
 		fmt.Printf("  packages(limit: 5) { name }\n")
 	}
 	fmt.Printf("}\n")
-
-	return nil
-}
-
-// ServeGraphQL starts an HTTPS server with the /graphql endpoint.
-func ServeGraphQL(listenAddr, certPath, keyPath string) error {
-	http.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPost {
-			http.Error(w, "Only POST is allowed", http.StatusMethodNotAllowed)
-			return
-		}
-		var params struct {
-			Query string `json:"query"`
-		}
-		if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-		result := graphql.Do(graphql.Params{
-			Schema:        schema,
-			RequestString: params.Query,
-		})
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(result)
-	})
-
-	fmt.Printf("Serving GraphQL endpoint at https://%s/graphql\n", listenAddr)
-	return http.ListenAndServeTLS(listenAddr, certPath, keyPath, nil)
 }

internal/catalogd/storage/localdir.go

@@ -17,6 +17,8 @@ import (
 	"golang.org/x/sync/singleflight"
 	"k8s.io/apimachinery/pkg/util/sets"
 
+	"github.com/graphql-go/graphql"
+	gql "github.com/operator-framework/operator-controller/internal/catalogd/graphql"
 	"github.com/operator-framework/operator-registry/alpha/declcfg"
 )
 
@@ -193,9 +195,16 @@ func (s *LocalDirV1) StorageServerHandler() http.Handler {
 	if s.EnableMetasHandler {
 		mux.HandleFunc(s.RootURL.JoinPath("{catalog}", "api", "v1", "metas").Path, s.handleV1Metas)
 	}
+	mux.HandleFunc(s.RootURL.JoinPath("{catalog}", "api", "v1", "graphql").Path, s.handleV1GraphQL)
+
 	allowedMethodsHandler := func(next http.Handler, allowedMethods ...string) http.Handler {
 		allowedMethodSet := sets.New[string](allowedMethods...)
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			// Allow POST requests for GraphQL endpoint
+			if r.URL.Path != "" && r.URL.Path[len(r.URL.Path)-7:] == "graphql" && r.Method == http.MethodPost {
+				next.ServeHTTP(w, r)
+				return
+			}
 			if !allowedMethodSet.Has(r.Method) {
 				http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
 				return
@@ -270,6 +279,59 @@ func (s *LocalDirV1) handleV1Metas(w http.ResponseWriter, r *http.Request) {
 	serveJSONLines(w, r, indexReader)
 }
 
+func (s *LocalDirV1) handleV1GraphQL(w http.ResponseWriter, r *http.Request) {
+	s.m.RLock()
+	defer s.m.RUnlock()
+
+	if r.Method != http.MethodPost {
+		http.Error(w, "Only POST is allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	catalog := r.PathValue("catalog")
+	catalogFile, _, err := s.catalogData(catalog)
+	if err != nil {
+		httpError(w, err)
+		return
+	}
+	defer catalogFile.Close()
+
+	// Parse GraphQL query from request body
+	var params struct {
+		Query string `json:"query"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	// Create catalog filesystem from the stored data
+	catalogFS, err := s.createCatalogFS(catalog)
+	if err != nil {
+		httpError(w, err)
+		return
+	}
+
+	// Build dynamic GraphQL schema for this catalog
+	dynamicSchema, err := s.buildCatalogGraphQLSchema(catalogFS)
+	if err != nil {
+		httpError(w, err)
+		return
+	}
+
+	// Execute GraphQL query
+	result := graphql.Do(graphql.Params{
+		Schema:        dynamicSchema.Schema,
+		RequestString: params.Query,
+	})
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		httpError(w, err)
+		return
+	}
+}
+
 func (s *LocalDirV1) catalogData(catalog string) (*os.File, os.FileInfo, error) {
 	catalogFile, err := os.Open(catalogFilePath(s.catalogDir(catalog)))
 	if err != nil {
@@ -329,3 +391,50 @@ func (s *LocalDirV1) getIndex(catalog string) (*index, error) {
 	}
 	return idx.(*index), nil
 }
+
+// createCatalogFS creates a filesystem interface for the catalog data
+func (s *LocalDirV1) createCatalogFS(catalog string) (fs.FS, error) {
+	catalogDir := s.catalogDir(catalog)
+	return os.DirFS(catalogDir), nil
+}
+
+// buildCatalogGraphQLSchema builds a dynamic GraphQL schema for the given catalog
+func (s *LocalDirV1) buildCatalogGraphQLSchema(catalogFS fs.FS) (*gql.DynamicSchema, error) {
+	var metas []*declcfg.Meta
+
+	// Collect all metas from the catalog filesystem
+	err := declcfg.WalkMetasFS(context.Background(), catalogFS, func(path string, meta *declcfg.Meta, err error) error {
+		if err != nil {
+			return err
+		}
+		if meta != nil {
+			metas = append(metas, meta)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("error walking catalog metas: %w", err)
+	}
+
+	// Discover schema from collected metas
+	catalogSchema, err := gql.DiscoverSchemaFromMetas(metas)
+	if err != nil {
+		return nil, fmt.Errorf("error discovering schema: %w", err)
+	}
+
+	// Organize metas by schema for resolvers
+	metasBySchema := make(map[string][]*declcfg.Meta)
+	for _, meta := range metas {
+		if meta.Schema != "" {
+			metasBySchema[meta.Schema] = append(metasBySchema[meta.Schema], meta)
+		}
+	}
+
+	// Build dynamic GraphQL schema
+	dynamicSchema, err := gql.BuildDynamicGraphQLSchema(catalogSchema, metasBySchema)
+	if err != nil {
+		return nil, fmt.Errorf("error building GraphQL schema: %w", err)
+	}
+
+	return dynamicSchema, nil
+}