add string prefix refinement

Author: austinvalle

tftypes/refinement/nullness.go

@@ -1,9 +1,21 @@
 package refinement
 
+import "github.com/vmihailenco/msgpack/v5"
+
 type nullness struct {
 	Value bool
 }
 
+func (n nullness) Encode(enc *msgpack.Encoder) error {
+	err := enc.EncodeInt(int64(KeyNullness))
+	if err != nil {
+		return err
+	}
+
+	// A value that is definitely null cannot be unknown
+	return enc.EncodeBool(false)
+}
+
 func (n nullness) Equal(Refinement) bool {
 	return false
 }
@@ -14,6 +26,8 @@ func (n nullness) String() string {
 
 func (n nullness) unimplementable() {}
 
+// TODO: Should this accept a value? If a value is unknown and the it's refined to be null
+// then the value should be a known value of null instead.
 func Nullness(value bool) Refinement {
 	return nullness{
 		Value: value,

tftypes/refinement/refinement.go

@@ -1,14 +1,16 @@
 package refinement
 
+import "github.com/vmihailenco/msgpack/v5"
+
 type Key int64
 
 func (k Key) String() string {
 	return "todo"
 }
 
 const (
-	KeyNullness = Key(1)
-	// KeyStringPrefix               = Key(2)
+	KeyNullness     = Key(1)
+	KeyStringPrefix = Key(2)
 	// KeyNumberLowerBound           = Key(3)
 	// KeyNumberUpperBound           = Key(4)
 	// KeyCollectionLengthLowerBound = Key(5)
@@ -17,6 +19,7 @@ const (
 
 type Refinement interface {
 	Equal(Refinement) bool
+	Encode(*msgpack.Encoder) error
 	String() string
 	unimplementable() // prevent external implementations
 }

tftypes/refinement/string_prefix.go

@@ -0,0 +1,43 @@
+package refinement
+
+import "github.com/vmihailenco/msgpack/v5"
+
+type stringPrefix struct {
+	Value string
+}
+
+// TODO: What if the prefix is empty? Should we skip encoding? Throw an error earlier? Throw an error here?
+func (s stringPrefix) Encode(enc *msgpack.Encoder) error {
+	// Matching go-cty for the max prefix length allowed here
+	//
+	// This ensures the total size of the refinements blob does not exceed the limit
+	// set by the decoder (1024).
+	maxPrefixLength := 256
+	prefix := s.Value
+	if len(s.Value) > maxPrefixLength {
+		prefix = prefix[:maxPrefixLength-1]
+	}
+
+	err := enc.EncodeInt(int64(KeyStringPrefix))
+	if err != nil {
+		return err
+	}
+
+	return enc.EncodeString(prefix)
+}
+
+func (s stringPrefix) Equal(Refinement) bool {
+	return false
+}
+
+func (s stringPrefix) String() string {
+	return "todo - stringPrefix"
+}
+
+func (s stringPrefix) unimplementable() {}
+
+func StringPrefix(value string) Refinement {
+	return stringPrefix{
+		Value: value,
+	}
+}

tftypes/value_msgpack.go

@@ -10,6 +10,7 @@ import (
 	"math"
 	"math/big"
 	"sort"
+	"unicode/utf8"
 
 	"github.com/hashicorp/terraform-plugin-go/tftypes/refinement"
 	msgpack "github.com/vmihailenco/msgpack/v5"
@@ -421,9 +422,22 @@ func msgpackUnmarshalUnknown(dec *msgpack.Decoder, typ Type, path *AttributePath
 			// way or another. If nullness is unknown then this key should not
 			// be present at all.
 			newRefinements[keyCode] = refinement.Nullness(isNull)
+		case refinement.KeyStringPrefix:
+			if !typ.Is(String) {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: string prefix refinement for non-string type")
+			}
+			prefix, err := rfnDec.DecodeString()
+			if err != nil {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: string prefix refinement is not string")
+			}
+			if !utf8.ValidString(prefix) {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: string prefix refinement is not valid UTF-8")
+			}
+
+			newRefinements[keyCode] = refinement.StringPrefix(prefix)
 		default:
 			// We don't want to error here, as go-cty could introduce new refinements that we'd
-			// want to just ignore until this code is updated
+			// want to just ignore until this logic is updated
 			continue
 		}
 	}
@@ -487,14 +501,23 @@ func marshalUnknownValue(val Value, typ Type, p *AttributePath, enc *msgpack.Enc
 	refnEnc := msgpack.NewEncoder(&refnBuf)
 	mapLen := 0
 
-	// TODO: Should the refinement interface define the encoding?
-	for kind := range val.refinements {
+	// TODO: Should the refinement interface be defining the encoding? Should we export the refinement implementations?
+	for kind, refn := range val.refinements {
 		switch kind {
 		case refinement.KeyNullness:
+			err := refn.Encode(refnEnc)
+			if err != nil {
+				return p.NewErrorf("error encoding Nullness value refinement: %w", err)
+			}
+			mapLen++
+		case refinement.KeyStringPrefix:
+			// TODO: If the prefix is empty, we shouldn't encode a refinement. This should
+			// probably be reflected in the interface.
+			err := refn.Encode(refnEnc)
+			if err != nil {
+				return p.NewErrorf("error encoding StringPrefix value refinement: %w", err)
+			}
 			mapLen++
-			refnEnc.EncodeInt(int64(kind)) //nolint
-			// An value that is definitely null cannot be unknown
-			refnEnc.EncodeBool(false) //nolint
 		default:
 			continue
 		}