feat: Support dynamic blocks in adv2v2 command (#67)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: lantoli

Makefile

@@ -27,6 +27,17 @@ clean: ## Clean binary folders
 test: ## Run unit tests
 	go test ./internal/... -timeout=30s -parallel=4 -race
 
+.PHONY: lint-fix
+lint-fix: ## Fix Go linter issues
+	@echo "==> Fixing linters errors..."
+	$(shell go env GOPATH)/bin/fieldalignment -json -fix ./...
+	golangci-lint run --fix
+
+.PHONY: lint
+lint: ## Check Go linter issues
+	@echo "==> Checking source code against linters..."
+	golangci-lint run
+
 .PHONY: test-update
 test-update: ## Run unit tests and update the golden files
 	go test ./internal/... -timeout=30s -parallel=4 -race -update

README.md

@@ -120,7 +120,6 @@ dynamic "replication_specs" {
 
 ### Limitations
 
-- [`num_shards`](https://registry.terraform.io/providers/mongodb/mongodbatlas/latest/docs/resources/cluster#num_shards-2) in `replication_specs` must be a numeric [literal expression](https://developer.hashicorp.com/nomad/docs/job-specification/hcl2/expressions#literal-expressions), e.g. `var.num_shards` is not supported. This is to allow creating a `replication_specs` element per shard in `mongodbatlas_advanced_cluster`. This limitation doesn't apply if you're using `dynamic` blocks in `regions_config` or `replication_specs`.
 - `dynamic` blocks are supported with some [limitations](./docs/guide_clu2adv_dynamic_block.md).
 
 ## Feedback

internal/convert/adv2v2.go

@@ -11,7 +11,6 @@ import (
 // AdvancedClusterToV2 transforms all mongodbatlas_advanced_cluster resource definitions in a
 // Terraform configuration file from SDKv2 schema to TPF (Terraform Plugin Framework) schema.
 // All other resources and data sources are left untouched.
-// TODO: Not implemented yet.
 func AdvancedClusterToV2(config []byte) ([]byte, error) {
 	parser, err := hcl.GetParser(config)
 	if err != nil {
@@ -37,6 +36,9 @@ func updateResource(resource *hclwrite.Block) (bool, error) {
 		return false, nil
 	}
 	resourceb := resource.Body()
+	if errDyn := checkDynamicBlock(resourceb); errDyn != nil {
+		return false, errDyn
+	}
 	if hasExpectedBlocksAsAttributes(resourceb) {
 		return false, nil
 	}
@@ -58,89 +60,163 @@ func updateResource(resource *hclwrite.Block) (bool, error) {
 }
 
 func convertRepSpecs(resourceb *hclwrite.Body, diskSizeGB hclwrite.Tokens) error {
-	var repSpecs []*hclwrite.Body
-	for {
-		block := resourceb.FirstMatchingBlock(nRepSpecs, nil)
-		if block == nil {
-			break
-		}
-		resourceb.RemoveBlock(block)
+	d, err := convertRepSpecsWithDynamicBlock(resourceb, diskSizeGB)
+	if err != nil {
+		return err
+	}
+	if d.IsPresent() {
+		resourceb.RemoveBlock(d.block)
+		resourceb.SetAttributeRaw(nRepSpecs, d.tokens)
+		return nil
+	}
+	repSpecBlocks := collectBlocks(resourceb, nRepSpecs)
+	if len(repSpecBlocks) == 0 {
+		return fmt.Errorf("must have at least one replication_specs")
+	}
+	hasVariableShards := hasVariableNumShards(repSpecBlocks)
+	var resultTokens []hclwrite.Tokens
+	var resultBodies []*hclwrite.Body
+	for _, block := range repSpecBlocks {
 		blockb := block.Body()
-		numShardsVal := 1 // default to 1 if num_shards not present
-		if numShardsAttr := blockb.GetAttribute(nNumShards); numShardsAttr != nil {
-			var err error
-			if numShardsVal, err = hcl.GetAttrInt(numShardsAttr, errNumShards); err != nil {
-				return err
+		shardsAttr := blockb.GetAttribute(nNumShards)
+		blockb.RemoveAttribute(nNumShards)
+		dConfig, err := getDynamicBlock(blockb, nConfig)
+		if err != nil {
+			return err
+		}
+		if dConfig.IsPresent() {
+			transformReferences(dConfig.content.Body(), getResourceName(dConfig.block), nRegion)
+			copyAttributesSorted(dConfig.content.Body(), dConfig.content.Body().Attributes())
+			processAllSpecs(dConfig.content.Body(), diskSizeGB)
+			tokens := hcl.TokensFromExpr(buildForExpr(nRegion, hcl.GetAttrExpr(dConfig.forEach), false))
+			tokens = append(tokens, hcl.TokensObject(dConfig.content.Body())...)
+			blockb.SetAttributeRaw(nConfig, hcl.EncloseBracketsNewLines(tokens))
+			blockb.RemoveBlock(dConfig.block)
+		} else {
+			var configs []*hclwrite.Body
+			for _, configBlock := range collectBlocks(blockb, nConfig) {
+				configBlockb := configBlock.Body()
+				processAllSpecs(configBlockb, diskSizeGB)
+				configs = append(configs, configBlockb)
 			}
-			blockb.RemoveAttribute(nNumShards)
+			if len(configs) == 0 {
+				return fmt.Errorf("replication_specs must have at least one region_configs")
+			}
+			blockb.SetAttributeRaw(nConfig, hcl.TokensArray(configs))
 		}
-		if err := convertConfig(blockb, diskSizeGB); err != nil {
-			return err
+		if hasVariableShards {
+			resultTokens = append(resultTokens, processNumShardsWhenSomeIsVariable(shardsAttr, blockb))
+			continue
+		}
+		numShardsVal := 1 // Default to 1 if num_shards is not set
+		if shardsAttr != nil {
+			numShardsVal, _ = hcl.GetAttrInt(shardsAttr, errNumShards)
 		}
 		for range numShardsVal {
-			repSpecs = append(repSpecs, blockb)
+			resultBodies = append(resultBodies, blockb)
 		}
 	}
-	if len(repSpecs) == 0 {
-		return fmt.Errorf("must have at least one replication_specs")
+	if hasVariableShards {
+		resourceb.SetAttributeRaw(nRepSpecs, hcl.TokensFuncConcat(resultTokens...))
+	} else {
+		resourceb.SetAttributeRaw(nRepSpecs, hcl.TokensArray(resultBodies))
 	}
-	resourceb.SetAttributeRaw(nRepSpecs, hcl.TokensArray(repSpecs))
 	return nil
 }
 
-func convertConfig(repSpecs *hclwrite.Body, diskSizeGB hclwrite.Tokens) error {
-	var configs []*hclwrite.Body
-	for {
-		block := repSpecs.FirstMatchingBlock(nConfig, nil)
-		if block == nil {
-			break
-		}
-		repSpecs.RemoveBlock(block)
-		blockb := block.Body()
-		fillSpecOpt(blockb, nElectableSpecs, diskSizeGB)
-		fillSpecOpt(blockb, nReadOnlySpecs, diskSizeGB)
-		fillSpecOpt(blockb, nAnalyticsSpecs, diskSizeGB)
-		fillSpecOpt(blockb, nAutoScaling, nil)          // auto_scaling doesn't need disk_size_gb
-		fillSpecOpt(blockb, nAnalyticsAutoScaling, nil) // analytics_auto_scaling doesn't need disk_size_gb
-		configs = append(configs, blockb)
+func convertRepSpecsWithDynamicBlock(resourceb *hclwrite.Body, diskSizeGB hclwrite.Tokens) (dynamicBlock, error) {
+	dSpec, err := getDynamicBlock(resourceb, nRepSpecs)
+	if err != nil || !dSpec.IsPresent() {
+		return dynamicBlock{}, err
 	}
-	if len(configs) == 0 {
-		return fmt.Errorf("replication_specs must have at least one region_configs")
+	transformReferences(dSpec.content.Body(), nRepSpecs, nSpec)
+	dConfig, err := convertConfigsWithDynamicBlock(dSpec.content.Body(), diskSizeGB)
+	if err != nil {
+		return dynamicBlock{}, err
 	}
-	repSpecs.SetAttributeRaw(nConfig, hcl.TokensArray(configs))
-	return nil
+	forSpec := hcl.TokensFromExpr(buildForExpr(nSpec, hcl.GetAttrExpr(dSpec.forEach), true))
+	dSpec.tokens = hcl.TokensFuncFlatten(append(forSpec, dConfig.tokens...))
+	return dSpec, nil
 }
 
-func fillSpecOpt(resourceb *hclwrite.Body, name string, diskSizeGBTokens hclwrite.Tokens) {
-	block := resourceb.FirstMatchingBlock(name, nil)
-	if block == nil {
-		return
+func convertConfigsWithDynamicBlock(specbSrc *hclwrite.Body, diskSizeGB hclwrite.Tokens) (dynamicBlock, error) {
+	d, err := getDynamicBlock(specbSrc, nConfig)
+	if err != nil {
+		return dynamicBlock{}, err
 	}
-	if diskSizeGBTokens != nil {
-		blockb := block.Body()
-		blockb.RemoveAttribute(nDiskSizeGB)
-		blockb.SetAttributeRaw(nDiskSizeGB, diskSizeGBTokens)
+	configBody := d.content.Body()
+	transformReferences(configBody, getResourceName(d.block), nRegion)
+	regionConfigBody := hclwrite.NewEmptyFile().Body()
+	copyAttributesSorted(regionConfigBody, configBody.Attributes())
+	for _, block := range configBody.Blocks() {
+		blockType := block.Type()
+		blockBody := hclwrite.NewEmptyFile().Body()
+		copyAttributesSorted(blockBody, block.Body().Attributes())
+		if diskSizeGB != nil &&
+			(blockType == nElectableSpecs || blockType == nReadOnlySpecs || blockType == nAnalyticsSpecs) {
+			blockBody.SetAttributeRaw(nDiskSizeGB, diskSizeGB)
+		}
+		regionConfigBody.SetAttributeRaw(blockType, hcl.TokensObject(blockBody))
 	}
-	fillBlockOpt(resourceb, name)
+	repSpecb := hclwrite.NewEmptyFile().Body()
+	if zoneNameAttr := specbSrc.GetAttribute(nZoneName); zoneNameAttr != nil {
+		repSpecb.SetAttributeRaw(nZoneName, hcl.TokensFromExpr(
+			transformReference(hcl.GetAttrExpr(zoneNameAttr), nRepSpecs, nSpec)))
+	}
+	regionTokens := hcl.TokensFromExpr(buildForExpr(nRegion, fmt.Sprintf("%s.%s", nSpec, nConfig), false))
+	regionTokens = append(regionTokens, hcl.TokensObject(regionConfigBody)...)
+	repSpecb.SetAttributeRaw(nConfig, hcl.EncloseBracketsNewLines(regionTokens))
+	if numShardsAttr := specbSrc.GetAttribute(nNumShards); numShardsAttr != nil {
+		tokens := hcl.TokensFromExpr(buildForExpr("i",
+			fmt.Sprintf("range(%s)", transformReference(hcl.GetAttrExpr(numShardsAttr), nRepSpecs, nSpec)), false))
+		tokens = append(tokens, hcl.TokensObject(repSpecb)...)
+		return dynamicBlock{tokens: hcl.EncloseBracketsNewLines(tokens)}, nil
+	}
+	return dynamicBlock{tokens: hcl.TokensArraySingle(repSpecb)}, nil
 }
 
 // hasExpectedBlocksAsAttributes checks if any of the expected block names
 // exist as attributes in the resource body. In that case conversion is not done
 // as advanced cluster is not in a valid SDKv2 configuration.
 func hasExpectedBlocksAsAttributes(resourceb *hclwrite.Body) bool {
-	expectedBlocks := []string{
-		nRepSpecs,
-		nTags,
-		nLabels,
-		nAdvConfig,
-		nBiConnector,
-		nPinnedFCV,
-		nTimeouts,
-	}
+	expectedBlocks := []string{nRepSpecs, nTags, nLabels, nAdvConfig, nBiConnector, nPinnedFCV, nTimeouts}
 	for name := range resourceb.Attributes() {
 		if slices.Contains(expectedBlocks, name) {
 			return true
 		}
 	}
 	return false
 }
+
+func copyAttributesSorted(targetBody *hclwrite.Body, sourceAttrs map[string]*hclwrite.Attribute) {
+	var names []string
+	for name := range sourceAttrs {
+		names = append(names, name)
+	}
+	slices.Sort(names)
+	for _, name := range names {
+		expr := hcl.GetAttrExpr(sourceAttrs[name])
+		targetBody.SetAttributeRaw(name, hcl.TokensFromExpr(expr))
+	}
+}
+
+func processAllSpecs(body *hclwrite.Body, diskSizeGB hclwrite.Tokens) {
+	fillSpecOpt(body, nElectableSpecs, diskSizeGB)
+	fillSpecOpt(body, nReadOnlySpecs, diskSizeGB)
+	fillSpecOpt(body, nAnalyticsSpecs, diskSizeGB)
+	fillSpecOpt(body, nAutoScaling, nil)
+	fillSpecOpt(body, nAnalyticsAutoScaling, nil)
+}
+
+func fillSpecOpt(resourceb *hclwrite.Body, name string, diskSizeGBTokens hclwrite.Tokens) {
+	block := resourceb.FirstMatchingBlock(name, nil)
+	if block == nil {
+		return
+	}
+	if diskSizeGBTokens != nil {
+		blockb := block.Body()
+		blockb.RemoveAttribute(nDiskSizeGB)
+		blockb.SetAttributeRaw(nDiskSizeGB, diskSizeGBTokens)
+	}
+	fillBlockOpt(resourceb, name)
+}