valid

Documentation

Index

• type CustomTypeFunc
• type FieldLevel
• type FilterFunc
• type Func
• type FuncCtx
• type StructLevel
• type TagNameFunc
• type Validate
  • func New() *Validate
  • func (v Validate) ValidateMap(ctx context.Context, data map[string]interface{}, rules map[string]interface{}) map[string]error
  • func (v *Validate) Var(field interface{}, tag string) error
  • func (v *Validate) VarCtx(ctx context.Context, field interface{}, tag string) (err error)
  • func (v *Validate) VarWithValue(field interface{}, other interface{}, tag string) error
  • func (v *Validate) VarWithValueCtx(ctx context.Context, field interface{}, other interface{}, tag string) (err error)

Types

type CustomTypeFunc

type CustomTypeFunc func(field reflect.Value) interface{}

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 FieldLevel

type FieldLevel interface {

	// Top returns the top level struct, if any
	Top() reflect.Value

	// Parent returns the current fields parent struct, if any or
	// the comparison value if called 'VarWithValue'
	Parent() reflect.Value

	// Field returns current field for validation
	Field() reflect.Value

	// FieldName returns the field's name with the tag
	// name taking precedence over the fields actual name.
	FieldName() string

	// StructFieldName returns the struct field's name
	StructFieldName() string

	// Param returns param for validation against current field
	Param() string

	// GetTag returns the current validations tag name
	GetTag() string

	// GetStructFieldOK traverses the parent struct to retrieve a specific field denoted by the provided namespace
	// in the param and returns the field, field kind and whether is was successful in retrieving
	// the field at all.
	//
	// NOTE: when not successful ok will be false, this can happen when a nested struct is nil and so the field
	// could not be retrieved because it didn't exist.
	//
	// Deprecated: Use GetStructFieldOK2() instead which also return if the value is nullable.
	GetStructFieldOK() (reflect.Value, reflect.Kind, bool)

	// GetStructFieldOKAdvanced is the same as GetStructFieldOK except that it accepts the parent struct to start looking for
	// the field and namespace allowing more extensibility for validators.
	//
	// Deprecated: Use GetStructFieldOKAdvanced2() instead which also return if the value is nullable.
	GetStructFieldOKAdvanced(val reflect.Value, namespace string) (reflect.Value, reflect.Kind, bool)

	// GetStructFieldOK2 traverses the parent struct to retrieve a specific field denoted by the provided namespace
	// in the param and returns the field, field kind, if it's a nullable type and whether is was successful in retrieving
	// the field at all.
	//
	// NOTE: when not successful ok will be false, this can happen when a nested struct is nil and so the field
	// could not be retrieved because it didn't exist.
	GetStructFieldOK2() (reflect.Value, reflect.Kind, bool, bool)

	// GetStructFieldOKAdvanced2 is the same as GetStructFieldOK except that it accepts the parent struct to start looking for
	// the field and namespace allowing more extensibility for validators.
	GetStructFieldOKAdvanced2(val reflect.Value, namespace string) (reflect.Value, reflect.Kind, bool, bool)
}

FieldLevel contains all the information and helper functions to validate a field

type FilterFunc

type FilterFunc func(ns []byte) bool

FilterFunc is the type used to filter fields using StructFiltered(...) function. returning true results in the field being filtered/skiped from validation

type Func

type Func func(fl FieldLevel) bool

Func accepts a FieldLevel interface for all validation needs. The return value should be true when validation succeeds.

type FuncCtx

type FuncCtx func(ctx context.Context, fl FieldLevel) bool

FuncCtx accepts a context.Context and FieldLevel interface for all validation needs. The return value should be true when validation succeeds.

type StructLevel

type StructLevel interface {

	// Validator returns the main validation object, in case one wants to call validations internally.
	// this is so you don't have to use anonymous functions to get access to the validate
	// instance.
	Validator() *Validate

	// Top returns the top level struct, if any
	Top() reflect.Value

	// Parent returns the current fields parent struct, if any
	Parent() reflect.Value

	// Current returns the current struct.
	Current() reflect.Value
}

StructLevel contains all the information and helper functions to validate a struct

type TagNameFunc

type TagNameFunc func(field reflect.StructField) string

TagNameFunc allows for adding of a custom tag name parser

type Validate

type Validate struct {
	// contains filtered or unexported fields
}

Validate contains the validator settings and cache

func New

func New() *Validate

New returns a new instance of 'validate' with sane defaults. Validate is designed to be thread-safe and used as a singleton instance. It caches information about your struct and validations, in essence only parsing your validation tags once per struct type. Using multiple instances neglects the benefit of caching.

func (Validate) ValidateMap

func (v Validate) ValidateMap(ctx context.Context, data map[string]interface{}, rules map[string]interface{}) map[string]error

ValidateMapCtx validates a map using a map of validation rules and allows passing of contextual validation validation information via context.Context.

func (*Validate) Var

func (v *Validate) Var(field interface{}, tag string) error

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 (*Validate) VarCtx

func (v *Validate) VarCtx(ctx context.Context, field interface{}, tag string) (err error)

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 (*Validate) VarWithValue

func (v *Validate) VarWithValue(field interface{}, other interface{}, tag string) error

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 (*Validate) VarWithValueCtx

func (v *Validate) VarWithValueCtx(ctx context.Context, field interface{}, other interface{}, tag string) (err error)

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