validation

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: Aug 24, 2025 License: MIT Imports: 9 Imported by: 0

README

validation - Data validation with generics

Go Reference

This library provides configurable and extensible data validation capabilities with use of generics.

Inspired by ozzo-validation.

Documentation

Overview

Package validation provides configurable and extensible data validation capabilities with use of generics.

Example (Config) 
package main

import (
	"encoding/json"
	"fmt"
	"os"

	"codeberg.org/go-toolbox/validation"
	isint "codeberg.org/go-toolbox/validation/is/int"
	isstr "codeberg.org/go-toolbox/validation/is/str"
)

type Config struct {
	Logger   LoggerConfig
	Database DatabaseConfig
}

func (cfg *Config) Validate() error {
	return validation.All(
		validation.Ptr(&cfg.Logger, "logger").With(validation.Custom),
		validation.Ptr(&cfg.Database, "database").With(validation.Custom),
	)
}

type LoggerConfig struct {
	Level string
}

func (cfg *LoggerConfig) Validate() error {
	return validation.All(
		validation.String(cfg.Level, "level").Required(true).In("debug", "info", "warn", "error"),
	)
}

type DatabaseConfig struct {
	Backend string

	Postgres PostgresConfig
	SQLite   SQLiteConfig
}

func (cfg *DatabaseConfig) Validate() error {
	return validation.All(
		validation.String(cfg.Backend, "backend").Required(true).In("postgres", "sqlite"),
		validation.PtrI(&cfg.Postgres).If(cfg.Backend == "postgres").With(validation.Custom).EndIf(),
		validation.PtrI(&cfg.SQLite).If(cfg.Backend == "sqlite").With(validation.Custom).EndIf(),
	)
}

type PostgresConfig struct {
	Host string
	Port int
}

func (cfg *PostgresConfig) Validate() error {
	return validation.All(
		validation.String(cfg.Host, "host").Required(true).With(isstr.Host),
		validation.Number(cfg.Port, "port").Required(true).With(isint.Port),
	)
}

type SQLiteConfig struct {
	Path string
}

func (cfg *SQLiteConfig) Validate() error {
	return validation.All(
		validation.String(cfg.Path, "path").Required(true),
	)
}

func main() {
	sqlite := DatabaseConfig{
		Backend: "sqlite",
	}
	fmt.Println(sqlite.Validate())

	postgres := DatabaseConfig{
		Backend: "postgres",
	}
	fmt.Println(postgres.Validate())

	config := Config{
		Logger: LoggerConfig{
			Level: "panic",
		},
		Database: DatabaseConfig{
			Backend: "postgres",
		},
	}

	b, _ := json.MarshalIndent(config.Validate(), "", "  ")
	os.Stdout.Write(b)
}
Example (Request) 
package main

import (
	"encoding/json"
	"os"
	"time"

	"codeberg.org/go-toolbox/validation"
)

type GeneralInfo struct {
	UserID     [16]byte `json:"user_id"`
	Device     Device   `json:"device"`
	AppVersion string   `json:"app_version"`
}

func (info *GeneralInfo) Validate() error {
	return validation.All(
		validation.Comparable(info.UserID, "user_id").Required(true),
		validation.Ptr(&info.Device, "device").With(validation.Custom),
		validation.String(info.AppVersion, "app_version").Required(true),
	)
}

type Device struct {
	Manufacturer string `json:"manufacturer"`
	Model        string `json:"model"`
	BuildNumber  string `json:"build_number"`
	OS           string `json:"os"`
	OSVersion    string `json:"os_version"`
	ScreenWidth  uint32 `json:"screen_width"`
	ScreenHeight uint32 `json:"screen_height"`
}

func (d *Device) Validate() error {
	return validation.All(
		validation.String(d.Manufacturer, "manufacturer").Required(true),
		validation.String(d.Model, "model").Required(true),
		validation.String(d.BuildNumber, "build_number").Required(true),
	)
}

type Telemetry struct {
	Action    string         `json:"action"`
	Data      map[string]any `json:"data"`
	Timestamp time.Time      `json:"timestamp"`
}

func (t *Telemetry) Validate() error {
	return validation.All(
		validation.String(t.Action, "action").Required(true),
		validation.Map(t.Data, "data").NotNil(true),
		validation.Time(t.Timestamp, "timestamp").Required(true),
	)
}

type TrackRequest struct {
	Info GeneralInfo `json:"info"`
	Data []Telemetry `json:"data"`
}

func (tr *TrackRequest) Validate() error {
	return validation.All(
		validation.Ptr(&tr.Info, "info").With(validation.Custom),
		validation.Slice(tr.Data, "data").NotNil(true).ValuesPtrWith(validation.Custom),
	)
}

func main() {
	tr := TrackRequest{}
	str, _ := json.Marshal(tr.Validate())
	os.Stdout.Write(str)
}

Index

Examples

Constants

This section is empty.

Variables

View Source 
var (
	ErrEmpty = NewRuleError("empty", "must be blank")
	ErrNil   = NewRuleError("nil", "must be blank")
)
View Source 
var (
	ErrNoMatch = NewRuleError("no_match", "must be a valid value")
	ErrMatch   = NewRuleError("match", "must be a valid value")
)
View Source 
var (
	ErrRequired      = NewRuleError("required", "cannot be blank")
	ErrNilOrNotEmpty = NewRuleError("nil_or_not_empty_required", "cannot be blank")
)
View Source 
var ErrInInvalid = NewRuleError("in_invalid", "must be a valid value")
View Source 
var ErrNotInInvalid = NewRuleError("not_in_invalid", "must be a valid value")
View Source 
var ErrNotNil = NewRuleError("not_nil", "is required")

Functions

func All 

func All(validators ...Validator) error

func Between 

func Between[T cmp.Ordered](a, b T) compareRule[T]

func BetweenAny 

func BetweenAny[T any](cmp func(a, b T) int, a, b T) compareRule[T]

func BetweenEqual 

func BetweenEqual[T cmp.Ordered](a, b T) compareRule[T]

func BetweenEqualAny 

func BetweenEqualAny[T any](cmp func(a, b T) int, a, b T) compareRule[T]

func BetweenEqualTime 

func BetweenEqualTime(a, b time.Time) compareTimeRule

func BetweenTime 

func BetweenTime(a, b time.Time) compareTimeRule

func Custom 

func Custom[T Validatable](v T) error

func Empty 

func Empty[T comparable](condition bool) absentRule[T]

func EmptyMap 

func EmptyMap[T any](condition bool) absentMapRule[T]

func EmptySlice 

func EmptySlice[T any](condition bool) absentSliceRule[T]

func EmptyTime 

func EmptyTime(condition bool) absentTimeRule

func Equal 

func Equal[T comparable](v T) compareRule[T]

func EqualAny 

func EqualAny[T any](eq func(a, b T) bool, v T) compareRule[T]

func EqualTime 

func EqualTime(v time.Time) compareTimeRule

func Greater 

func Greater[T cmp.Ordered](v T) compareRule[T]

func GreaterAny 

func GreaterAny[T any](cmp func(a, b T) int, v T) compareRule[T]

func GreaterEqual 

func GreaterEqual[T cmp.Ordered](v T) compareRule[T]

func GreaterEqualAny 

func GreaterEqualAny[T any](cmp func(a, b T) int, v T) compareRule[T]

func GreaterEqualTime 

func GreaterEqualTime(v time.Time) compareTimeRule

func GreaterTime 

func GreaterTime(v time.Time) compareTimeRule

func In 

func In[T comparable](elements ...T) inRule[T]

func InAny 

func InAny[T any](eq func(a, b T) bool, elements ...T) inAnyRule[T]

func InTime 

func InTime(elements ...time.Time) inTimeRule

func LengthMap 

func LengthMap[T any](min, max int) lengthMapRule[T]

func LengthSlice 

func LengthSlice[T any](min, max int) lengthSliceRule[T]

func LengthString 

func LengthString[T ~string](min, max int) lengthStringRule[T]

func LengthStringRune 

func LengthStringRune[T ~string](min, max int) lengthStringRule[T]

func Less 

func Less[T cmp.Ordered](v T) compareRule[T]

func LessAny 

func LessAny[T any](cmp func(a, b T) int, v T) compareRule[T]

func LessEqual 

func LessEqual[T cmp.Ordered](v T) compareRule[T]

func LessEqualAny 

func LessEqualAny[T any](cmp func(a, b T) int, v T) compareRule[T]

func LessEqualTime 

func LessEqualTime(v time.Time) compareTimeRule

func LessTime 

func LessTime(v time.Time) compareTimeRule

func Match 

func Match[T ~string](expr string) matchRule[T]

func NilMap 

func NilMap[T any](condition bool) absentMapRule[T]

func NilOrNotEmptyMap 

func NilOrNotEmptyMap[T any](condition bool) requiredMapRule[T]

func NilOrNotEmptySlice 

func NilOrNotEmptySlice[T any](condition bool) requiredSliceRule[T]

func NilPtr 

func NilPtr[T any](condition bool) absentPtrRule[T]

func NilSlice 

func NilSlice[T any](condition bool) absentSliceRule[T]

func NotIn 

func NotIn[T comparable](elements ...T) notInRule[T]

func NotInAny 

func NotInAny[T any](eq func(a, b T) bool, elements ...T) notInAnyRule[T]

func NotInTime 

func NotInTime(elements ...time.Time) notInTimeRule

func NotMatch 

func NotMatch[T ~string](expr string) matchRule[T]

func NotNilMap 

func NotNilMap[T any](condition bool) notNilMapRule[T]

func NotNilPtr 

func NotNilPtr[T any](condition bool) notNilPtrRule[T]

func NotNilSlice 

func NotNilSlice[T any](condition bool) notNilSliceRule[T]

func Required 

func Required[T comparable](condition bool) requiredRule[T]

func RequiredAny 

func RequiredAny[T any](condition bool, isDefault func(a T) bool) requiredAnyRule[T]

func RequiredMap 

func RequiredMap[T any](condition bool) requiredMapRule[T]

func RequiredSlice 

func RequiredSlice[T any](condition bool) requiredSliceRule[T]

func RequiredTime 

func RequiredTime(condition bool) requiredTimeRule

Types

type AnyRule 

type AnyRule[T any] interface {
	Validate(v T) error
}

func CustomRule 

func CustomRule[T Validatable]() AnyRule[T]

type AnyRuleFunc 

type AnyRuleFunc[T any] func(v T) error

func (AnyRuleFunc[T]) Validate 

func (fn AnyRuleFunc[T]) Validate(v T) error

type AnyValidator 

type AnyValidator[T any] struct {
	// contains filtered or unexported fields
}

func Any 

func Any[T any](v T, name string) AnyValidator[T]

func AnyI 

func AnyI[T any](v T) AnyValidator[T]

func AnyV 

func AnyV[T any]() AnyValidator[T]

func (AnyValidator[T]) Between 

func (av AnyValidator[T]) Between(cmp func(a, b T) int, a, b T) AnyValidator[T]

func (AnyValidator[T]) BetweenEqual 

func (av AnyValidator[T]) BetweenEqual(cmp func(a, b T) int, a, b T) AnyValidator[T]

func (AnyValidator[T]) Break 

func (av AnyValidator[T]) Break(condition bool) AnyValidator[T]

func (AnyValidator[T]) By 

func (av AnyValidator[T]) By(rules ...AnyRule[T]) AnyValidator[T]

func (AnyValidator[T]) Else 

func (av AnyValidator[T]) Else() AnyValidator[T]

func (AnyValidator[T]) ElseIf 

func (av AnyValidator[T]) ElseIf(condition bool) AnyValidator[T]

func (AnyValidator[T]) EndIf 

func (av AnyValidator[T]) EndIf() AnyValidator[T]

func (AnyValidator[T]) Equal 

func (av AnyValidator[T]) Equal(eq func(a, b T) bool, v T) AnyValidator[T]

func (AnyValidator[T]) Greater 

func (av AnyValidator[T]) Greater(cmp func(a, b T) int, v T) AnyValidator[T]

func (AnyValidator[T]) GreaterEqual 

func (av AnyValidator[T]) GreaterEqual(cmp func(a, b T) int, v T) AnyValidator[T]

func (AnyValidator[T]) If 

func (av AnyValidator[T]) If(condition bool) AnyValidator[T]

func (AnyValidator[T]) In 

func (av AnyValidator[T]) In(eq func(a, b T) bool, elements ...T) AnyValidator[T]

func (AnyValidator[T]) Less 

func (av AnyValidator[T]) Less(cmp func(a, b T) int, v T) AnyValidator[T]

func (AnyValidator[T]) LessEqual 

func (av AnyValidator[T]) LessEqual(cmp func(a, b T) int, v T) AnyValidator[T]

func (AnyValidator[T]) NotIn 

func (av AnyValidator[T]) NotIn(eq func(a, b T) bool, elements ...T) AnyValidator[T]

func (AnyValidator[T]) Required 

func (av AnyValidator[T]) Required(condition bool, isDefault func(v T) bool) AnyValidator[T]

func (AnyValidator[T]) Valid 

func (av AnyValidator[T]) Valid() error

func (AnyValidator[T]) Validate 

func (av AnyValidator[T]) Validate(v T) error

func (AnyValidator[T]) With 

func (av AnyValidator[T]) With(fns ...func(v T) error) AnyValidator[T]

type ComparableRule 

type ComparableRule[T comparable] interface {
	Validate(v T) error
}

type ComparableRuleFunc 

type ComparableRuleFunc[T comparable] func(v T) error

func (ComparableRuleFunc[T]) Validate 

func (fn ComparableRuleFunc[T]) Validate(v T) error

type ComparableValidator 

type ComparableValidator[T comparable] struct {
	// contains filtered or unexported fields
}

func Comparable 

func Comparable[T comparable](v T, name string) ComparableValidator[T]

func ComparableI 

func ComparableI[T comparable](v T) ComparableValidator[T]

func ComparableV 

func ComparableV[T comparable]() ComparableValidator[T]

func (ComparableValidator[T]) Break 

func (cv ComparableValidator[T]) Break(condition bool) ComparableValidator[T]

func (ComparableValidator[T]) By 

func (cv ComparableValidator[T]) By(rules ...ComparableRule[T]) ComparableValidator[T]

func (ComparableValidator[T]) Else 

func (cv ComparableValidator[T]) Else() ComparableValidator[T]

func (ComparableValidator[T]) ElseIf 

func (cv ComparableValidator[T]) ElseIf(condition bool) ComparableValidator[T]

func (ComparableValidator[T]) EndIf 

func (cv ComparableValidator[T]) EndIf() ComparableValidator[T]

func (ComparableValidator[T]) Equal 

func (cv ComparableValidator[T]) Equal(v T) ComparableValidator[T]

func (ComparableValidator[T]) If 

func (cv ComparableValidator[T]) If(condition bool) ComparableValidator[T]

func (ComparableValidator[T]) In 

func (cv ComparableValidator[T]) In(elements ...T) ComparableValidator[T]

func (ComparableValidator[T]) NotIn 

func (cv ComparableValidator[T]) NotIn(elements ...T) ComparableValidator[T]

func (ComparableValidator[T]) Required 

func (cv ComparableValidator[T]) Required(condition bool) ComparableValidator[T]

func (ComparableValidator[T]) Valid 

func (cv ComparableValidator[T]) Valid() error

func (ComparableValidator[T]) Validate 

func (cv ComparableValidator[T]) Validate(v T) error

func (ComparableValidator[T]) With 

func (cv ComparableValidator[T]) With(fns ...func(v T) error) ComparableValidator[T]

type Errors 

type Errors []error

func (Errors) Error 

func (es Errors) Error() string

func (Errors) MarshalJSON 

func (es Errors) MarshalJSON() ([]byte, error)

type IndexError 

type IndexError interface {
	Error() string
	Unwrap() error
	Index() int
}

func NewIndexError 

func NewIndexError(index int, nested error) IndexError

type MapRule 

type MapRule[T any] interface {
	Validate(m map[string]T) error
}

type MapRuleFunc 

type MapRuleFunc[T any] func(m map[string]T) error

func (MapRuleFunc[T]) Validate 

func (fn MapRuleFunc[T]) Validate(m map[string]T) error

type MapValidator 

type MapValidator[T any] struct {
	// contains filtered or unexported fields
}

func Map 

func Map[T any](m map[string]T, name string) MapValidator[T]

func MapI 

func MapI[T any](m map[string]T) MapValidator[T]

func MapV 

func MapV[T any]() MapValidator[T]

func (MapValidator[T]) Break 

func (mv MapValidator[T]) Break(condition bool) MapValidator[T]

func (MapValidator[T]) By 

func (mv MapValidator[T]) By(rules ...MapRule[T]) MapValidator[T]

func (MapValidator[T]) Else 

func (mv MapValidator[T]) Else() MapValidator[T]

func (MapValidator[T]) ElseIf 

func (mv MapValidator[T]) ElseIf(condition bool) MapValidator[T]

func (MapValidator[T]) Empty 

func (mv MapValidator[T]) Empty(condition bool) MapValidator[T]

func (MapValidator[T]) EndIf 

func (mv MapValidator[T]) EndIf() MapValidator[T]

func (MapValidator[T]) If 

func (mv MapValidator[T]) If(condition bool) MapValidator[T]

func (MapValidator[T]) Length 

func (mv MapValidator[T]) Length(min, max int) MapValidator[T]

func (MapValidator[T]) Nil 

func (mv MapValidator[T]) Nil(condition bool) MapValidator[T]

func (MapValidator[T]) NilOrNotEmpty 

func (mv MapValidator[T]) NilOrNotEmpty(condition bool) MapValidator[T]

func (MapValidator[T]) NotNil 

func (mv MapValidator[T]) NotNil(condition bool) MapValidator[T]

func (MapValidator[T]) Required 

func (mv MapValidator[T]) Required(condition bool) MapValidator[T]

func (MapValidator[T]) Valid 

func (mv MapValidator[T]) Valid() error

func (MapValidator[T]) Validate 

func (mv MapValidator[T]) Validate(m map[string]T) error

func (MapValidator[T]) With 

func (mv MapValidator[T]) With(fns ...func(s map[string]T) error) MapValidator[T]

type NumberRule 

type NumberRule[T constraints.Integer | constraints.Float] interface {
	Validate(n T) error
}

type NumberRuleFunc 

type NumberRuleFunc[T constraints.Integer | constraints.Float] func(n T) error

func (NumberRuleFunc[T]) Validate 

func (fn NumberRuleFunc[T]) Validate(n T) error

type NumberValidator 

type NumberValidator[T constraints.Integer | constraints.Float] struct {
	// contains filtered or unexported fields
}

func Number 

func Number[T constraints.Integer | constraints.Float](n T, name string) NumberValidator[T]

func NumberI 

func NumberI[T constraints.Integer | constraints.Float](n T) NumberValidator[T]

func NumberV 

func NumberV[T constraints.Integer | constraints.Float]() NumberValidator[T]

func (NumberValidator[T]) Between 

func (nv NumberValidator[T]) Between(a, b T) NumberValidator[T]

func (NumberValidator[T]) BetweenEqual 

func (nv NumberValidator[T]) BetweenEqual(a, b T) NumberValidator[T]

func (NumberValidator[T]) Break 

func (nv NumberValidator[T]) Break(condition bool) NumberValidator[T]

func (NumberValidator[T]) By 

func (nv NumberValidator[T]) By(rules ...NumberRule[T]) NumberValidator[T]

func (NumberValidator[T]) Else 

func (nv NumberValidator[T]) Else() NumberValidator[T]

func (NumberValidator[T]) ElseIf 

func (nv NumberValidator[T]) ElseIf(condition bool) NumberValidator[T]

func (NumberValidator[T]) EndIf 

func (nv NumberValidator[T]) EndIf() NumberValidator[T]

func (NumberValidator[T]) Equal 

func (nv NumberValidator[T]) Equal(v T) NumberValidator[T]

func (NumberValidator[T]) Greater 

func (nv NumberValidator[T]) Greater(v T) NumberValidator[T]

func (NumberValidator[T]) GreaterEqual 

func (nv NumberValidator[T]) GreaterEqual(v T) NumberValidator[T]

func (NumberValidator[T]) If 

func (nv NumberValidator[T]) If(condition bool) NumberValidator[T]

func (NumberValidator[T]) In 

func (nv NumberValidator[T]) In(elements ...T) NumberValidator[T]

func (NumberValidator[T]) Less 

func (nv NumberValidator[T]) Less(v T) NumberValidator[T]

func (NumberValidator[T]) LessEqual 

func (nv NumberValidator[T]) LessEqual(v T) NumberValidator[T]

func (NumberValidator[T]) NotIn 

func (nv NumberValidator[T]) NotIn(elements ...T) NumberValidator[T]

func (NumberValidator[T]) Required 

func (nv NumberValidator[T]) Required(condition bool) NumberValidator[T]

func (NumberValidator[T]) Valid 

func (nv NumberValidator[T]) Valid() error

func (NumberValidator[T]) Validate 

func (nv NumberValidator[T]) Validate(v T) error

func (NumberValidator[T]) With 

func (nv NumberValidator[T]) With(fns ...func(n T) error) NumberValidator[T]

type PtrRule 

type PtrRule[T any] interface {
	Validate(p *T) error
}

type PtrRuleFunc 

type PtrRuleFunc[T any] func(p *T) error

func (PtrRuleFunc[T]) Validate 

func (fn PtrRuleFunc[T]) Validate(p *T) error

type PtrValidator 

type PtrValidator[T any] struct {
	// contains filtered or unexported fields
}

func Ptr 

func Ptr[T any](p *T, name string) PtrValidator[T]

func PtrI 

func PtrI[T any](p *T) PtrValidator[T]

func PtrV 

func PtrV[T any]() PtrValidator[T]

func (PtrValidator[T]) Break 

func (pv PtrValidator[T]) Break(condition bool) PtrValidator[T]

func (PtrValidator[T]) By 

func (pv PtrValidator[T]) By(rules ...PtrRule[T]) PtrValidator[T]

func (PtrValidator[T]) Else 

func (pv PtrValidator[T]) Else() PtrValidator[T]

func (PtrValidator[T]) ElseIf 

func (pv PtrValidator[T]) ElseIf(condition bool) PtrValidator[T]

func (PtrValidator[T]) EndIf 

func (pv PtrValidator[T]) EndIf() PtrValidator[T]

func (PtrValidator[T]) If 

func (pv PtrValidator[T]) If(condition bool) PtrValidator[T]

func (PtrValidator[T]) Nil 

func (pv PtrValidator[T]) Nil(condition bool) PtrValidator[T]

func (PtrValidator[T]) NotNil 

func (pv PtrValidator[T]) NotNil(condition bool) PtrValidator[T]

func (PtrValidator[T]) Valid 

func (pv PtrValidator[T]) Valid() error

func (PtrValidator[T]) Validate 

func (pv PtrValidator[T]) Validate(v *T) error

func (PtrValidator[T]) ValueBy 

func (pv PtrValidator[T]) ValueBy(rules ...AnyRule[T]) PtrValidator[T]

func (PtrValidator[T]) ValueWith 

func (pv PtrValidator[T]) ValueWith(fns ...func(p T) error) PtrValidator[T]

func (PtrValidator[T]) With 

func (pv PtrValidator[T]) With(fns ...func(p *T) error) PtrValidator[T]

type RuleError 

type RuleError interface {
	Error() string
	Code() string
	Message() string
}

func NewRuleError 

func NewRuleError(code, message string) RuleError

type SliceRule 

type SliceRule[T any] interface {
	Validate(s []T) error
}

type SliceRuleFunc 

type SliceRuleFunc[T any] func(s []T) error

func (SliceRuleFunc[T]) Validate 

func (fn SliceRuleFunc[T]) Validate(s []T) error

type SliceValidator 

type SliceValidator[T any] struct {
	// contains filtered or unexported fields
}

func Slice 

func Slice[T any](s []T, name string) SliceValidator[T]

func SliceI 

func SliceI[T any](s []T) SliceValidator[T]

func SliceV 

func SliceV[T any]() SliceValidator[T]

func (SliceValidator[T]) Break 

func (sv SliceValidator[T]) Break(condition bool) SliceValidator[T]

func (SliceValidator[T]) By 

func (sv SliceValidator[T]) By(rules ...SliceRule[T]) SliceValidator[T]

func (SliceValidator[T]) Else 

func (sv SliceValidator[T]) Else() SliceValidator[T]

func (SliceValidator[T]) ElseIf 

func (sv SliceValidator[T]) ElseIf(condition bool) SliceValidator[T]

func (SliceValidator[T]) Empty 

func (sv SliceValidator[T]) Empty(condition bool) SliceValidator[T]

func (SliceValidator[T]) EndIf 

func (sv SliceValidator[T]) EndIf() SliceValidator[T]

func (SliceValidator[T]) If 

func (sv SliceValidator[T]) If(condition bool) SliceValidator[T]

func (SliceValidator[T]) Length 

func (sv SliceValidator[T]) Length(min, max int) SliceValidator[T]

func (SliceValidator[T]) Nil 

func (sv SliceValidator[T]) Nil(condition bool) SliceValidator[T]

func (SliceValidator[T]) NilOrNotEmpty 

func (sv SliceValidator[T]) NilOrNotEmpty(condition bool) SliceValidator[T]

func (SliceValidator[T]) NotNil 

func (sv SliceValidator[T]) NotNil(condition bool) SliceValidator[T]

func (SliceValidator[T]) Required 

func (sv SliceValidator[T]) Required(condition bool) SliceValidator[T]

func (SliceValidator[T]) Valid 

func (sv SliceValidator[T]) Valid() error

func (SliceValidator[T]) Validate 

func (sv SliceValidator[T]) Validate(v []T) error

func (SliceValidator[T]) ValuesBy 

func (sv SliceValidator[T]) ValuesBy(rules ...AnyRule[T]) SliceValidator[T]

func (SliceValidator[T]) ValuesPtrBy 

func (sv SliceValidator[T]) ValuesPtrBy(rules ...AnyRule[*T]) SliceValidator[T]

func (SliceValidator[T]) ValuesPtrWith 

func (sv SliceValidator[T]) ValuesPtrWith(fns ...func(v *T) error) SliceValidator[T]

func (SliceValidator[T]) ValuesWith 

func (sv SliceValidator[T]) ValuesWith(fns ...func(v T) error) SliceValidator[T]

func (SliceValidator[T]) With 

func (sv SliceValidator[T]) With(fns ...func(s []T) error) SliceValidator[T]

type StringRule 

type StringRule[T ~string] interface {
	Validate(s T) error
}

type StringRuleFunc 

type StringRuleFunc[T ~string] func(s T) error

func (StringRuleFunc[T]) Validate 

func (fn StringRuleFunc[T]) Validate(s T) error

type StringValidator 

type StringValidator[T ~string] struct {
	// contains filtered or unexported fields
}

func String 

func String[T ~string](s T, name string) StringValidator[T]

func StringI 

func StringI[T ~string](s T) StringValidator[T]

func StringV 

func StringV[T ~string]() StringValidator[T]

func (StringValidator[T]) Between 

func (sv StringValidator[T]) Between(a, b T) StringValidator[T]

func (StringValidator[T]) BetweenEqual 

func (sv StringValidator[T]) BetweenEqual(a, b T) StringValidator[T]

func (StringValidator[T]) Break 

func (sv StringValidator[T]) Break(condition bool) StringValidator[T]

func (StringValidator[T]) By 

func (sv StringValidator[T]) By(rules ...StringRule[T]) StringValidator[T]

func (StringValidator[T]) Else 

func (sv StringValidator[T]) Else() StringValidator[T]

func (StringValidator[T]) ElseIf 

func (sv StringValidator[T]) ElseIf(condition bool) StringValidator[T]

func (StringValidator[T]) EndIf 

func (sv StringValidator[T]) EndIf() StringValidator[T]

func (StringValidator[T]) Equal 

func (sv StringValidator[T]) Equal(v T) StringValidator[T]

func (StringValidator[T]) Greater 

func (sv StringValidator[T]) Greater(v T) StringValidator[T]

func (StringValidator[T]) GreaterEqual 

func (sv StringValidator[T]) GreaterEqual(v T) StringValidator[T]

func (StringValidator[T]) If 

func (sv StringValidator[T]) If(condition bool) StringValidator[T]

func (StringValidator[T]) In 

func (sv StringValidator[T]) In(elements ...T) StringValidator[T]

func (StringValidator[T]) Length 

func (sv StringValidator[T]) Length(min, max int) StringValidator[T]

func (StringValidator[T]) Less 

func (sv StringValidator[T]) Less(v T) StringValidator[T]

func (StringValidator[T]) LessEqual 

func (sv StringValidator[T]) LessEqual(v T) StringValidator[T]

func (StringValidator[T]) Match 

func (sv StringValidator[T]) Match(expr string) StringValidator[T]

func (StringValidator[T]) NotIn 

func (sv StringValidator[T]) NotIn(elements ...T) StringValidator[T]

func (StringValidator[T]) NotMatch 

func (sv StringValidator[T]) NotMatch(expr string) StringValidator[T]

func (StringValidator[T]) Required 

func (sv StringValidator[T]) Required(condition bool) StringValidator[T]

func (StringValidator[T]) Valid 

func (sv StringValidator[T]) Valid() error

func (StringValidator[T]) Validate 

func (sv StringValidator[T]) Validate(v T) error

func (StringValidator[T]) With 

func (sv StringValidator[T]) With(fns ...func(s T) error) StringValidator[T]

type TimeRule 

type TimeRule interface {
	Validate(t time.Time) error
}

type TimeRuleFunc 

type TimeRuleFunc func(t time.Time) error

func (TimeRuleFunc) Validate 

func (fn TimeRuleFunc) Validate(t time.Time) error

type TimeValidator 

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

func Time 

func Time(v time.Time, name string) TimeValidator

func TimeI 

func TimeI(v time.Time) TimeValidator

func TimeV 

func TimeV() TimeValidator

func (TimeValidator) Between 

func (tv TimeValidator) Between(a, b time.Time) TimeValidator

func (TimeValidator) BetweenEqual 

func (tv TimeValidator) BetweenEqual(a, b time.Time) TimeValidator

func (TimeValidator) Break 

func (tv TimeValidator) Break(condition bool) TimeValidator

func (TimeValidator) By 

func (tv TimeValidator) By(rules ...TimeRule) TimeValidator

func (TimeValidator) Else 

func (tv TimeValidator) Else() TimeValidator

func (TimeValidator) ElseIf 

func (tv TimeValidator) ElseIf(condition bool) TimeValidator

func (TimeValidator) EndIf 

func (tv TimeValidator) EndIf() TimeValidator

func (TimeValidator) Equal 

func (tv TimeValidator) Equal(v time.Time) TimeValidator

func (TimeValidator) Greater 

func (tv TimeValidator) Greater(v time.Time) TimeValidator

func (TimeValidator) GreaterEqual 

func (tv TimeValidator) GreaterEqual(v time.Time) TimeValidator

func (TimeValidator) If 

func (tv TimeValidator) If(condition bool) TimeValidator

func (TimeValidator) In 

func (tv TimeValidator) In(elements ...time.Time) TimeValidator

func (TimeValidator) Less 

func (tv TimeValidator) Less(v time.Time) TimeValidator

func (TimeValidator) LessEqual 

func (tv TimeValidator) LessEqual(v time.Time) TimeValidator

func (TimeValidator) NotIn 

func (tv TimeValidator) NotIn(elements ...time.Time) TimeValidator

func (TimeValidator) Required 

func (tv TimeValidator) Required(condition bool) TimeValidator

func (TimeValidator) Valid 

func (tv TimeValidator) Valid() error

func (TimeValidator) Validate 

func (tv TimeValidator) Validate(v time.Time) error

func (TimeValidator) With 

func (tv TimeValidator) With(fns ...func(v time.Time) error) TimeValidator

type Validatable 

type Validatable interface {
	Validate() error
}

type Validator 

type Validator interface {
	Valid() error
}

type ValueError 

type ValueError interface {
	Error() string
	Unwrap() error
	Name() string
}

func NewValueError 

func NewValueError(name string, nested error) ValueError

Source Files

View all Source files

Directories

Path Synopsis
is
int
str
uint

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.