fix: Correctly marshal/unmarshal custom types when null/unknown

ovh/types/bool.go

@@ -21,17 +21,24 @@ type TfBoolValue struct {
 var _ basetypes.BoolValuable = TfBoolValue{}
 
 func (t *TfBoolValue) UnmarshalJSON(data []byte) error {
-	var v bool
+	var v *bool
 	if err := json.Unmarshal(data, &v); err != nil {
 		return err
 	}
 
-	t.BoolValue = basetypes.NewBoolValue(v)
+	if v == nil {
+		t.BoolValue = basetypes.NewBoolNull()
+	} else {
+		t.BoolValue = basetypes.NewBoolValue(*v)
+	}
 
 	return nil
 }
 
 func (t TfBoolValue) MarshalJSON() ([]byte, error) {
+	if t.IsNull() || t.IsUnknown() {
+		return []byte("null"), nil
+	}
 	return json.Marshal(t.BoolValue.ValueBool())
 }
 

ovh/types/int64.go

@@ -72,17 +72,24 @@ type TfInt64Value struct {
 var _ basetypes.Int64Valuable = TfInt64Value{}
 
 func (t *TfInt64Value) UnmarshalJSON(data []byte) error {
-	var v int64
+	var v *int64
 	if err := json.Unmarshal(data, &v); err != nil {
 		return err
 	}
 
-	t.Int64Value = basetypes.NewInt64Value(v)
+	if v == nil {
+		t.Int64Value = basetypes.NewInt64Null()
+	} else {
+		t.Int64Value = basetypes.NewInt64Value(*v)
+	}
 
 	return nil
 }
 
 func (t TfInt64Value) MarshalJSON() ([]byte, error) {
+	if t.IsNull() || t.IsUnknown() {
+		return []byte("null"), nil
+	}
 	return json.Marshal(t.Int64Value.ValueInt64())
 }
 

ovh/types/list.go

@@ -130,26 +130,34 @@ var _ basetypes.SetValuable = (*TfListNestedValue[attr.Value])(nil)
 
 func (t *TfListNestedValue[T]) UnmarshalJSON(data []byte) error {
 	var v []T
-	var d []attr.Value
 
 	if err := json.Unmarshal(data, &v); err != nil {
 		return err
 	}
 
-	for _, c := range v {
-		d = append(d, c)
-	}
-
 	var zero T
-	t.ListValue = basetypes.NewListValueMust(zero.Type(context.Background()), d)
+
+	if v == nil {
+		t.ListValue = basetypes.NewListNull(zero.Type(context.Background()))
+	} else {
+		d := make([]attr.Value, 0, len(v))
+		for _, c := range v {
+			d = append(d, c)
+		}
+		t.ListValue = basetypes.NewListValueMust(zero.Type(context.Background()), d)
+	}
 
 	return nil
 }
 
 func (t TfListNestedValue[T]) MarshalJSON() ([]byte, error) {
-	var toMarshal []T
+	if t.IsNull() || t.IsUnknown() {
+		return []byte("null"), nil
+	}
 
-	for _, elem := range t.Elements() {
+	elems := t.Elements()
+	toMarshal := make([]T, 0, len(elems))
+	for _, elem := range elems {
 		toMarshal = append(toMarshal, elem.(T))
 	}
 

ovh/types/map.go

@@ -99,22 +99,39 @@ type TfMapNestedValue[T attr.Value] struct {
 
 func (v *TfMapNestedValue[T]) UnmarshalJSON(data []byte) error {
 	var mm map[string]T
-	d := make(map[string]attr.Value)
 
 	if err := json.Unmarshal(data, &mm); err != nil {
 		return err
 	}
 
-	for k, v := range mm {
-		d[k] = v
-	}
-
 	var zero T
-	v.MapValue = basetypes.NewMapValueMust(zero.Type(context.Background()), d)
+	if mm == nil {
+		v.MapValue = basetypes.NewMapNull(zero.Type(context.Background()))
+	} else {
+		d := make(map[string]attr.Value, len(mm))
+		for k, v := range mm {
+			d[k] = v
+		}
+		v.MapValue = basetypes.NewMapValueMust(zero.Type(context.Background()), d)
+	}
 
 	return nil
 }
 
+func (t TfMapNestedValue[T]) MarshalJSON() ([]byte, error) {
+	if t.IsNull() || t.IsUnknown() {
+		return []byte("null"), nil
+	}
+
+	elems := t.Elements()
+	toMarshal := make(map[string]T, len(elems))
+	for key, elem := range elems {
+		toMarshal[key] = elem.(T)
+	}
+
+	return json.Marshal(toMarshal)
+}
+
 // ToTerraformValue returns the data contained in the Map as a tftypes.Value.
 func (v TfMapNestedValue[T]) ToTerraformValue(ctx context.Context) (tftypes.Value, error) {
 

ovh/types/number.go

@@ -71,17 +71,25 @@ type TfNumberValue struct {
 var _ basetypes.NumberValuable = TfNumberValue{}
 
 func (t *TfNumberValue) UnmarshalJSON(data []byte) error {
-	var v float64
+	var v *float64
 	if err := json.Unmarshal(data, &v); err != nil {
 		return err
 	}
 
-	t.NumberValue = basetypes.NewNumberValue(big.NewFloat(v))
+	if v == nil {
+		t.NumberValue = basetypes.NewNumberNull()
+	} else {
+		t.NumberValue = basetypes.NewNumberValue(big.NewFloat(*v))
+	}
 
 	return nil
 }
 
 func (t TfNumberValue) MarshalJSON() ([]byte, error) {
+	if t.IsNull() || t.IsUnknown() {
+		return []byte("null"), nil
+	}
+
 	floatVal, _ := t.ValueBigFloat().Float64()
 	return json.Marshal(floatVal)
 }

ovh/types/string.go

@@ -21,17 +21,24 @@ type TfStringValue struct {
 var _ basetypes.StringValuable = TfStringValue{}
 
 func (t *TfStringValue) UnmarshalJSON(data []byte) error {
-	var v string
+	var v *string
 	if err := json.Unmarshal(data, &v); err != nil {
 		return err
 	}
 
-	t.StringValue = basetypes.NewStringValue(v)
+	if v == nil {
+		t.StringValue = basetypes.NewStringNull()
+	} else {
+		t.StringValue = basetypes.NewStringValue(*v)
+	}
 
 	return nil
 }
 
 func (t TfStringValue) MarshalJSON() ([]byte, error) {
+	if t.IsNull() || t.IsUnknown() {
+		return []byte("null"), nil
+	}
 	return json.Marshal(t.StringValue.ValueString())
 }