removed circular dep from gateway

On-behalf-of: @SAP [email protected]
Signed-off-by: Artem Shcherbatiuk <[email protected]>

Author: vertex451

gateway/schema/relations.go

@@ -11,20 +11,8 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
-// RelationEnhancer handles schema enhancement for relation fields
-type RelationEnhancer struct {
-	gateway *Gateway
-}
-
-// NewRelationEnhancer creates a new relation enhancer
-func NewRelationEnhancer(gateway *Gateway) *RelationEnhancer {
-	return &RelationEnhancer{
-		gateway: gateway,
-	}
-}
-
-// AddRelationFields adds relation fields to schemas that contain *Ref fields
-func (re *RelationEnhancer) AddRelationFields(fields graphql.Fields, properties map[string]spec.Schema) {
+// addRelationFields adds relation fields to schemas that contain *Ref fields
+func (g *Gateway) addRelationFields(fields graphql.Fields, properties map[string]spec.Schema) {
 	for fieldName := range properties {
 		if !strings.HasSuffix(fieldName, "Ref") {
 			continue
@@ -38,7 +26,7 @@ func (re *RelationEnhancer) AddRelationFields(fields graphql.Fields, properties
 			continue
 		}
 
-		enhancedType := re.enhanceRefTypeWithRelation(refField.Type, baseName)
+		enhancedType := g.enhanceRefTypeWithRelation(refField.Type, baseName)
 		if enhancedType == nil {
 			continue
 		}
@@ -50,31 +38,31 @@ func (re *RelationEnhancer) AddRelationFields(fields graphql.Fields, properties
 }
 
 // enhanceRefTypeWithRelation adds a relation field to a *Ref object type
-func (re *RelationEnhancer) enhanceRefTypeWithRelation(originalType graphql.Output, baseName string) graphql.Output {
+func (g *Gateway) enhanceRefTypeWithRelation(originalType graphql.Output, baseName string) graphql.Output {
 	objType, ok := originalType.(*graphql.Object)
 	if !ok {
 		return originalType
 	}
 
 	cacheKey := objType.Name() + "_" + baseName + "_Enhanced"
-	if enhancedType, exists := re.gateway.enhancedTypesCache[cacheKey]; exists {
+	if enhancedType, exists := g.enhancedTypesCache[cacheKey]; exists {
 		return enhancedType
 	}
 
-	enhancedFields := re.copyOriginalFields(objType.Fields())
-	re.addRelationField(enhancedFields, baseName)
+	enhancedFields := g.copyOriginalFields(objType.Fields())
+	g.addRelationField(enhancedFields, baseName)
 
 	enhancedType := graphql.NewObject(graphql.ObjectConfig{
 		Name:   sanitizeFieldName(cacheKey),
 		Fields: enhancedFields,
 	})
 
-	re.gateway.enhancedTypesCache[cacheKey] = enhancedType
+	g.enhancedTypesCache[cacheKey] = enhancedType
 	return enhancedType
 }
 
 // copyOriginalFields converts FieldDefinition to Field for reuse
-func (re *RelationEnhancer) copyOriginalFields(originalFieldDefs graphql.FieldDefinitionMap) graphql.Fields {
+func (g *Gateway) copyOriginalFields(originalFieldDefs graphql.FieldDefinitionMap) graphql.Fields {
 	enhancedFields := make(graphql.Fields, len(originalFieldDefs))
 	for fieldName, fieldDef := range originalFieldDefs {
 		enhancedFields[fieldName] = &graphql.Field{
@@ -87,39 +75,39 @@ func (re *RelationEnhancer) copyOriginalFields(originalFieldDefs graphql.FieldDe
 }
 
 // addRelationField adds a single relation field to the enhanced fields
-func (re *RelationEnhancer) addRelationField(enhancedFields graphql.Fields, baseName string) {
-	targetType, targetGVK, ok := re.findRelationTarget(baseName)
+func (g *Gateway) addRelationField(enhancedFields graphql.Fields, baseName string) {
+	targetType, targetGVK, ok := g.findRelationTarget(baseName)
 	if !ok {
 		return
 	}
 
 	sanitizedBaseName := sanitizeFieldName(baseName)
 	enhancedFields[sanitizedBaseName] = &graphql.Field{
 		Type:    targetType,
-		Resolve: re.gateway.resolver.RelationResolver(baseName, *targetGVK),
+		Resolve: g.resolver.RelationResolver(baseName, *targetGVK),
 	}
 }
 
 // findRelationTarget locates the GraphQL output type and its GVK for a relation target
-func (re *RelationEnhancer) findRelationTarget(baseName string) (graphql.Output, *schema.GroupVersionKind, bool) {
+func (g *Gateway) findRelationTarget(baseName string) (graphql.Output, *schema.GroupVersionKind, bool) {
 	targetKind := cases.Title(language.English).String(baseName)
 
-	for defKey, defSchema := range re.gateway.definitions {
-		if re.matchesTargetKind(defSchema, targetKind) {
+	for defKey, defSchema := range g.definitions {
+		if g.matchesTargetKind(defSchema, targetKind) {
 			// Resolve or build the GraphQL type
 			var fieldType graphql.Output
-			if existingType, exists := re.gateway.typesCache[defKey]; exists {
+			if existingType, exists := g.typesCache[defKey]; exists {
 				fieldType = existingType
 			} else {
-				ft, _, err := re.gateway.convertSwaggerTypeToGraphQL(defSchema, defKey, []string{}, make(map[string]bool))
+				ft, _, err := g.convertSwaggerTypeToGraphQL(defSchema, defKey, []string{}, make(map[string]bool))
 				if err != nil {
 					continue
 				}
 				fieldType = ft
 			}
 
 			// Extract GVK from the schema definition
-			gvk, err := re.gateway.getGroupVersionKind(defKey)
+			gvk, err := g.getGroupVersionKind(defKey)
 			if err != nil || gvk == nil {
 				continue
 			}
@@ -132,7 +120,7 @@ func (re *RelationEnhancer) findRelationTarget(baseName string) (graphql.Output,
 }
 
 // matchesTargetKind checks if a schema definition matches the target kind
-func (re *RelationEnhancer) matchesTargetKind(defSchema spec.Schema, targetKind string) bool {
+func (g *Gateway) matchesTargetKind(defSchema spec.Schema, targetKind string) bool {
 	gvkExt, ok := defSchema.Extensions["x-kubernetes-group-version-kind"]
 	if !ok {
 		return false

gateway/schema/schema.go

@@ -29,7 +29,6 @@ type Gateway struct {
 	typesCache         map[string]*graphql.Object
 	inputTypesCache    map[string]*graphql.InputObject
 	enhancedTypesCache map[string]*graphql.Object // Cache for enhanced *Ref types
-	relationEnhancer   *RelationEnhancer
 	// Prevents naming conflict in case of the same Kind name in different groups/versions
 	typeNameRegistry map[string]string // map[Kind]GroupVersion
 
@@ -49,9 +48,6 @@ func New(log *logger.Logger, definitions spec.Definitions, resolverProvider reso
 		typeByCategory:     make(map[string][]resolver.TypeByCategory),
 	}
 
-	// Initialize the relation enhancer after gateway is created
-	g.relationEnhancer = NewRelationEnhancer(g)
-
 	err := g.generateGraphqlSchema()
 
 	return g, err
@@ -339,7 +335,7 @@ func (g *Gateway) generateGraphQLFields(resourceScheme *spec.Schema, typePrefix
 	}
 
 	// Add relation fields for any *Ref fields in this schema
-	g.relationEnhancer.AddRelationFields(fields, resourceScheme.Properties)
+	g.addRelationFields(fields, resourceScheme.Properties)
 
 	return fields, inputFields, nil
 }