Add type-based provider-defined function parameter validation

attr/xattr/attribute.go

@@ -0,0 +1,37 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+// TODO: Just putting here for the moment to get rid of import cycle.
+package xattr
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/path"
+)
+
+// ValidateableAttribute defines an interface for validating an attribute value.
+type ValidateableAttribute interface {
+	// ValidateAttribute returns any warnings or errors generated during validation
+	// of the attribute. It is generally used to check the data format and ensure
+	// that it complies with the requirements of the Value.
+	ValidateAttribute(context.Context, ValidateAttributeRequest, *ValidateAttributeResponse)
+}
+
+// ValidateAttributeRequest represents a request for the Value to call its
+// validation logic. An instance of this request struct is supplied as an
+// argument to the ValidateAttribute method.
+type ValidateAttributeRequest struct {
+	// Path is the path to the attribute being validated.
+	Path path.Path
+}
+
+// ValidateAttributeResponse represents a response to a ValidateAttributeRequest.
+// An instance of this response struct is supplied as an argument to the
+// ValidateAttribute method.
+type ValidateAttributeResponse struct {
+	// Diagnostics is a collection of warnings or errors generated during
+	// validation of the Value.
+	Diagnostics diag.Diagnostics
+}

attr/xattr/type.go

@@ -6,14 +6,18 @@ package xattr
 import (
 	"context"
 
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+
 	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/hashicorp/terraform-plugin-framework/path"
-	"github.com/hashicorp/terraform-plugin-go/tftypes"
 )
 
 // TypeWithValidate extends the attr.Type interface to include a Validate
 // method, used to bundle consistent validation logic with the Type.
+//
+// Deprecated: Use the value type-specific AttributeWithValidate and
+// ParameterWithValidate interfaces in the validation package instead.
 type TypeWithValidate interface {
 	attr.Type
 

internal/fromproto5/arguments_data.go

@@ -7,44 +7,41 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/hashicorp/terraform-plugin-go/tfprotov5"
+
 	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/attr/xattr"
-	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/hashicorp/terraform-plugin-framework/function"
 	"github.com/hashicorp/terraform-plugin-framework/internal/logging"
 	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-	"github.com/hashicorp/terraform-plugin-go/tfprotov5"
+	"github.com/hashicorp/terraform-plugin-framework/types/validation"
 )
 
 // ArgumentsData returns the ArgumentsData for a given []*tfprotov5.DynamicValue
 // and function.Definition.
-func ArgumentsData(ctx context.Context, arguments []*tfprotov5.DynamicValue, definition function.Definition) (function.ArgumentsData, diag.Diagnostics) {
+func ArgumentsData(ctx context.Context, arguments []*tfprotov5.DynamicValue, definition function.Definition) (function.ArgumentsData, *function.FuncError) {
 	if definition.VariadicParameter == nil && len(arguments) != len(definition.Parameters) {
-		return function.NewArgumentsData(nil), diag.Diagnostics{
-			diag.NewErrorDiagnostic(
-				"Unexpected Function Arguments Data",
-				"The provider received an unexpected number of function arguments from Terraform for the given function definition. "+
-					"This is always an issue in terraform-plugin-framework or Terraform itself and should be reported to the provider developers.\n\n"+
-					fmt.Sprintf("Expected function arguments: %d\n", len(definition.Parameters))+
-					fmt.Sprintf("Given function arguments: %d", len(arguments)),
-			),
-		}
+		return function.NewArgumentsData(nil), function.NewFuncError(
+			"Unexpected Function Arguments Data: " +
+				"The provider received an unexpected number of function arguments from Terraform for the given function definition. " +
+				"This is always an issue in terraform-plugin-framework or Terraform itself and should be reported to the provider developers.\n\n" +
+				fmt.Sprintf("Expected function arguments: %d\n", len(definition.Parameters)) +
+				fmt.Sprintf("Given function arguments: %d", len(arguments)),
+		)
 	}
 
 	// Expect at least all parameters to have corresponding arguments. Variadic
 	// parameter might have 0 to n arguments, which is why it is not checked in
 	// this case.
 	if len(arguments) < len(definition.Parameters) {
-		return function.NewArgumentsData(nil), diag.Diagnostics{
-			diag.NewErrorDiagnostic(
-				"Unexpected Function Arguments Data",
-				"The provider received an unexpected number of function arguments from Terraform for the given function definition. "+
-					"This is always an issue in terraform-plugin-framework or Terraform itself and should be reported to the provider developers.\n\n"+
-					fmt.Sprintf("Expected minimum function arguments: %d\n", len(definition.Parameters))+
-					fmt.Sprintf("Given function arguments: %d", len(arguments)),
-			),
-		}
+		return function.NewArgumentsData(nil), function.NewFuncError(
+			"Unexpected Function Arguments Data: " +
+				"The provider received an unexpected number of function arguments from Terraform for the given function definition. " +
+				"This is always an issue in terraform-plugin-framework or Terraform itself and should be reported to the provider developers.\n\n" +
+				fmt.Sprintf("Expected minimum function arguments: %d\n", len(definition.Parameters)) +
+				fmt.Sprintf("Given function arguments: %d", len(arguments)),
+		)
 	}
 
 	if definition.VariadicParameter == nil && len(arguments) == 0 {
@@ -54,73 +51,115 @@ func ArgumentsData(ctx context.Context, arguments []*tfprotov5.DynamicValue, def
 	// Variadic values are collected as a separate tuple to ease developer usage.
 	argumentValues := make([]attr.Value, 0, len(definition.Parameters))
 	variadicValues := make([]attr.Value, 0, len(arguments)-len(definition.Parameters))
-	var diags diag.Diagnostics
+	var funcError *function.FuncError
 
 	for position, argument := range arguments {
 		parameter, parameterDiags := definition.Parameter(ctx, position)
 
-		diags.Append(parameterDiags...)
+		funcError = function.ConcatFuncErrors(funcError, function.FuncErrorFromDiags(ctx, parameterDiags))
 
-		if diags.HasError() {
-			return function.NewArgumentsData(nil), diags
+		if funcError != nil {
+			return function.NewArgumentsData(nil), funcError
 		}
 
 		parameterType := parameter.GetType()
 
+		pos := int64(position)
+
 		if parameterType == nil {
-			diags.AddError(
-				"Unable to Convert Function Argument",
-				"An unexpected error was encountered when converting the function argument from the protocol type. "+
+			funcError = function.ConcatFuncErrors(funcError, function.NewArgumentFuncError(
+				pos,
+				"Unable to Convert Function Argument: "+
+					"An unexpected error was encountered when converting the function argument from the protocol type. "+
 					"This is always an issue in terraform-plugin-framework used to implement the provider and should be reported to the provider developers.\n\n"+
 					"Please report this to the provider developer:\n\n"+
 					fmt.Sprintf("Parameter type missing at position %d", position),
-			)
+			))
 
-			return function.NewArgumentsData(nil), diags
+			return function.NewArgumentsData(nil), funcError
 		}
 
 		tfValue, err := argument.Unmarshal(parameterType.TerraformType(ctx))
 
 		if err != nil {
-			diags.AddError(
-				"Unable to Convert Function Argument",
-				"An unexpected error was encountered when converting the function argument from the protocol type. "+
+			funcError = function.ConcatFuncErrors(funcError, function.NewArgumentFuncError(
+				pos,
+				"Unable to Convert Function Argument: "+
+					"An unexpected error was encountered when converting the function argument from the protocol type. "+
 					"This is always an issue in terraform-plugin-framework used to implement the provider and should be reported to the provider developers.\n\n"+
 					"Please report this to the provider developer:\n\n"+
 					fmt.Sprintf("Unable to unmarshal DynamicValue at position %d: %s", position, err),
-			)
+			))
 
-			return function.NewArgumentsData(nil), diags
+			return function.NewArgumentsData(nil), funcError
 		}
 
 		attrValue, err := parameterType.ValueFromTerraform(ctx, tfValue)
 
 		if err != nil {
-			diags.AddError(
-				"Unable to Convert Function Argument",
-				"An unexpected error was encountered when converting the function argument from the protocol type. "+
+			funcError = function.ConcatFuncErrors(funcError, function.NewArgumentFuncError(
+				pos,
+				"Unable to Convert Function Argument"+
+					"An unexpected error was encountered when converting the function argument from the protocol type. "+
 					"Please report this to the provider developer:\n\n"+
-					fmt.Sprintf("Unable to convert tftypes to framework type at position %d: %s", position, err),
-			)
+					fmt.Sprintf("Unable to convert tftypes to framework type at position %d: %stringVal", position, err),
+			))
 
-			return function.NewArgumentsData(nil), diags
+			return function.NewArgumentsData(nil), funcError
 		}
 
-		// This is intentionally below the attr.Value conversion so it can be
-		// updated for any new type system validation interfaces. Note that the
+		// This is intentionally below the conversion of tftypes.Value to attr.Value
+		// so it can be updated for any new type system validation interfaces. Note that the
 		// original xattr.TypeWithValidation interface must set a path.Path,
 		// which will always be incorrect in the context of functions.
 		// Reference: https://github.com/hashicorp/terraform-plugin-framework/issues/589
 		// Reference: https://github.com/hashicorp/terraform-plugin-framework/issues/893
-		if attrTypeWithValidate, ok := parameterType.(xattr.TypeWithValidate); ok {
-			logging.FrameworkTrace(ctx, "Parameter type implements TypeWithValidate")
-			logging.FrameworkTrace(ctx, "Calling provider defined Type Validate")
-			diags.Append(attrTypeWithValidate.Validate(ctx, tfValue, path.Empty())...)
-			logging.FrameworkTrace(ctx, "Called provider defined Type Validate")
+		switch t := attrValue.(type) {
+		case validation.ValidateableParameter:
+			resp := validation.ValidateParameterResponse{}
+
+			logging.FrameworkTrace(ctx, "Parameter value implements ValidateableParameter")
+			logging.FrameworkTrace(ctx, "Calling provider defined Value ValidateParameter")
+
+			t.ValidateParameter(ctx,
+				validation.ValidateParameterRequest{
+					Position: pos,
+				},
+				&resp,
+			)
+
+			logging.FrameworkTrace(ctx, "Called provider defined Value ValidateParameter")
+
+			if resp.Error != nil {
+				funcError = function.ConcatFuncErrors(funcError, function.NewArgumentFuncError(
+					pos,
+					resp.Error.Error(),
+				))
 
-			if diags.HasError() {
 				continue
 			}
+		default:
+			//nolint:staticcheck // xattr.TypeWithValidate is deprecated, but we still need to support it.
+			if t, ok := parameterType.(xattr.TypeWithValidate); ok {
+				logging.FrameworkTrace(ctx, "Parameter type implements TypeWithValidate")
+				logging.FrameworkTrace(ctx, "Calling provider defined Type Validate")
+
+				diags := t.Validate(ctx, tfValue, path.Empty())
+
+				logging.FrameworkTrace(ctx, "Called provider defined Type Validate")
+
+				if diags.HasError() {
+					funcErrFromDiags := function.FuncErrorFromDiags(ctx, diags)
+
+					if funcErrFromDiags != nil {
+						funcError = function.ConcatFuncErrors(funcError, function.NewArgumentFuncError(
+							pos,
+							funcErrFromDiags.Error()))
+					}
+
+					continue
+				}
+			}
 		}
 
 		if definition.VariadicParameter != nil && position >= len(definition.Parameters) {
@@ -155,18 +194,14 @@ func ArgumentsData(ctx context.Context, arguments []*tfprotov5.DynamicValue, def
 
 		variadicValue, variadicValueDiags := basetypes.NewTupleValue(tupleTypes, tupleValues)
 
-		diags.Append(variadicValueDiags...)
+		funcError = function.ConcatFuncErrors(funcError, function.FuncErrorFromDiags(ctx, variadicValueDiags))
 
-		if diags.HasError() {
-			return function.NewArgumentsData(argumentValues), diags
+		if funcError != nil {
+			return function.NewArgumentsData(argumentValues), funcError
 		}
 
 		argumentValues = append(argumentValues, variadicValue)
 	}
 
-	if diags.HasError() {
-		return function.NewArgumentsData(nil), diags
-	}
-
-	return function.NewArgumentsData(argumentValues), diags
+	return function.NewArgumentsData(argumentValues), funcError
 }