Flatten emitter HTTPRoute ingress features

- Remove the emitter HTTPRoute IngressNginx wrapper.
- Project ingress-derived feature fields directly on HTTPRouteContext
using provider-neutral type names.
- Restructure provider_intermediate conversion to match upstream shape.
- Move downstream ingress feature projection into a dedicated helper file
for easier future rebases.

Signed-off-by: Daneyon Hansen <daneyon.hansen@solo.io>

Author: danehans

pkg/i2gw/emitter_intermediate/intermediate_representation.go

@@ -56,9 +56,20 @@ type GatewayContext struct {
 
 type HTTPRouteContext struct {
 	gatewayv1.HTTPRoute
-	// IngressNginx contains ingress-nginx-specific IR data for kgateway emitter
-	IngressNginx *IngressNginxHTTPRouteIR
-	// RuleBackendSources tracks the source Ingress resources for each backend
+
+	// PoliciesBySourceIngressName stores feature policy data keyed by source Ingress name.
+	PoliciesBySourceIngressName map[string]Policy
+
+	// RegexLocationForHost is true when regex location matching should be used for the route host.
+	RegexLocationForHost *bool
+
+	// RegexForcedByUseRegex is true when RegexLocationForHost is driven by use-regex annotation.
+	RegexForcedByUseRegex bool
+
+	// RegexForcedByRewrite is true when RegexLocationForHost is driven by rewrite-target annotation.
+	RegexForcedByRewrite bool
+
+	// RuleBackendSources tracks the source Ingress resources for each backend.
 	RuleBackendSources [][]BackendSource
 }
 
@@ -104,38 +115,14 @@ type ReferenceGrantContext struct {
 	gatewayv1beta1.ReferenceGrant
 }
 
-// IngressNginxGatewayIR is the emitter-side ingress-nginx gateway IR.
-type IngressNginxGatewayIR struct{}
-
-// IngressNginxServiceIR is the emitter-side ingress-nginx service IR.
-type IngressNginxServiceIR struct{}
-
-// IngressNginxHTTPRouteIR contains ingress-nginx-specific fields for HTTPRoute.
-type IngressNginxHTTPRouteIR struct {
-	// Policies keyed by source Ingress name.
-	Policies map[string]IngressNginxPolicy
-
-	// RegexLocationForHost is true when ingress-nginx would enforce the "~*" (case-insensitive)
-	// regex location modifier for all paths under a host.
-	RegexLocationForHost *bool
-
-	// RegexForcedByUseRegex is true when RegexLocationForHost is true specifically
-	// because of the nginx.ingress.kubernetes.io/use-regex annotation.
-	RegexForcedByUseRegex bool
-
-	// RegexForcedByRewrite is true when RegexLocationForHost is true specifically
-	// because of the nginx.ingress.kubernetes.io/rewrite-target annotation.
-	RegexForcedByRewrite bool
-}
-
-// IngressNginxPolicyIndex identifies a (rule, backend) pair within a merged HTTPRoute.
-type IngressNginxPolicyIndex struct {
+// PolicyIndex identifies a (rule, backend) pair within a merged HTTPRoute.
+type PolicyIndex struct {
 	Rule    int
 	Backend int
 }
 
-// IngressNginxCorsPolicy defines a CORS policy extracted from ingress-nginx annotations.
-type IngressNginxCorsPolicy struct {
+// CorsPolicy defines a CORS policy extracted from annotations.
+type CorsPolicy struct {
 	Enable           bool
 	AllowOrigin      []string
 	AllowCredentials *bool
@@ -145,20 +132,20 @@ type IngressNginxCorsPolicy struct {
 	MaxAge           *int32
 }
 
-// IngressNginxExtAuthPolicy defines an external auth policy extracted from ingress-nginx annotations.
-type IngressNginxExtAuthPolicy struct {
+// ExtAuthPolicy defines an external auth policy extracted from annotations.
+type ExtAuthPolicy struct {
 	AuthURL         string
 	ResponseHeaders []string
 }
 
-// IngressNginxBasicAuthPolicy defines a basic auth policy extracted from ingress-nginx annotations.
-type IngressNginxBasicAuthPolicy struct {
+// BasicAuthPolicy defines a basic auth policy extracted from annotations.
+type BasicAuthPolicy struct {
 	SecretName string
 	AuthType   string
 }
 
-// IngressNginxSessionAffinityPolicy defines a session affinity policy extracted from ingress-nginx annotations.
-type IngressNginxSessionAffinityPolicy struct {
+// SessionAffinityPolicy defines a session affinity policy extracted from annotations.
+type SessionAffinityPolicy struct {
 	CookieName     string
 	CookiePath     string
 	CookieDomain   string
@@ -167,99 +154,99 @@ type IngressNginxSessionAffinityPolicy struct {
 	CookieSecure   *bool
 }
 
-// IngressNginxBackendTLSPolicy defines a backend TLS policy extracted from ingress-nginx annotations.
-type IngressNginxBackendTLSPolicy struct {
+// BackendTLSPolicy defines a backend TLS policy extracted from annotations.
+type BackendTLSPolicy struct {
 	SecretName string
 	Verify     bool
 	Hostname   string
 }
 
-// IngressNginxPolicy describes per-Ingress policy knobs projected from ingress-nginx.
-type IngressNginxPolicy struct {
+// Policy describes per-Ingress policy knobs projected by providers.
+type Policy struct {
 	ClientBodyBufferSize *resource.Quantity
 	ProxyBodySize        *resource.Quantity
-	Cors                 *IngressNginxCorsPolicy
-	RateLimit            *IngressNginxRateLimitPolicy
+	Cors                 *CorsPolicy
+	RateLimit            *RateLimitPolicy
 	ProxySendTimeout     *metav1.Duration
 	ProxyReadTimeout     *metav1.Duration
 	ProxyConnectTimeout  *metav1.Duration
 	EnableAccessLog      *bool
-	ExtAuth              *IngressNginxExtAuthPolicy
-	BasicAuth            *IngressNginxBasicAuthPolicy
-	SessionAffinity      *IngressNginxSessionAffinityPolicy
-	LoadBalancing        *IngressNginxBackendLoadBalancingPolicy
-	BackendTLS           *IngressNginxBackendTLSPolicy
-	BackendProtocol      *IngressNginxBackendProtocol
+	ExtAuth              *ExtAuthPolicy
+	BasicAuth            *BasicAuthPolicy
+	SessionAffinity      *SessionAffinityPolicy
+	LoadBalancing        *BackendLoadBalancingPolicy
+	BackendTLS           *BackendTLSPolicy
+	BackendProtocol      *BackendProtocol
 	SSLRedirect          *bool
 	RewriteTarget        *string
 	UseRegexPaths        *bool
 
 	// RuleBackendSources lists covered (rule, backend) pairs in the merged HTTPRoute.
-	RuleBackendSources []IngressNginxPolicyIndex
+	RuleBackendSources []PolicyIndex
 
 	// Backends holds all proxied backends that cannot be rendered as a standard k8s service.
-	Backends map[types.NamespacedName]IngressNginxBackend
+	Backends map[types.NamespacedName]Backend
 
 	// ruleBackendIndexSet is an internal helper used to deduplicate RuleBackendSources entries.
-	ruleBackendIndexSet map[IngressNginxPolicyIndex]struct{}
+	ruleBackendIndexSet map[PolicyIndex]struct{}
 }
 
-// IngressNginxBackendProtocol defines the L7 protocol used to talk to a Backend.
-type IngressNginxBackendProtocol string
+// BackendProtocol defines the L7 protocol used to talk to a Backend.
+type BackendProtocol string
 
-// IngressNginxBackendProtocolGRPC is the gRPC protocol.
-const IngressNginxBackendProtocolGRPC IngressNginxBackendProtocol = "grpc"
+// BackendProtocolGRPC is the gRPC protocol.
+const BackendProtocolGRPC BackendProtocol = "grpc"
 
-// IngressNginxBackend defines a proxied backend that cannot be rendered as a standard k8s Service.
-type IngressNginxBackend struct {
+// Backend defines a proxied backend that cannot be rendered as a standard k8s Service.
+type Backend struct {
 	Namespace string
 	Name      string
 	Port      int32
 	Host      string
-	Protocol  *IngressNginxBackendProtocol
+	Protocol  *BackendProtocol
 }
 
-// IngressNginxRateLimitUnit defines the unit of rate limiting.
-type IngressNginxRateLimitUnit string
+// RateLimitUnit defines the unit of rate limiting.
+type RateLimitUnit string
 
 const (
-	// IngressNginxRateLimitUnitRPS defines rate limit in requests per second.
-	IngressNginxRateLimitUnitRPS IngressNginxRateLimitUnit = "rps"
-	// IngressNginxRateLimitUnitRPM defines rate limit in requests per minute.
-	IngressNginxRateLimitUnitRPM IngressNginxRateLimitUnit = "rpm"
+	// RateLimitUnitRPS defines rate limit in requests per second.
+	RateLimitUnitRPS RateLimitUnit = "rps"
+	// RateLimitUnitRPM defines rate limit in requests per minute.
+	RateLimitUnitRPM RateLimitUnit = "rpm"
 )
 
-// IngressNginxRateLimitPolicy defines a rate limiting policy derived from ingress-nginx annotations.
-type IngressNginxRateLimitPolicy struct {
+// RateLimitPolicy defines a rate limiting policy derived from annotations.
+type RateLimitPolicy struct {
 	Limit           int32
-	Unit            IngressNginxRateLimitUnit
+	Unit            RateLimitUnit
 	BurstMultiplier int32
 }
 
-// IngressNginxLoadBalancingStrategy represents upstream load-balancing mode.
-type IngressNginxLoadBalancingStrategy string
+// LoadBalancingStrategy represents upstream load-balancing mode.
+type LoadBalancingStrategy string
 
-// IngressNginxLoadBalancingStrategyRoundRobin is the supported round_robin strategy.
-const IngressNginxLoadBalancingStrategyRoundRobin IngressNginxLoadBalancingStrategy = "round_robin"
+// LoadBalancingStrategyRoundRobin is the supported round_robin strategy.
+const LoadBalancingStrategyRoundRobin LoadBalancingStrategy = "round_robin"
 
-// IngressNginxBackendLoadBalancingPolicy defines backend load-balancing policy.
-type IngressNginxBackendLoadBalancingPolicy struct {
-	Strategy IngressNginxLoadBalancingStrategy
+// BackendLoadBalancingPolicy defines backend load-balancing policy.
+type BackendLoadBalancingPolicy struct {
+	Strategy LoadBalancingStrategy
 }
 
 // AddRuleBackendSources returns a copy of p with idxs added to RuleBackendSources,
 // ensuring each (rule, backend) pair is unique.
-func (p IngressNginxPolicy) AddRuleBackendSources(idxs []IngressNginxPolicyIndex) IngressNginxPolicy {
+func (p Policy) AddRuleBackendSources(idxs []PolicyIndex) Policy {
 	pCopy := p
 
 	if len(pCopy.RuleBackendSources) > 0 && pCopy.ruleBackendIndexSet == nil {
-		pCopy.ruleBackendIndexSet = make(map[IngressNginxPolicyIndex]struct{}, len(pCopy.RuleBackendSources))
+		pCopy.ruleBackendIndexSet = make(map[PolicyIndex]struct{}, len(pCopy.RuleBackendSources))
 		for _, existing := range pCopy.RuleBackendSources {
 			pCopy.ruleBackendIndexSet[existing] = struct{}{}
 		}
 	}
 	if pCopy.ruleBackendIndexSet == nil {
-		pCopy.ruleBackendIndexSet = make(map[IngressNginxPolicyIndex]struct{})
+		pCopy.ruleBackendIndexSet = make(map[PolicyIndex]struct{})
 	}
 
 	for _, idx := range idxs {
@@ -273,38 +260,38 @@ func (p IngressNginxPolicy) AddRuleBackendSources(idxs []IngressNginxPolicyIndex
 	return pCopy
 }
 
-// Type aliases for emitter code ergonomics.
+// Backward-compatibility aliases for older ingress-nginx-prefixed names.
 
-type Policy = IngressNginxPolicy
+type IngressNginxPolicy = Policy
 
-type PolicyIndex = IngressNginxPolicyIndex
+type IngressNginxPolicyIndex = PolicyIndex
 
-type CorsPolicy = IngressNginxCorsPolicy
+type IngressNginxCorsPolicy = CorsPolicy
 
-type ExtAuthPolicy = IngressNginxExtAuthPolicy
+type IngressNginxExtAuthPolicy = ExtAuthPolicy
 
-type BasicAuthPolicy = IngressNginxBasicAuthPolicy
+type IngressNginxBasicAuthPolicy = BasicAuthPolicy
 
-type SessionAffinityPolicy = IngressNginxSessionAffinityPolicy
+type IngressNginxSessionAffinityPolicy = SessionAffinityPolicy
 
-type BackendTLSPolicy = IngressNginxBackendTLSPolicy
+type IngressNginxBackendTLSPolicy = BackendTLSPolicy
 
-type BackendProtocol = IngressNginxBackendProtocol
+type IngressNginxBackendProtocol = BackendProtocol
 
-const BackendProtocolGRPC = IngressNginxBackendProtocolGRPC
+const IngressNginxBackendProtocolGRPC = BackendProtocolGRPC
 
-type Backend = IngressNginxBackend
+type IngressNginxBackend = Backend
 
-type RateLimitUnit = IngressNginxRateLimitUnit
+type IngressNginxRateLimitUnit = RateLimitUnit
 
-const RateLimitUnitRPS = IngressNginxRateLimitUnitRPS
+const IngressNginxRateLimitUnitRPS = RateLimitUnitRPS
 
-const RateLimitUnitRPM = IngressNginxRateLimitUnitRPM
+const IngressNginxRateLimitUnitRPM = RateLimitUnitRPM
 
-type RateLimitPolicy = IngressNginxRateLimitPolicy
+type IngressNginxRateLimitPolicy = RateLimitPolicy
 
-type LoadBalancingStrategy = IngressNginxLoadBalancingStrategy
+type IngressNginxLoadBalancingStrategy = LoadBalancingStrategy
 
-const LoadBalancingStrategyRoundRobin = IngressNginxLoadBalancingStrategyRoundRobin
+const IngressNginxLoadBalancingStrategyRoundRobin = LoadBalancingStrategyRoundRobin
 
-type BackendLoadBalancingPolicy = IngressNginxBackendLoadBalancingPolicy
+type IngressNginxBackendLoadBalancingPolicy = BackendLoadBalancingPolicy

pkg/i2gw/emitters/agentgateway/emitter.go

@@ -75,23 +75,22 @@ func (e *Emitter) Emit(ir emitterir.EmitterIR) (i2gw.GatewayResources, field.Err
 	basicAuthSecretSeen := map[basicAuthSecretKey]struct{}{}
 
 	for httpRouteKey, httpRouteContext := range ir.HTTPRoutes {
-		ingx := httpRouteContext.IngressNginx
-		if ingx == nil {
+		if len(httpRouteContext.PoliciesBySourceIngressName) == 0 {
 			continue
 		}
 
 		// Apply host-wide regex enforcement first (so rule path regex is finalized)
 		// TODO: implement regex path matching if needed
 
 		// deterministic policy iteration
-		policyNames := make([]string, 0, len(ingx.Policies))
-		for name := range ingx.Policies {
+		policyNames := make([]string, 0, len(httpRouteContext.PoliciesBySourceIngressName))
+		for name := range httpRouteContext.PoliciesBySourceIngressName {
 			policyNames = append(policyNames, name)
 		}
 		sort.Strings(policyNames)
 
 		for _, polSourceIngressName := range policyNames {
-			pol := ingx.Policies[polSourceIngressName]
+			pol := httpRouteContext.PoliciesBySourceIngressName[polSourceIngressName]
 
 			// Normalize (rule, backend) coverage to unique pairs to avoid
 			// generating duplicate filters on the same backendRef.

pkg/i2gw/emitters/agentgateway/ssl_redirect.go

@@ -32,7 +32,7 @@ import (
 // Semantics:
 //   - If SSLRedirect is enabled, mark the HTTPRoute for later splitting
 //   - Returns true if SSL redirect is enabled for this policy
-func applySSLRedirectPolicy(pol emitterir.IngressNginxPolicy) bool {
+func applySSLRedirectPolicy(pol emitterir.Policy) bool {
 	if pol.SSLRedirect == nil || !*pol.SSLRedirect {
 		return false
 	}
@@ -83,9 +83,12 @@ func splitHTTPRouteForSSLRedirect(
 
 	// Create HTTP redirect route
 	httpRedirectRoute := emitterir.HTTPRouteContext{
-		HTTPRoute:          *httpRouteContext.HTTPRoute.DeepCopy(),
-		IngressNginx:       httpRouteContext.IngressNginx,
-		RuleBackendSources: httpRouteContext.RuleBackendSources,
+		HTTPRoute:                   *httpRouteContext.HTTPRoute.DeepCopy(),
+		PoliciesBySourceIngressName: httpRouteContext.PoliciesBySourceIngressName,
+		RegexLocationForHost:        httpRouteContext.RegexLocationForHost,
+		RegexForcedByUseRegex:       httpRouteContext.RegexForcedByUseRegex,
+		RegexForcedByRewrite:        httpRouteContext.RegexForcedByRewrite,
+		RuleBackendSources:          httpRouteContext.RuleBackendSources,
 	}
 	httpRedirectRoute.ObjectMeta.Name = fmt.Sprintf("%s-http-redirect", httpRouteKey.Name)
 	httpRedirectRoute.ObjectMeta.Namespace = httpRouteKey.Namespace
@@ -125,9 +128,12 @@ func splitHTTPRouteForSSLRedirect(
 	var httpsBackendRoute *emitterir.HTTPRouteContext
 	if httpsListenerName != nil {
 		route := emitterir.HTTPRouteContext{
-			HTTPRoute:          *httpRouteContext.HTTPRoute.DeepCopy(),
-			IngressNginx:       httpRouteContext.IngressNginx,
-			RuleBackendSources: httpRouteContext.RuleBackendSources,
+			HTTPRoute:                   *httpRouteContext.HTTPRoute.DeepCopy(),
+			PoliciesBySourceIngressName: httpRouteContext.PoliciesBySourceIngressName,
+			RegexLocationForHost:        httpRouteContext.RegexLocationForHost,
+			RegexForcedByUseRegex:       httpRouteContext.RegexForcedByUseRegex,
+			RegexForcedByRewrite:        httpRouteContext.RegexForcedByRewrite,
+			RuleBackendSources:          httpRouteContext.RuleBackendSources,
 		}
 		route.ObjectMeta.Name = fmt.Sprintf("%s-https", httpRouteKey.Name)
 		route.ObjectMeta.Namespace = httpRouteKey.Namespace

pkg/i2gw/emitters/kgateway/emitter.go

@@ -86,8 +86,7 @@ func (e *Emitter) Emit(ir emitterir.EmitterIR) (i2gw.GatewayResources, field.Err
 	routesToSplitForSSLRedirect := map[types.NamespacedName]bool{}
 
 	for httpRouteKey, httpRouteContext := range ir.HTTPRoutes {
-		ingx := httpRouteContext.IngressNginx
-		if ingx == nil {
+		if len(httpRouteContext.PoliciesBySourceIngressName) == 0 {
 			continue
 		}
 
@@ -98,22 +97,23 @@ func (e *Emitter) Emit(ir emitterir.EmitterIR) (i2gw.GatewayResources, field.Err
 		tp := map[string]*kgateway.TrafficPolicy{}
 
 		// Apply host-wide regex enforcement first (so rule path regex is finalized)
-		applyRegexPathMatchingForHost(ingx, &httpRouteContext)
+		applyRegexPathMatchingForHost(&httpRouteContext)
 
 		// deterministic policy iteration
-		policyNames := make([]string, 0, len(ingx.Policies))
-		for name := range ingx.Policies {
+		policyNames := make([]string, 0, len(httpRouteContext.PoliciesBySourceIngressName))
+		for name := range httpRouteContext.PoliciesBySourceIngressName {
 			policyNames = append(policyNames, name)
 		}
 		sort.Strings(policyNames)
 
 		// Rewrite-target pass: creates per-rule TPs and attaches filters itself.
 		for _, name := range policyNames {
-			pol := ingx.Policies[name]
+			pol := httpRouteContext.PoliciesBySourceIngressName[name]
 			applyRewriteTargetPolicies(pol, name, httpRouteKey.Namespace, &httpRouteContext, tp)
 		}
 
-		for polSourceIngressName, pol := range ingx.Policies {
+		for _, polSourceIngressName := range policyNames {
+			pol := httpRouteContext.PoliciesBySourceIngressName[polSourceIngressName]
 			// Normalize (rule, backend) coverage to unique pairs to avoid
 			// generating duplicate filters on the same backendRef.
 			coverage := uniquePolicyIndices(pol.RuleBackendSources)