forked from ebhomengo/niki
146 lines
3.7 KiB
Go
146 lines
3.7 KiB
Go
package validation
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"reflect"
|
|
)
|
|
|
|
var (
|
|
// ErrNotMap is the error that the value being validated is not a map.
|
|
ErrNotMap = errors.New("only a map can be validated")
|
|
|
|
// ErrKeyWrongType is the error returned in case of an incorrect key type.
|
|
ErrKeyWrongType = NewError("validation_key_wrong_type", "key not the correct type")
|
|
|
|
// ErrKeyMissing is the error returned in case of a missing key.
|
|
ErrKeyMissing = NewError("validation_key_missing", "required key is missing")
|
|
|
|
// ErrKeyUnexpected is the error returned in case of an unexpected key.
|
|
ErrKeyUnexpected = NewError("validation_key_unexpected", "key not expected")
|
|
)
|
|
|
|
type (
|
|
// MapRule represents a rule set associated with a map.
|
|
MapRule struct {
|
|
keys []*KeyRules
|
|
allowExtraKeys bool
|
|
}
|
|
|
|
// KeyRules represents a rule set associated with a map key.
|
|
KeyRules struct {
|
|
key interface{}
|
|
optional bool
|
|
rules []Rule
|
|
}
|
|
)
|
|
|
|
// Map returns a validation rule that checks the keys and values of a map.
|
|
// This rule should only be used for validating maps, or a validation error will be reported.
|
|
// Use Key() to specify map keys that need to be validated. Each Key() call specifies a single key which can
|
|
// be associated with multiple rules.
|
|
// For example,
|
|
//
|
|
// validation.Map(
|
|
// validation.Key("Name", validation.Required),
|
|
// validation.Key("Value", validation.Required, validation.Length(5, 10)),
|
|
// )
|
|
//
|
|
// A nil value is considered valid. Use the Required rule to make sure a map value is present.
|
|
func Map(keys ...*KeyRules) MapRule {
|
|
return MapRule{keys: keys}
|
|
}
|
|
|
|
// AllowExtraKeys configures the rule to ignore extra keys.
|
|
func (r MapRule) AllowExtraKeys() MapRule {
|
|
r.allowExtraKeys = true
|
|
return r
|
|
}
|
|
|
|
// Validate checks if the given value is valid or not.
|
|
func (r MapRule) Validate(m interface{}) error {
|
|
return r.ValidateWithContext(nil, m)
|
|
}
|
|
|
|
// ValidateWithContext checks if the given value is valid or not.
|
|
func (r MapRule) ValidateWithContext(ctx context.Context, m interface{}) error {
|
|
value := reflect.ValueOf(m)
|
|
if value.Kind() == reflect.Ptr {
|
|
value = value.Elem()
|
|
}
|
|
if value.Kind() != reflect.Map {
|
|
// must be a map
|
|
return NewInternalError(ErrNotMap)
|
|
}
|
|
if value.IsNil() {
|
|
// treat a nil map as valid
|
|
return nil
|
|
}
|
|
|
|
errs := Errors{}
|
|
kt := value.Type().Key()
|
|
|
|
var extraKeys map[interface{}]bool
|
|
if !r.allowExtraKeys {
|
|
extraKeys = make(map[interface{}]bool, value.Len())
|
|
for _, k := range value.MapKeys() {
|
|
extraKeys[k.Interface()] = true
|
|
}
|
|
}
|
|
|
|
for _, kr := range r.keys {
|
|
var err error
|
|
if kv := reflect.ValueOf(kr.key); !kt.AssignableTo(kv.Type()) {
|
|
err = ErrKeyWrongType
|
|
} else if vv := value.MapIndex(kv); !vv.IsValid() {
|
|
if !kr.optional {
|
|
err = ErrKeyMissing
|
|
}
|
|
} else if ctx == nil {
|
|
err = Validate(vv.Interface(), kr.rules...)
|
|
} else {
|
|
err = ValidateWithContext(ctx, vv.Interface(), kr.rules...)
|
|
}
|
|
if err != nil {
|
|
if ie, ok := err.(InternalError); ok && ie.InternalError() != nil {
|
|
return err
|
|
}
|
|
errs[getErrorKeyName(kr.key)] = err
|
|
}
|
|
if !r.allowExtraKeys {
|
|
delete(extraKeys, kr.key)
|
|
}
|
|
}
|
|
|
|
if !r.allowExtraKeys {
|
|
for key := range extraKeys {
|
|
errs[getErrorKeyName(key)] = ErrKeyUnexpected
|
|
}
|
|
}
|
|
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Key specifies a map key and the corresponding validation rules.
|
|
func Key(key interface{}, rules ...Rule) *KeyRules {
|
|
return &KeyRules{
|
|
key: key,
|
|
rules: rules,
|
|
}
|
|
}
|
|
|
|
// Optional configures the rule to ignore the key if missing.
|
|
func (r *KeyRules) Optional() *KeyRules {
|
|
r.optional = true
|
|
return r
|
|
}
|
|
|
|
// getErrorKeyName returns the name that should be used to represent the validation error of a map key.
|
|
func getErrorKeyName(key interface{}) string {
|
|
return fmt.Sprintf("%v", key)
|
|
}
|