- package validator
-
- import (
- "context"
- "errors"
- "fmt"
- "reflect"
- "strings"
- "sync"
- "time"
-
- ut "github.com/go-playground/universal-translator"
- )
-
- const (
- defaultTagName = "validate"
- utf8HexComma = "0x2C"
- utf8Pipe = "0x7C"
- tagSeparator = ","
- orSeparator = "|"
- tagKeySeparator = "="
- structOnlyTag = "structonly"
- noStructLevelTag = "nostructlevel"
- omitempty = "omitempty"
- isdefault = "isdefault"
- skipValidationTag = "-"
- diveTag = "dive"
- keysTag = "keys"
- endKeysTag = "endkeys"
- requiredTag = "required"
- namespaceSeparator = "."
- leftBracket = "["
- rightBracket = "]"
- restrictedTagChars = ".[],|=+()`~!@#$%^&*\\\"/?<>{}"
- restrictedAliasErr = "Alias '%s' either contains restricted characters or is the same as a restricted tag needed for normal operation"
- restrictedTagErr = "Tag '%s' either contains restricted characters or is the same as a restricted tag needed for normal operation"
- )
-
- var (
- timeType = reflect.TypeOf(time.Time{})
- defaultCField = &cField{namesEqual: true}
- )
-
- // FilterFunc is the type used to filter fields using
- // StructFiltered(...) function.
- // returning true results in the field being filtered/skiped from
- // validation
- type FilterFunc func(ns []byte) bool
-
- // CustomTypeFunc allows for overriding or adding custom field type handler functions
- // field = field value of the type to return a value to be validated
- // example Valuer from sql drive see https://golang.org/src/database/sql/driver/types.go?s=1210:1293#L29
- type CustomTypeFunc func(field reflect.Value) interface{}
-
- // TagNameFunc allows for adding of a custom tag name parser
- type TagNameFunc func(field reflect.StructField) string
-
- // Validate contains the validator settings and cache
- type Validate struct {
- tagName string
- pool *sync.Pool
- hasCustomFuncs bool
- hasTagNameFunc bool
- tagNameFunc TagNameFunc
- structLevelFuncs map[reflect.Type]StructLevelFuncCtx
- customFuncs map[reflect.Type]CustomTypeFunc
- aliases map[string]string
- validations map[string]FuncCtx
- transTagFunc map[ut.Translator]map[string]TranslationFunc // map[<locale>]map[<tag>]TranslationFunc
- tagCache *tagCache
- structCache *structCache
- }
-
- // New returns a new instance of 'validate' with sane defaults.
- func New() *Validate {
-
- tc := new(tagCache)
- tc.m.Store(make(map[string]*cTag))
-
- sc := new(structCache)
- sc.m.Store(make(map[reflect.Type]*cStruct))
-
- v := &Validate{
- tagName: defaultTagName,
- aliases: make(map[string]string, len(bakedInAliases)),
- validations: make(map[string]FuncCtx, len(bakedInValidators)),
- tagCache: tc,
- structCache: sc,
- }
-
- // must copy alias validators for separate validations to be used in each validator instance
- for k, val := range bakedInAliases {
- v.RegisterAlias(k, val)
- }
-
- // must copy validators for separate validations to be used in each instance
- for k, val := range bakedInValidators {
-
- // no need to error check here, baked in will always be valid
- _ = v.registerValidation(k, wrapFunc(val), true)
- }
-
- v.pool = &sync.Pool{
- New: func() interface{} {
- return &validate{
- v: v,
- ns: make([]byte, 0, 64),
- actualNs: make([]byte, 0, 64),
- misc: make([]byte, 32),
- }
- },
- }
-
- return v
- }
-
- // SetTagName allows for changing of the default tag name of 'validate'
- func (v *Validate) SetTagName(name string) {
- v.tagName = name
- }
-
- // RegisterTagNameFunc registers a function to get alternate names for StructFields.
- //
- // eg. to use the names which have been specified for JSON representations of structs, rather than normal Go field names:
- //
- // validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
- // name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
- // if name == "-" {
- // return ""
- // }
- // return name
- // })
- func (v *Validate) RegisterTagNameFunc(fn TagNameFunc) {
- v.tagNameFunc = fn
- v.hasTagNameFunc = true
- }
-
- // RegisterValidation adds a validation with the given tag
- //
- // NOTES:
- // - if the key already exists, the previous validation function will be replaced.
- // - this method is not thread-safe it is intended that these all be registered prior to any validation
- func (v *Validate) RegisterValidation(tag string, fn Func) error {
- return v.RegisterValidationCtx(tag, wrapFunc(fn))
- }
-
- // RegisterValidationCtx does the same as RegisterValidation on accepts a FuncCtx validation
- // allowing context.Context validation support.
- func (v *Validate) RegisterValidationCtx(tag string, fn FuncCtx) error {
- return v.registerValidation(tag, fn, false)
- }
-
- func (v *Validate) registerValidation(tag string, fn FuncCtx, bakedIn bool) error {
-
- if len(tag) == 0 {
- return errors.New("Function Key cannot be empty")
- }
-
- if fn == nil {
- return errors.New("Function cannot be empty")
- }
-
- _, ok := restrictedTags[tag]
-
- if !bakedIn && (ok || strings.ContainsAny(tag, restrictedTagChars)) {
- panic(fmt.Sprintf(restrictedTagErr, tag))
- }
-
- v.validations[tag] = fn
-
- return nil
- }
-
- // RegisterAlias registers a mapping of a single validation tag that
- // defines a common or complex set of validation(s) to simplify adding validation
- // to structs.
- //
- // NOTE: this function is not thread-safe it is intended that these all be registered prior to any validation
- func (v *Validate) RegisterAlias(alias, tags string) {
-
- _, ok := restrictedTags[alias]
-
- if ok || strings.ContainsAny(alias, restrictedTagChars) {
- panic(fmt.Sprintf(restrictedAliasErr, alias))
- }
-
- v.aliases[alias] = tags
- }
-
- // RegisterStructValidation registers a StructLevelFunc against a number of types.
- //
- // NOTE:
- // - this method is not thread-safe it is intended that these all be registered prior to any validation
- func (v *Validate) RegisterStructValidation(fn StructLevelFunc, types ...interface{}) {
- v.RegisterStructValidationCtx(wrapStructLevelFunc(fn), types...)
- }
-
- // RegisterStructValidationCtx registers a StructLevelFuncCtx against a number of types and allows passing
- // of contextual validation information via context.Context.
- //
- // NOTE:
- // - this method is not thread-safe it is intended that these all be registered prior to any validation
- func (v *Validate) RegisterStructValidationCtx(fn StructLevelFuncCtx, types ...interface{}) {
-
- if v.structLevelFuncs == nil {
- v.structLevelFuncs = make(map[reflect.Type]StructLevelFuncCtx)
- }
-
- for _, t := range types {
- tv := reflect.ValueOf(t)
- if tv.Kind() == reflect.Ptr {
- t = reflect.Indirect(tv).Interface()
- }
-
- v.structLevelFuncs[reflect.TypeOf(t)] = fn
- }
- }
-
- // RegisterCustomTypeFunc registers a CustomTypeFunc against a number of types
- //
- // NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
- func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{}) {
-
- if v.customFuncs == nil {
- v.customFuncs = make(map[reflect.Type]CustomTypeFunc)
- }
-
- for _, t := range types {
- v.customFuncs[reflect.TypeOf(t)] = fn
- }
-
- v.hasCustomFuncs = true
- }
-
- // RegisterTranslation registers translations against the provided tag.
- func (v *Validate) RegisterTranslation(tag string, trans ut.Translator, registerFn RegisterTranslationsFunc, translationFn TranslationFunc) (err error) {
-
- if v.transTagFunc == nil {
- v.transTagFunc = make(map[ut.Translator]map[string]TranslationFunc)
- }
-
- if err = registerFn(trans); err != nil {
- return
- }
-
- m, ok := v.transTagFunc[trans]
- if !ok {
- m = make(map[string]TranslationFunc)
- v.transTagFunc[trans] = m
- }
-
- m[tag] = translationFn
-
- return
- }
-
- // Struct validates a structs exposed fields, and automatically validates nested structs, unless otherwise specified.
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) Struct(s interface{}) error {
- return v.StructCtx(context.Background(), s)
- }
-
- // StructCtx validates a structs exposed fields, and automatically validates nested structs, unless otherwise specified
- // and also allows passing of context.Context for contextual validation information.
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) StructCtx(ctx context.Context, s interface{}) (err error) {
-
- val := reflect.ValueOf(s)
- top := val
-
- if val.Kind() == reflect.Ptr && !val.IsNil() {
- val = val.Elem()
- }
-
- if val.Kind() != reflect.Struct || val.Type() == timeType {
- return &InvalidValidationError{Type: reflect.TypeOf(s)}
- }
-
- // good to validate
- vd := v.pool.Get().(*validate)
- vd.top = top
- vd.isPartial = false
- // vd.hasExcludes = false // only need to reset in StructPartial and StructExcept
-
- vd.validateStruct(ctx, top, val, val.Type(), vd.ns[0:0], vd.actualNs[0:0], nil)
-
- if len(vd.errs) > 0 {
- err = vd.errs
- vd.errs = nil
- }
-
- v.pool.Put(vd)
-
- return
- }
-
- // StructFiltered validates a structs exposed fields, that pass the FilterFunc check and automatically validates
- // nested structs, unless otherwise specified.
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) StructFiltered(s interface{}, fn FilterFunc) error {
- return v.StructFilteredCtx(context.Background(), s, fn)
- }
-
- // StructFilteredCtx validates a structs exposed fields, that pass the FilterFunc check and automatically validates
- // nested structs, unless otherwise specified and also allows passing of contextual validation information via
- // context.Context
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) StructFilteredCtx(ctx context.Context, s interface{}, fn FilterFunc) (err error) {
- val := reflect.ValueOf(s)
- top := val
-
- if val.Kind() == reflect.Ptr && !val.IsNil() {
- val = val.Elem()
- }
-
- if val.Kind() != reflect.Struct || val.Type() == timeType {
- return &InvalidValidationError{Type: reflect.TypeOf(s)}
- }
-
- // good to validate
- vd := v.pool.Get().(*validate)
- vd.top = top
- vd.isPartial = true
- vd.ffn = fn
- // vd.hasExcludes = false // only need to reset in StructPartial and StructExcept
-
- vd.validateStruct(ctx, top, val, val.Type(), vd.ns[0:0], vd.actualNs[0:0], nil)
-
- if len(vd.errs) > 0 {
- err = vd.errs
- vd.errs = nil
- }
-
- v.pool.Put(vd)
-
- return
- }
-
- // StructPartial validates the fields passed in only, ignoring all others.
- // Fields may be provided in a namespaced fashion relative to the struct provided
- // eg. NestedStruct.Field or NestedArrayField[0].Struct.Name
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) StructPartial(s interface{}, fields ...string) error {
- return v.StructPartialCtx(context.Background(), s, fields...)
- }
-
- // StructPartialCtx validates the fields passed in only, ignoring all others and allows passing of contextual
- // validation validation information via context.Context
- // Fields may be provided in a namespaced fashion relative to the struct provided
- // eg. NestedStruct.Field or NestedArrayField[0].Struct.Name
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) StructPartialCtx(ctx context.Context, s interface{}, fields ...string) (err error) {
- val := reflect.ValueOf(s)
- top := val
-
- if val.Kind() == reflect.Ptr && !val.IsNil() {
- val = val.Elem()
- }
-
- if val.Kind() != reflect.Struct || val.Type() == timeType {
- return &InvalidValidationError{Type: reflect.TypeOf(s)}
- }
-
- // good to validate
- vd := v.pool.Get().(*validate)
- vd.top = top
- vd.isPartial = true
- vd.ffn = nil
- vd.hasExcludes = false
- vd.includeExclude = make(map[string]struct{})
-
- typ := val.Type()
- name := typ.Name()
-
- for _, k := range fields {
-
- flds := strings.Split(k, namespaceSeparator)
- if len(flds) > 0 {
-
- vd.misc = append(vd.misc[0:0], name...)
- vd.misc = append(vd.misc, '.')
-
- for _, s := range flds {
-
- idx := strings.Index(s, leftBracket)
-
- if idx != -1 {
- for idx != -1 {
- vd.misc = append(vd.misc, s[:idx]...)
- vd.includeExclude[string(vd.misc)] = struct{}{}
-
- idx2 := strings.Index(s, rightBracket)
- idx2++
- vd.misc = append(vd.misc, s[idx:idx2]...)
- vd.includeExclude[string(vd.misc)] = struct{}{}
- s = s[idx2:]
- idx = strings.Index(s, leftBracket)
- }
- } else {
-
- vd.misc = append(vd.misc, s...)
- vd.includeExclude[string(vd.misc)] = struct{}{}
- }
-
- vd.misc = append(vd.misc, '.')
- }
- }
- }
-
- vd.validateStruct(ctx, top, val, typ, vd.ns[0:0], vd.actualNs[0:0], nil)
-
- if len(vd.errs) > 0 {
- err = vd.errs
- vd.errs = nil
- }
-
- v.pool.Put(vd)
-
- return
- }
-
- // StructExcept validates all fields except the ones passed in.
- // Fields may be provided in a namespaced fashion relative to the struct provided
- // i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) StructExcept(s interface{}, fields ...string) error {
- return v.StructExceptCtx(context.Background(), s, fields...)
- }
-
- // StructExceptCtx validates all fields except the ones passed in and allows passing of contextual
- // validation validation information via context.Context
- // Fields may be provided in a namespaced fashion relative to the struct provided
- // i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- func (v *Validate) StructExceptCtx(ctx context.Context, s interface{}, fields ...string) (err error) {
- val := reflect.ValueOf(s)
- top := val
-
- if val.Kind() == reflect.Ptr && !val.IsNil() {
- val = val.Elem()
- }
-
- if val.Kind() != reflect.Struct || val.Type() == timeType {
- return &InvalidValidationError{Type: reflect.TypeOf(s)}
- }
-
- // good to validate
- vd := v.pool.Get().(*validate)
- vd.top = top
- vd.isPartial = true
- vd.ffn = nil
- vd.hasExcludes = true
- vd.includeExclude = make(map[string]struct{})
-
- typ := val.Type()
- name := typ.Name()
-
- for _, key := range fields {
-
- vd.misc = vd.misc[0:0]
-
- if len(name) > 0 {
- vd.misc = append(vd.misc, name...)
- vd.misc = append(vd.misc, '.')
- }
-
- vd.misc = append(vd.misc, key...)
- vd.includeExclude[string(vd.misc)] = struct{}{}
- }
-
- vd.validateStruct(ctx, top, val, typ, vd.ns[0:0], vd.actualNs[0:0], nil)
-
- if len(vd.errs) > 0 {
- err = vd.errs
- vd.errs = nil
- }
-
- v.pool.Put(vd)
-
- return
- }
-
- // Var validates a single variable using tag style validation.
- // eg.
- // var i int
- // validate.Var(i, "gt=1,lt=10")
- //
- // WARNING: a struct can be passed for validation eg. time.Time is a struct or
- // if you have a custom type and have registered a custom type handler, so must
- // allow it; however unforeseen validations will occur if trying to validate a
- // struct that is meant to be passed to 'validate.Struct'
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- // validate Array, Slice and maps fields which may contain more than one error
- func (v *Validate) Var(field interface{}, tag string) error {
- return v.VarCtx(context.Background(), field, tag)
- }
-
- // VarCtx validates a single variable using tag style validation and allows passing of contextual
- // validation validation information via context.Context.
- // eg.
- // var i int
- // validate.Var(i, "gt=1,lt=10")
- //
- // WARNING: a struct can be passed for validation eg. time.Time is a struct or
- // if you have a custom type and have registered a custom type handler, so must
- // allow it; however unforeseen validations will occur if trying to validate a
- // struct that is meant to be passed to 'validate.Struct'
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- // validate Array, Slice and maps fields which may contain more than one error
- func (v *Validate) VarCtx(ctx context.Context, field interface{}, tag string) (err error) {
- if len(tag) == 0 || tag == skipValidationTag {
- return nil
- }
-
- ctag := v.fetchCacheTag(tag)
- val := reflect.ValueOf(field)
- vd := v.pool.Get().(*validate)
- vd.top = val
- vd.isPartial = false
- vd.traverseField(ctx, val, val, vd.ns[0:0], vd.actualNs[0:0], defaultCField, ctag)
-
- if len(vd.errs) > 0 {
- err = vd.errs
- vd.errs = nil
- }
- v.pool.Put(vd)
- return
- }
-
- // VarWithValue validates a single variable, against another variable/field's value using tag style validation
- // eg.
- // s1 := "abcd"
- // s2 := "abcd"
- // validate.VarWithValue(s1, s2, "eqcsfield") // returns true
- //
- // WARNING: a struct can be passed for validation eg. time.Time is a struct or
- // if you have a custom type and have registered a custom type handler, so must
- // allow it; however unforeseen validations will occur if trying to validate a
- // struct that is meant to be passed to 'validate.Struct'
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- // validate Array, Slice and maps fields which may contain more than one error
- func (v *Validate) VarWithValue(field interface{}, other interface{}, tag string) error {
- return v.VarWithValueCtx(context.Background(), field, other, tag)
- }
-
- // VarWithValueCtx validates a single variable, against another variable/field's value using tag style validation and
- // allows passing of contextual validation validation information via context.Context.
- // eg.
- // s1 := "abcd"
- // s2 := "abcd"
- // validate.VarWithValue(s1, s2, "eqcsfield") // returns true
- //
- // WARNING: a struct can be passed for validation eg. time.Time is a struct or
- // if you have a custom type and have registered a custom type handler, so must
- // allow it; however unforeseen validations will occur if trying to validate a
- // struct that is meant to be passed to 'validate.Struct'
- //
- // It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
- // You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
- // validate Array, Slice and maps fields which may contain more than one error
- func (v *Validate) VarWithValueCtx(ctx context.Context, field interface{}, other interface{}, tag string) (err error) {
- if len(tag) == 0 || tag == skipValidationTag {
- return nil
- }
- ctag := v.fetchCacheTag(tag)
- otherVal := reflect.ValueOf(other)
- vd := v.pool.Get().(*validate)
- vd.top = otherVal
- vd.isPartial = false
- vd.traverseField(ctx, otherVal, reflect.ValueOf(field), vd.ns[0:0], vd.actualNs[0:0], defaultCField, ctag)
-
- if len(vd.errs) > 0 {
- err = vd.errs
- vd.errs = nil
- }
- v.pool.Put(vd)
- return
- }
|