[Enhancement] aws_lb_listener_rule: Add transform configuration block

.changelog/44702.txt

@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_lb_listener_rule: Add `transform` configuration block
+```
+
+```release-note:enhancement
+data-source/aws_lb_listener_rule: Add `transform` attribute
+```

internal/service/elbv2/listener_rule.go

@@ -486,6 +486,40 @@ func resourceListenerRule() *schema.Resource {
 			},
 			names.AttrTags:    tftags.TagsSchema(),
 			names.AttrTagsAll: tftags.TagsSchemaComputed(),
+			"transform": {
+				Type:     schema.TypeSet,
+				Optional: true,
+				MaxItems: 2,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						names.AttrType: {
+							Type:             schema.TypeString,
+							Required:         true,
+							ValidateDiagFunc: enum.Validate[awstypes.TransformTypeEnum](),
+						},
+						"host_header_rewrite_config": {
+							Type:     schema.TypeList,
+							Optional: true,
+							MaxItems: 1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"rewrite": transformRewriteConfigSchema(),
+								},
+							},
+						},
+						"url_rewrite_config": {
+							Type:     schema.TypeList,
+							Optional: true,
+							MaxItems: 1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"rewrite": transformRewriteConfigSchema(),
+								},
+							},
+						},
+					},
+				},
+			},
 		},
 
 		CustomizeDiff: customdiff.All(
@@ -494,6 +528,28 @@ func resourceListenerRule() *schema.Resource {
 	}
 }
 
+func transformRewriteConfigSchema() *schema.Schema {
+	return &schema.Schema{
+		Type:     schema.TypeList,
+		Optional: true,
+		MaxItems: 1, // This argument is an array, but the current AWS API accepts exactly only one `rewrite`
+		Elem: &schema.Resource{
+			Schema: map[string]*schema.Schema{
+				"regex": {
+					Type:         schema.TypeString,
+					Required:     true,
+					ValidateFunc: validation.StringLenBetween(1, 1024),
+				},
+				"replace": {
+					Type:         schema.TypeString,
+					Required:     true,
+					ValidateFunc: validation.StringLenBetween(0, 1024),
+				},
+			},
+		},
+	}
+}
+
 func suppressIfActionTypeNot(t awstypes.ActionTypeEnum) schema.SchemaDiffSuppressFunc {
 	return func(k, old, new string, d *schema.ResourceData) bool {
 		take := 2
@@ -531,6 +587,10 @@ func resourceListenerRuleCreate(ctx context.Context, d *schema.ResourceData, met
 		return sdkdiag.AppendFromErr(diags, err)
 	}
 
+	if v, ok := d.GetOk("transform"); ok && len(v.(*schema.Set).List()) > 0 {
+		input.Transforms = expandRuleTransforms(v.(*schema.Set).List())
+	}
+
 	output, err := retryListenerRuleCreate(ctx, conn, d, input, listenerARN)
 
 	// Some partitions (e.g. ISO) may not support tag-on-create.
@@ -648,6 +708,10 @@ func resourceListenerRuleRead(ctx context.Context, d *schema.ResourceData, meta
 		return sdkdiag.AppendErrorf(diags, "setting condition: %s", err)
 	}
 
+	if err := d.Set("transform", flattenRuleTransforms(rule.Transforms)); err != nil {
+		return sdkdiag.AppendErrorf(diags, "setting transform: %s", err)
+	}
+
 	return diags
 }
 
@@ -695,6 +759,15 @@ func resourceListenerRuleUpdate(ctx context.Context, d *schema.ResourceData, met
 			requestUpdate = true
 		}
 
+		if d.HasChange("transform") {
+			if v, ok := d.GetOk("transform"); ok && len(v.(*schema.Set).List()) > 0 {
+				input.Transforms = expandRuleTransforms(d.Get("transform").(*schema.Set).List())
+			} else {
+				input.ResetTransforms = aws.Bool(true)
+			}
+			requestUpdate = true
+		}
+
 		if requestUpdate {
 			resp, err := conn.ModifyRule(ctx, input)
 			if err != nil {
@@ -993,6 +1066,74 @@ func expandPathPatternConditionConfig(tfMap map[string]any) *awstypes.PathPatter
 	return apiObject
 }
 
+func expandRuleTransforms(tfList []any) []awstypes.RuleTransform {
+	var apiObjects []awstypes.RuleTransform
+
+	for _, tfMapRaw := range tfList {
+		if tfMapRaw == nil {
+			continue
+		}
+		tfMap := tfMapRaw.(map[string]any)
+		apiObject := awstypes.RuleTransform{}
+
+		if v, ok := tfMap[names.AttrType]; ok && v.(string) != "" {
+			apiObject.Type = awstypes.TransformTypeEnum(v.(string))
+		}
+		if v, ok := tfMap["host_header_rewrite_config"].([]any); ok && len(v) > 0 {
+			apiObject.HostHeaderRewriteConfig = expandHostHeaderRewriteConfig(v[0].(map[string]any))
+		}
+		if v, ok := tfMap["url_rewrite_config"].([]any); ok && len(v) > 0 {
+			apiObject.UrlRewriteConfig = expandURLRewriteConfig(v[0].(map[string]any))
+		}
+		apiObjects = append(apiObjects, apiObject)
+	}
+	return apiObjects
+}
+
+func expandHostHeaderRewriteConfig(tfMap map[string]any) *awstypes.HostHeaderRewriteConfig {
+	if tfMap == nil {
+		return &awstypes.HostHeaderRewriteConfig{}
+	}
+
+	apiObject := &awstypes.HostHeaderRewriteConfig{}
+	if v, ok := tfMap["rewrite"].([]any); ok && len(v) > 0 {
+		apiObject.Rewrites = expandRewriteConfig(v)
+	}
+	return apiObject
+}
+
+func expandURLRewriteConfig(tfMap map[string]any) *awstypes.UrlRewriteConfig {
+	if tfMap == nil {
+		return &awstypes.UrlRewriteConfig{}
+	}
+
+	apiObject := &awstypes.UrlRewriteConfig{}
+	if v, ok := tfMap["rewrite"].([]any); ok && len(v) > 0 {
+		apiObject.Rewrites = expandRewriteConfig(v)
+	}
+	return apiObject
+}
+
+func expandRewriteConfig(tfList []any) []awstypes.RewriteConfig {
+	if len(tfList) == 0 {
+		return nil
+	}
+	var apiObjects []awstypes.RewriteConfig
+
+	for _, tfMapRaw := range tfList {
+		if tfMapRaw == nil {
+			continue
+		}
+		tfMap := tfMapRaw.(map[string]any)
+		apiObject := awstypes.RewriteConfig{
+			Regex:   aws.String(tfMap["regex"].(string)),
+			Replace: aws.String(tfMap["replace"].(string)),
+		}
+		apiObjects = append(apiObjects, apiObject)
+	}
+	return apiObjects
+}
+
 func flattenHostHeaderConditionConfig(apiObject *awstypes.HostHeaderConditionConfig) map[string]any {
 	if apiObject == nil {
 		return nil
@@ -1039,3 +1180,66 @@ func flattenPathPatternConditionConfig(apiObject *awstypes.PathPatternConditionC
 	}
 	return tfMap
 }
+
+func flattenRuleTransforms(apiObjects []awstypes.RuleTransform) []any {
+	if len(apiObjects) == 0 {
+		return nil
+	}
+	var tfList []any
+
+	for _, apiObject := range apiObjects {
+		tfMap := make(map[string]any)
+
+		if v := string(apiObject.Type); v != "" {
+			tfMap[names.AttrType] = v
+		}
+		if v := flattenHostHeaderRewriteConfig(apiObject.HostHeaderRewriteConfig); v != nil {
+			tfMap["host_header_rewrite_config"] = []any{v}
+		}
+		if v := flattenURLRewriteConfig(apiObject.UrlRewriteConfig); v != nil {
+			tfMap["url_rewrite_config"] = []any{v}
+		}
+		tfList = append(tfList, tfMap)
+	}
+	return tfList
+}
+
+func flattenHostHeaderRewriteConfig(apiObject *awstypes.HostHeaderRewriteConfig) map[string]any {
+	if apiObject == nil {
+		return nil
+	}
+	tfMap := make(map[string]any)
+
+	if v := flattenRewriteConfig(apiObject.Rewrites); v != nil {
+		tfMap["rewrite"] = v
+	}
+	return tfMap
+}
+
+func flattenURLRewriteConfig(apiObject *awstypes.UrlRewriteConfig) map[string]any {
+	if apiObject == nil {
+		return nil
+	}
+	tfMap := make(map[string]any)
+
+	if v := flattenRewriteConfig(apiObject.Rewrites); v != nil {
+		tfMap["rewrite"] = v
+	}
+	return tfMap
+}
+
+func flattenRewriteConfig(apiObjects []awstypes.RewriteConfig) []any {
+	if len(apiObjects) == 0 {
+		return nil
+	}
+	var tfList []any
+
+	for _, apiObject := range apiObjects {
+		tfMap := map[string]any{
+			"regex":   aws.ToString(apiObject.Regex),
+			"replace": aws.ToString(apiObject.Replace),
+		}
+		tfList = append(tfList, tfMap)
+	}
+	return tfList
+}

internal/service/elbv2/listener_rule_data_source.go

@@ -313,6 +313,50 @@ func (d *listenerRuleDataSource) Schema(ctx context.Context, req datasource.Sche
 					},
 				},
 			},
+			"transform": schema.SetNestedBlock{
+				CustomType: fwtypes.NewSetNestedObjectTypeOf[transformModel](ctx),
+				NestedObject: schema.NestedBlockObject{
+					Attributes: map[string]schema.Attribute{
+						names.AttrType: schema.StringAttribute{
+							Computed: true,
+						},
+					},
+					Blocks: map[string]schema.Block{
+						"host_header_rewrite_config": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[hostHeaderRewriteConfigModel](ctx),
+							NestedObject: schema.NestedBlockObject{
+								Blocks: map[string]schema.Block{
+									"rewrite": transformRewriteConfigDataSourceSchema(ctx),
+								},
+							},
+						},
+						"url_rewrite_config": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[urlRewriteConfigModel](ctx),
+							NestedObject: schema.NestedBlockObject{
+								Blocks: map[string]schema.Block{
+									"rewrite": transformRewriteConfigDataSourceSchema(ctx),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func transformRewriteConfigDataSourceSchema(ctx context.Context) schema.Block {
+	return schema.ListNestedBlock{
+		CustomType: fwtypes.NewListNestedObjectTypeOf[rewriteConfigModel](ctx),
+		NestedObject: schema.NestedBlockObject{
+			Attributes: map[string]schema.Attribute{
+				"regex": schema.StringAttribute{
+					Computed: true,
+				},
+				"replace": schema.StringAttribute{
+					Computed: true,
+				},
+			},
 		},
 	}
 }
@@ -397,6 +441,7 @@ type listenerRuleDataSourceModel struct {
 	ListenerARN fwtypes.ARN                                        `tfsdk:"listener_arn"`
 	Priority    types.Int32                                        `tfsdk:"priority" autoflex:"-"`
 	Tags        tftags.Map                                         `tfsdk:"tags"`
+	Transform   fwtypes.SetNestedObjectValueOf[transformModel]     `tfsdk:"transform"`
 }
 
 // The API includes a TargetGroupArn field at the root level of the Action. This only applies when Type == "forward"
@@ -507,3 +552,22 @@ type queryStringKeyValuePairModel struct {
 type sourceIPConfigModel struct {
 	Values fwtypes.SetValueOf[types.String] `tfsdk:"values"`
 }
+
+type transformModel struct {
+	Type                    types.String                                                  `tfsdk:"type"`
+	HostHeaderRewriteConfig fwtypes.ListNestedObjectValueOf[hostHeaderRewriteConfigModel] `tfsdk:"host_header_rewrite_config"`
+	URLRewriteConfig        fwtypes.ListNestedObjectValueOf[urlRewriteConfigModel]        `tfsdk:"url_rewrite_config"`
+}
+
+type hostHeaderRewriteConfigModel struct {
+	Rewrites fwtypes.ListNestedObjectValueOf[rewriteConfigModel] `tfsdk:"rewrite"`
+}
+
+type urlRewriteConfigModel struct {
+	Rewrites fwtypes.ListNestedObjectValueOf[rewriteConfigModel] `tfsdk:"rewrite"`
+}
+
+type rewriteConfigModel struct {
+	Regex   types.String `tfsdk:"regex"`
+	Replace types.String `tfsdk:"replace"`
+}