fix: Validator Bind can't cast value

validation/validation.go

@@ -2,8 +2,7 @@
 
 import (
 	"errors"
-	"reflect"
-	"time"
+	"net/url"
 
 	"github.com/gookit/validate"
 
@@ -29,34 +28,25 @@
 		return nil, errors.New("rules can't be empty")
 	}
 
-	var dataType reflect.Kind
-	switch data := data.(type) {
+	var dataFace validate.DataFace
+	var err error
+	switch td := data.(type) {
+	case validate.DataFace:
+		dataFace = td
 	case map[string]any:
-		if len(data) == 0 {
+		if len(td) == 0 {
 			return nil, errors.New("data can't be empty")
 		}
-		dataType = reflect.Map
-	}
-
-	val := reflect.ValueOf(data)
-	indirectVal := reflect.Indirect(val)
-	typ := indirectVal.Type()
-	if indirectVal.Kind() == reflect.Struct && typ != reflect.TypeOf(time.Time{}) {
-		dataType = reflect.Struct
-	}
-
-	var dataFace validate.DataFace
-	switch dataType {
-	case reflect.Map:
-		dataFace = validate.FromMap(data.(map[string]any))
-	case reflect.Struct:
-		var err error
+		dataFace = validate.FromMap(td)
+	case url.Values:
+		dataFace = validate.FromURLValues(td)
+	case map[string][]string:
+		dataFace = validate.FromURLValues(td)
+	default:
 		dataFace, err = validate.FromStruct(data)
 		if err != nil {
 			return nil, err
 		}
-	default:
-		return nil, errors.New("data must be map[string]any or struct")
 	}
 
 	options = append(options, Rules(rules), CustomRules(r.rules))
@@ -70,7 +60,7 @@
 	v := dataFace.Create()
 	AppendOptions(v, generateOptions)
 
-	return NewValidator(v, dataFace), nil
+	return NewValidator(v), nil
 }
 
 func (r *Validation) AddRules(rules []validatecontract.Rule) error {

validation/validation_test.go

@@ -45,7 +45,7 @@ func TestMake(t *testing.T) {
 			description: "error when data isn't map[string]any or struct",
 			data:        "1",
 			rules:       map[string]string{"a": "required"},
-			expectErr:   errors.New("data must be map[string]any or struct"),
+			expectErr:   errors.New("invalid input data"),
 		},
 		{
 			description: "error when data is empty map",
@@ -106,7 +106,7 @@ func TestMake(t *testing.T) {
 				}),
 			},
 			expectValidator:    true,
-			expectData:         Data{A: "c"},
+			expectData:         Data{A: ""},
 			expectErrors:       true,
 			expectErrorMessage: "B can't be empty",
 		},
@@ -146,7 +146,7 @@ func TestMake(t *testing.T) {
 				}),
 			},
 			expectValidator:    true,
-			expectData:         Data{A: "c"},
+			expectData:         Data{A: ""},
 			expectErrors:       true,
 			expectErrorMessage: "b can't be empty",
 		},
@@ -2676,57 +2676,57 @@ func TestCustomRule(t *testing.T) {
 type Uppercase struct {
 }
 
-//Signature The name of the rule.
+// Signature The name of the rule.
 func (receiver *Uppercase) Signature() string {
 	return "uppercase"
 }
 
-//Passes Determine if the validation rule passes.
+// Passes Determine if the validation rule passes.
 func (receiver *Uppercase) Passes(data httpvalidate.Data, val any, options ...any) bool {
 	name, exist := data.Get("name")
 
 	return strings.ToUpper(val.(string)) == val.(string) && len(val.(string)) == cast.ToInt(options[0]) && name == val && exist
 }
 
-//Message Get the validation error message.
+// Message Get the validation error message.
 func (receiver *Uppercase) Message() string {
 	return ":attribute must be upper"
 }
 
 type Lowercase struct {
 }
 
-//Signature The name of the rule.
+// Signature The name of the rule.
 func (receiver *Lowercase) Signature() string {
 	return "lowercase"
 }
 
-//Passes Determine if the validation rule passes.
+// Passes Determine if the validation rule passes.
 func (receiver *Lowercase) Passes(data httpvalidate.Data, val any, options ...any) bool {
 	address, exist := data.Get("address")
 
 	return strings.ToLower(val.(string)) == val.(string) && len(val.(string)) == cast.ToInt(options[0]) && address == val && exist
 }
 
-//Message Get the validation error message.
+// Message Get the validation error message.
 func (receiver *Lowercase) Message() string {
 	return ":attribute must be lower"
 }
 
 type Duplicate struct {
 }
 
-//Signature The name of the rule.
+// Signature The name of the rule.
 func (receiver *Duplicate) Signature() string {
 	return "required"
 }
 
-//Passes Determine if the validation rule passes.
+// Passes Determine if the validation rule passes.
 func (receiver *Duplicate) Passes(data httpvalidate.Data, val any, options ...any) bool {
 	return true
 }
 
-//Message Get the validation error message.
+// Message Get the validation error message.
 func (receiver *Duplicate) Message() string {
 	return ""
 }

validation/validator.go

@@ -1,9 +1,11 @@
 package validation
 
 import (
-	"net/url"
+	"reflect"
 
 	"github.com/gookit/validate"
+	"github.com/mitchellh/mapstructure"
+	"github.com/spf13/cast"
 
 	httpvalidate "github.com/goravel/framework/contracts/validation"
 )
@@ -12,48 +14,32 @@
 	validate.Config(func(opt *validate.GlobalOption) {
 		opt.StopOnError = false
 		opt.SkipOnEmpty = true
+		opt.FieldTag = "form"
 	})
 }
 
 type Validator struct {
 	instance *validate.Validation
-	data     validate.DataFace
 }
 
-func NewValidator(instance *validate.Validation, data validate.DataFace) *Validator {
+func NewValidator(instance *validate.Validation) *Validator {
 	instance.Validate()
 
-	return &Validator{instance: instance, data: data}
+	return &Validator{instance: instance}
 }
 
 func (v *Validator) Bind(ptr any) error {
-	var data any
-	if _, ok := v.data.Src().(url.Values); ok {
-		values := make(map[string]any)
-		for key, value := range v.data.Src().(url.Values) {
-			if len(value) > 0 {
-				values[key] = value[0]
-			}
-		}
-
-		formData, ok := v.data.(*validate.FormData)
-		if ok {
-			for key, value := range formData.Files {
-				values[key] = value
-			}
-		}
-
-		data = values
-	} else {
-		data = v.data.Src()
-	}
-
-	bts, err := validate.Marshal(data)
+	data := v.instance.SafeData()
+	decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
+		TagName:    "form",
+		Result:     &ptr,
+		DecodeHook: v.castValue(),
+	})
 	if err != nil {
 		return err
 	}
 
-	return validate.Unmarshal(bts, ptr)
+	return decoder.Decode(data)
 }
 
 func (v *Validator) Errors() httpvalidate.Errors {
@@ -67,3 +53,74 @@
 func (v *Validator) Fails() bool {
 	return v.instance.IsFail()
 }
+
+func (v *Validator) castValue() mapstructure.DecodeHookFunc {
+	return func(from reflect.Value, to reflect.Value) (any, error) {
+		var castedValue any
+		var err error
+
+		switch to.Kind() {
+		case reflect.String:
+			castedValue = cast.ToString(from.Interface())
+		case reflect.Int:
+			castedValue, err = cast.ToIntE(from.Interface())
+		case reflect.Int8:
+			castedValue, err = cast.ToInt8E(from.Interface())
+		case reflect.Int16:
+			castedValue, err = cast.ToInt16E(from.Interface())
+		case reflect.Int32:
+			castedValue, err = cast.ToInt32E(from.Interface())
+		case reflect.Int64:
+			castedValue, err = cast.ToInt64E(from.Interface())
+		case reflect.Uint:
+			castedValue, err = cast.ToUintE(from.Interface())
+		case reflect.Uint8:
+			castedValue, err = cast.ToUint8E(from.Interface())
+		case reflect.Uint16:
+			castedValue, err = cast.ToUint16E(from.Interface())
+		case reflect.Uint32:
+			castedValue, err = cast.ToUint32E(from.Interface())
+		case reflect.Uint64:
+			castedValue, err = cast.ToUint64E(from.Interface())
+		case reflect.Bool:
+			castedValue, err = cast.ToBoolE(from.Interface())
+		case reflect.Float32:
+			castedValue, err = cast.ToFloat32E(from.Interface())
+		case reflect.Float64:
+			castedValue, err = cast.ToFloat64E(from.Interface())
+		case reflect.Slice, reflect.Array:
+			switch to.Type().Elem().Kind() {
+			case reflect.String:
+				castedValue, err = cast.ToStringSliceE(from.Interface())
+			case reflect.Int:
+				castedValue, err = cast.ToIntSliceE(from.Interface())
+			case reflect.Bool:
+				castedValue, err = cast.ToBoolSliceE(from.Interface())
+			default:
+				castedValue, err = cast.ToSliceE(from.Interface())
+			}
+		case reflect.Map:
+			switch to.Type().Key().Kind() {
+			case reflect.String:
+				castedValue, err = cast.ToStringMapStringE(from.Interface())
+			case reflect.Bool:
+				castedValue, err = cast.ToStringMapBoolE(from.Interface())
+			case reflect.Int:
+				castedValue, err = cast.ToStringMapIntE(from.Interface())
+			case reflect.Int64:
+				castedValue, err = cast.ToStringMapInt64E(from.Interface())
+			default:
+				castedValue, err = cast.ToStringMapE(from.Interface())
+			}
+		default:
+			castedValue = from.Interface()
+		}
+
+		// Only return casted value if there was no error
+		if err == nil {
+			return castedValue, nil
+		}
+
+		return from.Interface(), nil
+	}
+}