added support for node selectors and matchLables

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

Author: vertex451

gateway/resolver/resolver.go

@@ -25,62 +25,132 @@ import (
 	"github.com/openmfp/golang-commons/logger"
 )
 
-// convertMapsToArrays transforms labels and annotations from maps to arrays (for GraphQL output)
+// convertMapsToArrays transforms label-like fields from maps to arrays (for GraphQL output)
 // map[string]string → []Label
 func convertMapsToArrays(obj any) any {
 	objMap, ok := obj.(map[string]interface{})
 	if !ok {
 		return obj
 	}
 
-	// Check if this object has metadata
-	metadata, hasMetadata := objMap["metadata"]
-	if !hasMetadata {
-		return obj
-	}
-
-	metadataMap, ok := metadata.(map[string]interface{})
-	if !ok {
-		return obj
+	// Process metadata fields
+	if metadata := objMap["metadata"]; metadata != nil {
+		objMap["metadata"] = processMetadataToArrays(metadata)
 	}
 
-	// Transform labels and annotations to arrays (in-place)
-	for k, v := range metadataMap {
-		if (k == "labels" || k == "annotations") && v != nil {
-			metadataMap[k] = mapToArray(v)
-		}
+	// Process spec fields
+	if spec := objMap["spec"]; spec != nil {
+		objMap["spec"] = processSpecToArrays(spec)
 	}
 
 	return obj
 }
 
-// convertArraysToMaps transforms labels and annotations from arrays to maps (for Kubernetes input)
+// convertArraysToMaps transforms label-like fields from arrays to maps (for Kubernetes input)
 // []Label → map[string]string
 func convertArraysToMaps(obj any) any {
 	objMap, ok := obj.(map[string]interface{})
 	if !ok {
 		return obj
 	}
 
-	// Check if this object has metadata
-	metadata, hasMetadata := objMap["metadata"]
-	if !hasMetadata {
-		return obj
+	// Process metadata fields
+	if metadata := objMap["metadata"]; metadata != nil {
+		objMap["metadata"] = processMetadataToMaps(metadata)
+	}
+
+	// Process spec fields
+	if spec := objMap["spec"]; spec != nil {
+		objMap["spec"] = processSpecToMaps(spec)
+	}
+
+	return obj
+}
+
+// processMetadataToArrays handles metadata.labels and metadata.annotations conversion to arrays
+func processMetadataToArrays(metadata any) any {
+	metadataMap, ok := metadata.(map[string]interface{})
+	if !ok {
+		return metadata
+	}
+
+	if labels := metadataMap["labels"]; labels != nil {
+		metadataMap["labels"] = mapToArray(labels)
+	}
+	if annotations := metadataMap["annotations"]; annotations != nil {
+		metadataMap["annotations"] = mapToArray(annotations)
 	}
 
+	return metadataMap
+}
+
+// processMetadataToMaps handles metadata.labels and metadata.annotations conversion to maps
+func processMetadataToMaps(metadata any) any {
 	metadataMap, ok := metadata.(map[string]interface{})
 	if !ok {
-		return obj
+		return metadata
+	}
+
+	if labels := metadataMap["labels"]; labels != nil {
+		metadataMap["labels"] = arrayToMap(labels)
+	}
+	if annotations := metadataMap["annotations"]; annotations != nil {
+		metadataMap["annotations"] = arrayToMap(annotations)
+	}
+
+	return metadataMap
+}
+
+// processSpecToArrays handles spec.nodeSelector and spec.selector.matchLabels conversion to arrays
+func processSpecToArrays(spec any) any {
+	specMap, ok := spec.(map[string]interface{})
+	if !ok {
+		return spec
+	}
+
+	if nodeSelector := specMap["nodeSelector"]; nodeSelector != nil {
+		specMap["nodeSelector"] = mapToArray(nodeSelector)
+	}
+	if selector := specMap["selector"]; selector != nil {
+		specMap["selector"] = processSelector(selector, true)
+	}
+
+	return specMap
+}
+
+// processSpecToMaps handles spec.nodeSelector and spec.selector.matchLabels conversion to maps
+func processSpecToMaps(spec any) any {
+	specMap, ok := spec.(map[string]interface{})
+	if !ok {
+		return spec
+	}
+
+	if nodeSelector := specMap["nodeSelector"]; nodeSelector != nil {
+		specMap["nodeSelector"] = arrayToMap(nodeSelector)
+	}
+	if selector := specMap["selector"]; selector != nil {
+		specMap["selector"] = processSelector(selector, false)
 	}
 
-	// Transform labels and annotations to maps (in-place)
-	for k, v := range metadataMap {
-		if (k == "labels" || k == "annotations") && v != nil {
-			metadataMap[k] = arrayToMap(v)
+	return specMap
+}
+
+// processSelector handles selector.matchLabels conversion
+func processSelector(selector any, toArray bool) any {
+	selectorMap, ok := selector.(map[string]interface{})
+	if !ok {
+		return selector
+	}
+
+	if matchLabels := selectorMap["matchLabels"]; matchLabels != nil {
+		if toArray {
+			selectorMap["matchLabels"] = mapToArray(matchLabels)
+		} else {
+			selectorMap["matchLabels"] = arrayToMap(matchLabels)
 		}
 	}
 
-	return obj
+	return selectorMap
 }
 
 // mapToArray converts a label map to array format

gateway/schema/schema.go

@@ -448,18 +448,24 @@ func (g *Gateway) handleObjectFieldSpecType(fieldSpec spec.Schema, typePrefix st
 	} else if fieldSpec.AdditionalProperties != nil && fieldSpec.AdditionalProperties.Schema != nil {
 		// Handle map types
 		if len(fieldSpec.AdditionalProperties.Schema.Type) == 1 && fieldSpec.AdditionalProperties.Schema.Type[0] == "string" {
-			// Check if this is a labels or annotations field
+			// Check if this is a field that should use Label arrays for dot-notation support
 			currentFieldName := ""
 			if len(fieldPath) > 0 {
 				currentFieldName = fieldPath[len(fieldPath)-1]
 			}
 
-			// Check if we're in a metadata context or processing a known ObjectMeta type
+			// Check various contexts where Label arrays should be used
 			isInMetadata := len(fieldPath) >= 2 && fieldPath[len(fieldPath)-2] == "metadata"
 			isObjectMetaType := strings.Contains(typePrefix, "ObjectMeta") || strings.Contains(typePrefix, "meta_v1")
+			isInSelector := len(fieldPath) >= 2 && fieldPath[len(fieldPath)-2] == "selector"
+			isInSpec := len(fieldPath) >= 2 && fieldPath[len(fieldPath)-2] == "spec"
 
-			if (isInMetadata || isObjectMetaType) && (currentFieldName == "labels" || currentFieldName == "annotations") {
-				// This is a labels or annotations field
+			// Identify fields that need Label array treatment
+			isLabelsOrAnnotations := (isInMetadata || isObjectMetaType) && (currentFieldName == "labels" || currentFieldName == "annotations")
+			isNodeSelector := isInSpec && currentFieldName == "nodeSelector"
+			isMatchLabels := isInSelector && currentFieldName == "matchLabels"
+
+			if isLabelsOrAnnotations || isNodeSelector || isMatchLabels {
 				// Use List(LabelType) for output (allows querying key/value fields)
 				// Use List(LabelInputType) for input (supports array syntax)
 				return graphql.NewList(LabelType), graphql.NewList(LabelInputType), nil