fix: redis 8 modules correctly handled by active active databases in state

Author: burythehammer

provider/rediscloud_active_active_database_test.go

@@ -50,8 +50,7 @@ func TestAccResourceRedisCloudActiveActiveDatabase_CRUDI(t *testing.T) {
 					resource.TestCheckResourceAttr(databaseResourceName, "global_alert.#", "1"),
 					resource.TestCheckResourceAttr(databaseResourceName, "global_alert.0.name", "dataset-size"),
 					resource.TestCheckResourceAttr(databaseResourceName, "global_alert.0.value", "1"),
-					resource.TestCheckResourceAttr(databaseResourceName, "global_modules.#", "1"),
-					resource.TestCheckResourceAttr(databaseResourceName, "global_modules.0", "RedisJSON"),
+					resource.TestCheckResourceAttr(databaseResourceName, "global_modules.#", "0"),
 					resource.TestCheckResourceAttr(databaseResourceName, "global_source_ips.#", "2"),
 					resource.TestCheckResourceAttr(databaseResourceName, "global_enable_default_user", "true"),
 
@@ -118,8 +117,7 @@ func TestAccResourceRedisCloudActiveActiveDatabase_CRUDI(t *testing.T) {
 					resource.TestCheckResourceAttrSet(datasourceName, "tls_certificate"),
 
 					resource.TestCheckResourceAttr(datasourceName, "data_eviction", "volatile-lru"),
-					resource.TestCheckResourceAttr(datasourceName, "global_modules.#", "1"),
-					resource.TestCheckResourceAttr(datasourceName, "global_modules.0", "RedisJSON"),
+					resource.TestCheckResourceAttr(datasourceName, "global_modules.#", "0"),
 
 					resource.TestCheckResourceAttr(datasourceName, "tags.deployment_family", "blue"),
 					resource.TestCheckResourceAttr(datasourceName, "tags.priority", "code-2"),

provider/resource_rediscloud_active_active_database.go

@@ -272,6 +272,7 @@ func resourceRedisCloudActiveActiveDatabase() *schema.Resource {
 							Description: "When 'true', enables connecting to the database with the 'default' user. If not specified, the region inherits the value from global_enable_default_user.",
 							Type:        schema.TypeBool,
 							Optional:    true,
+							Computed:    true,
 							DiffSuppressFunc: func(k, old, new string, d *schema.ResourceData) bool {
 								// Smart diff suppression: only suppress when truly inheriting from global
 								// Check both: value matches global AND field not explicitly set in config
@@ -692,10 +693,45 @@ func resourceRedisCloudActiveActiveDatabaseRead(ctx context.Context, d *schema.R
 
 		regionDbConfig["remote_backup"] = pro.FlattenBackupPlan(regionDb.Backup, getStateRemoteBackup(d, region), "")
 
-		// Always include enable_default_user in state (even when inheriting from global)
-		// DiffSuppressFunc will prevent drift when value matches global
+		// Conditionally include enable_default_user in state
+		// Only include if: (1) explicitly set in config, OR (2) differs from global (API override)
+		// DiffSuppressFunc provides additional safety net for edge cases
 		if regionDb.Security.EnableDefaultUser != nil {
-			regionDbConfig["enable_default_user"] = redis.BoolValue(regionDb.Security.EnableDefaultUser)
+			globalValue := d.Get("global_enable_default_user").(bool)
+			regionValue := redis.BoolValue(regionDb.Security.EnableDefaultUser)
+
+			shouldInclude := false
+
+			rawConfig := d.GetRawConfig()
+			if !rawConfig.IsNull() && rawConfig.IsKnown() {
+				// Apply/Update mode: GetRawConfig available - check actual HCL config
+				explicitInConfig := isFieldInConfigForRegion(d, region, "enable_default_user")
+
+				if explicitInConfig {
+					// User explicitly set it in config → always include
+					shouldInclude = true
+				} else if regionValue != globalValue {
+					// Not in config but differs from global → API override exists, include to track it
+					shouldInclude = true
+				}
+				// else: not in config and matches global → inheriting, omit from state
+			} else {
+				// Refresh mode: GetRawConfig is null - check previous state via GetRawState
+				fieldWasInState := isFieldInStateForRegion(d, region, "enable_default_user")
+
+				if fieldWasInState {
+					// Was explicitly tracked before → continue tracking
+					shouldInclude = true
+				} else if regionValue != globalValue {
+					// New API override detected → start tracking
+					shouldInclude = true
+				}
+				// else: wasn't tracked and matches global → keep omitted
+			}
+
+			if shouldInclude {
+				regionDbConfig["enable_default_user"] = regionValue
+			}
 		}
 
 		regionDbConfigs = append(regionDbConfigs, regionDbConfig)
@@ -714,8 +750,21 @@ func resourceRedisCloudActiveActiveDatabaseRead(ctx context.Context, d *schema.R
 	if err := d.Set("private_endpoint", privateEndpointConfig); err != nil {
 		return diag.FromErr(err)
 	}
-	if err := d.Set("global_modules", flattenModulesToNames(db.Modules)); err != nil {
-		return diag.FromErr(err)
+	// For Redis 8.0+, modules are bundled by default and returned by the API
+	// Only set modules in state if they were explicitly defined in the config
+	redisVersion := redis.StringValue(db.RedisVersion)
+	if shouldSuppressModuleDiffsForRedis8(redisVersion) {
+		// Only set modules if they were explicitly configured by the user
+		if _, ok := d.GetOk("global_modules"); ok {
+			if err := d.Set("global_modules", flattenModulesToNames(db.Modules)); err != nil {
+				return diag.FromErr(err)
+			}
+		}
+	} else {
+		// For Redis < 8.0, always set modules from API response
+		if err := d.Set("global_modules", flattenModulesToNames(db.Modules)); err != nil {
+			return diag.FromErr(err)
+		}
 	}
 
 	if err := d.Set("redis_version", redis.StringValue(db.RedisVersion)); err != nil {
@@ -1102,3 +1151,66 @@ func isFieldInConfigForRegion(d *schema.ResourceData, regionName string, fieldNa
 	return false
 }
 
+// isFieldInStateForRegion checks if a field is present in the actual persisted state
+// for a specific region's override_region block. Uses GetRawState() to bypass materialization.
+// Returns true only if the field exists in the actual state file.
+func isFieldInStateForRegion(d *schema.ResourceData, regionName string, fieldName string) bool {
+	rawState := d.GetRawState()
+	if rawState.IsNull() || !rawState.IsKnown() {
+		return false
+	}
+
+	if !rawState.Type().HasAttribute("override_region") {
+		return false
+	}
+
+	overrideRegions := rawState.GetAttr("override_region")
+	if overrideRegions.IsNull() || !overrideRegions.IsKnown() {
+		return false
+	}
+
+	// Iterate through regions to find matching name
+	iter := overrideRegions.ElementIterator()
+	for iter.Next() {
+		_, regionVal := iter.Element()
+
+		if regionVal.IsNull() || !regionVal.IsKnown() {
+			continue
+		}
+
+		if !regionVal.Type().HasAttribute("name") {
+			continue
+		}
+
+		nameAttr := regionVal.GetAttr("name")
+		if nameAttr.IsNull() || !nameAttr.IsKnown() {
+			continue
+		}
+
+		// Check if the name matches
+		if nameAttr.AsString() == regionName {
+			// Found the region, check if field exists
+			if !regionVal.Type().HasAttribute(fieldName) {
+				return false
+			}
+			fieldAttr := regionVal.GetAttr(fieldName)
+			return !fieldAttr.IsNull()
+		}
+	}
+
+	return false
+}
+
+// shouldSuppressModuleDiffsForRedis8 checks if the Redis version is 8.0 or higher.
+// For Redis 8+, modules are bundled by default, so we suppress drift for modules
+// that weren't explicitly configured by the user.
+func shouldSuppressModuleDiffsForRedis8(version string) bool {
+	if len(version) == 0 {
+		return false
+	}
+	majorVersionStr := strings.Split(version, ".")[0]
+	if majorVersion, err := strconv.Atoi(majorVersionStr); err == nil {
+		return majorVersion >= 8
+	}
+	return false
+}