chore: Add support for typed nested objects in autogen (#3801)

Author: manupedrozo

.golangci.yml

@@ -108,7 +108,7 @@ linters:
       - linters:
           - gocritic
         text: "^hugeParam: req is heavy"
-      - path: schema\.go # exclude rules for schema files as it's auto-genereated from OpenAPI spec
+      - path: schema\.go # exclude rules for schema files as it's auto-generated from OpenAPI spec
         text: var-naming|exceeds the maximum|regexpSimplify
       - path: (.+)\.go$
         text: declaration of ".*" shadows declaration at line .*

internal/common/autogen/customtype/object.go

@@ -0,0 +1,237 @@
+package customtype
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+)
+
+/*
+	Custom Object type used in auto-generated code to enable the generic marshal/unmarshal operations to access nested attribute struct tags during conversion.
+	Custom types docs: https://developer.hashicorp.com/terraform/plugin/framework/handling-data/types/custom
+
+	Usage:
+		- Schema definition:
+			"sample_nested_object": schema.SingleNestedAttribute{
+				...
+				CustomType: customtype.NewObjectType[TFSampleNestedObjectModel](ctx),
+				Attributes: map[string]schema.Attribute{
+					"string_attribute": schema.StringAttribute{...},
+				},
+			}
+
+		- TF Models:
+			type TFModel struct {
+				SampleNestedObject customtype.ObjectValue[TFSampleNestedObjectModel] `tfsdk:"sample_nested_object"`
+				...
+			}
+
+			type TFSampleNestedObjectModel struct {
+				StringAttribute types.String `tfsdk:"string_attribute"`
+				...
+			}
+*/
+
+var (
+	_ basetypes.ObjectTypable  = ObjectType[struct{}]{}
+	_ basetypes.ObjectValuable = ObjectValue[struct{}]{}
+	_ ObjectValueInterface     = ObjectValue[struct{}]{}
+)
+
+type ObjectType[T any] struct {
+	basetypes.ObjectType
+}
+
+func NewObjectType[T any](ctx context.Context) ObjectType[T] {
+	result := ObjectType[T]{}
+
+	attrTypes, diags := getAttributeTypes[T](ctx)
+	if diags.HasError() {
+		panic(fmt.Errorf("error creating ObjectType: %v", diags))
+	}
+
+	result.ObjectType = basetypes.ObjectType{AttrTypes: attrTypes}
+	return result
+}
+
+func (t ObjectType[T]) Equal(o attr.Type) bool {
+	other, ok := o.(ObjectType[T])
+	if !ok {
+		return false
+	}
+	return t.ObjectType.Equal(other.ObjectType)
+}
+
+func (ObjectType[T]) String() string {
+	var t T
+	return fmt.Sprintf("ObjectType[%T]", t)
+}
+
+func (t ObjectType[T]) ValueFromObject(ctx context.Context, in basetypes.ObjectValue) (basetypes.ObjectValuable, diag.Diagnostics) {
+	if in.IsNull() {
+		return NewObjectValueNull[T](ctx), nil
+	}
+
+	if in.IsUnknown() {
+		return NewObjectValueUnknown[T](ctx), nil
+	}
+
+	attrTypes, diags := getAttributeTypes[T](ctx)
+	if diags.HasError() {
+		return nil, diags
+	}
+
+	baseObjectValue, diags := basetypes.NewObjectValue(attrTypes, in.Attributes())
+	if diags.HasError() {
+		return nil, diags
+	}
+
+	return ObjectValue[T]{ObjectValue: baseObjectValue}, nil
+}
+
+func (t ObjectType[T]) ValueFromTerraform(ctx context.Context, in tftypes.Value) (attr.Value, error) {
+	attrValue, err := t.ObjectType.ValueFromTerraform(ctx, in)
+
+	if err != nil {
+		return nil, err
+	}
+
+	objectValue, ok := attrValue.(basetypes.ObjectValue)
+	if !ok {
+		return nil, fmt.Errorf("unexpected value type of %T", attrValue)
+	}
+
+	objectValuable, diags := t.ValueFromObject(ctx, objectValue)
+	if diags.HasError() {
+		return nil, fmt.Errorf("unexpected error converting ObjectValue to ObjectValuable: %v", diags)
+	}
+
+	return objectValuable, nil
+}
+
+func (t ObjectType[T]) ValueType(_ context.Context) attr.Value {
+	return ObjectValue[T]{}
+}
+
+type ObjectValue[T any] struct {
+	basetypes.ObjectValue
+}
+
+type ObjectValueInterface interface {
+	basetypes.ObjectValuable
+	ValuePtrAsAny(ctx context.Context) (any, diag.Diagnostics)
+	NewObjectValue(ctx context.Context, value any) ObjectValueInterface
+	NewObjectValueNull(ctx context.Context) ObjectValueInterface
+}
+
+func (v ObjectValue[T]) NewObjectValue(ctx context.Context, value any) ObjectValueInterface {
+	return NewObjectValue[T](ctx, value)
+}
+
+func NewObjectValue[T any](ctx context.Context, value any) ObjectValue[T] {
+	attrTypes, diags := getAttributeTypes[T](ctx)
+	if diags.HasError() {
+		panic(fmt.Errorf("error creating ObjectValue: %v", diags))
+	}
+
+	newValue, diags := basetypes.NewObjectValueFrom(ctx, attrTypes, value)
+	if diags.HasError() {
+		return NewObjectValueUnknown[T](ctx)
+	}
+
+	return ObjectValue[T]{ObjectValue: newValue}
+}
+
+func (v ObjectValue[T]) NewObjectValueNull(ctx context.Context) ObjectValueInterface {
+	return NewObjectValueNull[T](ctx)
+}
+
+func NewObjectValueNull[T any](ctx context.Context) ObjectValue[T] {
+	attrTypes, diags := getAttributeTypes[T](ctx)
+	if diags.HasError() {
+		panic(fmt.Errorf("error creating null ObjectValue: %v", diags))
+	}
+	return ObjectValue[T]{ObjectValue: basetypes.NewObjectNull(attrTypes)}
+}
+
+func NewObjectValueUnknown[T any](ctx context.Context) ObjectValue[T] {
+	attrTypes, diags := getAttributeTypes[T](ctx)
+	if diags.HasError() {
+		panic(fmt.Errorf("error creating unknown ObjectValue: %v", diags))
+	}
+	return ObjectValue[T]{ObjectValue: basetypes.NewObjectUnknown(attrTypes)}
+}
+
+func (v ObjectValue[T]) Equal(o attr.Value) bool {
+	other, ok := o.(ObjectValue[T])
+	if !ok {
+		return false
+	}
+	return v.ObjectValue.Equal(other.ObjectValue)
+}
+
+func (v ObjectValue[T]) Type(ctx context.Context) attr.Type {
+	return NewObjectType[T](ctx)
+}
+
+func (v ObjectValue[T]) ValuePtrAsAny(ctx context.Context) (any, diag.Diagnostics) {
+	valuePtr := new(T)
+
+	if v.IsNull() || v.IsUnknown() {
+		return valuePtr, nil
+	}
+
+	diags := v.As(ctx, valuePtr, basetypes.ObjectAsOptions{})
+	if diags.HasError() {
+		return nil, diags
+	}
+
+	return valuePtr, diags
+}
+
+func getAttributeTypes[T any](ctx context.Context) (map[string]attr.Type, diag.Diagnostics) {
+	var t T
+	return valueToAttributeTypes(ctx, reflect.ValueOf(t))
+}
+
+func valueToAttributeTypes(ctx context.Context, value reflect.Value) (map[string]attr.Type, diag.Diagnostics) {
+	valueType := value.Type()
+
+	if valueType.Kind() != reflect.Struct {
+		return nil, diag.Diagnostics{diag.NewErrorDiagnostic(
+			"Error getting value attribute types",
+			fmt.Sprintf(`%T has usupported type: %s`, value.Interface(), valueType),
+		)}
+	}
+
+	attributeTypes := make(map[string]attr.Type)
+	for i := range valueType.NumField() {
+		typeField := valueType.Field(i)
+		valueField := value.Field(i)
+
+		tfName := typeField.Tag.Get(`tfsdk`)
+		if tfName == "" {
+			return nil, diag.Diagnostics{diag.NewErrorDiagnostic(
+				"Error getting value attribute types",
+				fmt.Sprintf(`%T has no tfsdk tag on field %s`, value.Interface(), typeField.Name),
+			)}
+		}
+
+		attrValue, ok := valueField.Interface().(attr.Value)
+		if !ok {
+			return nil, diag.Diagnostics{diag.NewErrorDiagnostic(
+				"Error getting value attribute types",
+				fmt.Sprintf(`%T has unsupported type in field %s: %T`, value.Interface(), typeField.Name, valueField.Interface()),
+			)}
+		}
+
+		attributeTypes[tfName] = attrValue.Type(ctx)
+	}
+
+	return attributeTypes, nil
+}

internal/common/autogen/marshal.go

@@ -1,13 +1,15 @@
 package autogen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"reflect"
 
 	"github.com/hashicorp/terraform-plugin-framework-jsontypes/jsontypes"
 	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/autogen/customtype"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/autogen/stringcase"
 )
 
@@ -43,7 +45,7 @@ func Marshal(model any, isUpdate bool) ([]byte, error) {
 
 func marshalAttrs(valModel reflect.Value, isUpdate bool) (map[string]any, error) {
 	objJSON := make(map[string]any)
-	for i := 0; i < valModel.NumField(); i++ {
+	for i := range valModel.NumField() {
 		attrTypeModel := valModel.Type().Field(i)
 		tag := attrTypeModel.Tag.Get(tagKey)
 		if tag == tagValOmitJSON {
@@ -68,7 +70,7 @@ func marshalAttr(attrNameModel string, attrValModel reflect.Value, objJSON map[s
 	if !ok {
 		panic("marshal expects only Terraform types in the model")
 	}
-	val, err := getModelAttr(obj)
+	val, err := getModelAttr(obj, isUpdate)
 	if err != nil {
 		return err
 	}
@@ -86,7 +88,7 @@ func marshalAttr(attrNameModel string, attrValModel reflect.Value, objJSON map[s
 	return nil
 }
 
-func getModelAttr(val attr.Value) (any, error) {
+func getModelAttr(val attr.Value, isUpdate bool) (any, error) {
 	if val.IsNull() || val.IsUnknown() {
 		return nil, nil // skip null or unknown values
 	}
@@ -100,28 +102,36 @@ func getModelAttr(val attr.Value) (any, error) {
 	case types.Float64:
 		return v.ValueFloat64(), nil
 	case types.Object:
-		return getMapAttr(v.Attributes(), false)
+		return getMapAttr(v.Attributes(), false, isUpdate)
 	case types.Map:
-		return getMapAttr(v.Elements(), true)
+		return getMapAttr(v.Elements(), true, isUpdate)
 	case types.List:
-		return getListAttr(v.Elements())
+		return getListAttr(v.Elements(), isUpdate)
 	case types.Set:
-		return getListAttr(v.Elements())
+		return getListAttr(v.Elements(), isUpdate)
 	case jsontypes.Normalized:
 		var valueJSON any
 		if err := json.Unmarshal([]byte(v.ValueString()), &valueJSON); err != nil {
 			return nil, fmt.Errorf("marshal failed for JSON custom type: %v", err)
 		}
 		return valueJSON, nil
+	case customtype.ObjectValueInterface:
+		valuePtr, diags := v.ValuePtrAsAny(context.Background())
+		if diags.HasError() {
+			return nil, fmt.Errorf("marshal failed for type: %v", diags)
+		}
+
+		result, err := marshalAttrs(reflect.ValueOf(valuePtr).Elem(), isUpdate)
+		return result, err
 	default:
 		return nil, fmt.Errorf("marshal not supported yet for type %T", v)
 	}
 }
 
-func getListAttr(elms []attr.Value) (any, error) {
+func getListAttr(elms []attr.Value, isUpdate bool) (any, error) {
 	arr := make([]any, 0)
 	for _, attr := range elms {
-		valChild, err := getModelAttr(attr)
+		valChild, err := getModelAttr(attr, isUpdate)
 		if err != nil {
 			return nil, err
 		}
@@ -134,10 +144,10 @@ func getListAttr(elms []attr.Value) (any, error) {
 
 // getMapAttr gets a map of attributes and returns a map of JSON attributes.
 // keepKeyCase is used for types.Map to keep key case. However, we want to use JSON key case for types.Object
-func getMapAttr(elms map[string]attr.Value, keepKeyCase bool) (any, error) {
+func getMapAttr(elms map[string]attr.Value, keepKeyCase, isUpdate bool) (any, error) {
 	objJSON := make(map[string]any)
 	for name, attr := range elms {
-		valChild, err := getModelAttr(attr)
+		valChild, err := getModelAttr(attr, isUpdate)
 		if err != nil {
 			return nil, err
 		}