added integration test

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

Author: vertex451

gateway/resolver/dotted_keys.go

@@ -84,6 +84,8 @@ func processSpecToArrays(spec any) any {
 			specMap[k] = mapToArray(v)
 		} else if k == "selector" && v != nil {
 			specMap[k] = processSelectorToArrays(v)
+		} else if k == "template" && v != nil {
+			specMap[k] = processTemplateToArrays(v)
 		}
 	}
 	return spec
@@ -101,6 +103,8 @@ func processSpecToMaps(spec any) any {
 			specMap[k] = arrayToMap(v)
 		} else if k == "selector" && v != nil {
 			specMap[k] = processSelectorToMaps(v)
+		} else if k == "template" && v != nil {
+			specMap[k] = processTemplateToMaps(v)
 		}
 	}
 	return spec
@@ -136,6 +140,40 @@ func processSelectorToMaps(selector any) any {
 	return selector
 }
 
+// processTemplateToArrays handles spec.template.metadata and spec.template.spec conversion to arrays
+func processTemplateToArrays(template any) any {
+	templateMap, ok := template.(map[string]interface{})
+	if !ok {
+		return template
+	}
+
+	for k, v := range templateMap {
+		if k == "metadata" && v != nil {
+			templateMap[k] = processMetadataToArrays(v)
+		} else if k == "spec" && v != nil {
+			templateMap[k] = processSpecToArrays(v)
+		}
+	}
+	return template
+}
+
+// processTemplateToMaps handles spec.template.metadata and spec.template.spec conversion to maps
+func processTemplateToMaps(template any) any {
+	templateMap, ok := template.(map[string]interface{})
+	if !ok {
+		return template
+	}
+
+	for k, v := range templateMap {
+		if k == "metadata" && v != nil {
+			templateMap[k] = processMetadataToMaps(v)
+		} else if k == "spec" && v != nil {
+			templateMap[k] = processSpecToMaps(v)
+		}
+	}
+	return template
+}
+
 // mapToArray converts map[string]string to []Label
 func mapToArray(value any) any {
 	valueMap, ok := value.(map[string]interface{})

gateway/schema/schema.go

@@ -413,70 +413,181 @@ func (g *Gateway) convertSwaggerTypeToGraphQL(schema spec.Schema, typePrefix str
 }
 
 func (g *Gateway) handleObjectFieldSpecType(fieldSpec spec.Schema, typePrefix string, fieldPath []string, processingTypes map[string]bool) (graphql.Output, graphql.Input, error) {
+	// Handle object types with nested properties
 	if len(fieldSpec.Properties) > 0 {
-		typeName := g.generateTypeName(typePrefix, fieldPath)
+		return g.handleObjectWithProperties(fieldSpec, typePrefix, fieldPath, processingTypes)
+	}
 
-		// Check if type already generated
-		if existingType, exists := g.typesCache[typeName]; exists {
-			return existingType, g.inputTypesCache[typeName], nil
-		}
+	// Handle map types (map[string]string)
+	if g.isStringMapType(fieldSpec) {
+		return g.handleMapType(fieldPath, typePrefix)
+	}
 
-		// Store placeholder to prevent recursion
-		g.typesCache[typeName] = nil
-		g.inputTypesCache[typeName] = nil
+	// Fallback: empty object as JSON string
+	return jsonStringScalar, jsonStringScalar, nil
+}
 
-		nestedFields, nestedInputFields, err := g.generateGraphQLFields(&fieldSpec, typeName, fieldPath, processingTypes)
-		if err != nil {
-			return nil, nil, err
-		}
+// handleObjectWithProperties creates GraphQL types for objects with nested properties
+func (g *Gateway) handleObjectWithProperties(fieldSpec spec.Schema, typePrefix string, fieldPath []string, processingTypes map[string]bool) (graphql.Output, graphql.Input, error) {
+	typeName := g.generateTypeName(typePrefix, fieldPath)
 
-		newType := graphql.NewObject(graphql.ObjectConfig{
-			Name:   sanitizeFieldName(typeName),
-			Fields: nestedFields,
-		})
+	// Check if type already generated
+	if existingType, exists := g.typesCache[typeName]; exists {
+		return existingType, g.inputTypesCache[typeName], nil
+	}
 
-		newInputType := graphql.NewInputObject(graphql.InputObjectConfig{
-			Name:   sanitizeFieldName(typeName) + "Input",
-			Fields: nestedInputFields,
-		})
+	// Store placeholder to prevent recursion
+	g.typesCache[typeName] = nil
+	g.inputTypesCache[typeName] = nil
 
-		// Store the generated types
-		g.typesCache[typeName] = newType
-		g.inputTypesCache[typeName] = newInputType
-
-		return newType, newInputType, nil
-	} 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 field that should use Label arrays for dot-notation support
-			currentFieldName := ""
-			if len(fieldPath) > 0 {
-				currentFieldName = fieldPath[len(fieldPath)-1]
-			}
+	nestedFields, nestedInputFields, err := g.generateGraphQLFields(&fieldSpec, typeName, fieldPath, processingTypes)
+	if err != nil {
+		return nil, nil, err
+	}
 
-			// 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"
-
-			// 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
-			}
-			// This is a regular map[string]string
-			return stringMapScalar, stringMapScalar, nil
-		}
+	newType := graphql.NewObject(graphql.ObjectConfig{
+		Name:   sanitizeFieldName(typeName),
+		Fields: nestedFields,
+	})
+
+	newInputType := graphql.NewInputObject(graphql.InputObjectConfig{
+		Name:   sanitizeFieldName(typeName) + "Input",
+		Fields: nestedInputFields,
+	})
+
+	// Store the generated types
+	g.typesCache[typeName] = newType
+	g.inputTypesCache[typeName] = newInputType
+
+	return newType, newInputType, nil
+}
+
+// handleMapType determines the appropriate GraphQL type for map[string]string fields
+func (g *Gateway) handleMapType(fieldPath []string, typePrefix string) (graphql.Output, graphql.Input, error) {
+	if g.shouldUseLabelArrays(fieldPath, typePrefix) {
+		// Use Label arrays for fields that can have dotted keys
+		return graphql.NewList(LabelType), graphql.NewList(LabelInputType), nil
 	}
 
-	// It's an empty object, serialize as JSON string
-	return jsonStringScalar, jsonStringScalar, nil
+	// Use regular string map scalar for normal map[string]string fields
+	return stringMapScalar, stringMapScalar, nil
+}
+
+// isStringMapType checks if the field spec represents a map[string]string
+func (g *Gateway) isStringMapType(fieldSpec spec.Schema) bool {
+	if fieldSpec.AdditionalProperties == nil {
+		return false
+	}
+
+	if fieldSpec.AdditionalProperties.Schema == nil {
+		return false
+	}
+
+	if len(fieldSpec.AdditionalProperties.Schema.Type) != 1 {
+		return false
+	}
+
+	return fieldSpec.AdditionalProperties.Schema.Type[0] == "string"
+}
+
+// shouldUseLabelArrays determines if a field needs Label array treatment for dotted keys
+func (g *Gateway) shouldUseLabelArrays(fieldPath []string, typePrefix string) bool {
+	if len(fieldPath) == 0 {
+		return false
+	}
+
+	fieldName := fieldPath[len(fieldPath)-1]
+
+	if g.isLabelsField(fieldPath, typePrefix, fieldName) {
+		return true
+	}
+
+	if g.isAnnotationsField(fieldPath, typePrefix, fieldName) {
+		return true
+	}
+
+	if g.isNodeSelectorField(fieldPath, fieldName) {
+		return true
+	}
+
+	if g.isMatchLabelsField(fieldPath, fieldName) {
+		return true
+	}
+
+	return false
+}
+
+// isLabelsField checks if this is a metadata.labels field
+func (g *Gateway) isLabelsField(fieldPath []string, typePrefix string, fieldName string) bool {
+	if fieldName != "labels" {
+		return false
+	}
+
+	return g.isInMetadataContext(fieldPath, typePrefix)
+}
+
+// isAnnotationsField checks if this is a metadata.annotations field
+func (g *Gateway) isAnnotationsField(fieldPath []string, typePrefix string, fieldName string) bool {
+	if fieldName != "annotations" {
+		return false
+	}
+
+	return g.isInMetadataContext(fieldPath, typePrefix)
+}
+
+// isNodeSelectorField checks if this is a spec.nodeSelector field
+func (g *Gateway) isNodeSelectorField(fieldPath []string, fieldName string) bool {
+	if fieldName != "nodeSelector" {
+		return false
+	}
+
+	return g.isInSpecContext(fieldPath)
+}
+
+// isMatchLabelsField checks if this is a selector.matchLabels field
+func (g *Gateway) isMatchLabelsField(fieldPath []string, fieldName string) bool {
+	if fieldName != "matchLabels" {
+		return false
+	}
+
+	return g.isInSelectorContext(fieldPath)
+}
+
+// isInMetadataContext checks if the field is within a metadata context
+func (g *Gateway) isInMetadataContext(fieldPath []string, typePrefix string) bool {
+	// Check if we're directly in a metadata field
+	if len(fieldPath) >= 2 && fieldPath[len(fieldPath)-2] == "metadata" {
+		return true
+	}
+
+	// Check if this is an ObjectMeta type
+	if strings.Contains(typePrefix, "ObjectMeta") {
+		return true
+	}
+
+	if strings.Contains(typePrefix, "meta_v1") {
+		return true
+	}
+
+	return false
+}
+
+// isInSpecContext checks if the field is within a spec context
+func (g *Gateway) isInSpecContext(fieldPath []string) bool {
+	if len(fieldPath) < 2 {
+		return false
+	}
+
+	return fieldPath[len(fieldPath)-2] == "spec"
+}
+
+// isInSelectorContext checks if the field is within a selector context
+func (g *Gateway) isInSelectorContext(fieldPath []string) bool {
+	if len(fieldPath) < 2 {
+		return false
+	}
+
+	return fieldPath[len(fieldPath)-2] == "selector"
 }
 
 func (g *Gateway) generateTypeName(typePrefix string, fieldPath []string) string {