prep valid function to inherit from provider repo

Author: Emyrk

extract/parameter.go

@@ -101,7 +101,7 @@ func ParameterFromBlock(block *terraform.Block) (*types.Parameter, hcl.Diagnosti
 		valStr := pVal.Value.AsString()
 		// Apply validations to the parameter value
 		for _, v := range p.Validations {
-			if err := v.Valid(valStr); err != nil {
+			if err := v.Valid(string(pType), valStr); err != nil {
 				diags = diags.Append(&hcl.Diagnostic{
 					Severity:   hcl.DiagError,
 					Summary:    fmt.Sprintf("Paramater validation failed for value %q", valStr),

todo.md

@@ -2,24 +2,23 @@
 
 ## Errors
 
-- Dynamic parameter names? Changing names?
-- `terraform init` not run before a `preview` fails to load a module. Should this prevent a preview?
+- Dynamic parameter names? A parameter's name can change. Should we throw a warning if it is not static?
+- [18](https://github.com/coder/preview/issues/18) `terraform init` not run before a `preview` fails to load a module. Should this prevent a preview?
 
 ## Security
 
-- Ensure local disk is not accessible from terraform
-- Ensure no remote http requests for module fetching
+- [19](https://github.com/coder/preview/issues/19) Ensure local disk is not accessible from terraform
+- [20](https://github.com/coder/preview/issues/20) Ensure no remote http requests for module fetching
 
 ## Performance
 
-- Ensure no remote http requests for module fetching
 - Plan hook replaces the same context for every block in a module. This work is duplicated and could be trimmed down.
-- Ensure no panics can occur during a preview.
+- [21](https://github.com/coder/preview/issues/21) Ensure no panics can occur during a preview.
 
 ## Features
 
 - Allow a "force submit" to bypass any `preview` errors. This would defer to the terraform errors (basically the status quo today)
-- Errors during the parsing should be reported.
+- [22](https://github.com/coder/preview/issues/22) Errors during the parsing should be reported.
 - Errors during the hooks should be reported.
 - Interactive shell to debug references
 
@@ -34,15 +33,16 @@
 ## Verification
 
 - Nested blocks (within 1 module) should have correct context set via plan files. Since plan files are set on the parent, the parent of a sub-block is the incorrect level for a context.
+ - This might be already correct
 
 ## Debt
 
-- Implement `validation` blocks with a common code component to be reused by terraform provider?
+- [23](https://github.com/coder/preview/issues/23) Implement `validation` blocks with a common code component to be reused by terraform provider?
 - Parameter values/defaults are only `string` types. 
 
 ## Upstream work
 
-- How will the hooks work if they cannot be merged upstream? Alternative?
+- [24](https://github.com/coder/preview/issues/24)How will the hooks work if they cannot be merged upstream? Alternative?
   - Load in plan state
   - Semantics for parameter coder blocks
 
@@ -52,8 +52,8 @@
 
 ## Bugs
 
-- Submodule references ignored in `count` meta arguments (and dynamic blocks)?
- - https://github.com/aquasecurity/trivy/pull/8479 
+- [25](https://github.com/coder/preview/issues/25) Submodule references ignored in `count` meta arguments (and dynamic blocks)?
+  - https://github.com/aquasecurity/trivy/pull/8479 
 
 ## Websocket demo
 

types/parameter.go

@@ -1,6 +1,8 @@
 package types
 
 import (
+	"encoding/json"
+	"errors"
 	"fmt"
 	"regexp"
 	"slices"
@@ -16,6 +18,9 @@ import (
 const (
 	BlockTypeParameter    = "coder_parameter"
 	BlockTypeWorkspaceTag = "coder_workspace_tag"
+
+	ValidationMonotonicIncreasing = "increasing"
+	ValidationMonotonicDecreasing = "decreasing"
 )
 
 func SortParameters(lists []Parameter) {
@@ -59,55 +64,106 @@ type RichParameter struct {
 }
 
 type ParameterValidation struct {
+	Error string `json:"validation_error"`
+
+	// All validation attributes are optional.
 	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"`
 }
 
 // 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)
+
+// Valid takes the type of the value and the value itself and returns an error
+// if the value is invalid.
+func (v ParameterValidation) Valid(typ, value string) error {
+	if typ != "number" {
+		var cannot []string
+		if v.Min != nil {
+			cannot = append(cannot, "min")
+		}
+
+		if v.Max != nil {
+			cannot = append(cannot, "max")
+		}
+
+		if v.Monotonic != nil {
+			cannot = append(cannot, "monotonic")
 		}
 
-		if !exp.MatchString(p) {
-			return validErr
+		if len(cannot) == 1 {
+			return fmt.Errorf("field %q is not supported for the type %q", cannot[0], typ)
 		}
+
+		if len(cannot) > 1 {
+			return fmt.Errorf("fields [%s] are not supported for the type %q", strings.Join(cannot, ", "), typ)
+		}
+	}
+
+	if typ != "string" && v.Regex != nil {
+		return fmt.Errorf("field %q is not supported for the type %q", "regex", typ)
 	}
 
-	if v.Min != nil || v.Max != nil {
-		vd, err := strconv.ParseInt(p, 10, 64)
+	switch typ {
+	case "bool":
+		// Terraform boolean literals are "true" and "false" case-sensitive.
+		// Do not allow alternate casing.
+		if value != "true" && value != "false" {
+			return fmt.Errorf(`boolean value can be either "true" or "false"`)
+		}
+		return nil
+	case "string":
+		if v.Regex == nil {
+			return nil
+		}
+
+		exp, err := regexp.Compile(*v.Regex)
 		if err != nil {
-			return fmt.Errorf("invalid number value %q: %w", p, err)
+			return fmt.Errorf("compile regex %q: %s", *v.Regex, err)
 		}
 
-		if v.Min != nil && vd < *v.Min {
-			return validErr
+		if v.Error == "" {
+			return fmt.Errorf("an error must be specified with a regex validation")
 		}
 
-		if v.Max != nil && vd > *v.Max {
-			return validErr
+		matched := exp.MatchString(value)
+		if !matched {
+			return fmt.Errorf("%s (value %q does not match %q)", v.errorRendered(value), value, exp)
+		}
+	case "number":
+		num, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return takeFirstError(v.errorRendered(value), fmt.Errorf("value %q is not a number", value))
+		}
+		if v.Min != nil && num < *v.Min {
+			return takeFirstError(v.errorRendered(value), fmt.Errorf("value %d is less than the minimum %d", num, v.Min))
+		}
+		if v.Max != nil && num > *v.Max {
+			return takeFirstError(v.errorRendered(value), fmt.Errorf("value %d is more than the maximum %d", num, v.Max))
+		}
+		if v.Monotonic != nil && *v.Monotonic != ValidationMonotonicIncreasing && *v.Monotonic != ValidationMonotonicDecreasing {
+			return fmt.Errorf("number monotonicity can be either %q or %q", ValidationMonotonicIncreasing, ValidationMonotonicDecreasing)
+		}
+	case "list(string)":
+		var listOfStrings []string
+		err := json.Unmarshal([]byte(value), &listOfStrings)
+		if err != nil {
+			return fmt.Errorf("value %q is not valid list of strings", value)
 		}
 	}
 
-	// Monotonic?
-
 	return nil
 }
 
-func (v ParameterValidation) errorRendered(value string) string {
+func (v ParameterValidation) errorRendered(value string) error {
 	r := strings.NewReplacer(
 		"{min}", fmt.Sprintf("%d", safeDeref(v.Min)),
 		"{max}", fmt.Sprintf("%d", safeDeref(v.Max)),
 		"{value}", value,
 	)
-	return r.Replace(v.Error)
+	return errors.New(r.Replace(v.Error))
 }
 
 type ParameterOption struct {
@@ -141,3 +197,12 @@ func safeDeref[T any](v *T) T {
 	}
 	return *v
 }
+
+func takeFirstError(errs ...error) error {
+	for _, err := range errs {
+		if err != nil {
+			return err
+		}
+	}
+	return xerrors.Errorf("developer error: error message is not provided")
+}