Fix nil pointer exceptions + infinite recursion

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

Author: vertex451

gateway/resolver/relations.go

@@ -28,7 +28,7 @@ func NewRelationResolver(service *Service) *RelationResolver {
 
 // CreateResolver creates a GraphQL resolver for relation fields
 func (rr *RelationResolver) CreateResolver(fieldName string) graphql.FieldResolveFn {
-	return func(p graphql.ResolveParams) (interface{}, error) {
+	return func(p graphql.ResolveParams) (any, error) {
 		parentObj, ok := p.Source.(map[string]any)
 		if !ok {
 			return nil, nil
@@ -76,7 +76,7 @@ func (rr *RelationResolver) extractReferenceInfo(parentObj map[string]any, field
 }
 
 // resolveReference fetches a referenced Kubernetes resource
-func (rr *RelationResolver) resolveReference(ctx context.Context, name, namespace, kind, apiGroup string) (interface{}, error) {
+func (rr *RelationResolver) resolveReference(ctx context.Context, name, namespace, kind, apiGroup string) (any, error) {
 	// Try RESTMapper preferred mapping first
 	if rr.service != nil && rr.service.restMapper != nil {
 		gk := schema.GroupKind{Group: apiGroup, Kind: kind}

gateway/schema/relations.go

@@ -125,12 +125,12 @@ func (re *RelationEnhancer) matchesTargetKind(defSchema spec.Schema, targetKind
 		return false
 	}
 
-	gvkSlice, ok := gvkExt.([]interface{})
+	gvkSlice, ok := gvkExt.([]any)
 	if !ok || len(gvkSlice) == 0 {
 		return false
 	}
 
-	gvkMap, ok := gvkSlice[0].(map[string]interface{})
+	gvkMap, ok := gvkSlice[0].(map[string]any)
 	if !ok {
 		return false
 	}

listener/pkg/apischema/builder.go

@@ -118,69 +118,84 @@ func (b *SchemaBuilder) WithScope(rm meta.RESTMapper) *SchemaBuilder {
 				Str("group", gvks[0].Group).
 				Str("version", gvks[0].Version).
 				Str("kind", gvks[0].Kind).
-				Msg("failed to determine if GVK is namespaced")
+				Msg("failed to get namespaced info for GVK")
 			continue
 		}
 
 		if namespaced {
-			schema.VendorExtensible.AddExtension(common.ScopeExtensionKey, apiextensionsv1.NamespaceScoped)
+			if schema.VendorExtensible.Extensions == nil {
+				schema.VendorExtensible.Extensions = map[string]any{}
+			}
+			schema.VendorExtensible.Extensions[common.ScopeExtensionKey] = apiextensionsv1.NamespaceScoped
 		} else {
-			schema.VendorExtensible.AddExtension(common.ScopeExtensionKey, apiextensionsv1.ClusterScoped)
+			if schema.VendorExtensible.Extensions == nil {
+				schema.VendorExtensible.Extensions = map[string]any{}
+			}
+			schema.VendorExtensible.Extensions[common.ScopeExtensionKey] = apiextensionsv1.ClusterScoped
 		}
-
 	}
-
 	return b
 }
 
 func (b *SchemaBuilder) WithCRDCategories(crd *apiextensionsv1.CustomResourceDefinition) *SchemaBuilder {
-	categories := crd.Spec.Names.Categories
-	if len(categories) == 0 {
-		return b
-	}
-	gvk, err := getCRDGroupVersionKind(crd.Spec)
-	if err != nil {
-		b.err = multierror.Append(b.err, errors.Join(ErrGetCRDGVK, err))
+	if crd == nil {
 		return b
 	}
 
-	schema, ok := b.schemas[getOpenAPISchemaKey(*gvk)]
-	if !ok {
+	gkv, err := getCRDGroupVersionKind(crd.Spec)
+	if err != nil {
+		b.err = multierror.Append(b.err, ErrGetCRDGVK)
 		return b
 	}
 
-	schema.VendorExtensible.AddExtension(common.CategoriesExtensionKey, categories)
+	for _, v := range crd.Spec.Versions {
+		resourceKey := getOpenAPISchemaKey(metav1.GroupVersionKind{Group: gkv.Group, Version: v.Name, Kind: gkv.Kind})
+		resourceSchema, ok := b.schemas[resourceKey]
+		if !ok {
+			continue
+		}
 
+		if len(crd.Spec.Names.Categories) == 0 {
+			b.log.Debug().Str("resource", resourceKey).Msg("no categories provided for CRD kind")
+			continue
+		}
+		if resourceSchema.VendorExtensible.Extensions == nil {
+			resourceSchema.VendorExtensible.Extensions = map[string]any{}
+		}
+		resourceSchema.VendorExtensible.Extensions[common.CategoriesExtensionKey] = crd.Spec.Names.Categories
+		b.schemas[resourceKey] = resourceSchema
+	}
 	return b
 }
 
 func (b *SchemaBuilder) WithApiResourceCategories(list []*metav1.APIResourceList) *SchemaBuilder {
+	if len(list) == 0 {
+		return b
+	}
+
 	for _, apiResourceList := range list {
+		gv, err := runtimeSchema.ParseGroupVersion(apiResourceList.GroupVersion)
+		if err != nil {
+			b.err = multierror.Append(b.err, errors.Join(ErrParseGroupVersion, err))
+			continue
+		}
 		for _, apiResource := range apiResourceList.APIResources {
 			if apiResource.Categories == nil {
 				continue
 			}
-
-			gv, err := runtimeSchema.ParseGroupVersion(apiResourceList.GroupVersion)
-			if err != nil {
-				b.err = multierror.Append(b.err, errors.Join(ErrParseGroupVersion, err))
-				continue
-			}
-			gvk := metav1.GroupVersionKind{
-				Group:   gv.Group,
-				Version: gv.Version,
-				Kind:    apiResource.Kind,
-			}
-
-			schema, ok := b.schemas[getOpenAPISchemaKey(gvk)]
+			gvk := metav1.GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: apiResource.Kind}
+			resourceKey := getOpenAPISchemaKey(gvk)
+			resourceSchema, ok := b.schemas[resourceKey]
 			if !ok {
 				continue
 			}
-
-			schema.VendorExtensible.AddExtension(common.CategoriesExtensionKey, apiResource.Categories)
+			if resourceSchema.VendorExtensible.Extensions == nil {
+				resourceSchema.VendorExtensible.Extensions = map[string]any{}
+			}
+			resourceSchema.VendorExtensible.Extensions[common.CategoriesExtensionKey] = apiResource.Categories
+			b.schemas[resourceKey] = resourceSchema
 		}
 	}
-
 	return b
 }
 
@@ -298,10 +313,11 @@ func (b *SchemaBuilder) expandRelationships(schema *spec.Schema) {
 		}
 	}
 
-	// Recursively process nested objects
-	for _, prop := range schema.Properties {
+	// Recursively process nested objects and write back modifications
+	for key, prop := range schema.Properties {
 		if prop.Type.Contains("object") && prop.Properties != nil {
 			b.expandRelationships(&prop)
+			schema.Properties[key] = prop
 		}
 	}
 }
@@ -313,18 +329,18 @@ func (b *SchemaBuilder) Complete() ([]byte, error) {
 		},
 	})
 	if err != nil {
-		b.err = multierror.Append(b.err, errors.Join(ErrMarshalOpenAPISchema, err))
-		return nil, b.err
+		return nil, errors.Join(ErrMarshalOpenAPISchema, err)
 	}
+
 	v2JSON, err := ConvertJSON(v3JSON)
 	if err != nil {
-		b.err = multierror.Append(b.err, errors.Join(ErrConvertOpenAPISchema, err))
-		return nil, b.err
+		return nil, errors.Join(ErrConvertOpenAPISchema, err)
 	}
 
 	return v2JSON, nil
 }
 
+// getOpenAPISchemaKey creates the key that kubernetes uses in its OpenAPI Definitions
 func getOpenAPISchemaKey(gvk metav1.GroupVersionKind) string {
 	// we need to inverse group to match the runtimeSchema key(io.openmfp.core.v1alpha1.Account)
 	parts := strings.Split(gvk.Group, ".")