chore: add parameter min/max/regex validation

Author: Emyrk

cli/clidisplay/resources.go

@@ -1,6 +1,7 @@
 package clidisplay
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 	"strings"
@@ -49,7 +50,7 @@ func WorkspaceTags(writer io.Writer, tags types.TagBlocks) hcl.Diagnostics {
 	return diags
 }
 
-func Parameters(writer io.Writer, params []types.Parameter) {
+func Parameters(writer io.Writer, params []types.Parameter, files map[string]*hcl.File) {
 	tableWriter := table.NewWriter()
 	//tableWriter.SetTitle("Parameters")
 	tableWriter.SetStyle(table.StyleLight)
@@ -73,6 +74,14 @@ func Parameters(writer io.Writer, params []types.Parameter) {
 		tableWriter.AppendRow(table.Row{
 			fmt.Sprintf("%s: %s\n%s", p.Name, p.Description, formatOptions(strVal, p.Options)),
 		})
+
+		if hcl.Diagnostics(p.Diagnostics).HasErrors() {
+			var out bytes.Buffer
+			WriteDiagnostics(&out, files, hcl.Diagnostics(p.Diagnostics))
+			tableWriter.AppendRow(table.Row{out.String()})
+
+		}
+
 		tableWriter.AppendSeparator()
 	}
 	_, _ = fmt.Fprintln(writer, tableWriter.Render())

cli/root.go

@@ -87,7 +87,7 @@ func (r *RootCmd) Root() *serpent.Command {
 				clidisplay.WriteDiagnostics(os.Stderr, output.Files, diags)
 			}
 
-			clidisplay.Parameters(os.Stdout, output.Parameters)
+			clidisplay.Parameters(os.Stdout, output.Parameters, output.Files)
 
 			return nil
 		},

extract/parameter.go

@@ -77,6 +77,40 @@ func ParameterFromBlock(block *terraform.Block) (*types.Parameter, hcl.Diagnosti
 		p.Validations = append(p.Validations, &valid)
 	}
 
+	ctyType, err := p.CtyType()
+	if err != nil {
+		paramTypeDiag := &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Invalid parameter type %q", p.Type),
+			Detail:   err.Error(),
+			Context:  &block.HCLBlock().DefRange,
+		}
+
+		if attr := block.GetAttribute("type"); attr != nil && !attr.IsNil() {
+			paramTypeDiag.Subject = &attr.HCLAttribute().Range
+			paramTypeDiag.Expression = attr.HCLAttribute().Expr
+			paramTypeDiag.EvalContext = block.Context().Inner()
+		}
+		diags = diags.Append(paramTypeDiag)
+	}
+
+	if ctyType != cty.NilType && pVal.Value.Type().Equals(cty.String) {
+		// TODO: Wish we could support more types, but only string types are
+		// allowed.
+		valStr := pVal.Value.AsString()
+		// Apply validations to the parameter value
+		for _, v := range p.Validations {
+			if err := v.Valid(valStr); err != nil {
+				diags = diags.Append(&hcl.Diagnostic{
+					Severity:   hcl.DiagError,
+					Summary:    fmt.Sprintf("Paramater validation failed for value %q", valStr),
+					Detail:     err.Error(),
+					Expression: pVal.ValueExpr,
+				})
+			}
+		}
+	}
+
 	// Diagnostics are scoped to the parameter
 	p.Diagnostics = types.Diagnostics(diags)
 

testdata/conditional/main.tf

@@ -22,6 +22,11 @@ data "coder_parameter" "project" {
     value = "small"
     description = "The small project with minimal resource requirements to work on."
   }
+
+  validation {
+    regex = "^massive|small$"
+    error = "You must select either massive or small."
+  }
 }
 
 locals {

types/parameter.go

@@ -2,10 +2,13 @@ package types
 
 import (
 	"fmt"
+	"regexp"
 	"slices"
+	"strconv"
 	"strings"
 
 	"github.com/zclconf/go-cty/cty"
+	"golang.org/x/xerrors"
 )
 
 // @typescript-ignore BlockTypeParameter
@@ -63,6 +66,50 @@ type ParameterValidation struct {
 	Monotonic *string `json:"validation_monotonic"`
 }
 
+// TODO: Match implementation from https://github.com/coder/terraform-provider-coder/blob/main/provider/parameter.go#L404-L462
+// TODO: Does the value have to be an option from the set of options?
+func (v ParameterValidation) Valid(p string) error {
+	validErr := xerrors.New(v.errorRendered(p))
+	if v.Regex != nil {
+		exp, err := regexp.Compile(*v.Regex)
+		if err != nil {
+			return fmt.Errorf("invalid regex %q: %w", *v.Regex, err)
+		}
+
+		if !exp.MatchString(p) {
+			return validErr
+		}
+	}
+
+	if v.Min != nil || v.Max != nil {
+		vd, err := strconv.ParseInt(p, 10, 64)
+		if err != nil {
+			return fmt.Errorf("invalid number value %q: %w", p, err)
+		}
+
+		if v.Min != nil && vd < *v.Min {
+			return validErr
+		}
+
+		if v.Max != nil && vd > *v.Max {
+			return validErr
+		}
+	}
+
+	// Monotonic?
+
+	return nil
+}
+
+func (v ParameterValidation) errorRendered(value string) string {
+	r := strings.NewReplacer(
+		"{min}", fmt.Sprintf("%d", safeDeref(v.Min)),
+		"{max}", fmt.Sprintf("%d", safeDeref(v.Max)),
+		"{value}", value,
+	)
+	return r.Replace(v.Error)
+}
+
 type ParameterOption struct {
 	Name        string `json:"name"`
 	Description string `json:"description"`
@@ -83,6 +130,14 @@ func (r *RichParameter) CtyType() (cty.Type, error) {
 	case "list(string)":
 		return cty.List(cty.String), nil
 	default:
-		return cty.Type{}, fmt.Errorf("unsupported type: %q", r.Type)
+		return cty.NilType, fmt.Errorf("unsupported type: %q", r.Type)
+	}
+}
+
+func safeDeref[T any](v *T) T {
+	if v == nil {
+		var zero T
+		return zero
 	}
+	return *v
 }