feat(kustomizer): enable port list mutation in manifests (#102)

Extends the field mutator Kustomize plugin to handle array indices in field paths (e.g., `spec.ports[0].port`, `spec.containers[0].ports[0].containerPort`). This enables dynamic configuration of array-based fields in Kubernetes resources during the migration from programmatic resource creation to declarative YAML manifests, maintaining existing port override capabilities across Services, Deployments, and NetworkPolicies.


Approved-by: VaishnaviHire

Author: mfleader

pkg/deploy/plugins/field_mutator.go

@@ -2,6 +2,8 @@ package plugins
 
 import (
 	"fmt"
+	"regexp"
+	"strconv"
 	"strings"
 
 	"sigs.k8s.io/kustomize/api/resmap"
@@ -17,6 +19,7 @@ type FieldMapping struct {
 	// This provides a fallback mechanism, making transformations more robust.
 	DefaultValue any `json:"defaultValue,omitempty"`
 	// TargetField is the dot-notation path to the field in the target object.
+	// Supports array indices like "spec.ports[0].port"
 	TargetField string `json:"targetField"`
 	// TargetKind is the kind of resource to apply the transformation to.
 	TargetKind string `json:"targetKind"`
@@ -40,6 +43,46 @@ type fieldMutator struct {
 	config FieldMutatorConfig
 }
 
+type fieldSegment struct {
+	name     string // field name (e.g., "ports")
+	isArray  bool   // true if this segment has an array index
+	index    int    // array index if isArray is true
+	original string // original segment string for error messages
+}
+
+func parseFieldPath(path string) ([]fieldSegment, error) {
+	// Regular expression to match field names with optional array indices
+	// Matches: "fieldname" or "fieldname[123]"
+	re := regexp.MustCompile(`^([a-zA-Z_][a-zA-Z0-9_]*)\[(\d+)\]$`)
+
+	parts := strings.Split(path, ".")
+	segments := make([]fieldSegment, len(parts))
+
+	for i, part := range parts {
+		if matches := re.FindStringSubmatch(part); matches != nil {
+			index, err := strconv.Atoi(matches[2])
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse array index in field path segment %q: %w", part, err)
+			}
+			segments[i] = fieldSegment{
+				name:     matches[1],
+				isArray:  true,
+				index:    index,
+				original: part,
+			}
+		} else {
+			segments[i] = fieldSegment{
+				name:     part,
+				isArray:  false,
+				index:    -1,
+				original: part,
+			}
+		}
+	}
+
+	return segments, nil
+}
+
 // isEmpty checks if a value is nil or an empty string, slice, or map.
 func isEmpty(v any) bool {
 	if v == nil {
@@ -90,7 +133,7 @@ func (t *fieldMutator) Config(h *resmap.PluginHelpers, _ []byte) error {
 }
 
 // setTargetField modifies the resource by setting the specified value at the
-// given dot-notation path.
+// given dot-notation path with support for array indices.
 func setTargetField(res *resource.Resource, value any, mapping FieldMapping) error {
 	yamlBytes, err := res.AsYAML()
 	if err != nil {
@@ -102,35 +145,21 @@ func setTargetField(res *resource.Resource, value any, mapping FieldMapping) err
 		return fmt.Errorf("failed to unmarshal YAML: %w", unmarshalErr)
 	}
 
-	// This loop navigates to the parent of the target field. We must stop one
-	// level short because Golang does not allow taking a pointer to a map value
-	// (e.g., `&myMap["key"]`). To mutate the map, we need a reference to the
-	// parent container to use the `parent[key] = value` syntax.
-	//
-	// This "stop at the parent" approach also gives us the `CreateIfNotExists`
-	// behavior for free, as we can create missing parent maps during traversal.
-	fields := strings.Split(mapping.TargetField, ".")
-	current := data
-	for _, field := range fields[:len(fields)-1] {
-		next, ok := current[field]
-		if !ok {
-			if !mapping.CreateIfNotExists {
-				return fmt.Errorf("failed to find field %s", field)
-			}
-			next = make(map[string]any)
-			current[field] = next
-		}
-
-		nextMap, ok := next.(map[string]any)
-		if !ok {
-			return fmt.Errorf("failed to convert field %s to map", field)
-		}
+	segments, err := parseFieldPath(mapping.TargetField)
+	if err != nil {
+		return fmt.Errorf("failed to parse field path %q: %w", mapping.TargetField, err)
+	}
 
-		current = nextMap
+	// Navigate to parent first, then set value - arrays vs maps need different handling.
+	current, err := navigateToParent(data, segments, mapping.CreateIfNotExists)
+	if err != nil {
+		return err
 	}
 
-	lastField := fields[len(fields)-1]
-	current[lastField] = value
+	lastSegment := segments[len(segments)-1]
+	if setErr := setFieldValue(current, lastSegment, value, mapping.CreateIfNotExists); setErr != nil {
+		return fmt.Errorf("failed to set field %q: %w", lastSegment.original, setErr)
+	}
 
 	// After modifying the map, we must marshal it back to YAML and create a new
 	// resource object to ensure the internal state is consistent.
@@ -150,3 +179,130 @@ func setTargetField(res *resource.Resource, value any, mapping FieldMapping) err
 	res.ResetRNode(newRes)
 	return nil
 }
+
+// navigateToParent walks through all field segments except the last one,
+// returning the parent container where the final field should be set.
+func navigateToParent(data map[string]any, segments []fieldSegment, createIfNotExists bool) (map[string]any, error) {
+	current := data
+	// This loop navigates to the parent of the target field. We must stop one
+	// level short because Golang does not allow taking a pointer to a map value
+	// (e.g., `&myMap["key"]`). To mutate the map, we need a reference to the
+	// parent container to use the `parent[key] = value` syntax.
+	//
+	// This "stop at the parent" approach also gives us the `CreateIfNotExists`
+	// behavior for free, as we can create missing parent maps during traversal.
+	for _, segment := range segments[:len(segments)-1] {
+		next, navErr := navigateToField(current, segment, createIfNotExists)
+		if navErr != nil {
+			if strings.Contains(navErr.Error(), "failed to find field") {
+				return nil, navErr
+			}
+			return nil, fmt.Errorf("failed to navigate to field %q: %w", segment.original, navErr)
+		}
+		currentMap, ok := next.(map[string]any)
+		if !ok {
+			return nil, fmt.Errorf("failed to convert field %s to map", segment.name)
+		}
+		current = currentMap
+	}
+	return current, nil
+}
+
+// navigateToField returns the value at the specified field, creating it if needed.
+func navigateToField(current any, segment fieldSegment, createIfNotExists bool) (any, error) {
+	currentMap, ok := current.(map[string]any)
+	if !ok {
+		return nil, fmt.Errorf("failed to convert current value to map[string]any, got %T", current)
+	}
+
+	next, exists := currentMap[segment.name]
+	if !exists {
+		if !createIfNotExists {
+			return nil, fmt.Errorf("failed to find field %s", segment.name)
+		}
+
+		if segment.isArray {
+			next = make([]any, segment.index+1)
+		} else {
+			next = make(map[string]any)
+		}
+		currentMap[segment.name] = next
+	}
+
+	if segment.isArray {
+		return handleArrayAccess(currentMap, segment, next, createIfNotExists)
+	}
+
+	return next, nil
+}
+
+// handleArrayAccess navigates to a specific array index, expanding the array and
+// creating missing elements if needed. Returns the element at the specified index.
+func handleArrayAccess(currentMap map[string]any, segment fieldSegment, next any, createIfNotExists bool) (any, error) {
+	arr, err := ensureArrayWithCapacity(currentMap, segment, next, createIfNotExists)
+	if err != nil {
+		return nil, err
+	}
+
+	if arr[segment.index] == nil {
+		if !createIfNotExists {
+			return nil, fmt.Errorf("failed to access array element at index %d for field %q", segment.index, segment.name)
+		}
+		arr[segment.index] = make(map[string]any)
+	}
+
+	return arr[segment.index], nil
+}
+
+// ensureArrayWithCapacity ensures an array exists at the specified field with sufficient capacity.
+// If the array doesn't exist or is too small, it creates or expands it as needed.
+func ensureArrayWithCapacity(currentMap map[string]any, segment fieldSegment, field any, createIfNotExists bool) ([]any, error) {
+	if field == nil {
+		if !createIfNotExists {
+			return nil, fmt.Errorf("failed to find array field %q", segment.name)
+		}
+		arr := make([]any, segment.index+1)
+		currentMap[segment.name] = arr
+		return arr, nil
+	}
+
+	arr, ok := field.([]any)
+	if !ok {
+		return nil, fmt.Errorf("failed to convert field %q to array, got %T", segment.name, field)
+	}
+
+	if segment.index >= len(arr) {
+		if !createIfNotExists {
+			return nil, fmt.Errorf("failed to access array index %d for field %q (length: %d)", segment.index, segment.name, len(arr))
+		}
+		newArr := make([]any, segment.index+1)
+		copy(newArr, arr)
+		for i := len(arr); i <= segment.index; i++ {
+			newArr[i] = make(map[string]any)
+		}
+		currentMap[segment.name] = newArr
+		return newArr, nil
+	}
+
+	return arr, nil
+}
+
+func setFieldValue(current any, segment fieldSegment, value any, createIfNotExists bool) error {
+	currentMap, ok := current.(map[string]any)
+	if !ok {
+		return fmt.Errorf("failed to convert current value to map[string]any, got %T", current)
+	}
+
+	if segment.isArray {
+		field := currentMap[segment.name]
+		arr, err := ensureArrayWithCapacity(currentMap, segment, field, createIfNotExists)
+		if err != nil {
+			return err
+		}
+		arr[segment.index] = value
+		return nil
+	}
+
+	currentMap[segment.name] = value
+	return nil
+}

pkg/deploy/plugins/field_mutator_test.go

@@ -218,6 +218,29 @@ func TestTransform(t *testing.T) {
 			},
 			expectError: true,
 		},
+		{
+			name: "array index support integration",
+			transformer: CreateFieldMutator(FieldMutatorConfig{
+				Mappings: []FieldMapping{
+					{TargetKind: "Service", TargetField: "spec.ports[0].port", SourceValue: 8080, CreateIfNotExists: true},
+					{TargetKind: "Service", TargetField: "spec.ports[0].targetPort", SourceValue: 8080, CreateIfNotExists: true},
+				},
+			}),
+			initialResources: []*resource.Resource{
+				newTestResource(t, "v1", "Service", "my-service", "", map[string]any{
+					"ports": []any{
+						map[string]any{"port": 80, "name": "http"},
+					},
+				}),
+			},
+			expectedSpecs: map[string]map[string]any{
+				"my-service": {
+					"ports": []any{
+						map[string]any{"port": 8080, "targetPort": 8080, "name": "http"},
+					},
+				},
+			},
+		},
 	}
 
 	for _, tc := range testCases {