niki/vendor/github.com/go-ozzo/ozzo-validation/v4/validation.go

273 lines
8.0 KiB
Go
Raw Permalink Normal View History

2024-02-18 10:42:21 +00:00
// Copyright 2016 Qiang Xue. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
// Package validation provides configurable and extensible rules for validating data of various types.
package validation
import (
"context"
"fmt"
"reflect"
"strconv"
)
type (
// Validatable is the interface indicating the type implementing it supports data validation.
Validatable interface {
// Validate validates the data and returns an error if validation fails.
Validate() error
}
// ValidatableWithContext is the interface indicating the type implementing it supports context-aware data validation.
ValidatableWithContext interface {
// ValidateWithContext validates the data with the given context and returns an error if validation fails.
ValidateWithContext(ctx context.Context) error
}
// Rule represents a validation rule.
Rule interface {
// Validate validates a value and returns a value if validation fails.
Validate(value interface{}) error
}
// RuleWithContext represents a context-aware validation rule.
RuleWithContext interface {
// ValidateWithContext validates a value and returns a value if validation fails.
ValidateWithContext(ctx context.Context, value interface{}) error
}
// RuleFunc represents a validator function.
// You may wrap it as a Rule by calling By().
RuleFunc func(value interface{}) error
// RuleWithContextFunc represents a validator function that is context-aware.
// You may wrap it as a Rule by calling WithContext().
RuleWithContextFunc func(ctx context.Context, value interface{}) error
)
var (
// ErrorTag is the struct tag name used to customize the error field name for a struct field.
ErrorTag = "json"
// Skip is a special validation rule that indicates all rules following it should be skipped.
Skip = skipRule{skip: true}
validatableType = reflect.TypeOf((*Validatable)(nil)).Elem()
validatableWithContextType = reflect.TypeOf((*ValidatableWithContext)(nil)).Elem()
)
// Validate validates the given value and returns the validation error, if any.
//
// Validate performs validation using the following steps:
2024-06-14 08:41:36 +00:00
// 1. For each rule, call its `Validate()` to validate the value. Return if any error is found.
// 2. If the value being validated implements `Validatable`, call the value's `Validate()`.
// Return with the validation result.
// 3. If the value being validated is a map/slice/array, and the element type implements `Validatable`,
// for each element call the element value's `Validate()`. Return with the validation result.
2024-02-18 10:42:21 +00:00
func Validate(value interface{}, rules ...Rule) error {
for _, rule := range rules {
if s, ok := rule.(skipRule); ok && s.skip {
return nil
}
if err := rule.Validate(value); err != nil {
return err
}
}
rv := reflect.ValueOf(value)
if (rv.Kind() == reflect.Ptr || rv.Kind() == reflect.Interface) && rv.IsNil() {
return nil
}
if v, ok := value.(Validatable); ok {
return v.Validate()
}
switch rv.Kind() {
case reflect.Map:
if rv.Type().Elem().Implements(validatableType) {
return validateMap(rv)
}
case reflect.Slice, reflect.Array:
if rv.Type().Elem().Implements(validatableType) {
return validateSlice(rv)
}
case reflect.Ptr, reflect.Interface:
return Validate(rv.Elem().Interface())
}
return nil
}
// ValidateWithContext validates the given value with the given context and returns the validation error, if any.
//
// ValidateWithContext performs validation using the following steps:
2024-06-14 08:41:36 +00:00
// 1. For each rule, call its `ValidateWithContext()` to validate the value if the rule implements `RuleWithContext`.
// Otherwise call `Validate()` of the rule. Return if any error is found.
// 2. If the value being validated implements `ValidatableWithContext`, call the value's `ValidateWithContext()`
// and return with the validation result.
// 3. If the value being validated implements `Validatable`, call the value's `Validate()`
// and return with the validation result.
// 4. If the value being validated is a map/slice/array, and the element type implements `ValidatableWithContext`,
// for each element call the element value's `ValidateWithContext()`. Return with the validation result.
// 5. If the value being validated is a map/slice/array, and the element type implements `Validatable`,
// for each element call the element value's `Validate()`. Return with the validation result.
2024-02-18 10:42:21 +00:00
func ValidateWithContext(ctx context.Context, value interface{}, rules ...Rule) error {
for _, rule := range rules {
if s, ok := rule.(skipRule); ok && s.skip {
return nil
}
if rc, ok := rule.(RuleWithContext); ok {
if err := rc.ValidateWithContext(ctx, value); err != nil {
return err
}
} else if err := rule.Validate(value); err != nil {
return err
}
}
rv := reflect.ValueOf(value)
if (rv.Kind() == reflect.Ptr || rv.Kind() == reflect.Interface) && rv.IsNil() {
return nil
}
if v, ok := value.(ValidatableWithContext); ok {
return v.ValidateWithContext(ctx)
}
if v, ok := value.(Validatable); ok {
return v.Validate()
}
switch rv.Kind() {
case reflect.Map:
if rv.Type().Elem().Implements(validatableWithContextType) {
return validateMapWithContext(ctx, rv)
}
if rv.Type().Elem().Implements(validatableType) {
return validateMap(rv)
}
case reflect.Slice, reflect.Array:
if rv.Type().Elem().Implements(validatableWithContextType) {
return validateSliceWithContext(ctx, rv)
}
if rv.Type().Elem().Implements(validatableType) {
return validateSlice(rv)
}
case reflect.Ptr, reflect.Interface:
return ValidateWithContext(ctx, rv.Elem().Interface())
}
return nil
}
// validateMap validates a map of validatable elements
func validateMap(rv reflect.Value) error {
errs := Errors{}
for _, key := range rv.MapKeys() {
if mv := rv.MapIndex(key).Interface(); mv != nil {
if err := mv.(Validatable).Validate(); err != nil {
errs[fmt.Sprintf("%v", key.Interface())] = err
}
}
}
if len(errs) > 0 {
return errs
}
return nil
}
// validateMapWithContext validates a map of validatable elements with the given context.
func validateMapWithContext(ctx context.Context, rv reflect.Value) error {
errs := Errors{}
for _, key := range rv.MapKeys() {
if mv := rv.MapIndex(key).Interface(); mv != nil {
if err := mv.(ValidatableWithContext).ValidateWithContext(ctx); err != nil {
errs[fmt.Sprintf("%v", key.Interface())] = err
}
}
}
if len(errs) > 0 {
return errs
}
return nil
}
// validateSlice validates a slice/array of validatable elements
func validateSlice(rv reflect.Value) error {
errs := Errors{}
l := rv.Len()
for i := 0; i < l; i++ {
if ev := rv.Index(i).Interface(); ev != nil {
if err := ev.(Validatable).Validate(); err != nil {
errs[strconv.Itoa(i)] = err
}
}
}
if len(errs) > 0 {
return errs
}
return nil
}
// validateSliceWithContext validates a slice/array of validatable elements with the given context.
func validateSliceWithContext(ctx context.Context, rv reflect.Value) error {
errs := Errors{}
l := rv.Len()
for i := 0; i < l; i++ {
if ev := rv.Index(i).Interface(); ev != nil {
if err := ev.(ValidatableWithContext).ValidateWithContext(ctx); err != nil {
errs[strconv.Itoa(i)] = err
}
}
}
if len(errs) > 0 {
return errs
}
return nil
}
type skipRule struct {
skip bool
}
func (r skipRule) Validate(interface{}) error {
return nil
}
// When determines if all rules following it should be skipped.
func (r skipRule) When(condition bool) skipRule {
r.skip = condition
return r
}
type inlineRule struct {
f RuleFunc
fc RuleWithContextFunc
}
func (r *inlineRule) Validate(value interface{}) error {
if r.f == nil {
return r.fc(context.Background(), value)
}
return r.f(value)
}
func (r *inlineRule) ValidateWithContext(ctx context.Context, value interface{}) error {
if r.fc == nil {
return r.f(value)
}
return r.fc(ctx, value)
}
// By wraps a RuleFunc into a Rule.
func By(f RuleFunc) Rule {
return &inlineRule{f: f}
}
// WithContext wraps a RuleWithContextFunc into a context-aware Rule.
func WithContext(f RuleWithContextFunc) Rule {
return &inlineRule{fc: f}
}