feat(mnq/sqs): support for dead_letter_queue

Author: jremy42

internal/services/mnq/helpers_mnq.go

@@ -1,6 +1,7 @@
 package mnq
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strconv"
@@ -172,17 +173,14 @@ func ComposeSNSARN(region scw.Region, projectID string, resourceName string) str
 	return composeARN("sns", region, projectID, resourceName)
 }
 
-// Set the value inside values at the resource path (e.g. a.0.b sets b's value)
 func setResourceValue(values map[string]any, resourcePath string, value any, resourceSchemas map[string]*schema.Schema) {
 	parts := strings.Split(resourcePath, ".")
 	if len(parts) > 1 {
-		// Terraform's nested objects are represented as slices of maps
 		if _, ok := values[parts[0]]; !ok {
 			values[parts[0]] = []any{make(map[string]any)}
 		}
 
 		setResourceValue(values[parts[0]].([]any)[0].(map[string]any), strings.Join(parts[2:], "."), value, resourceSchemas[parts[0]].Elem.(*schema.Resource).Schema)
-
 		return
 	}
 
@@ -224,6 +222,60 @@ func awsResourceDataToAttribute(awsAttributes map[string]string, awsAttribute st
 		s = strconv.Itoa(resourceValue.(int))
 	case schema.TypeString:
 		s = resourceValue.(string)
+	case schema.TypeList:
+		// Handle dead-letter queue configuration
+		if resourcePath == "dead_letter_queue" {
+			deadLetterConfig := resourceValue.([]interface{})
+			if len(deadLetterConfig) > 0 {
+				config := deadLetterConfig[0].(map[string]interface{})
+				queueID := config["id"].(string)
+				maxReceiveCount := config["max_receive_count"].(int)
+
+				// Build AWS-compatible ARN for SQS
+				// The queueID can be either:
+				// 1. A Terraform ID in format: region/project-id/queue-name
+				// 2. A Scaleway ARN in format: arn:scw:sqs:region:project-id:queue-name
+
+				var scwARN string
+
+				switch {
+				case strings.HasPrefix(queueID, "arn:scw:sqs:"):
+					// Already a Scaleway ARN, use it directly
+					scwARN = queueID
+				case strings.Contains(queueID, "/"):
+					// Parse Terraform ID format: region/project-id/queue-name
+					parts := strings.Split(queueID, "/")
+					if len(parts) == 3 {
+						region := parts[0]
+						projectID := parts[1]
+						queueName := parts[2]
+
+						// Build Scaleway ARN: arn:scw:sqs:region:project-id:queue-name
+						scwARN = fmt.Sprintf("arn:scw:sqs:%s:project-%s:%s", region, projectID, queueName)
+					} else {
+						return fmt.Errorf("invalid queue ID format for dead-letter queue: %s (expected region/project-id/queue-name or arn:scw:sqs:region:project-id:queue-name)", queueID)
+					}
+				default:
+					// Assume it's already a valid ARN or queue identifier
+					scwARN = queueID
+				}
+
+				// Create RedrivePolicy JSON
+				redrivePolicy := map[string]interface{}{
+					"deadLetterTargetArn": scwARN,
+					"maxReceiveCount":     maxReceiveCount,
+				}
+
+				jsonData, err := json.Marshal(redrivePolicy)
+				if err != nil {
+					return fmt.Errorf("failed to marshal redrive policy: %w", err)
+				}
+
+				s = string(jsonData)
+			}
+		} else {
+			return fmt.Errorf("unsupported list type for %s", resourcePath)
+		}
 	default:
 		return fmt.Errorf("unsupported type %s for %s", resourceSchema.Type, resourcePath)
 	}
@@ -265,14 +317,47 @@ func awsAttributeToResourceData(values map[string]any, value string, resourcePat
 		setResourceValue(values, resourcePath, i, resourceSchemas)
 	case schema.TypeString:
 		setResourceValue(values, resourcePath, value, resourceSchemas)
+	case schema.TypeList:
+		if resourcePath == "dead_letter_queue" && value != "" {
+			var redrivePolicy map[string]interface{}
+			if err := json.Unmarshal([]byte(value), &redrivePolicy); err != nil {
+				return fmt.Errorf("failed to unmarshal redrive policy: %w", err)
+			}
+
+			deadLetterTargetArn := redrivePolicy["deadLetterTargetArn"].(string)
+
+			var terraformID string
+
+			if strings.HasPrefix(deadLetterTargetArn, "arn:scw:sqs:") {
+				parts := strings.Split(deadLetterTargetArn, ":")
+				if len(parts) >= 6 {
+					region := parts[3]
+					projectID := strings.TrimPrefix(parts[4], "project-")
+					queueName := parts[5]
+					terraformID = fmt.Sprintf("%s/%s/%s", region, projectID, queueName)
+				} else {
+					terraformID = deadLetterTargetArn
+				}
+			} else {
+				terraformID = deadLetterTargetArn
+			}
+
+			deadLetterConfig := map[string]interface{}{
+				"id":                terraformID,
+				"max_receive_count": int(redrivePolicy["maxReceiveCount"].(float64)),
+			}
+
+			setResourceValue(values, resourcePath, []interface{}{deadLetterConfig}, resourceSchemas)
+		} else {
+			return fmt.Errorf("unsupported list type for %s", resourcePath)
+		}
 	default:
 		return fmt.Errorf("unsupported type %s for %s", resourceSchema.Type, resourcePath)
 	}
 
 	return nil
 }
 
-// awsAttributesToResourceData returns a map of valid values for a terraform schema from an attributes map and a conversion map
 func awsAttributesToResourceData(attributes map[string]string, resourceSchemas map[string]*schema.Schema, attributesToResourceMap map[string]string) (map[string]any, error) {
 	values := make(map[string]any)
 

internal/services/mnq/helpers_mnq_queue.go

@@ -155,6 +155,8 @@ var SQSAttributesToResourceMap = map[string]string{
 	string(awstype.QueueAttributeNameContentBasedDeduplication):     "content_based_deduplication",
 	string(awstype.QueueAttributeNameReceiveMessageWaitTimeSeconds): "receive_wait_time_seconds",
 	string(awstype.QueueAttributeNameVisibilityTimeout):             "visibility_timeout_seconds",
+	string(awstype.QueueAttributeNameRedrivePolicy):                 "dead_letter_queue",
+	string(awstype.QueueAttributeNameQueueArn):                      "arn",
 }
 
 // Returns all managed SQS attribute names
@@ -208,6 +210,31 @@ func resourceMNQQueueCustomizeDiff(_ context.Context, d *schema.ResourceDiff, _
 		return errors.New("content-based deduplication can only be set for FIFO queue")
 	}
 
+	// Validate dead-letter queue configuration
+	if deadLetterConfig, ok := d.GetOk("dead_letter_queue"); ok {
+		deadLetterList := deadLetterConfig.([]interface{})
+		if len(deadLetterList) > 0 {
+			config := deadLetterList[0].(map[string]interface{})
+			queueID := config["id"].(string)
+			maxReceiveCount := config["max_receive_count"].(int)
+
+			// Skip validation if queueID is empty or contains a reference
+			// This means the reference hasn't been resolved yet during planning
+			if queueID == "" || strings.Contains(queueID, "scaleway_mnq_sqs_queue") {
+				// Reference not resolved yet, skip validation
+				return nil
+			}
+
+			if queueID == "" {
+				return errors.New("dead-letter queue ID cannot be empty")
+			}
+
+			if maxReceiveCount < 1 || maxReceiveCount > 1000 {
+				return errors.New("max_receive_count must be between 1 and 1,000")
+			}
+		}
+	}
+
 	if !nameRegex.MatchString(name) {
 		return fmt.Errorf("invalid queue name: %s (format is %s)", name, nameRegex.String())
 	}

internal/services/mnq/sqs_queue.go

@@ -106,6 +106,27 @@ func ResourceSQSQueue() *schema.Resource {
 				ValidateFunc: validation.IntBetween(1024, 262_144),
 				Description:  "The maximum size of a message. Should be in bytes.",
 			},
+			"dead_letter_queue": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				MaxItems:    1,
+				Description: "Configuration for the dead-letter queue",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"id": {
+							Type:        schema.TypeString,
+							Required:    true,
+							Description: "The ID or ARN of the dead-letter queue where messages are sent after the maximum receive count is exceeded.",
+						},
+						"max_receive_count": {
+							Type:         schema.TypeInt,
+							Required:     true,
+							ValidateFunc: validation.IntBetween(1, 1000),
+							Description:  "The number of times a message is delivered to the source queue before being sent to the dead-letter queue. Must be between 1 and 1,000.",
+						},
+					},
+				},
+			},
 			"region":     regional.Schema(),
 			"project_id": account.ProjectIDSchema(),
 
@@ -116,6 +137,11 @@ func ResourceSQSQueue() *schema.Resource {
 				Computed:    true,
 				Description: "The URL of the queue",
 			},
+			"arn": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The ARN of the queue",
+			},
 		},
 		CustomizeDiff: resourceMNQQueueCustomizeDiff,
 		StateUpgraders: []schema.StateUpgrader{

internal/services/mnq/sqs_queue_test.go

@@ -3,6 +3,7 @@ package mnq_test
 import (
 	"context"
 	"fmt"
+	"regexp"
 	"testing"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
@@ -170,6 +171,131 @@ func TestAccSQSQueue_DefaultProject(t *testing.T) {
 	})
 }
 
+func TestAccSQSQueue_DeadLetterQueue(t *testing.T) {
+	tt := acctest.NewTestTools(t)
+	defer tt.Cleanup()
+
+	ctx := t.Context()
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { acctest.PreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      isSQSQueueDestroyed(ctx, tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource scaleway_account_project main {
+						name = "tf_tests_mnq_sqs_queue_dead_letter"
+					}
+
+					resource scaleway_mnq_sqs main {
+						project_id = scaleway_account_project.main.id
+					}
+
+					resource scaleway_mnq_sqs_credentials main {
+						project_id = scaleway_mnq_sqs.main.project_id
+						permissions {
+							can_manage = true
+						}
+					}
+
+					resource scaleway_mnq_sqs_queue dead_letter_queue {
+						project_id = scaleway_mnq_sqs.main.project_id
+						name = "dead-letter-queue"
+						sqs_endpoint = scaleway_mnq_sqs.main.endpoint
+						access_key = scaleway_mnq_sqs_credentials.main.access_key
+						secret_key = scaleway_mnq_sqs_credentials.main.secret_key
+					}
+
+					resource scaleway_mnq_sqs_queue main {
+						project_id = scaleway_mnq_sqs.main.project_id
+						name = "test-mnq-sqs-queue-dead-letter"
+						sqs_endpoint = scaleway_mnq_sqs.main.endpoint
+						access_key = scaleway_mnq_sqs_credentials.main.access_key
+						secret_key = scaleway_mnq_sqs_credentials.main.secret_key
+
+						dead_letter_queue {
+							id = scaleway_mnq_sqs_queue.dead_letter_queue.id
+							max_receive_count = 3
+						}
+
+						depends_on = [scaleway_mnq_sqs_queue.dead_letter_queue]
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					isSQSQueuePresent(ctx, tt, "scaleway_mnq_sqs_queue.main"),
+					isSQSQueuePresent(ctx, tt, "scaleway_mnq_sqs_queue.dead_letter_queue"),
+					acctest.CheckResourceAttrUUID("scaleway_mnq_sqs_queue.main", "id"),
+					acctest.CheckResourceAttrUUID("scaleway_mnq_sqs_queue.dead_letter_queue", "id"),
+					resource.TestCheckResourceAttr("scaleway_mnq_sqs_queue.main", "name", "test-mnq-sqs-queue-dead-letter"),
+					resource.TestCheckResourceAttr("scaleway_mnq_sqs_queue.dead_letter_queue", "name", "dead-letter-queue"),
+					resource.TestCheckResourceAttr("scaleway_mnq_sqs_queue.main", "dead_letter_queue.0.max_receive_count", "3"),
+					// Test that ARN is computed and follows expected format
+					resource.TestCheckResourceAttrSet("scaleway_mnq_sqs_queue.main", "arn"),
+					resource.TestCheckResourceAttrSet("scaleway_mnq_sqs_queue.dead_letter_queue", "arn"),
+					resource.TestMatchResourceAttr("scaleway_mnq_sqs_queue.main", "arn", regexp.MustCompile(`^arn:scw:sqs:.*:.*:.*$`)),
+					resource.TestMatchResourceAttr("scaleway_mnq_sqs_queue.dead_letter_queue", "arn", regexp.MustCompile(`^arn:scw:sqs:.*:.*:.*$`)),
+				),
+			},
+			{
+				Config: `
+					resource scaleway_account_project main {
+						name = "tf_tests_mnq_sqs_queue_dead_letter"
+					}
+
+					resource scaleway_mnq_sqs main {
+						project_id = scaleway_account_project.main.id
+					}
+
+					resource scaleway_mnq_sqs_credentials main {
+						project_id = scaleway_mnq_sqs.main.project_id
+						permissions {
+							can_manage = true
+						}
+					}
+
+					resource scaleway_mnq_sqs_queue dead_letter_queue {
+						project_id = scaleway_mnq_sqs.main.project_id
+						name = "dead-letter-queue"
+						sqs_endpoint = scaleway_mnq_sqs.main.endpoint
+						access_key = scaleway_mnq_sqs_credentials.main.access_key
+						secret_key = scaleway_mnq_sqs_credentials.main.secret_key
+					}
+
+					resource scaleway_mnq_sqs_queue main {
+						project_id = scaleway_mnq_sqs.main.project_id
+						name = "test-mnq-sqs-queue-dead-letter"
+						sqs_endpoint = scaleway_mnq_sqs.main.endpoint
+						access_key = scaleway_mnq_sqs_credentials.main.access_key
+						secret_key = scaleway_mnq_sqs_credentials.main.secret_key
+
+						dead_letter_queue {
+							id = scaleway_mnq_sqs_queue.dead_letter_queue.id
+							max_receive_count = 5
+						}
+
+						depends_on = [scaleway_mnq_sqs_queue.dead_letter_queue]
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					isSQSQueuePresent(ctx, tt, "scaleway_mnq_sqs_queue.main"),
+					isSQSQueuePresent(ctx, tt, "scaleway_mnq_sqs_queue.dead_letter_queue"),
+					acctest.CheckResourceAttrUUID("scaleway_mnq_sqs_queue.main", "id"),
+					acctest.CheckResourceAttrUUID("scaleway_mnq_sqs_queue.dead_letter_queue", "id"),
+					resource.TestCheckResourceAttr("scaleway_mnq_sqs_queue.main", "name", "test-mnq-sqs-queue-dead-letter"),
+					resource.TestCheckResourceAttr("scaleway_mnq_sqs_queue.dead_letter_queue", "name", "dead-letter-queue"),
+					resource.TestCheckResourceAttr("scaleway_mnq_sqs_queue.main", "dead_letter_queue.0.max_receive_count", "5"),
+					// Test that ARN is computed and follows expected format
+					resource.TestCheckResourceAttrSet("scaleway_mnq_sqs_queue.main", "arn"),
+					resource.TestCheckResourceAttrSet("scaleway_mnq_sqs_queue.dead_letter_queue", "arn"),
+					resource.TestMatchResourceAttr("scaleway_mnq_sqs_queue.main", "arn", regexp.MustCompile(`^arn:scw:sqs:.*:.*:.*$`)),
+					resource.TestMatchResourceAttr("scaleway_mnq_sqs_queue.dead_letter_queue", "arn", regexp.MustCompile(`^arn:scw:sqs:.*:.*:.*$`)),
+				),
+			},
+		},
+	})
+}
+
 func isSQSQueuePresent(ctx context.Context, tt *acctest.TestTools, n string) resource.TestCheckFunc {
 	return func(state *terraform.State) error {
 		rs, ok := state.RootModule().Resources[n]