add number bounds

Author: austinvalle

tftypes/refinement/nullness.go

@@ -1,23 +1,9 @@
 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
-	}
-
-	// It shouldn't be possible for an unknown value to be definitely null (i.e. nullness.value = true),
-	// as that should be represented by a known null value instead. This encoding is in place to be compliant
-	// with Terraform's encoding which uses a definitely null refinement to collapse into a known null value.
-	return enc.EncodeBool(n.value)
-}
-
 func (n Nullness) Equal(Refinement) bool {
 	return false
 }
@@ -26,8 +12,8 @@ func (n Nullness) String() string {
 	return "todo - Nullness"
 }
 
-func (n Nullness) NotNull() bool {
-	return !n.value
+func (n Nullness) Nullness() bool {
+	return n.value
 }
 
 func (n Nullness) unimplementable() {}

tftypes/refinement/number_lower_bound.go

@@ -0,0 +1,35 @@
+package refinement
+
+import (
+	"math/big"
+)
+
+type NumberLowerBound struct {
+	inclusive bool
+	value     *big.Float
+}
+
+func (n NumberLowerBound) Equal(Refinement) bool {
+	return false
+}
+
+func (n NumberLowerBound) String() string {
+	return "todo - NumberLowerBound"
+}
+
+func (n NumberLowerBound) IsInclusive() bool {
+	return n.inclusive
+}
+
+func (n NumberLowerBound) LowerBound() *big.Float {
+	return n.value
+}
+
+func (n NumberLowerBound) unimplementable() {}
+
+func NewNumberLowerBound(value *big.Float, inclusive bool) Refinement {
+	return NumberLowerBound{
+		value:     value,
+		inclusive: inclusive,
+	}
+}

tftypes/refinement/number_upper_bound.go

@@ -0,0 +1,35 @@
+package refinement
+
+import (
+	"math/big"
+)
+
+type NumberUpperBound struct {
+	inclusive bool
+	value     *big.Float
+}
+
+func (n NumberUpperBound) Equal(Refinement) bool {
+	return false
+}
+
+func (n NumberUpperBound) String() string {
+	return "todo - NumberUpperBound"
+}
+
+func (n NumberUpperBound) IsInclusive() bool {
+	return n.inclusive
+}
+
+func (n NumberUpperBound) UpperBound() *big.Float {
+	return n.value
+}
+
+func (n NumberUpperBound) unimplementable() {}
+
+func NewNumberUpperBound(value *big.Float, inclusive bool) Refinement {
+	return NumberUpperBound{
+		value:     value,
+		inclusive: inclusive,
+	}
+}

tftypes/refinement/refinement.go

@@ -2,8 +2,6 @@ package refinement
 
 import (
 	"fmt"
-
-	"github.com/vmihailenco/msgpack/v5"
 )
 
 type Key int64
@@ -15,23 +13,26 @@ func (k Key) String() string {
 		return "nullness"
 	case KeyStringPrefix:
 		return "string_prefix"
+	case KeyNumberLowerBound:
+		return "number_lower_bound"
+	case KeyNumberUpperBound:
+		return "number_upper_bound"
 	default:
 		return fmt.Sprintf("unsupported refinement: %d", k)
 	}
 }
 
 const (
-	KeyNullness     = Key(1)
-	KeyStringPrefix = Key(2)
-	// KeyNumberLowerBound           = Key(3)
-	// KeyNumberUpperBound           = Key(4)
+	KeyNullness         = Key(1)
+	KeyStringPrefix     = Key(2)
+	KeyNumberLowerBound = Key(3)
+	KeyNumberUpperBound = Key(4)
 	// KeyCollectionLengthLowerBound = Key(5)
 	// KeyCollectionLengthUpperBound = Key(6)
 )
 
 type Refinement interface {
 	Equal(Refinement) bool
-	Encode(*msgpack.Encoder) error
 	String() string
 	unimplementable() // prevents external implementations, all refinements are defined in the Terraform/HCL type system go-cty.
 }

tftypes/refinement/string_prefix.go

@@ -1,33 +1,9 @@
 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?
-// - I think an empty prefix string is valid, empty string is still more information then wholly unknown?
-// - I wonder what Terraform does in this situation today
-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
 }

tftypes/value_msgpack.go

@@ -441,6 +441,44 @@ func msgpackUnmarshalUnknown(dec *msgpack.Decoder, typ Type, path *AttributePath
 			// TODO: If terraform doesn't support an empty string prefix, then neither should we, potentially return an error here.
 
 			newRefinements[keyCode] = refinement.NewStringPrefix(prefix)
+		case refinement.KeyNumberLowerBound, refinement.KeyNumberUpperBound:
+			if !typ.Is(Number) {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: numeric bound refinement for non-number type")
+			}
+
+			// We know these refinements are a tuple of [number, bool] so we can re-use the msgpack decoding logic on this refinement
+			tfValBound, err := msgpackUnmarshal(rfnDec, Tuple{ElementTypes: []Type{Number, Bool}}, path)
+			if err != nil || tfValBound.IsNull() || !tfValBound.IsKnown() {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: numeric bound refinement must be [number, bool] tuple")
+			}
+
+			tupleVal := []Value{}
+			err = tfValBound.As(&tupleVal)
+			if err != nil {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: numeric bound refinement tuple value conversion failed: %w", err)
+			}
+
+			if len(tupleVal) != 2 {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: numeric bound refinement tuple value conversion failed: expected 2 elements, got %d elements", len(tupleVal))
+			}
+
+			var boundVal *big.Float
+			err = tupleVal[0].As(&boundVal)
+			if err != nil {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: numeric bound refinement bound value conversion failed: %w", err)
+			}
+
+			var inclusiveVal bool
+			err = tupleVal[1].As(&inclusiveVal)
+			if err != nil {
+				return Value{}, path.NewErrorf("failed to decode msgpack extension body: numeric bound refinement inclusive value conversion failed: %w", err)
+			}
+
+			if keyCode == refinement.KeyNumberLowerBound {
+				newRefinements[keyCode] = refinement.NewNumberLowerBound(boundVal, inclusiveVal)
+			} else {
+				newRefinements[keyCode] = refinement.NewNumberUpperBound(boundVal, inclusiveVal)
+			}
 		default:
 			err := rfnDec.Skip()
 			if err != nil {
@@ -511,23 +549,95 @@ func marshalUnknownValue(val Value, typ Type, p *AttributePath, enc *msgpack.Enc
 	refnEnc := msgpack.NewEncoder(&refnBuf)
 	mapLen := 0
 
-	// TODO: Should the refinement interface be defining the encoding? Should we export the refinement implementation details?
-	// - If we keep it in the interface, then we can simplify this logic
-	for kind, refn := range val.refinements {
-		switch kind {
-		case refinement.KeyNullness:
-			err := refn.Encode(refnEnc)
+	for _, refn := range val.refinements {
+		switch refnVal := refn.(type) {
+		case refinement.Nullness:
+			err := refnEnc.EncodeInt(int64(refinement.KeyNullness))
+			if err != nil {
+				return p.NewErrorf("error encoding Nullness value refinement key: %w", err)
+			}
+
+			// It shouldn't be possible for an unknown value to be definitely null (i.e. nullness.value = true),
+			// as that should be represented by a known null value instead. This encoding is in place to be compliant
+			// with Terraform's encoding which uses a definitely null refinement to collapse into a known null value.
+			err = refnEnc.EncodeBool(refnVal.Nullness())
 			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)
+		case refinement.StringPrefix:
+			if rawPrefix := refnVal.PrefixValue(); rawPrefix != "" {
+				// 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 := rawPrefix
+				if len(rawPrefix) > maxPrefixLength {
+					prefix = prefix[:maxPrefixLength-1]
+				}
+
+				err := refnEnc.EncodeInt(int64(refinement.KeyStringPrefix))
+				if err != nil {
+					return p.NewErrorf("error encoding StringPrefix value refinement key: %w", err)
+				}
+
+				err = refnEnc.EncodeString(prefix)
+				if err != nil {
+					return p.NewErrorf("error encoding StringPrefix value refinement: %w", err)
+				}
+
+				mapLen++
+			}
+
+		case refinement.NumberLowerBound:
+			// TODO: should check this isn't negative infinity? To match go-cty
+			boundTfType := Tuple{ElementTypes: []Type{Number, Bool}}
+
+			// TODO: Do we need to do this? Kind of nasty
+			boundTfVal := NewValue(
+				boundTfType,
+				[]Value{
+					NewValue(Number, refnVal.LowerBound()),
+					NewValue(Bool, refnVal.IsInclusive()),
+				},
+			)
+
+			err := refnEnc.EncodeInt(int64(refinement.KeyNumberLowerBound))
+			if err != nil {
+				return p.NewErrorf("error encoding NumberLowerBound value refinement key: %w", err)
+			}
+
+			err = marshalMsgPack(boundTfVal, boundTfType, p, refnEnc)
+			if err != nil {
+				return p.NewErrorf("error encoding NumberLowerBound value refinement: %w", err)
+			}
+
+			mapLen++
+		case refinement.NumberUpperBound:
+			// TODO: should check this isn't positive infinity? To match go-cty
+			boundTfType := Tuple{ElementTypes: []Type{Number, Bool}}
+
+			// TODO: Do we need to do this? Kind of nasty
+			boundTfVal := NewValue(
+				boundTfType,
+				[]Value{
+					NewValue(Number, refnVal.UpperBound()),
+					NewValue(Bool, refnVal.IsInclusive()),
+				},
+			)
+
+			err := refnEnc.EncodeInt(int64(refinement.KeyNumberUpperBound))
 			if err != nil {
-				return p.NewErrorf("error encoding StringPrefix value refinement: %w", err)
+				return p.NewErrorf("error encoding NumberUpperBound value refinement key: %w", err)
 			}
+
+			err = marshalMsgPack(boundTfVal, boundTfType, p, refnEnc)
+			if err != nil {
+				return p.NewErrorf("error encoding NumberUpperBound value refinement: %w", err)
+			}
+
 			mapLen++
 		default:
 			continue