cleanup

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

Author: vertex451

gateway/resolver/relationships.go

@@ -1,7 +1,6 @@
 package resolver
 
 import (
-	"context"
 	"fmt"
 	"strings"
 
@@ -11,24 +10,14 @@ import (
 	"go.opentelemetry.io/otel/trace"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/openmfp/golang-commons/logger"
 )
 
 // RelationshipResolver handles resolution of relationships between Kubernetes resources
 type RelationshipResolver struct {
-	log           *logger.Logger
-	runtimeClient client.WithWatch
-	groupNames    map[string]string
-}
-
-// RelationshipRef represents a reference to another Kubernetes resource
-type RelationshipRef struct {
-	Kind         string `json:"kind,omitempty"`
-	GroupVersion string `json:"groupVersion,omitempty"`
-	Name         string `json:"name"`
-	Namespace    string `json:"namespace,omitempty"`
+	log        *logger.Logger
+	groupNames map[string]string
 }
 
 // EnhancedRef represents our custom relationship reference structure
@@ -40,11 +29,10 @@ type EnhancedRef struct {
 }
 
 // NewRelationshipResolver creates a new relationship resolver
-func NewRelationshipResolver(log *logger.Logger, runtimeClient client.WithWatch, groupNames map[string]string) *RelationshipResolver {
+func NewRelationshipResolver(log *logger.Logger, groupNames map[string]string) *RelationshipResolver {
 	return &RelationshipResolver{
-		log:           log,
-		runtimeClient: runtimeClient,
-		groupNames:    groupNames,
+		log:        log,
+		groupNames: groupNames,
 	}
 }
 
@@ -69,110 +57,6 @@ func ExtractTargetKind(fieldName string) string {
 	return strings.ToUpper(kindName[:1]) + kindName[1:]
 }
 
-// CreateRelationshipResolver creates a GraphQL field resolver for relationship fields
-func (r *RelationshipResolver) CreateRelationshipResolver(sourceGVK schema.GroupVersionKind, fieldName string, targetKind string) graphql.FieldResolveFn {
-	return func(p graphql.ResolveParams) (interface{}, error) {
-		ctx, span := otel.Tracer("").Start(p.Context, "ResolveRelationship",
-			trace.WithAttributes(
-				attribute.String("sourceKind", sourceGVK.Kind),
-				attribute.String("fieldName", fieldName),
-				attribute.String("targetKind", targetKind),
-			))
-		defer span.End()
-
-		// Get the source object from the parent resolver
-		sourceObj, ok := p.Source.(map[string]interface{})
-		if !ok {
-			return nil, fmt.Errorf("expected source to be map[string]interface{}, got %T", p.Source)
-		}
-
-		// Extract the relationship reference from the source object
-		refValue, found, err := unstructured.NestedFieldNoCopy(sourceObj, fieldName)
-		if err != nil {
-			return nil, fmt.Errorf("error accessing field %s: %v", fieldName, err)
-		}
-		if !found {
-			return nil, nil // Field not present
-		}
-
-		refMap, ok := refValue.(map[string]interface{})
-		if !ok {
-			return nil, fmt.Errorf("expected %s to be map[string]interface{}, got %T", fieldName, refValue)
-		}
-
-		// Parse the relationship reference
-		ref, err := r.parseRelationshipRef(refMap, sourceObj, sourceGVK, fieldName)
-		if err != nil {
-			return nil, fmt.Errorf("error parsing relationship ref: %v", err)
-		}
-
-		// If no kind specified in ref, use the target kind from field name
-		if ref.Kind == "" {
-			ref.Kind = targetKind
-		}
-
-		// Resolve the target GVK
-		targetGVK, err := r.resolveTargetGVK(ref, sourceGVK)
-		if err != nil {
-			return nil, fmt.Errorf("error resolving target GVK: %v", err)
-		}
-
-		// Fetch the referenced resource
-		return r.fetchReferencedResource(ctx, ref, targetGVK, sourceObj, sourceGVK)
-	}
-}
-
-// CreateRelationsResolver creates a GraphQL field resolver for the relations field
-func (r *RelationshipResolver) CreateRelationsResolver(sourceGVK schema.GroupVersionKind, relationshipFields []string) graphql.FieldResolveFn {
-	return func(p graphql.ResolveParams) (interface{}, error) {
-		_, span := otel.Tracer("").Start(p.Context, "ResolveRelations",
-			trace.WithAttributes(
-				attribute.String("sourceKind", sourceGVK.Kind),
-				attribute.Int("relationshipCount", len(relationshipFields)),
-			))
-		defer span.End()
-
-		// Get the source object from the parent resolver
-		sourceObj, ok := p.Source.(map[string]interface{})
-		if !ok {
-			return nil, fmt.Errorf("expected source to be map[string]interface{}, got %T", p.Source)
-		}
-
-		relations := make(map[string]interface{})
-
-		for _, fieldName := range relationshipFields {
-			// Extract the relationship reference from the source object
-			refValue, found, err := unstructured.NestedFieldNoCopy(sourceObj, fieldName)
-			if err != nil {
-				r.log.Debug().Err(err).Str("field", fieldName).Msg("Error accessing relationship field")
-				continue
-			}
-			if !found {
-				continue // Field not present, skip
-			}
-
-			refMap, ok := refValue.(map[string]interface{})
-			if !ok {
-				r.log.Debug().Str("field", fieldName).Msg("Relationship field is not a map")
-				continue
-			}
-
-			// Create enhanced reference
-			enhancedRef, err := r.createEnhancedRef(refMap, sourceObj, sourceGVK, fieldName)
-			if err != nil {
-				r.log.Debug().Err(err).Str("field", fieldName).Msg("Error creating enhanced reference")
-				continue
-			}
-
-			// Add to relations without "Ref" suffix
-			relationName := strings.TrimSuffix(fieldName, "Ref")
-			relations[relationName] = enhancedRef
-		}
-
-		return relations, nil
-	}
-}
-
 // CreateSingleRelationResolver creates a GraphQL field resolver for a single relation field
 func (r *RelationshipResolver) CreateSingleRelationResolver(sourceGVK schema.GroupVersionKind, fieldName string) graphql.FieldResolveFn {
 	return func(p graphql.ResolveParams) (interface{}, error) {
@@ -216,48 +100,6 @@ func (r *RelationshipResolver) CreateSingleRelationResolver(sourceGVK schema.Gro
 	}
 }
 
-// parseRelationshipRef parses a relationship reference from a map
-func (r *RelationshipResolver) parseRelationshipRef(refMap map[string]interface{}, sourceObj map[string]interface{}, sourceGVK schema.GroupVersionKind, fieldName string) (*RelationshipRef, error) {
-	ref := &RelationshipRef{}
-
-	if kind, ok := refMap["kind"].(string); ok {
-		ref.Kind = kind
-	}
-
-	if groupVersion, ok := refMap["groupVersion"].(string); ok {
-		ref.GroupVersion = groupVersion
-	}
-
-	// Handle native Kubernetes apiGroup field (used in roleRef, clusterRoleRef, etc.)
-	if apiGroup, ok := refMap["apiGroup"].(string); ok {
-		// For RBAC resources, apiGroup + kind determines the groupVersion
-		if apiGroup == "rbac.authorization.k8s.io" {
-			ref.GroupVersion = "rbac.authorization.k8s.io/v1"
-		} else if apiGroup == "" {
-			// Empty apiGroup means core/v1
-			ref.GroupVersion = "v1"
-		} else {
-			// Default to v1 for other groups
-			ref.GroupVersion = apiGroup + "/v1"
-		}
-	}
-
-	name, ok := refMap["name"].(string)
-	if !ok {
-		return nil, fmt.Errorf("name is required in relationship reference")
-	}
-	ref.Name = name
-
-	if namespace, ok := refMap["namespace"].(string); ok {
-		ref.Namespace = namespace
-	} else {
-		// For native Kubernetes references like roleRef, infer namespace from source
-		ref.Namespace = r.inferNamespaceForReference(sourceObj, sourceGVK, fieldName, ref.Kind)
-	}
-
-	return ref, nil
-}
-
 // createEnhancedRef transforms a native Kubernetes reference to our enhanced structure
 func (r *RelationshipResolver) createEnhancedRef(nativeRefMap map[string]interface{}, sourceObj map[string]interface{}, sourceGVK schema.GroupVersionKind, fieldName string) (map[string]interface{}, error) {
 	enhancedRef := make(map[string]interface{})
@@ -345,72 +187,4 @@ func (r *RelationshipResolver) inferNamespaceForReference(sourceObj map[string]i
 	return ""
 }
 
-// resolveTargetGVK resolves the target GroupVersionKind from the relationship reference
-func (r *RelationshipResolver) resolveTargetGVK(ref *RelationshipRef, sourceGVK schema.GroupVersionKind) (schema.GroupVersionKind, error) {
-	targetGVK := schema.GroupVersionKind{
-		Kind: ref.Kind,
-	}
-
-	if ref.GroupVersion != "" {
-		// Parse group and version from groupVersion
-		parts := strings.Split(ref.GroupVersion, "/")
-		if len(parts) == 2 {
-			targetGVK.Group = parts[0]
-			targetGVK.Version = parts[1]
-		} else if len(parts) == 1 {
-			// Could be just version (for core resources) or just group
-			if ref.GroupVersion == "v1" || strings.HasPrefix(ref.GroupVersion, "v") {
-				targetGVK.Group = ""
-				targetGVK.Version = ref.GroupVersion
-			} else {
-				targetGVK.Group = ref.GroupVersion
-				targetGVK.Version = "v1" // Default version
-			}
-		} else {
-			return targetGVK, fmt.Errorf("invalid groupVersion format: %s", ref.GroupVersion)
-		}
-	} else {
-		// If no groupVersion specified, inherit from source or use defaults
-		targetGVK.Group = sourceGVK.Group
-		targetGVK.Version = sourceGVK.Version
-	}
-
-	return targetGVK, nil
-}
-
-// fetchReferencedResource fetches the referenced Kubernetes resource
-func (r *RelationshipResolver) fetchReferencedResource(ctx context.Context, ref *RelationshipRef, targetGVK schema.GroupVersionKind, sourceObj map[string]interface{}, sourceGVK schema.GroupVersionKind) (interface{}, error) {
-	// Create an unstructured object to hold the result
-	obj := &unstructured.Unstructured{}
-	obj.SetGroupVersionKind(targetGVK)
-
-	key := client.ObjectKey{
-		Name: ref.Name,
-	}
-
-	// Set namespace if specified and target is namespaced
-	if ref.Namespace != "" {
-		key.Namespace = ref.Namespace
-	}
-
-	r.log.Debug().
-		Str("refName", ref.Name).
-		Str("refNamespace", ref.Namespace).
-		Str("targetGVK", targetGVK.String()).
-		Str("sourceKind", sourceGVK.Kind).
-		Msg("Fetching referenced resource")
-
-	// Get the object using the runtime client
-	if err := r.runtimeClient.Get(ctx, key, obj); err != nil {
-		r.log.Error().Err(err).
-			Str("name", ref.Name).
-			Str("namespace", ref.Namespace).
-			Str("gvk", targetGVK.String()).
-			Msg("Unable to get referenced object")
-		return nil, err
-	}
-
-	return obj.Object, nil
-}
-
 // getOriginalGroupName converts sanitized group name back to original

gateway/resolver/resolver.go

@@ -64,7 +64,7 @@ func New(log *logger.Logger, runtimeClient client.WithWatch) *Service {
 	}
 
 	// Initialize relationship resolver
-	service.relationshipResolver = NewRelationshipResolver(log, runtimeClient, service.groupNames)
+	service.relationshipResolver = NewRelationshipResolver(log, service.groupNames)
 
 	return service
 }

gateway/schema/schema.go

@@ -80,7 +80,6 @@ func (g *Gateway) generateGraphqlSchema() error {
 	g.AddTypeByCategoryQuery(rootQueryFields)
 
 	// Add relations fields to existing types that have relationship fields
-	g.addRelationsToExistingTypes()
 
 	newSchema, err := graphql.NewSchema(graphql.SchemaConfig{
 		Query: graphql.NewObject(graphql.ObjectConfig{
@@ -727,56 +726,6 @@ func (g *Gateway) createEnhancedRefType(targetKind string) graphql.Output {
 	return refType
 }
 
-// addRelationsToExistingTypes adds relations fields to existing types that have relationship fields
-func (g *Gateway) addRelationsToExistingTypes() {
-	// List of types that should have relations fields added
-	typesToEnhance := []string{"RoleBinding", "ClusterRoleBinding"}
-
-	for _, typeName := range typesToEnhance {
-		if existingType, exists := g.typesCache[typeName]; exists && existingType != nil {
-			g.log.Info().
-				Str("typeName", typeName).
-				Msg("Checking existing type for relationship fields")
-
-			// Check if this type has relationship fields by examining its existing fields
-			relationshipFields := g.findRelationshipFieldsInType(existingType)
-
-			if len(relationshipFields) > 0 {
-				g.log.Info().
-					Str("typeName", typeName).
-					Strs("relationshipFields", relationshipFields).
-					Msg("Found relationship fields, but cannot modify existing GraphQL object")
-
-				// Note: GraphQL objects are immutable after creation
-				// We need to recreate the type with the relations field
-				// This is a limitation we need to address differently
-			} else {
-				g.log.Info().
-					Str("typeName", typeName).
-					Msg("No relationship fields found in existing type")
-			}
-		} else {
-			g.log.Info().
-				Str("typeName", typeName).
-				Msg("Type not found in cache")
-		}
-	}
-}
-
-// findRelationshipFieldsInType finds relationship fields in an existing GraphQL type
-func (g *Gateway) findRelationshipFieldsInType(objType *graphql.Object) []string {
-	var relationshipFields []string
-
-	fields := objType.Fields()
-	for fieldName := range fields {
-		if resolver.IsRelationshipField(fieldName) {
-			relationshipFields = append(relationshipFields, fieldName)
-		}
-	}
-
-	return relationshipFields
-}
-
 // getGVKForTypeName gets the GroupVersionKind for a type name
 func (g *Gateway) getGVKForTypeName(typeName string) *schema.GroupVersionKind {
 	switch typeName {