add conversion function for cty type to tftype type

Author: stephybun

helper/convert/convert.go

@@ -0,0 +1,40 @@
+package convert
+
+import (
+	"github.com/hashicorp/go-cty/cty"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+)
+
+func ConvertToTfType(in cty.Type) tftypes.Type {
+	switch {
+	case in.IsPrimitiveType():
+		if in == cty.String {
+			return tftypes.String
+		}
+		if in == cty.Bool {
+			return tftypes.Bool
+		}
+		if in == cty.Number {
+			return tftypes.Number
+		}
+	case in.IsListType():
+		elemType := ConvertToTfType(in.ElementType())
+		return tftypes.List{ElementType: elemType}
+	case in.IsSetType():
+		elemType := ConvertToTfType(in.ElementType())
+		return tftypes.Set{ElementType: elemType}
+	case in.IsMapType():
+		elemType := ConvertToTfType(in.ElementType())
+		return tftypes.Map{ElementType: elemType}
+	case in.IsObjectType():
+		attrTypes := map[string]tftypes.Type{}
+
+		for k, v := range in.AttributeTypes() {
+			attrTypes[k] = ConvertToTfType(v)
+		}
+		return tftypes.Object{AttributeTypes: attrTypes}
+	case in.IsTupleType():
+		// TODO
+	}
+	return nil
+}

helper/convert/type.go

@@ -0,0 +1,113 @@
+package convert
+
+import (
+	"github.com/hashicorp/go-cty/cty"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+)
+
+func PrimitiveTfValue(in cty.Value) tftypes.Value {
+	if in.IsNull() {
+		return emptyTfValue(ToTfType(in.Type()))
+	}
+
+	var val tftypes.Value
+	switch in.Type() {
+	case cty.String:
+		val = tftypes.NewValue(tftypes.String, in.AsString())
+	case cty.Bool:
+		val = tftypes.NewValue(tftypes.Bool, in.True())
+	case cty.Number:
+		val = tftypes.NewValue(tftypes.Number, in.AsBigFloat())
+		// TODO other number types?
+	}
+
+	return val
+}
+
+func ListTfValue(in cty.Value) tftypes.Value {
+	listType := ToTfType(in.Type())
+
+	if in.IsNull() || in.LengthInt() == 0 {
+		return emptyTfValue(listType)
+	}
+
+	vals := make([]tftypes.Value, 0)
+
+	for _, v := range in.AsValueSlice() {
+		vals = append(vals, ToTfValue(v))
+	}
+
+	return tftypes.NewValue(listType, vals)
+}
+
+func MapTfValue(in cty.Value) tftypes.Value {
+	mapType := ToTfType(in.Type())
+
+	if in.IsNull() || in.LengthInt() == 0 {
+		return emptyTfValue(mapType)
+	}
+
+	vals := make(map[string]tftypes.Value)
+
+	for k, v := range in.AsValueMap() {
+		vals[k] = ToTfValue(v)
+	}
+
+	return tftypes.NewValue(mapType, vals)
+}
+
+func SetTfValue(in cty.Value) tftypes.Value {
+	setType := ToTfType(in.Type())
+
+	if in.IsNull() || in.LengthInt() == 0 {
+		return emptyTfValue(setType)
+	}
+
+	vals := make([]tftypes.Value, 0)
+
+	for _, v := range in.AsValueSlice() {
+		vals = append(vals, ToTfValue(v))
+	}
+
+	return tftypes.NewValue(setType, vals)
+}
+
+func ObjectTfValue(in cty.Value) tftypes.Value {
+	objType := ToTfType(in.Type())
+
+	if in.IsNull() || in.LengthInt() == 0 {
+		return emptyTfValue(objType)
+	}
+
+	vals := make(map[string]tftypes.Value)
+
+	for k, v := range in.AsValueMap() {
+		vals[k] = ToTfValue(v)
+	}
+
+	return tftypes.NewValue(objType, vals)
+}
+
+func ToTfValue(in cty.Value) tftypes.Value {
+	ty := in.Type()
+	switch {
+	case ty.IsPrimitiveType():
+		return PrimitiveTfValue(in)
+	case ty.IsListType():
+		return ListTfValue(in)
+	case ty.IsObjectType():
+		return ObjectTfValue(in)
+	case ty.IsMapType():
+		return MapTfValue(in)
+	case ty.IsSetType():
+		return SetTfValue(in)
+	case ty.IsTupleType():
+		// TODO
+	}
+
+	return emptyTfValue(ToTfType(in.Type()))
+}
+
+func emptyTfValue(ty tftypes.Type) tftypes.Value {
+	return tftypes.NewValue(ty, nil)
+}

helper/convert/value.go

@@ -34,7 +34,7 @@ func TestPrimitiveTfType(t *testing.T) {
 		t.Run(test.Value.GoString(), func(t *testing.T) {
 			t.Parallel()
 
-			got := PrimitiveTfType(test.Value)
+			got := PrimitiveTfValue(test.Value)
 
 			if diff := cmp.Diff(test.Want, got); diff != "" {
 				t.Errorf("unexpected differences: %s", diff)
@@ -142,13 +142,35 @@ func TestListTfType(t *testing.T) {
 				}),
 			}),
 		},
+		{
+			Value: cty.ListVal([]cty.Value{
+				cty.ObjectVal(map[string]cty.Value{
+					"enforcement": cty.NullVal(cty.String),
+				}),
+			}),
+			Want: tftypes.NewValue(tftypes.List{
+				ElementType: tftypes.Object{
+					AttributeTypes: map[string]tftypes.Type{
+						"enforcement": tftypes.String,
+					},
+				},
+			}, []tftypes.Value{
+				tftypes.NewValue(tftypes.Object{
+					AttributeTypes: map[string]tftypes.Type{
+						"enforcement": tftypes.String,
+					},
+				}, map[string]tftypes.Value{
+					"enforcement": tftypes.NewValue(tftypes.String, nil),
+				}),
+			}),
+		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.Value.GoString(), func(t *testing.T) {
 			t.Parallel()
 
-			got := ListTfType(test.Value)
+			got := ListTfValue(test.Value)
 
 			if diff := cmp.Diff(test.Want, got); diff != "" {
 				t.Errorf("unexpected differences: %s", diff)

helper/convert/convert_test.go renamed to helper/convert/value_test.go

@@ -73,7 +73,7 @@ func (d *ResourceData) TfTypeIdentity() tftypes.Value {
 		// TODO should we return an error of panic if something goes wrong here
 	}
 
-	return convert.ObjectTfType(stateVal)
+	return convert.ToTfValue(stateVal)
 }
 
 func (d *ResourceData) TfTypeResource() tftypes.Value {
@@ -145,7 +145,7 @@ func (d *ResourceData) TfTypeResource() tftypes.Value {
 		// TODO should we return an error of panic if something goes wrong here
 	}
 
-	return convert.ObjectTfType(stateVal)
+	return convert.ToTfValue(stateVal)
 }
 
 // Get returns the data for the given key, or nil if the key doesn't exist