validator

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 18, 2021 License: MIT Imports: 17 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

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 FieldError 

type FieldError interface {

	// Tag returns the validation tag that failed. if the
	// validation was an alias, this will return the
	// alias name and not the underlying tag that failed.
	//
	// eg. alias "iscolor": "hexcolor|rgb|rgba|hsl|hsla"
	// will return "iscolor"
	Tag() string

	// ActualTag returns the validation tag that failed, even if an
	// alias the actual tag within the alias will be returned.
	// If an 'or' validation fails the entire or will be returned.
	//
	// eg. alias "iscolor": "hexcolor|rgb|rgba|hsl|hsla"
	// will return "hexcolor|rgb|rgba|hsl|hsla"
	ActualTag() string

	// Namespace returns the namespace for the field error, with the tag
	// name taking precedence over the field's actual name.
	//
	// eg. JSON name "User.fname"
	//
	// See StructNamespace() for a version that returns actual names.
	//
	// NOTE: this field can be blank when validating a single primitive field
	// using validate.Field(...) as there is no way to extract it's name
	Namespace() string

	// StructNamespace returns the namespace for the field error, with the field's
	// actual name.
	//
	// eq. "User.FirstName" see Namespace for comparison
	//
	// NOTE: this field can be blank when validating a single primitive field
	// using validate.Field(...) as there is no way to extract its name
	StructNamespace() string

	// Field returns the fields name with the tag name taking precedence over the
	// field's actual name.
	//
	// eq. JSON name "fname"
	// see StructField for comparison
	Field() string

	// StructField returns the field's actual name from the struct, when able to determine.
	//
	// eq.  "FirstName"
	// see Field for comparison
	StructField() string

	// Value returns the actual field's value in case needed for creating the error
	// message
	Value() interface{}

	// Param returns the param value, in string form for comparison; this will also
	// help with generating an error message
	Param() string

	// Kind returns the Field's reflect Kind
	//
	// eg. time.Time's kind is a struct
	Kind() reflect.Kind

	// Type returns the Field's reflect Type
	//
	// eg. time.Time's type is time.Time
	Type() reflect.Type

	// Error returns the FieldError's message
	Error() string
}

FieldError contains all functions to get error details

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

	// ExtractType gets the actual underlying type of field value.
	// It will dive into pointers, customTypes and return you the
	// underlying value and it's kind.
	ExtractType(field reflect.Value) (value reflect.Value, kind reflect.Kind, nullable bool)

	// 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 FilterJoi 

type FilterJoi struct {
	Key   string `json:"key" validate:"required,min=1"`
	Val   string `json:"val" validate:"required,min=1"`
	Val1  string `json:"val1" validate:"omitempty,min=1"`
	Order string `json:"order" validate:"omitempty,oneof=asc desc"`
}

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 HeaderApiKeyFiltersPaging 

type HeaderApiKeyFiltersPaging struct {
	ApiKey  string `header:"api_key" validate:"-"`
	Filters string `header:"filters" validate:"-"`
}

type HeaderCredentialsFiltersPaging 

type HeaderCredentialsFiltersPaging struct {
	UserId       string `header:"user_id" validate:"required,min=1"`
	UserToken    string `header:"user_token" validate:"required,min=1"`
	EnablePaging bool   `header:"enable_paging" validate:"omitempty"`
	PagingSize   uint32 `header:"paging_size" validate:"omitempty,min=5,max=100"`
	PagingIndex  uint32 `header:"paging_index" validate:"omitempty,min=1"`
	Filters      string `header:"filters" validate:"omitempty"`
}

type HeaderCredentialsFiltersPagingOrders 

type HeaderCredentialsFiltersPagingOrders struct {
	UserId       string `header:"user_id" validate:"required,min=1"`
	UserToken    string `header:"user_token" validate:"required,min=1"`
	EnablePaging bool   `header:"enable_paging" validate:"omitempty"`
	PagingSize   uint32 `header:"paging_size" validate:"omitempty,min=2,max=100"`
	PagingIndex  uint32 `header:"paging_index" validate:"omitempty,min=1"`
	Filters      string `header:"filters" validate:"omitempty"`
	Orders       string `header:"orders" validate:"omitempty"`
}

type InvalidValidationError 

type InvalidValidationError struct {
	Type reflect.Type
}

InvalidValidationError describes an invalid argument passed to `Struct`, `StructExcept`, StructPartial` or `Field`

func (*InvalidValidationError) Error 

func (e *InvalidValidationError) Error() string

Error returns InvalidValidationError message

type OrderJoi 

type OrderJoi struct {
	Key   string `json:"key" validate:"required,min=1"`
	Order string `json:"order" validate:"omitempty,oneof=asc desc"`
}

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

	// ExtractType gets the actual underlying type of field value.
	// It will dive into pointers, customTypes and return you the
	// underlying value and its kind.
	ExtractType(field reflect.Value) (value reflect.Value, kind reflect.Kind, nullable bool)

	// ReportError reports an error just by passing the field and tag information
	//
	// NOTES:
	//
	// fieldName and altName get appended to the existing namespace that
	// validator is on. e.g. pass 'FirstName' or 'Names[0]' depending
	// on the nesting
	//
	// tag can be an existing validation tag or just something you make up
	// and process on the flip side it's up to you.
	ReportError(field interface{}, fieldName, structFieldName string, tag, param string)

	// ReportValidationErrors reports an error just by passing ValidationErrors
	//
	// NOTES:
	//
	// relativeNamespace and relativeActualNamespace get appended to the
	// existing namespace that validator is on.
	// e.g. pass 'User.FirstName' or 'Users[0].FirstName' depending
	// on the nesting. most of the time they will be blank, unless you validate
	// at a level lower the the current field depth
	ReportValidationErrors(relativeNamespace, relativeActualNamespace string, errs ValidationErrors)
}

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

type StructLevelFunc 

type StructLevelFunc func(sl StructLevel)

StructLevelFunc accepts all values needed for struct level validation

type StructLevelFuncCtx 

type StructLevelFuncCtx func(ctx context.Context, sl StructLevel)

StructLevelFuncCtx accepts all values needed for struct level validation but also allows passing of contextual validation information via context.Context.

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) RegisterAlias 

func (v *Validate) RegisterAlias(alias, tags string)

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

func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{})

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

func (v *Validate) RegisterStructValidation(fn StructLevelFunc, types ...interface{})

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

func (v *Validate) RegisterStructValidationCtx(fn StructLevelFuncCtx, types ...interface{})

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

func (v *Validate) RegisterTagNameFunc(fn TagNameFunc)

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

func (v *Validate) RegisterValidation(tag string, fn Func, callValidationEvenIfNull ...bool) error

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

func (v *Validate) RegisterValidationCtx(tag string, fn FuncCtx, callValidationEvenIfNull ...bool) error

RegisterValidationCtx does the same as RegisterValidation on accepts a FuncCtx validation allowing context.Context validation support.

func (*Validate) SetTagName 

func (v *Validate) SetTagName(name string)

SetTagName allows for changing of the default tag name of 'validate'

func (*Validate) Struct 

func (v *Validate) Struct(s interface{}) error

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

func (v *Validate) StructCtx(ctx context.Context, s interface{}) (err error)

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

func (v *Validate) StructExcept(s interface{}, fields ...string) error

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

func (v *Validate) StructExceptCtx(ctx context.Context, s interface{}, fields ...string) (err error)

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

func (v *Validate) StructFiltered(s interface{}, fn FilterFunc) error

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

func (v *Validate) StructFilteredCtx(ctx context.Context, s interface{}, fn FilterFunc) (err error)

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

func (v *Validate) StructPartial(s interface{}, fields ...string) error

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

func (v *Validate) StructPartialCtx(ctx context.Context, s interface{}, fields ...string) (err error)

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

func (v *Validate) ValidateMap(data map[string]interface{}, rules map[string]interface{}) map[string]interface{}

ValidateMap validates map data form a map of tags

func (Validate) ValidateMapCtx 

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

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

type ValidationErrors 

type ValidationErrors []FieldError

ValidationErrors is an array of FieldError's for use in custom error messages post validation.

func (ValidationErrors) Error 

func (ve ValidationErrors) Error() string

Error is intended for use in development + debugging and not intended to be a production error message. It allows ValidationErrors to subscribe to the Error interface. All information to create an error message specific to your application is contained within the FieldError found within the ValidationErrors array

type ValidationErrorsTranslations 

type ValidationErrorsTranslations map[string]string

ValidationErrorsTranslations is the translation return type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.