fix: serialise value.List fields through proto round-trip (#61)

Author: liamg

pkg/tree/convert.go

@@ -33,6 +33,12 @@ func structToValueObject(v reflect.Value) *prototree.ValueObject {
 	if v.Kind() == reflect.Pointer {
 		v = v.Elem()
 	}
+	// Make the struct addressable so its fields can satisfy pointer-receiver Valuer interfaces.
+	if !v.CanAddr() {
+		addr := reflect.New(v.Type()).Elem()
+		addr.Set(v)
+		v = addr
+	}
 
 	obj := &prototree.ValueObject{
 		Entries: make(map[string]*prototree.Value),
@@ -66,6 +72,9 @@ func fieldToProtoValue(field reflect.Value) *prototree.Value {
 	if field.Type().Implements(valuerType) {
 		return field.Interface().(value.Valuer).ToProto()
 	}
+	if field.CanAddr() && reflect.PointerTo(field.Type()).Implements(valuerType) {
+		return field.Addr().Interface().(value.Valuer).ToProto()
+	}
 
 	switch field.Kind() {
 	case reflect.Pointer:

pkg/tree/proto_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/infracost/go-proto/pkg/tree/aws"
 	"github.com/infracost/go-proto/pkg/tree/aws/ec2"
+	"github.com/infracost/go-proto/pkg/tree/aws/eks"
 	"github.com/infracost/go-proto/pkg/tree/resource"
 	"github.com/infracost/go-proto/pkg/tree/value"
 	prototree "github.com/infracost/proto/gen/go/infracost/tree"
@@ -87,6 +88,33 @@ func TestRoundTrip(t *testing.T) {
 	assert.Equal(t, "c5.xlarge", result.AWS.EC2.Instances[2].Type.Value())
 }
 
+func TestRoundTrip_ListField(t *testing.T) {
+	original := &Tree{
+		AWS: aws.AWS{
+			EKS: eks.EKS{
+				NodeGroups: []eks.NodeGroup{{
+					InstanceTypes: *value.NewList([]value.Value[string]{
+						value.New("t3.micro", 0, "instance_types", nil),
+						value.New("t3.small", 0, "instance_types", nil),
+					}, 0, "instance_types", nil),
+				}},
+			},
+		},
+	}
+
+	proto, err := original.ToProto()
+	require.NoError(t, err)
+
+	result, err := FromProto(proto)
+	require.NoError(t, err)
+
+	require.Len(t, result.AWS.EKS.NodeGroups, 1)
+	items := result.AWS.EKS.NodeGroups[0].InstanceTypes.Items()
+	require.Len(t, items, 2, "list items should survive proto round-trip")
+	assert.Equal(t, "t3.micro", items[0].Value())
+	assert.Equal(t, "t3.small", items[1].Value())
+}
+
 func TestFromProtoUnmappedProvider(t *testing.T) {
 	proto := &prototree.Tree{
 		Providers: map[string]*prototree.Provider{

pkg/tree/value/value.go

@@ -21,6 +21,8 @@ type Value[T Primitive] struct {
 var (
 	_ Valuer   = (*Value[bool])(nil)
 	_ Settable = (*Value[bool])(nil)
+	_ Valuer   = (*List[bool])(nil)
+	_ Settable = (*List[bool])(nil)
 )
 
 // Settable extends Valuer to allow setting the proto value via reflection.
@@ -325,6 +327,43 @@ func (l *List[T]) Items() []Value[T] {
 	return l.items
 }
 
+func (l *List[T]) ToProto() *prototree.Value {
+	if l == nil {
+		return nil
+	}
+	pl := &prototree.ValueList{
+		Values: make([]*prototree.Value, len(l.items)),
+	}
+	for i, item := range l.items {
+		pl.Values[i] = item.ToProto()
+	}
+	return &prototree.Value{
+		Flags:           l.Flags,
+		SourceFieldName: l.SourceFieldName,
+		Source:          l.Source,
+		Value:           &prototree.Value_ListValue{ListValue: pl},
+	}
+}
+
+func (l *List[T]) SetProto(p *prototree.Value) {
+	if l == nil || p == nil {
+		return
+	}
+	l.Flags = p.Flags
+	l.SourceFieldName = p.SourceFieldName
+	l.Source = p.Source
+	lv := p.GetListValue()
+	if lv == nil {
+		l.items = nil
+		return
+	}
+	items := make([]Value[T], 0, len(lv.Values))
+	for _, item := range lv.Values {
+		items = append(items, FromProto[T](item))
+	}
+	l.items = items
+}
+
 func (l *List[T]) Contains(v T) bool {
 	for _, item := range l.items {
 		if item.Value() == v {

pkg/tree/value/value_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/infracost/go-proto/pkg/flag"
 	prototree "github.com/infracost/proto/gen/go/infracost/tree"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStringValue(t *testing.T) {
@@ -217,6 +218,25 @@ func TestNewList_Empty(t *testing.T) {
 	assert.Empty(t, l.Items())
 }
 
+func TestList_ToProtoRoundTrip(t *testing.T) {
+	in := NewList([]Value[string]{
+		New("a", flag.TerraformCode, "items", nil),
+		New("b", flag.TerraformCode, "items", nil),
+	}, flag.TerraformCode, "items", nil)
+
+	p := in.ToProto()
+	require.NotNil(t, p)
+	require.NotNil(t, p.GetListValue())
+	require.Len(t, p.GetListValue().Values, 2)
+
+	var out List[string]
+	out.SetProto(p)
+	assert.Equal(t, "items", *out.SourceFieldName)
+	require.Len(t, out.Items(), 2)
+	assert.Equal(t, "a", out.Items()[0].Value())
+	assert.Equal(t, "b", out.Items()[1].Value())
+}
+
 func TestContains(t *testing.T) {
 	v := New("hello world", 0, "", nil)
 	assert.True(t, v.Contains("world"))