shift to file-based cache, leveraging existing metas indexer

Author: grokspawn

internal/catalogd/graphql/graphql.go

@@ -0,0 +1,73 @@
+package graphql
+
+import (
+	"fmt"
+
+	"github.com/graphql-go/graphql/language/ast"
+	"github.com/graphql-go/graphql/language/parser"
+)
+
+const (
+	MaxQueryDepth   = 10
+	MaxQueryAliases = 50
+	MaxQueryFields  = 500
+)
+
+type queryComplexity struct {
+	aliases int
+	fields  int
+}
+
+// ValidateQueryComplexity parses the query AST and rejects it if it exceeds
+// depth, alias, or total field count thresholds.
+func ValidateQueryComplexity(query string) error {
+	doc, err := parser.Parse(parser.ParseParams{Source: query})
+	if err != nil {
+		return fmt.Errorf("query parse error: %w", err)
+	}
+
+	c := &queryComplexity{}
+	for _, def := range doc.Definitions {
+		if op, ok := def.(*ast.OperationDefinition); ok {
+			if err := c.walkSelectionSet(op.SelectionSet, 1); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (c *queryComplexity) walkSelectionSet(ss *ast.SelectionSet, depth int) error {
+	if ss == nil {
+		return nil
+	}
+	if depth > MaxQueryDepth {
+		return fmt.Errorf("query exceeds maximum depth of %d", MaxQueryDepth)
+	}
+
+	for _, sel := range ss.Selections {
+		switch s := sel.(type) {
+		case *ast.Field:
+			c.fields++
+			if c.fields > MaxQueryFields {
+				return fmt.Errorf("query exceeds maximum field count of %d", MaxQueryFields)
+			}
+			if s.Alias != nil && s.Alias.Value != "" {
+				c.aliases++
+				if c.aliases > MaxQueryAliases {
+					return fmt.Errorf("query exceeds maximum alias count of %d", MaxQueryAliases)
+				}
+			}
+			if err := c.walkSelectionSet(s.SelectionSet, depth+1); err != nil {
+				return err
+			}
+		case *ast.InlineFragment:
+			if err := c.walkSelectionSet(s.SelectionSet, depth+1); err != nil {
+				return err
+			}
+		case *ast.FragmentSpread:
+			c.fields++
+		}
+	}
+	return nil
+}

internal/catalogd/graphql/validation.go

@@ -223,15 +223,7 @@ func (h *CatalogHandlers) handleV1GraphQL(w http.ResponseWriter, r *http.Request
 		return
 	}
 
-	// Get catalog filesystem
-	catalogFS, err := h.store.GetCatalogFS(catalog)
-	if err != nil {
-		httpError(w, err)
-		return
-	}
-
-	// Execute GraphQL query through the service
-	result, err := h.graphqlSvc.ExecuteQuery(catalog, catalogFS, params.Query)
+	result, err := h.graphqlSvc.ExecuteQuery(r.Context(), catalog, params.Query)
 	if err != nil {
 		httpError(w, err)
 		return

internal/catalogd/server/handlers.go

@@ -8,7 +8,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
-	"os"
 	"strings"
 	"testing"
 
@@ -146,12 +145,7 @@ func TestHandleV1GraphQL_Success(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	rootURL, _ := url.Parse("http://localhost/")
 
-	// Create a temporary directory for the mock filesystem
-	tmpDir := t.TempDir()
-	catalogFS := os.DirFS(tmpDir)
-
 	store := mockcatalogdserver.NewMockCatalogStore(ctrl)
-	store.EXPECT().GetCatalogFS("test-catalog").Return(catalogFS, nil)
 
 	expectedResult := &graphql.Result{
 		Data: map[string]interface{}{
@@ -162,7 +156,7 @@ func TestHandleV1GraphQL_Success(t *testing.T) {
 	}
 
 	graphqlSvc := mockcatalogdservice.NewMockGraphQLService(ctrl)
-	graphqlSvc.EXPECT().ExecuteQuery("test-catalog", catalogFS, "{ summary { totalSchemas } }").Return(expectedResult, nil)
+	graphqlSvc.EXPECT().ExecuteQuery(gomock.Any(), "test-catalog", "{ summary { totalSchemas } }").Return(expectedResult, nil)
 
 	handlers := server.NewCatalogHandlers(store, graphqlSvc, rootURL, server.MetasHandlerDisabled, server.GraphQLQueriesEnabled)
 	handler := handlers.Handler()
@@ -201,14 +195,14 @@ func TestHandleV1GraphQL_Success(t *testing.T) {
 	}
 }
 
-func TestHandleV1GraphQL_GetCatalogFSError(t *testing.T) {
+func TestHandleV1GraphQL_CatalogNotFoundError(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	rootURL, _ := url.Parse("http://localhost/")
 
 	store := mockcatalogdserver.NewMockCatalogStore(ctrl)
-	store.EXPECT().GetCatalogFS("test-catalog").Return(nil, fs.ErrNotExist)
 
 	graphqlSvc := mockcatalogdservice.NewMockGraphQLService(ctrl)
+	graphqlSvc.EXPECT().ExecuteQuery(gomock.Any(), "test-catalog", "{ summary { totalSchemas } }").Return(nil, fs.ErrNotExist)
 
 	handlers := server.NewCatalogHandlers(store, graphqlSvc, rootURL, server.MetasHandlerDisabled, server.GraphQLQueriesEnabled)
 	handler := handlers.Handler()
@@ -228,14 +222,10 @@ func TestHandleV1GraphQL_ExecuteQueryError(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	rootURL, _ := url.Parse("http://localhost/")
 
-	tmpDir := t.TempDir()
-	catalogFS := os.DirFS(tmpDir)
-
 	store := mockcatalogdserver.NewMockCatalogStore(ctrl)
-	store.EXPECT().GetCatalogFS("test-catalog").Return(catalogFS, nil)
 
 	graphqlSvc := mockcatalogdservice.NewMockGraphQLService(ctrl)
-	graphqlSvc.EXPECT().ExecuteQuery("test-catalog", catalogFS, "{ summary { totalSchemas } }").Return(nil, context.DeadlineExceeded)
+	graphqlSvc.EXPECT().ExecuteQuery(gomock.Any(), "test-catalog", "{ summary { totalSchemas } }").Return(nil, context.DeadlineExceeded)
 
 	handlers := server.NewCatalogHandlers(store, graphqlSvc, rootURL, server.MetasHandlerDisabled, server.GraphQLQueriesEnabled)
 	handler := handlers.Handler()
@@ -255,10 +245,9 @@ func TestAllowedMethodsHandler_POSTOnlyForGraphQL(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	rootURL, _ := url.Parse("http://localhost/")
 	store := mockcatalogdserver.NewMockCatalogStore(ctrl)
-	store.EXPECT().GetCatalogFS("test-catalog").Return(nil, nil)
 
 	graphqlSvc := mockcatalogdservice.NewMockGraphQLService(ctrl)
-	graphqlSvc.EXPECT().ExecuteQuery("test-catalog", nil, "{ summary { totalSchemas } }").Return(nil, nil)
+	graphqlSvc.EXPECT().ExecuteQuery(gomock.Any(), "test-catalog", "{ summary { totalSchemas } }").Return(nil, nil)
 
 	handlers := server.NewCatalogHandlers(store, graphqlSvc, rootURL, server.MetasHandlerDisabled, server.GraphQLQueriesEnabled)
 	handler := handlers.Handler()

internal/catalogd/server/handlers_test.go

@@ -3,70 +3,68 @@ package service
 import (
 	"context"
 	"fmt"
-	"io/fs"
 	"sync"
+	"time"
 
 	"github.com/graphql-go/graphql"
+	"github.com/graphql-go/graphql/gqlerrors"
 	"golang.org/x/sync/singleflight"
 
-	"github.com/operator-framework/operator-registry/alpha/declcfg"
-
 	gql "github.com/operator-framework/operator-controller/internal/catalogd/graphql"
 )
 
+// CatalogDataProvider provides access to catalog data for GraphQL schema building.
+// Implemented by the storage layer.
+type CatalogDataProvider interface {
+	LoadCatalogSchema(catalog string) (*gql.CatalogSchema, error)
+	NewObjectLoader(catalog string) (gql.ObjectLoader, error)
+}
+
 // GraphQLService handles GraphQL schema generation and query execution for catalogs
 type GraphQLService interface {
-	// GetSchema returns the GraphQL schema for a catalog, using cache if available
-	GetSchema(catalog string, catalogFS fs.FS) (*gql.DynamicSchema, error)
-
-	// ExecuteQuery executes a GraphQL query against a catalog
-	ExecuteQuery(catalog string, catalogFS fs.FS, query string) (*graphql.Result, error)
-
-	// InvalidateCache removes the cached schema for a catalog
+	GetSchema(ctx context.Context, catalog string) (*gql.DynamicSchema, error)
+	ExecuteQuery(ctx context.Context, catalog string, query string) (*graphql.Result, error)
 	InvalidateCache(catalog string)
 }
 
-// CachedGraphQLService implements GraphQLService with an in-memory schema cache
+// CachedGraphQLService implements GraphQLService with an in-memory schema cache.
+// The cached DynamicSchema contains only the GraphQL type system and schema metadata
+// (a few KB). Object data is loaded from disk at query time via the ObjectLoader.
 type CachedGraphQLService struct {
+	provider    CatalogDataProvider
 	schemaMux   sync.RWMutex
 	schemaCache map[string]*gql.DynamicSchema
-	buildGroup  singleflight.Group // Prevents duplicate concurrent schema builds
+	buildGroup  singleflight.Group
 }
 
-// NewCachedGraphQLService creates a new GraphQL service with caching
-func NewCachedGraphQLService() *CachedGraphQLService {
+func NewCachedGraphQLService(provider CatalogDataProvider) *CachedGraphQLService {
 	return &CachedGraphQLService{
+		provider:    provider,
 		schemaCache: make(map[string]*gql.DynamicSchema),
 	}
 }
 
-// GetSchema returns the GraphQL schema for a catalog, using cache if available
-func (s *CachedGraphQLService) GetSchema(catalog string, catalogFS fs.FS) (*gql.DynamicSchema, error) {
-	// Check cache first (read lock)
+func (s *CachedGraphQLService) GetSchema(ctx context.Context, catalog string) (*gql.DynamicSchema, error) {
 	s.schemaMux.RLock()
 	if cachedSchema, ok := s.schemaCache[catalog]; ok {
 		s.schemaMux.RUnlock()
 		return cachedSchema, nil
 	}
 	s.schemaMux.RUnlock()
 
-	// Use singleflight to prevent duplicate concurrent builds for the same catalog
 	result, err, _ := s.buildGroup.Do(catalog, func() (interface{}, error) {
-		// Double-check cache after acquiring singleflight lock
 		s.schemaMux.RLock()
 		if cachedSchema, ok := s.schemaCache[catalog]; ok {
 			s.schemaMux.RUnlock()
 			return cachedSchema, nil
 		}
 		s.schemaMux.RUnlock()
 
-		// Schema not in cache, build it
-		dynamicSchema, err := buildSchemaFromFS(catalogFS)
+		dynamicSchema, err := s.buildSchema(catalog)
 		if err != nil {
 			return nil, err
 		}
 
-		// Cache the result (write lock)
 		s.schemaMux.Lock()
 		s.schemaCache[catalog] = dynamicSchema
 		s.schemaMux.Unlock()
@@ -81,80 +79,50 @@ func (s *CachedGraphQLService) GetSchema(catalog string, catalogFS fs.FS) (*gql.
 	return result.(*gql.DynamicSchema), nil
 }
 
-// ExecuteQuery executes a GraphQL query against a catalog
-func (s *CachedGraphQLService) ExecuteQuery(catalog string, catalogFS fs.FS, query string) (*graphql.Result, error) {
-	// Get or build the schema (uses cache and singleflight)
-	dynamicSchema, err := s.GetSchema(catalog, catalogFS)
+func (s *CachedGraphQLService) ExecuteQuery(ctx context.Context, catalog string, query string) (*graphql.Result, error) {
+	if err := gql.ValidateQueryComplexity(query); err != nil {
+		return &graphql.Result{
+			Errors: []gqlerrors.FormattedError{
+				gqlerrors.FormatError(err),
+			},
+		}, nil
+	}
+
+	dynamicSchema, err := s.GetSchema(ctx, catalog)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get GraphQL schema: %w", err)
 	}
 
-	// Execute the query
+	queryCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+	defer cancel()
+
 	result := graphql.Do(graphql.Params{
 		Schema:        dynamicSchema.Schema,
 		RequestString: query,
+		Context:       queryCtx,
 	})
 
 	return result, nil
 }
 
-// InvalidateCache removes the cached schema for a catalog
 func (s *CachedGraphQLService) InvalidateCache(catalog string) {
 	s.schemaMux.Lock()
 	delete(s.schemaCache, catalog)
 	s.schemaMux.Unlock()
 }
 
-// buildSchemaFromFS builds a GraphQL schema from a catalog filesystem
-func buildSchemaFromFS(catalogFS fs.FS) (*gql.DynamicSchema, error) {
-	var metas []*declcfg.Meta
-	var metasMux sync.Mutex
-	var walkErr error
-
-	// Collect all metas from the catalog filesystem
-	// WalkMetasFS walks the filesystem concurrently, so we need to protect the metas slice and error
-	err := declcfg.WalkMetasFS(context.Background(), catalogFS, func(path string, meta *declcfg.Meta, err error) error {
-		metasMux.Lock()
-		defer metasMux.Unlock()
-
-		if err != nil {
-			// Set shared error so other goroutines can check
-			if walkErr == nil {
-				walkErr = err
-			}
-			return err
-		}
-
-		// If an error has already occurred, skip further mutation
-		if walkErr != nil {
-			return walkErr
-		}
-
-		if meta != nil {
-			metas = append(metas, meta)
-		}
-		return nil
-	})
+func (s *CachedGraphQLService) buildSchema(catalog string) (*gql.DynamicSchema, error) {
+	catalogSchema, err := s.provider.LoadCatalogSchema(catalog)
 	if err != nil {
-		return nil, fmt.Errorf("error walking catalog metas: %w", err)
+		return nil, fmt.Errorf("error loading catalog schema: %w", err)
 	}
 
-	// Discover schema from collected metas
-	catalogSchema, err := gql.DiscoverSchemaFromMetas(metas)
+	loader, err := s.provider.NewObjectLoader(catalog)
 	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)
-		}
+		return nil, fmt.Errorf("error creating object loader: %w", err)
 	}
 
-	// Build dynamic GraphQL schema
-	dynamicSchema, err := gql.BuildDynamicGraphQLSchema(catalogSchema, metasBySchema)
+	dynamicSchema, err := gql.BuildDynamicGraphQLSchema(catalogSchema, loader)
 	if err != nil {
 		return nil, fmt.Errorf("error building GraphQL schema: %w", err)
 	}