feat: relations

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

Author: vertex451

gateway/manager/targetcluster/cluster.go

@@ -17,6 +17,9 @@ import (
 	appConfig "github.com/openmfp/kubernetes-graphql-gateway/common/config"
 	"github.com/openmfp/kubernetes-graphql-gateway/gateway/resolver"
 	"github.com/openmfp/kubernetes-graphql-gateway/gateway/schema"
+
+	// for REST mapper
+	apiutil "sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 )
 
 // FileData represents the data extracted from a schema file
@@ -172,8 +175,18 @@ func (tc *TargetCluster) createHandler(definitions map[string]interface{}, appCf
 		return fmt.Errorf("failed to convert definitions: %w", err)
 	}
 
+	// Build RESTMapper for this cluster (used by relation resolver)
+	httpClient, err := rest.HTTPClientFor(tc.restCfg)
+	if err != nil {
+		return fmt.Errorf("failed to create HTTP client: %w", err)
+	}
+	restMapper, err := apiutil.NewDynamicRESTMapper(tc.restCfg, httpClient)
+	if err != nil {
+		return fmt.Errorf("failed to create REST mapper: %w", err)
+	}
+
 	// Create resolver
-	resolverProvider := resolver.New(tc.log, tc.client)
+	resolverProvider := resolver.New(tc.log, tc.client, restMapper)
 
 	// Create schema gateway
 	schemaGateway, err := schema.New(tc.log, specDefs, resolverProvider)

gateway/resolver/relations.go

@@ -0,0 +1,127 @@
+package resolver
+
+import (
+	"context"
+
+	"github.com/graphql-go/graphql"
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	meta "k8s.io/apimachinery/pkg/api/meta"
+)
+
+// RelationResolver handles runtime resolution of relation fields
+type RelationResolver struct {
+	service *Service
+}
+
+// NewRelationResolver creates a new relation resolver
+func NewRelationResolver(service *Service) *RelationResolver {
+	return &RelationResolver{
+		service: service,
+	}
+}
+
+// CreateResolver creates a GraphQL resolver for relation fields
+func (rr *RelationResolver) CreateResolver(fieldName string) graphql.FieldResolveFn {
+	return func(p graphql.ResolveParams) (interface{}, error) {
+		parentObj, ok := p.Source.(map[string]any)
+		if !ok {
+			return nil, nil
+		}
+
+		refInfo := rr.extractReferenceInfo(parentObj, fieldName)
+		if refInfo.name == "" {
+			return nil, nil
+		}
+
+		return rr.resolveReference(p.Context, refInfo.name, refInfo.namespace, refInfo.kind, refInfo.apiGroup)
+	}
+}
+
+// referenceInfo holds extracted reference details
+type referenceInfo struct {
+	name      string
+	namespace string
+	kind      string
+	apiGroup  string
+}
+
+// extractReferenceInfo extracts reference details from a *Ref object
+func (rr *RelationResolver) extractReferenceInfo(parentObj map[string]any, fieldName string) referenceInfo {
+	name, _ := parentObj["name"].(string)
+	if name == "" {
+		return referenceInfo{}
+	}
+
+	namespace, _ := parentObj["namespace"].(string)
+	apiGroup, _ := parentObj["apiGroup"].(string)
+
+	kind, _ := parentObj["kind"].(string)
+	if kind == "" {
+		// Fallback: infer kind from field name (e.g., "role" -> "Role")
+		kind = cases.Title(language.English).String(fieldName)
+	}
+
+	return referenceInfo{
+		name:      name,
+		namespace: namespace,
+		kind:      kind,
+		apiGroup:  apiGroup,
+	}
+}
+
+// resolveReference fetches a referenced Kubernetes resource
+func (rr *RelationResolver) resolveReference(ctx context.Context, name, namespace, kind, apiGroup string) (interface{}, error) {
+	// Try RESTMapper preferred mapping first
+	if rr.service != nil && rr.service.restMapper != nil {
+		gk := schema.GroupKind{Group: apiGroup, Kind: kind}
+		mapping, err := rr.service.restMapper.RESTMapping(gk)
+		if err != nil {
+			if !meta.IsNoMatchError(err) {
+				return nil, err
+			}
+		} else {
+			obj := &unstructured.Unstructured{}
+			obj.SetGroupVersionKind(mapping.GroupVersionKind)
+
+			key := client.ObjectKey{Name: name}
+			if namespace != "" {
+				key.Namespace = namespace
+			}
+
+			err = rr.service.runtimeClient.Get(ctx, key, obj)
+			if err == nil {
+				return obj.Object, nil
+			}
+			if !apierrors.IsNotFound(err) {
+				return nil, err
+			}
+			// NotFound: continue to fallback
+		}
+	}
+
+	// Fallback to common Kubernetes version ordering
+	for _, version := range []string{"v1", "v1beta1", "v1alpha1"} {
+		gvk := schema.GroupVersionKind{Group: apiGroup, Version: version, Kind: kind}
+		obj := &unstructured.Unstructured{}
+		obj.SetGroupVersionKind(gvk)
+
+		key := client.ObjectKey{Name: name}
+		if namespace != "" {
+			key.Namespace = namespace
+		}
+
+		if err := rr.service.runtimeClient.Get(ctx, key, obj); err == nil {
+			return obj.Object, nil
+		} else if !apierrors.IsNotFound(err) {
+			return nil, err
+		}
+	}
+
+	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"
@@ -23,13 +22,18 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/openmfp/golang-commons/logger"
+
+	// add api/meta for RESTMapper
+	meta "k8s.io/apimachinery/pkg/api/meta"
 )
 
 type Provider interface {
 	CrudProvider
 	CustomQueriesProvider
 	CommonResolver() graphql.FieldResolveFn
 	SanitizeGroupName(string) string
+	RuntimeClient() client.WithWatch
+	RelationResolver(fieldName string) graphql.FieldResolveFn
 }
 
 type CrudProvider interface {
@@ -50,16 +54,32 @@ type CustomQueriesProvider interface {
 type Service struct {
 	log *logger.Logger
 	// groupNames stores relation between sanitized group names and original group names that are used in the Kubernetes API
-	groupNames    map[string]string // map[sanitizedGroupName]originalGroupName
-	runtimeClient client.WithWatch
+	groupNames       map[string]string // map[sanitizedGroupName]originalGroupName
+	runtimeClient    client.WithWatch
+	restMapper       meta.RESTMapper
+	relationResolver *RelationResolver
 }
 
-func New(log *logger.Logger, runtimeClient client.WithWatch) *Service {
-	return &Service{
+func New(log *logger.Logger, runtimeClient client.WithWatch, restMapper meta.RESTMapper) *Service {
+	s := &Service{
 		log:           log,
 		groupNames:    make(map[string]string),
 		runtimeClient: runtimeClient,
+		restMapper:    restMapper,
+	}
+
+	// Initialize the relation resolver
+	s.relationResolver = NewRelationResolver(s)
+
+	return s
+}
+
+// RelationResolver returns a resolver function for relation fields
+func (r *Service) RelationResolver(fieldName string) graphql.FieldResolveFn {
+	if r.relationResolver == nil {
+		r.relationResolver = NewRelationResolver(r)
 	}
+	return r.relationResolver.CreateResolver(fieldName)
 }
 
 // ListItems returns a GraphQL CommonResolver function that lists Kubernetes resources of the given GroupVersionKind.
@@ -82,7 +102,6 @@ func (r *Service) ListItems(gvk schema.GroupVersionKind, scope v1.ResourceScope)
 			log = r.log
 		}
 
-		// Create an unstructured list to hold the results
 		list := &unstructured.UnstructuredList{}
 		list.SetGroupVersionKind(gvk)
 
@@ -109,7 +128,7 @@ 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")
+			return nil, fmt.Errorf("unable to list objects: %w", err)
 		}
 
 		sortBy, err := getStringArg(p.Args, SortByArg, false)
@@ -385,6 +404,11 @@ func (r *Service) SanitizeGroupName(groupName string) string {
 	return groupName
 }
 
+// RuntimeClient returns the underlying controller-runtime client with watch support
+func (r *Service) RuntimeClient() client.WithWatch {
+	return r.runtimeClient
+}
+
 func (r *Service) storeOriginalGroupName(groupName, originalName string) {
 	r.groupNames[groupName] = originalName
 }

gateway/resolver/resolver_test.go

@@ -79,7 +79,7 @@ func TestListItems(t *testing.T) {
 				tt.mockSetup(runtimeClientMock)
 			}
 
-			r := resolver.New(testlogger.New().Logger, runtimeClientMock)
+			r := resolver.New(testlogger.New().Logger, runtimeClientMock, nil)
 			result, err := r.ListItems(schema.GroupVersionKind{
 				Group:   "group",
 				Version: "version",
@@ -168,7 +168,7 @@ func TestGetItem(t *testing.T) {
 				tt.mockSetup(runtimeClientMock)
 			}
 
-			r := resolver.New(testlogger.New().Logger, runtimeClientMock)
+			r := resolver.New(testlogger.New().Logger, runtimeClientMock, nil)
 
 			result, err := r.GetItem(schema.GroupVersionKind{
 				Group:   "group",
@@ -238,7 +238,7 @@ func TestGetItemAsYAML(t *testing.T) {
 				tt.mockSetup(runtimeClientMock)
 			}
 
-			r := resolver.New(testlogger.New().Logger, runtimeClientMock)
+			r := resolver.New(testlogger.New().Logger, runtimeClientMock, nil)
 
 			result, err := r.GetItemAsYAML(schema.GroupVersionKind{
 				Group:   "group",
@@ -371,7 +371,7 @@ func TestCreateItem(t *testing.T) {
 				tt.mockSetup(runtimeClientMock)
 			}
 
-			r := resolver.New(testlogger.New().Logger, runtimeClientMock)
+			r := resolver.New(testlogger.New().Logger, runtimeClientMock, nil)
 
 			result, err := r.CreateItem(schema.GroupVersionKind{
 				Group:   "group",
@@ -553,7 +553,7 @@ func TestUpdateItem(t *testing.T) {
 				tt.mockSetup(runtimeClientMock)
 			}
 
-			r := resolver.New(testlogger.New().Logger, runtimeClientMock)
+			r := resolver.New(testlogger.New().Logger, runtimeClientMock, nil)
 
 			result, err := r.UpdateItem(schema.GroupVersionKind{
 				Group:   "group",
@@ -637,7 +637,7 @@ func TestDeleteItem(t *testing.T) {
 				tt.mockSetup(runtimeClientMock)
 			}
 
-			r := resolver.New(testlogger.New().Logger, runtimeClientMock)
+			r := resolver.New(testlogger.New().Logger, runtimeClientMock, nil)
 
 			result, err := r.DeleteItem(schema.GroupVersionKind{
 				Group:   "group",