removed hardcoded versions

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

Author: vertex451

gateway/resolver/relations.go

@@ -24,7 +24,7 @@ func NewRelationResolver(service *Service) *RelationResolver {
 }
 
 // CreateResolver creates a GraphQL resolver for relation fields
-func (rr *RelationResolver) CreateResolver(fieldName string) graphql.FieldResolveFn {
+func (rr *RelationResolver) CreateResolver(fieldName string, targetGVK schema.GroupVersionKind) graphql.FieldResolveFn {
 	return func(p graphql.ResolveParams) (interface{}, error) {
 		parentObj, ok := p.Source.(map[string]interface{})
 		if !ok {
@@ -36,7 +36,7 @@ func (rr *RelationResolver) CreateResolver(fieldName string) graphql.FieldResolv
 			return nil, nil
 		}
 
-		return rr.resolveReference(p.Context, refInfo.name, refInfo.namespace, refInfo.kind, refInfo.apiGroup)
+		return rr.resolveReference(p.Context, refInfo, targetGVK)
 	}
 }
 
@@ -72,49 +72,32 @@ func (rr *RelationResolver) extractReferenceInfo(parentObj map[string]interface{
 	}
 }
 
-// resolveReference fetches a referenced Kubernetes resource
-func (rr *RelationResolver) resolveReference(ctx context.Context, name, namespace, kind, apiGroup string) (interface{}, error) {
-	versions := []string{"v1", "v1beta1", "v1alpha1"}
+// resolveReference fetches a referenced Kubernetes resource using provided target GVK
+func (rr *RelationResolver) resolveReference(ctx context.Context, ref referenceInfo, targetGVK schema.GroupVersionKind) (interface{}, error) {
+	gvk := targetGVK
 
-	for _, version := range versions {
-		if obj := rr.tryFetchResource(ctx, name, namespace, kind, apiGroup, version); obj != nil {
-			return obj, nil
-		}
+	// Allow overrides from the reference object if specified
+	if ref.apiGroup != "" {
+		gvk.Group = ref.apiGroup
 	}
-
-	return nil, nil
-}
-
-// tryFetchResource attempts to fetch a Kubernetes resource with the given parameters
-func (rr *RelationResolver) tryFetchResource(ctx context.Context, name, namespace, kind, apiGroup, version string) map[string]interface{} {
-	gvk := schema.GroupVersionKind{
-		Group:   apiGroup,
-		Version: version,
-		Kind:    kind,
+	if ref.kind != "" {
+		gvk.Kind = ref.kind
 	}
 
+	// Convert sanitized group to original before calling the client
+	gvk.Group = rr.service.getOriginalGroupName(gvk.Group)
+
 	obj := &unstructured.Unstructured{}
 	obj.SetGroupVersionKind(gvk)
 
-	key := client.ObjectKey{Name: name}
-	if namespace != "" {
-		key.Namespace = namespace
+	key := client.ObjectKey{Name: ref.name}
+	if ref.namespace != "" {
+		key.Namespace = ref.namespace
 	}
 
 	if err := rr.service.runtimeClient.Get(ctx, key, obj); err == nil {
-		return obj.Object
+		return obj.Object, nil
 	}
 
-	return nil
-}
-
-// GetSupportedVersions returns the list of API versions to try for resource resolution
-func (rr *RelationResolver) GetSupportedVersions() []string {
-	return []string{"v1", "v1beta1", "v1alpha1"}
-}
-
-// SetSupportedVersions allows customizing the API versions to try (for future extensibility)
-func (rr *RelationResolver) SetSupportedVersions(versions []string) {
-	// Future: Store in resolver state for customization
-	// For now, this is a placeholder for extensibility
+	return nil, nil
 }

gateway/resolver/resolver.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 
 	"github.com/graphql-go/graphql"
-	pkgErrors "github.com/pkg/errors"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/trace"
@@ -31,7 +30,7 @@ type Provider interface {
 	CommonResolver() graphql.FieldResolveFn
 	SanitizeGroupName(string) string
 	RuntimeClient() client.WithWatch
-	RelationResolver(fieldName string) graphql.FieldResolveFn
+	RelationResolver(fieldName string, gvk schema.GroupVersionKind) graphql.FieldResolveFn
 }
 
 type CrudProvider interface {
@@ -90,21 +89,11 @@ func (r *Service) ListItems(gvk schema.GroupVersionKind, scope v1.ResourceScope)
 			log = r.log
 		}
 
-		// Create an unstructured list to hold the results
+		// Create a list of unstructured objects to hold the results
 		list := &unstructured.UnstructuredList{}
-		list.SetGroupVersionKind(gvk)
+		list.SetGroupVersionKind(schema.GroupVersionKind{Group: gvk.Group, Version: gvk.Version, Kind: gvk.Kind + "List"})
 
 		var opts []client.ListOption
-		// Handle label selector argument
-		if labelSelector, ok := p.Args[LabelSelectorArg].(string); ok && labelSelector != "" {
-			selector, err := labels.Parse(labelSelector)
-			if err != nil {
-				log.Error().Err(err).Str(LabelSelectorArg, labelSelector).Msg("Unable to parse given label selector")
-				return nil, err
-			}
-			opts = append(opts, client.MatchingLabelsSelector{Selector: selector})
-		}
-
 		if isResourceNamespaceScoped(scope) {
 			namespace, err := getStringArg(p.Args, NamespaceArg, false)
 			if err != nil {
@@ -115,25 +104,34 @@ func (r *Service) ListItems(gvk schema.GroupVersionKind, scope v1.ResourceScope)
 			}
 		}
 
-		if err = r.runtimeClient.List(ctx, list, opts...); err != nil {
-			log.Error().Err(err).Msg("Unable to list objects")
-			return nil, pkgErrors.Wrap(err, "unable to list objects")
+		if val, ok := p.Args[LabelSelectorArg].(string); ok && val != "" {
+			selector, err := labels.Parse(val)
+			if err != nil {
+				log.Error().Err(err).Str(LabelSelectorArg, val).Msg("Unable to parse given label selector")
+				return nil, err
+			}
+			opts = append(opts, client.MatchingLabelsSelector{Selector: selector})
 		}
 
-		sortBy, err := getStringArg(p.Args, SortByArg, false)
-		if err != nil {
+		if err = r.runtimeClient.List(ctx, list, opts...); err != nil {
+			log.Error().Err(err).Str("scope", string(scope)).Msg("Unable to list objects")
 			return nil, err
 		}
 
-		err = validateSortBy(list.Items, sortBy)
+		sortBy, err := getStringArg(p.Args, SortByArg, false)
 		if err != nil {
-			log.Error().Err(err).Str(SortByArg, sortBy).Msg("Invalid sortBy field path")
 			return nil, err
 		}
 
-		sort.Slice(list.Items, func(i, j int) bool {
-			return compareUnstructured(list.Items[i], list.Items[j], sortBy) < 0
-		})
+		if sortBy != "" {
+			if err := validateSortBy(list.Items, sortBy); err != nil {
+				log.Error().Err(err).Str(SortByArg, sortBy).Msg("Invalid sortBy field path")
+				return nil, err
+			}
+			sort.Slice(list.Items, func(i, j int) bool {
+				return compareUnstructured(list.Items[i], list.Items[j], sortBy) < 0
+			})
+		}
 
 		items := make([]map[string]any, len(list.Items))
 		for i, item := range list.Items {
@@ -471,6 +469,6 @@ func (r *Service) RuntimeClient() client.WithWatch {
 }
 
 // RelationResolver creates a GraphQL resolver for relation fields
-func (r *Service) RelationResolver(fieldName string) graphql.FieldResolveFn {
-	return r.relationResolver.CreateResolver(fieldName)
+func (r *Service) RelationResolver(fieldName string, gvk schema.GroupVersionKind) graphql.FieldResolveFn {
+	return r.relationResolver.CreateResolver(fieldName, gvk)
 }

gateway/schema/relations.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/go-openapi/spec"
 	"github.com/graphql-go/graphql"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
 // RelationEnhancer handles schema enhancement for relation fields
@@ -87,35 +88,47 @@ 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 := re.findRelationTargetType(baseName)
-	if targetType == nil {
+	targetType, targetGVK, ok := re.findRelationTarget(baseName)
+	if !ok {
 		return
 	}
 
 	sanitizedBaseName := sanitizeFieldName(baseName)
 	enhancedFields[sanitizedBaseName] = &graphql.Field{
 		Type:    targetType,
-		Resolve: re.gateway.resolver.RelationResolver(baseName),
+		Resolve: re.gateway.resolver.RelationResolver(baseName, *targetGVK),
 	}
 }
 
-// findRelationTargetType finds the GraphQL type for a relation target
-func (re *RelationEnhancer) findRelationTargetType(baseName string) graphql.Output {
+// findRelationTarget locates the GraphQL output type and its GVK for a relation target
+func (re *RelationEnhancer) 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) {
+			// Resolve or build the GraphQL type
+			var fieldType graphql.Output
 			if existingType, exists := re.gateway.typesCache[defKey]; exists {
-				return existingType
+				fieldType = existingType
+			} else {
+				ft, _, err := re.gateway.convertSwaggerTypeToGraphQL(defSchema, defKey, []string{}, make(map[string]bool))
+				if err != nil {
+					continue
+				}
+				fieldType = ft
 			}
 
-			if fieldType, _, err := re.gateway.convertSwaggerTypeToGraphQL(defSchema, defKey, []string{}, make(map[string]bool)); err == nil {
-				return fieldType
+			// Extract GVK from the schema definition
+			gvk, err := re.gateway.getGroupVersionKind(defKey)
+			if err != nil || gvk == nil {
+				continue
 			}
+
+			return fieldType, gvk, true
 		}
 	}
 
-	return graphql.String
+	return nil, nil, false
 }
 
 // matchesTargetKind checks if a schema definition matches the target kind