Add support for nested schema packing/unpacking

Author: JacobsonMT

internal/resources/grafana/resource_alerting_contact_point.go

@@ -442,7 +442,7 @@ func valueAsString(value any) any {
 //   - Flattening the "settings" field created by TF when unpacking the resource schema. This contains any unknown fields
 //     not present in the resource schema.
 func unpackNotifier(tfSettings map[string]any, name string, n notifier) *models.EmbeddedContactPoint {
-	gfSettings := unpackFields(tfSettings, n.schema().Schema, n.meta().fieldMapper)
+	gfSettings := unpackFields(tfSettings, "", n.schema().Schema, n.meta().fieldMapper)
 
 	// UID, disable_resolve_message, and leftover "settings" are part of the schema so are currently unpacked into gfSettings.
 	// However, they are not part of the settings schema in Grafana, so we extract them.
@@ -475,34 +475,59 @@ func unpackNotifier(tfSettings map[string]any, name string, n notifier) *models.
 	}
 }
 
-func unpackFields(tfSettings map[string]any, schemas map[string]*schema.Schema, fieldMapping map[string]fieldMapper) map[string]any {
+// unpackFields is the recursive counterpart to unpackNotifier.
+func unpackFields(tfSettings map[string]any, prefix string, schemas map[string]*schema.Schema, fieldMapping map[string]fieldMapper) map[string]any {
 	gfSettings := make(map[string]any, len(schemas))
-	for tfKey := range schemas {
+	for tfKey, sch := range schemas {
+		fullTfKey := tfKey
+		if prefix != "" {
+			fullTfKey = fmt.Sprintf("%s.%s", prefix, tfKey)
+		}
+
 		val, ok := tfSettings[tfKey]
 		if !ok {
 			continue // Skip if the key is not present in the resource map
 		}
 
 		gfKey := tfKey
-		fMap := fieldMapping[tfKey]
 		// Apply key mapping to get the grafana-style key if defined.
-		if fMap.newKey != "" {
+		if fMap := fieldMapping[fullTfKey]; fMap.newKey != "" {
 			gfKey = fMap.newKey
 		}
 
-		// Apply the transformation function if provided.
-		if fMap.unpackValFunc != nil {
-			val = fMap.unpackValFunc(val)
-		}
-
-		if val != nil {
+		if unpackedVal := unpackedValue(val, fullTfKey, sch, fieldMapping); unpackedVal != nil {
 			// Omit nil values, this is usually from a custom transform function or an empty set.
-			gfSettings[gfKey] = val
+			gfSettings[gfKey] = unpackedVal
 		}
 	}
 	return gfSettings
 }
 
+// unpackedValue recursively returns the appropriate Grafana representation of the TF field value based on the schema.
+func unpackedValue(val any, tfKey string, sch *schema.Schema, fieldMapping map[string]fieldMapper) any {
+	// Apply the transformation function if provided
+	if fMap := fieldMapping[tfKey]; fMap.unpackValFunc != nil {
+		val = fMap.unpackValFunc(val)
+	}
+
+	switch sch.Type {
+	case schema.TypeSet:
+		// This is a nested schema type, so we coerce the nested value into a map to continue the recursion.
+		valAsMap, err := extractMapFromSet(val)
+		if err != nil {
+			log.Printf("[WARN] cannot extract map from set for key '%s': %v", tfKey, err)
+			return val
+		}
+		if len(valAsMap) == 0 {
+			return nil // omit empty sets
+		}
+
+		return unpackFields(valAsMap, tfKey, sch.Elem.(*schema.Resource).Schema, fieldMapping)
+	default:
+		return val
+	}
+}
+
 // packNotifier takes the grafana-style settings and packs them into the Terraform-style settings. It handles:
 //   - Applying any transformation functions defined in fieldMapping to the keys and values in gfSettings. This is necessary
 //     because some field names differ between Terraform and Grafana, and some values need to be transformed (e.g., converting a string to an integer).
@@ -511,7 +536,7 @@ func unpackFields(tfSettings map[string]any, schemas map[string]*schema.Schema,
 //   - Collecting all remaining fields from the Grafana settings that are not in the resource schema into a "settings" field.
 func packNotifier(p *models.EmbeddedContactPoint, data *schema.ResourceData, n notifier) map[string]any {
 	gfSettings := p.Settings.(map[string]any)
-	tfSettings := packFields(gfSettings, getNotifierConfigFromStateWithUID(data, n, p.UID), n.schema().Schema, n.meta().fieldMapper)
+	tfSettings := packFields(gfSettings, getNotifierConfigFromStateWithUID(data, n, p.UID), "", n.schema().Schema, n.meta().fieldMapper)
 
 	// Add common fields to the Terraform settings as these aren't available in EmbeddedContactPoint settings.
 	for k, v := range packCommonNotifierFields(p) {
@@ -528,13 +553,18 @@ func packNotifier(p *models.EmbeddedContactPoint, data *schema.ResourceData, n n
 	return tfSettings
 }
 
-func packFields(gfSettings, state map[string]any, schemas map[string]*schema.Schema, fieldMapping map[string]fieldMapper) map[string]any {
+// packFields is the recursive counterpart to packNotifier.
+func packFields(gfSettings, state map[string]any, prefix string, schemas map[string]*schema.Schema, fieldMapping map[string]fieldMapper) map[string]any {
 	settings := make(map[string]any, len(schemas))
 	for tfKey, sch := range schemas {
+		fullTfKey := tfKey
+		if prefix != "" {
+			fullTfKey = fmt.Sprintf("%s.%s", prefix, tfKey)
+		}
+
 		gfKey := tfKey
-		fMap := fieldMapping[tfKey]
 		// Apply key mapping to get the grafana-style key if defined.
-		if fMap.newKey != "" {
+		if fMap := fieldMapping[fullTfKey]; fMap.newKey != "" {
 			gfKey = fMap.newKey
 		}
 
@@ -543,23 +573,75 @@ func packFields(gfSettings, state map[string]any, schemas map[string]*schema.Sch
 			continue // Skip if the key is not present in the grafana settings
 		}
 
-		// Use the state value for sensitive fields as the API returns [REDACTED].
-		if sch.Sensitive {
-			val = state[tfKey]
+		packedVal, remove := packedValue(val, state[tfKey], fullTfKey, sch, fieldMapping)
+		if packedVal != nil {
+			// Omit nil values.
+			settings[tfKey] = packedVal
 		}
+		if remove {
+			delete(gfSettings, gfKey) // Remove the key from the original map to avoid including it in leftover "settings"
+		}
+	}
+	return settings
+}
+
+// packedValue recursively returns the appropriate TF representation of the Grafana field value based on the schema.
+func packedValue(val any, stateVal any, tfKey string, sch *schema.Schema, fieldMapping map[string]fieldMapper) (any, bool) {
+	// Use the state value for sensitive fields as the API returns [REDACTED].
+	if sch.Sensitive {
+		// Values in state and already correctly packed, so no need to continue the recursion.
+		return stateVal, true
+	}
+
+	// Apply the transformation function if provided
+	if fMap := fieldMapping[tfKey]; fMap.packValFunc != nil {
+		val = fMap.packValFunc(val)
+	}
 
-		// Apply the transformation function if provided
-		if fMap.packValFunc != nil {
-			val = fMap.packValFunc(val)
+	switch sch.Type {
+	case schema.TypeSet:
+		// This is a nested schema type, so we coerce the nested value and state into maps to continue the recursion.
+		valAsMap, ok := val.(map[string]any)
+		if !ok {
+			log.Printf("[WARN] Unsupported value type '%s' for key '%s'", sch.Type.String(), tfKey)
+			return val, true
 		}
 
-		if val != nil {
-			// Omit nil values.
-			settings[tfKey] = val
+		// For nested schemas, the state value should be a schema.Set with MaxItems=1.
+		stateValAsMap, err := extractMapFromSet(stateVal)
+		if err != nil {
+			log.Printf("[WARN] cannot extract map from set for key '%s': %v", tfKey, err)
 		}
-		delete(gfSettings, gfKey) // Remove the key from the original map to avoid including it in leftover "settings"
+
+		// We use TypeSet with MaxItems=1 to represent nested schemas (map[string]any), but they are technically slices
+		// and need to be packed as such.
+		return []any{packFields(valAsMap, stateValAsMap, tfKey, sch.Elem.(*schema.Resource).Schema, fieldMapping)}, len(valAsMap) == 0
+	default:
+		return val, true
 	}
-	return settings
+}
+
+// extractMapFromSet extracts the first item from a schema.Set and returns it as a map[string]any.
+// We use TypeSet with MaxItems=1 to represent nested schemas (map[string]any), but they are technically slices in TF.
+func extractMapFromSet(val any) (map[string]any, error) {
+	set, ok := val.(*schema.Set)
+	if !ok {
+		return map[string]any{}, fmt.Errorf("unsupported value: %q", val)
+	}
+
+	items := set.List()
+	if len(items) == 0 {
+		return map[string]any{}, nil // empty set
+	}
+	if len(items) > 1 {
+		return map[string]any{}, fmt.Errorf("set contains more than one item: %q", items)
+	}
+	// Use the first item in the set as the child map
+	m, ok := items[0].(map[string]any)
+	if !ok {
+		return map[string]any{}, fmt.Errorf("unsupported value in set: %q", items[0])
+	}
+	return m, nil
 }
 
 type notifier interface {