chore: HCLString should always marshal to a singular string

Author: Emyrk

extract/json.go

@@ -36,6 +36,14 @@ func (p *stateParse) nullableInteger(key string) *int64 {
 	return &v
 }
 
+func (p *stateParse) nullableString(key string) *string {
+	if p.values[key] == nil {
+		return nil
+	}
+	v := optional[string](p.values, key)
+	return &v
+}
+
 func (p *stateParse) string(key string) string {
 	v, err := expected[string](p.values, key)
 	if err != nil {

extract/parameter.go

@@ -13,17 +13,19 @@ import (
 )
 
 func ParameterFromBlock(block *terraform.Block) (*types.Parameter, hcl.Diagnostics) {
-	diags := required(block, "name", "type")
+	diags := required(block, "name")
 	if diags.HasErrors() {
 		return nil, diags
 	}
 
-	pType, typDiag := requiredString("type", block)
+	pType, typDiag := optionalStringEnum[types.ParameterType](block, "type", types.ParameterTypeString, func(s types.ParameterType) error {
+		return s.Valid()
+	})
 	if typDiag != nil {
 		diags = diags.Append(typDiag)
 	}
 
-	pName, nameDiag := requiredString("name", block)
+	pName, nameDiag := requiredString(block, "name")
 	if nameDiag != nil {
 		diags = diags.Append(nameDiag)
 	}
@@ -87,7 +89,7 @@ func ParameterValidationFromBlock(block *terraform.Block) (types.ParameterValida
 		return types.ParameterValidation{}, diags
 	}
 
-	pErr, errDiag := requiredString("error", block)
+	pErr, errDiag := requiredString(block, "error")
 	if errDiag != nil {
 		diags = diags.Append(errDiag)
 	}
@@ -97,11 +99,11 @@ func ParameterValidationFromBlock(block *terraform.Block) (types.ParameterValida
 	}
 
 	p := types.ParameterValidation{
-		Regex:     optionalString(block, "regex"),
+		Regex:     nullableString(block, "regex"),
 		Error:     pErr,
 		Min:       nullableInteger(block, "min"),
 		Max:       nullableInteger(block, "max"),
-		Monotonic: optionalString(block, "monotonic"),
+		Monotonic: nullableString(block, "monotonic"),
 	}
 
 	return p, diags
@@ -113,12 +115,12 @@ func ParameterOptionFromBlock(block *terraform.Block) (types.ParameterOption, hc
 		return types.ParameterOption{}, diags
 	}
 
-	pName, nameDiag := requiredString("name", block)
+	pName, nameDiag := requiredString(block, "name")
 	if nameDiag != nil {
 		diags = diags.Append(nameDiag)
 	}
 
-	pVal, valDiag := requiredString("value", block)
+	pVal, valDiag := requiredString(block, "value")
 	if valDiag != nil {
 		diags = diags.Append(valDiag)
 	}
@@ -137,7 +139,29 @@ func ParameterOptionFromBlock(block *terraform.Block) (types.ParameterOption, hc
 	return p, diags
 }
 
-func requiredString(key string, block *terraform.Block) (string, *hcl.Diagnostic) {
+func optionalStringEnum[T ~string](block *terraform.Block, key string, def T, valid func(s T) error) (T, *hcl.Diagnostic) {
+	str := optionalString(block, key)
+	if str == "" {
+		return def, nil
+	}
+
+	if err := valid(T(str)); err != nil {
+		tyAttr := block.GetAttribute(key)
+		return "", &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Invalid %q attribute", key),
+			Detail:   err.Error(),
+			Subject:  &(tyAttr.HCLAttribute().Range),
+			//Context:     &(block.HCLBlock().DefRange),
+			Expression:  tyAttr.HCLAttribute().Expr,
+			EvalContext: block.Context().Inner(),
+		}
+	}
+
+	return T(str), nil
+}
+
+func requiredString(block *terraform.Block, key string) (string, *hcl.Diagnostic) {
 	tyAttr := block.GetAttribute(key)
 	tyVal := tyAttr.Value()
 	if tyVal.Type() != cty.String {
@@ -210,6 +234,20 @@ func optionalInteger(block *terraform.Block, key string) int64 {
 	return i
 }
 
+func nullableString(block *terraform.Block, key string) *string {
+	attr := block.GetAttribute(key)
+	if attr == nil || attr.IsNil() {
+		return nil
+	}
+	val := attr.Value()
+	if val.Type() != cty.String {
+		return nil
+	}
+
+	str := val.AsString()
+	return &str
+}
+
 func optionalString(block *terraform.Block, key string) string {
 	attr := block.GetAttribute(key)
 	if attr == nil || attr.IsNil() {

extract/state.go

@@ -56,7 +56,7 @@ func ParameterFromState(block *tfjson.StateResource) (types.Parameter, error) {
 		RichParameter: types.RichParameter{
 			Name:         st.string("name"),
 			Description:  st.optionalString("description"),
-			Type:         st.string("type"),
+			Type:         types.ParameterType(st.optionalString("type")),
 			Mutable:      st.optionalBool("mutable"),
 			DefaultValue: st.optionalString("default"),
 			Icon:         st.optionalString("icon"),
@@ -107,11 +107,11 @@ func parameterValidation(vals map[string]any) (*types.ParameterValidation, error
 	st := newStateParse(vals)
 
 	opt := types.ParameterValidation{
-		Regex:     st.optionalString("regex"),
+		Regex:     st.nullableString("regex"),
 		Error:     st.optionalString("error"),
 		Min:       st.nullableInteger("min"),
 		Max:       st.nullableInteger("max"),
-		Monotonic: st.optionalString("monotonic"),
+		Monotonic: st.nullableString("monotonic"),
 	}
 
 	if len(st.errors) > 0 {

internal/verify/cmp.go

@@ -1,6 +1,7 @@
 package verify
 
 import (
+	"encoding/json"
 	"testing"
 
 	tfjson "github.com/hashicorp/terraform-json"
@@ -34,8 +35,13 @@ func CompareParameters(t *testing.T, pr *preview.Output, values *tfjson.StateMod
 	types.SortParameters(stateParams)
 	types.SortParameters(pr.Parameters)
 	for i, param := range stateParams {
-		// TODO: A better compare function would be easier to debug
-		assert.Equal(t, param, pr.Parameters[i], "parameter %q %d", param.Name, i)
+		adata, err := json.Marshal(param)
+		require.NoError(t, err, "marshal parameter %q", param.Name)
+
+		bdata, err := json.Marshal(pr.Parameters[i])
+		require.NoError(t, err, "marshal parameter %q", pr.Parameters[i].Name)
+
+		require.JSONEq(t, string(adata), string(bdata), "parameter %q", param.Name)
 	}
 
 	return passed

types/enum.go

@@ -0,0 +1,30 @@
+package types
+
+import (
+	"fmt"
+	"strings"
+)
+
+type ParameterType string
+
+const (
+	ParameterTypeString     ParameterType = "string"
+	ParameterTypeNumber     ParameterType = "number"
+	ParameterTypeBoolean    ParameterType = "boolean"
+	ParameterTypeListString ParameterType = "list(string)"
+)
+
+func (t ParameterType) Valid() error {
+	switch t {
+	case ParameterTypeString, ParameterTypeNumber, ParameterTypeBoolean, ParameterTypeListString:
+		return nil
+	default:
+		return fmt.Errorf("invalid parameter type %q, expected one of [%s]", t,
+			strings.Join([]string{
+				string(ParameterTypeString),
+				string(ParameterTypeNumber),
+				string(ParameterTypeBoolean),
+				string(ParameterTypeListString),
+			}, ", "))
+	}
+}

types/parameter.go

@@ -43,7 +43,7 @@ type RichParameter struct {
 	Name         string                 `json:"name"`
 	DisplayName  string                 `json:"display_name"`
 	Description  string                 `json:"description"`
-	Type         string                 `json:"type"`
+	Type         ParameterType          `json:"type"`
 	Mutable      bool                   `json:"mutable"`
 	DefaultValue string                 `json:"default_value"`
 	Icon         string                 `json:"icon"`
@@ -56,11 +56,11 @@ type RichParameter struct {
 }
 
 type ParameterValidation struct {
-	Regex     string `json:"validation_regex"`
-	Error     string `json:"validation_error"`
-	Min       *int64 `json:"validation_min"`
-	Max       *int64 `json:"validation_max"`
-	Monotonic string `json:"validation_monotonic"`
+	Regex     *string `json:"validation_regex"`
+	Error     string  `json:"validation_error"`
+	Min       *int64  `json:"validation_min"`
+	Max       *int64  `json:"validation_max"`
+	Monotonic *string `json:"validation_monotonic"`
 }
 
 type ParameterOption struct {

types/parameter_test.go

@@ -21,7 +21,7 @@ type HCLString struct {
 	Source *string
 }
 
-func (s *HCLString) MarshalJSON() ([]byte, error) {
+func (s HCLString) MarshalJSON() ([]byte, error) {
 	return json.Marshal(s.AsString())
 }