refactor: use shallow copy from endpoint.go

Author: Apoorva64

endpoint/endpoint.go

@@ -313,6 +313,26 @@ func (e *Endpoint) WithSetIdentifier(setIdentifier string) *Endpoint {
 	return e
 }
 
+// WithTargets returns a shallow copy of the endpoint with only Targets and RecordType replaced.
+// The RecordType is derived from the first target using SuitableType.
+// All other fields remain intact (shared with the original endpoint).
+func (e *Endpoint) WithTargets(targets Targets) *Endpoint {
+	recordType := e.RecordType
+	if len(targets) > 0 {
+		recordType = SuitableType(targets[0])
+	}
+	return &Endpoint{
+		DNSName:          e.DNSName,
+		Targets:          targets,
+		RecordType:       recordType,
+		SetIdentifier:    e.SetIdentifier,
+		RecordTTL:        e.RecordTTL,
+		Labels:           e.Labels,
+		ProviderSpecific: e.ProviderSpecific,
+		refObject:        e.refObject,
+	}
+}
+
 // WithProviderSpecific attaches a key/value pair to the Endpoint and returns the Endpoint.
 // This can be used to pass additional data through the stages of ExternalDNS's Endpoint processing.
 // The assumption is that most of the time this will be provider specific metadata that doesn't

source/wrappers/resolvetarget.go

@@ -18,7 +18,6 @@ package wrappers
 
 import (
 	"context"
-	"maps"
 	"net"
 
 	log "github.com/sirupsen/logrus"
@@ -76,17 +75,19 @@ func (rs *resolveTarget) Endpoints(ctx context.Context) ([]*endpoint.Endpoint, e
 	result := make([]*endpoint.Endpoint, 0, len(endpoints))
 	for _, ep := range endpoints {
 		if ep == nil {
-			result = append(result, nil)
 			continue
 		}
 
-		shouldResolve := false
-		if v, ok := ep.GetProviderSpecificProperty("resolve-target"); ok {
-			shouldResolve = v == "true"
-			ep.DeleteProviderSpecificProperty("resolve-target")
+		// Skip early if not a CNAME record, as only those can have hostname targets that need resolution.
+		if ep.RecordType != endpoint.RecordTypeCNAME {
+			result = append(result, ep)
+			continue
 		}
 
-		if !shouldResolve || ep.RecordType != endpoint.RecordTypeCNAME {
+		// Check if the "resolve-target" provider-specific property is set to "true" for this endpoint.
+		v, _ := ep.GetProviderSpecificProperty("resolve-target")
+		ep.DeleteProviderSpecificProperty("resolve-target")
+		if v != "true" {
 			result = append(result, ep)
 			continue
 		}
@@ -106,11 +107,20 @@ func (rs *resolveTarget) Endpoints(ctx context.Context) ([]*endpoint.Endpoint, e
 			// All resolutions failed; skip this endpoint entirely.
 			continue
 		}
-		resolved := endpoint.EndpointsForHostname(ep.DNSName, ipTargets, ep.RecordTTL, ep.ProviderSpecific, ep.SetIdentifier, "")
-		for _, r := range resolved {
-			maps.Copy(r.Labels, ep.Labels)
+
+		// Group targets by record type (A vs AAAA)
+		byType := map[string]endpoint.Targets{}
+		for _, t := range ipTargets {
+			rt := endpoint.SuitableType(t)
+			byType[rt] = append(byType[rt], t)
+		}
+
+		// Emit one endpoint per record type with the same DNSName and provider-specific properties.
+		for _, rt := range []string{endpoint.RecordTypeA, endpoint.RecordTypeAAAA} {
+			if targets := byType[rt]; len(targets) > 0 {
+				result = append(result, ep.WithTargets(targets))
+			}
 		}
-		result = append(result, resolved...)
 	}
 
 	return result, nil