feat: relations

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

Author: vertex451

gateway/resolver/relations.go

@@ -0,0 +1,120 @@
+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"
+)
+
+// 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]interface{})
+		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]interface{}, 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) {
+	versions := []string{"v1", "v1beta1", "v1alpha1"}
+
+	for _, version := range versions {
+		if obj := rr.tryFetchResource(ctx, name, namespace, kind, apiGroup, version); obj != nil {
+			return obj, nil
+		}
+	}
+
+	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,
+	}
+
+	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
+	}
+
+	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
+}

gateway/resolver/resolver.go

@@ -30,6 +30,8 @@ type Provider interface {
 	CustomQueriesProvider
 	CommonResolver() graphql.FieldResolveFn
 	SanitizeGroupName(string) string
+	RuntimeClient() client.WithWatch
+	RelationResolver(fieldName string) graphql.FieldResolveFn
 }
 
 type CrudProvider interface {
@@ -50,16 +52,22 @@ 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
+	relationResolver *RelationResolver
 }
 
 func New(log *logger.Logger, runtimeClient client.WithWatch) *Service {
-	return &Service{
+	s := &Service{
 		log:           log,
 		groupNames:    make(map[string]string),
 		runtimeClient: runtimeClient,
 	}
+
+	// Initialize the relation resolver
+	s.relationResolver = NewRelationResolver(s)
+
+	return s
 }
 
 // ListItems returns a GraphQL CommonResolver function that lists Kubernetes resources of the given GroupVersionKind.
@@ -456,3 +464,13 @@ func compareNumbers[T int64 | float64](a, b T) int {
 		return 0
 	}
 }
+
+// RuntimeClient returns the runtime client for use in relationship resolution
+func (r *Service) RuntimeClient() client.WithWatch {
+	return r.runtimeClient
+}
+
+// RelationResolver creates a GraphQL resolver for relation fields
+func (r *Service) RelationResolver(fieldName string) graphql.FieldResolveFn {
+	return r.relationResolver.CreateResolver(fieldName)
+}

gateway/schema/relations.go

@@ -0,0 +1,140 @@
+package schema
+
+import (
+	"strings"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+
+	"github.com/go-openapi/spec"
+	"github.com/graphql-go/graphql"
+)
+
+// 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) {
+	for fieldName := range properties {
+		if !strings.HasSuffix(fieldName, "Ref") {
+			continue
+		}
+
+		baseName := strings.TrimSuffix(fieldName, "Ref")
+		sanitizedFieldName := sanitizeFieldName(fieldName)
+
+		refField, exists := fields[sanitizedFieldName]
+		if !exists {
+			continue
+		}
+
+		enhancedType := re.enhanceRefTypeWithRelation(refField.Type, baseName)
+		if enhancedType == nil {
+			continue
+		}
+
+		fields[sanitizedFieldName] = &graphql.Field{
+			Type: enhancedType,
+		}
+	}
+}
+
+// enhanceRefTypeWithRelation adds a relation field to a *Ref object type
+func (re *RelationEnhancer) 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 {
+		return enhancedType
+	}
+
+	enhancedFields := re.copyOriginalFields(objType.Fields())
+	re.addRelationField(enhancedFields, baseName)
+
+	enhancedType := graphql.NewObject(graphql.ObjectConfig{
+		Name:   sanitizeFieldName(cacheKey),
+		Fields: enhancedFields,
+	})
+
+	re.gateway.enhancedTypesCache[cacheKey] = enhancedType
+	return enhancedType
+}
+
+// copyOriginalFields converts FieldDefinition to Field for reuse
+func (re *RelationEnhancer) copyOriginalFields(originalFieldDefs graphql.FieldDefinitionMap) graphql.Fields {
+	enhancedFields := make(graphql.Fields, len(originalFieldDefs))
+	for fieldName, fieldDef := range originalFieldDefs {
+		enhancedFields[fieldName] = &graphql.Field{
+			Type:        fieldDef.Type,
+			Description: fieldDef.Description,
+			Resolve:     fieldDef.Resolve,
+		}
+	}
+	return enhancedFields
+}
+
+// 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 {
+		return
+	}
+
+	sanitizedBaseName := sanitizeFieldName(baseName)
+	enhancedFields[sanitizedBaseName] = &graphql.Field{
+		Type:    targetType,
+		Resolve: re.gateway.resolver.RelationResolver(baseName),
+	}
+}
+
+// findRelationTargetType finds the GraphQL type for a relation target
+func (re *RelationEnhancer) findRelationTargetType(baseName string) graphql.Output {
+	targetKind := cases.Title(language.English).String(baseName)
+
+	for defKey, defSchema := range re.gateway.definitions {
+		if re.matchesTargetKind(defSchema, targetKind) {
+			if existingType, exists := re.gateway.typesCache[defKey]; exists {
+				return existingType
+			}
+
+			if fieldType, _, err := re.gateway.convertSwaggerTypeToGraphQL(defSchema, defKey, []string{}, make(map[string]bool)); err == nil {
+				return fieldType
+			}
+		}
+	}
+
+	return graphql.String
+}
+
+// matchesTargetKind checks if a schema definition matches the target kind
+func (re *RelationEnhancer) matchesTargetKind(defSchema spec.Schema, targetKind string) bool {
+	gvkExt, ok := defSchema.Extensions["x-kubernetes-group-version-kind"]
+	if !ok {
+		return false
+	}
+
+	gvkSlice, ok := gvkExt.([]any)
+	if !ok || len(gvkSlice) == 0 {
+		return false
+	}
+
+	gvkMap, ok := gvkSlice[0].(map[string]any)
+	if !ok {
+		return false
+	}
+
+	kind, ok := gvkMap["kind"].(string)
+	return ok && kind == targetKind
+}

gateway/schema/schema.go

@@ -22,16 +22,14 @@ type Provider interface {
 }
 
 type Gateway struct {
-	log           *logger.Logger
-	resolver      resolver.Provider
-	graphqlSchema graphql.Schema
-
-	definitions spec.Definitions
-
-	// typesCache stores generated GraphQL object types(fields) to prevent redundant repeated generation.
-	typesCache map[string]*graphql.Object
-	// inputTypesCache stores generated GraphQL input object types(input fields) to prevent redundant repeated generation.
-	inputTypesCache map[string]*graphql.InputObject
+	log                *logger.Logger
+	resolver           resolver.Provider
+	graphqlSchema      graphql.Schema
+	definitions        spec.Definitions
+	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
 
@@ -41,15 +39,19 @@ type Gateway struct {
 
 func New(log *logger.Logger, definitions spec.Definitions, resolverProvider resolver.Provider) (*Gateway, error) {
 	g := &Gateway{
-		log:              log,
-		resolver:         resolverProvider,
-		definitions:      definitions,
-		typesCache:       make(map[string]*graphql.Object),
-		inputTypesCache:  make(map[string]*graphql.InputObject),
-		typeNameRegistry: make(map[string]string),
-		typeByCategory:   make(map[string][]resolver.TypeByCategory),
+		log:                log,
+		resolver:           resolverProvider,
+		definitions:        definitions,
+		typesCache:         make(map[string]*graphql.Object),
+		inputTypesCache:    make(map[string]*graphql.InputObject),
+		enhancedTypesCache: make(map[string]*graphql.Object),
+		typeNameRegistry:   make(map[string]string),
+		typeByCategory:     make(map[string][]resolver.TypeByCategory),
 	}
 
+	// Initialize the relation enhancer after gateway is created
+	g.relationEnhancer = NewRelationEnhancer(g)
+
 	err := g.generateGraphqlSchema()
 
 	return g, err
@@ -336,6 +338,9 @@ func (g *Gateway) generateGraphQLFields(resourceScheme *spec.Schema, typePrefix
 		}
 	}
 
+	// Add relation fields for any *Ref fields in this schema
+	g.relationEnhancer.AddRelationFields(fields, resourceScheme.Properties)
+
 	return fields, inputFields, nil
 }