[![Go Version][gover-img]][gover] [![GoDoc][doc-img]][doc] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov] [![GoReport][rpt-img]][rpt]

# Fast and intuitive validation library for Go

This lib uses the `Is...` validation functions from the [govalidator](https://github.com/asaskevich/govalidator) project.

## Installation

```shell
go get github.com/tiendc/go-validator
```

## Usage

#### General usage
```go
    import (
        vld "github.com/tiendc/go-validator"
    )

    type Person struct {
        FirstName string
        LastName  string
        Birthdate time.Time

        Unemployed bool
        Salary     uint
        Rank       string
        WorkEmail  string
        Projects   []string
        TaskMap    map[string]Task
    }
    var p Person

    errs := vld.Validate(
        // Validate first and last names separately
        vld.StrLen(&p.FirstName, 3, 30).OnError(
            vld.SetField("first_name", nil),
            vld.SetCustomKey("ERR_VLD_PERSON_FIRST_NAME_INVALID"),
        ),
        vld.StrLen(&p.FirstName, 3, 30).OnError(
            vld.SetField("last_name", nil),
            vld.SetCustomKey("ERR_VLD_PERSON_LAST_NAME_INVALID"),
        ),

        // OR use this to produce only one error when one of them fails
        vld.Group(
            vld.StrLen(&p.FirstName, 3, 30),
            vld.StrLen(&p.LastName, 3, 30),
        ).OnError(
            vld.SetField("name", nil),
            vld.SetCustomKey("ERR_VLD_PERSON_NAME_INVALID"),
        ),

        // Birthdate is optional, but when it's present, it must be within 1950 and now
        vld.When(!p.Birthdate.IsZero()).Then(
            vld.TimeRange(p.Birthdate, <1950-01-01>, time.Now()).OnError(...),
        )

        vld.When(!p.Unemployed).Then(
            vld.Required(&p.Salary),
            // Work email must be valid
            vld.StrIsEmail(&p.WorkEmail),

            // Rank must be one of the constants
            vld.StrIn(&p.Rank, "Employee", "Manager", "Director"),
            vld.Case(
                vld.When(p.Rank == "Manager").Then(vld.NumGT(&p.Salary, 10000)),
                vld.When(p.Rank == "Director").Then(vld.NumGT(&p.Salary, 30000)),
            ).Default(
                vld.NumLT(&p.Salary, 10000),
            ),

            // Projects are optional, but when they are present, they must be unique and sorted
            vld.When(len(p.Projects) > 0).Then(
                vld.SliceUnique(p.Projects).OnError(...),
                vld.SliceSorted(p.Projects).OnError(...),
            )
        ).Else(
            // When person is unemployed
            vld.NumEQ(&p.Salary, 0),
            vld.StrEQ(&p.WorkEmail, ""),
        ),

        // Validate slice elements
        vld.Slice(p.Projects).ForEach(func(elem int, index int, validator ItemValidator) {
            validator.Validate(
                vld.StrLen(&elem, 10, 30).OnError(
                    vld.SetField(fmt.Sprintf("projects[%d]", index), nil),
                    vld.SetCustomKey("ERR_VLD_PROJECT_NAME_INVALID"),
                ),
            )
        }),

        // Validate map entries
        vld.Map(p.TaskMap).ForEach(func(k string, v Task, validator ItemValidator) {
            validator.Validate(
                vld.StrLen(&v.Name, 10, 30).OnError(
                    vld.SetField(fmt.Sprintf("taskMap[%s].name", k), nil),
                    vld.SetCustomKey("ERR_VLD_TASK_NAME_INVALID"),
                ),
            )
        }),

        // OTHER FUNCTIONS
        // Pass if at least one of the validations passes
        vld.OneOf(
            // List of validations
        ),

        // Pass if exact one of the validations passes
        vld.ExactOneOf(
            // List of validations
        ),

        // Pass if none of the validations passes
        vld.NotOf(
            // List of validations
        ),
    )

    for _, e := range errs {
        detail, warnErr := e.BuildDetail()
        fmt.Printf("%+v\n", detail)
    }
```

#### Error message localization

- Method 1: inline localization (not recommended)
```go
    errs := Validate(
        NumLTE(&p.Age, 40).OnError(
            // Override the default template in english
            SetTemplate("Tuổi nhân viên phải nhỏ hơn hoặc bằng {{.Max}}"),
        ),
    )

    for _, e := range errs {
        detail, warnErr := e.BuildDetail()
        fmt.Printf("%+v\n", detail)
    }
```

- Method 2: using another localization lib (recommended)
```go
    // Supposed you have 2 files defining error messages
    // In `error_messages.en`:
    // ERR_VLD_EMPLOYEE_AGE_TOO_BIG = "Employee {{.EmployeeName}} has age bigger than {{.Max}}"
    // In `error_messages.vi`:
    // ERR_VLD_EMPLOYEE_AGE_TOO_BIG = "Nhân viên {{.EmployeeName}} có tuổi lớn hơn {{.Max}}"

    errs := Validate(
        NumLTE(&p.Age, 40).OnError(
            // Custom param (the default template doesn't have this one)
            SetParam("EmployeeName", p.Name),
            // Custom key to define custom template to use
            SetCustomKey("ERR_VLD_EMPLOYEE_AGE_TOO_BIG"),
        ),
    )

    for _, e := range errs {
        errKey := e.CustomKey()
        errParams : = e.Params() // or e.ParamsWithFormatter()
        errorMsg := translationFunction(errKey, errParams) // You need to provide this function
        fmt.Printf("%+v\n", errorMsg)
    }
```

#### Custom error param formatter

```go
    errs := Validate(
        NumLT(&budget, 1000000).OnError(
            SetField("Budget", nil),
        ),
    )

    // e.BuildDetail() may produce message `Budget must be less than 1000000`,
    // but you may want a message like: `Budget must be less than 1,000,000`.
    // Let's use a custom formatter

    errs := Validate(
        NumLT(&budget, 1000000).OnError(
            SetField("Budget", nil),
            SetNumParamFormatter(NewDecimalFormatFunc('.', ',', "%f")),
        ),
    )
```

## Contributing

- You are welcome to make pull requests for new functions and bug fixes.

## License

- [MIT License](LICENSE)

[doc-img]: https://pkg.go.dev/badge/github.com/tiendc/go-validator
[doc]: https://pkg.go.dev/github.com/tiendc/go-validator
[gover-img]: https://img.shields.io/badge/Go-%3E%3D%201.20-blue
[gover]: https://img.shields.io/badge/Go-%3E%3D%201.20-blue
[ci-img]: https://github.com/tiendc/go-validator/actions/workflows/go.yml/badge.svg
[ci]: https://github.com/tiendc/go-validator/actions/workflows/go.yml
[cov-img]: https://codecov.io/gh/tiendc/go-validator/branch/main/graph/badge.svg
[cov]: https://codecov.io/gh/tiendc/go-validator
[rpt-img]: https://goreportcard.com/badge/github.com/tiendc/go-validator
[rpt]: https://goreportcard.com/report/github.com/tiendc/go-validator

go-validator

:balloon: A lightweight struct validator for Go

# gody

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![Last commit](https://img.shields.io/github/last-commit/guiferpa/gody)](https://img.shields.io/github/last-commit/guiferpa/gody)
[![GoDoc](https://godoc.org/github.com/guiferpa/gody?status.svg)](https://godoc.org/github.com/guiferpa/gody)
[![Go Report Card](https://goreportcard.com/badge/github.com/guiferpa/gody)](https://goreportcard.com/report/github.com/guiferpa/gody)
![Pipeline workflow](https://github.com/guiferpa/gody/actions/workflows/pipeline.yml/badge.svg)
[![Coverage Status](https://coveralls.io/repos/github/guiferpa/gody/badge.svg?branch=main)](https://coveralls.io/github/guiferpa/gody?branch=main)
[![GitHub release (latest by date)](https://img.shields.io/github/v/release/guiferpa/gody?color=purple&label=latest)](https://github.com/guiferpa/gody/releases/latest)

### [Go versions supported](https://github.com/guiferpa/gody/blob/main/.github/workflows/pipeline.yml#L12)

### Installation
```bash
go get github.com/guiferpa/gody/v2
```

### Usage

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"

    gody "github.com/guiferpa/gody/v2"
    "github.com/guiferpa/gody/v2/rule"
) 

type RequestBody struct {
    Name string `json:"name" validate:"not_empty"`
    Age  int    `json:"age" validate:"min=21"`
}

func HTTPHandler(v *gody.Validator) http.HandlerFunc {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var body RequestBody
        if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
	    // ...
    	}
	defer r.Body.Close()

	if isValidated, err := v.Validate(body); err != nil {
	    // ...                                                                                
	}
    })
}

func main() {
    validator := gody.NewValidator()

    validator.AddRules(rule.NotEmpty, rule.Min)

    port := ":3000"
    http.ListenAndServe(port, HTTPHandler(validator))
}
```

### Others ways for validation

There are others ways to valid a struct, take a look on functions below:

- **RawValidate** - It's a function that make validate with no rule, it's necessary put the struct for validation, some rule(s) and tag name.

```go
gody.RawValidate(interface{}, string, []gody.Rule) (bool, error)
```

- **Validate** - It's a function that make validate with no rule, it's necessary put the struct for validation and some rule(s).
```go
gody.Validate(interface{}, []gody.Rule) (bool, error)
```

- **RawDefaultValidate** - It's a function that already have [built-in rules](https://github.com/guiferpa/gody/blob/72ce1caecc5fdacf40ee282716ec1b5abe6f7adf/validate.go#L15-L23) configured, it's necessary put the struct for validation, tag name and optional custom rule(s).
```go
gody.RawDefaultValidate(interface{}, string, []gody.Rule) (bool, error)
```

- **DefaultValidate** - It's a function that already have [built-in rules](https://github.com/guiferpa/gody/blob/72ce1caecc5fdacf40ee282716ec1b5abe6f7adf/validate.go#L15-L23) configured, it's necessary put the struct for validation and optional custom rule(s).
```go
gody.DefaultValidate(interface{}, []gody.Rule) (bool, error)
```

### Dynamic Enum Validation (No Duplication)

You can avoid duplicating enum values in struct tags by using dynamic parameters:

```go
const (
    StatusCreated = "__CREATED__"
    StatusPending = "__PENDING__"
    StatusDoing   = "__DOING__"
    StatusDone    = "__DONE__"
)

type Task struct {
    Name   string `json:"name"`
    Status string `json:"status" validate:"enum={status}"`
}

validator := gody.NewValidator()
validator.AddRuleParameters(map[string]string{
    "status": fmt.Sprintf("%s,%s,%s,%s", StatusCreated, StatusPending, StatusDoing, StatusDone),
})
validator.AddRules(rule.Enum)

// Now you can validate Task structs without duplicating enum values in the tag!
```

### Contribution policies

1. At this time the only policy is don't create a Pull Request directly, it's necessary some discussions for some implementation then open an issue before to dicussion anything about the project.


gody

# Govalid

[![](https://goreportcard.com/badge/github.com/twharmon/govalid)](https://goreportcard.com/report/github.com/twharmon/govalid)

Use Govalid to validate structs.

## Basic Example
```go
package main

import (
	"errors"
	"fmt"
	"log"
	"strings"
	"unicode/utf8"

	"github.com/twharmon/govalid"
)

type Post struct {
	// ID has no constraints
	ID int

	// Title is required, must be at least 3 characters long, and
	// cannot be more than 20 characters long
	Title string `valid:"req|min:3|max:20"`

	// Body is not required, cannot be more than 10000 charachers,
	// and must be "fun" (a custom rule defined below).
	Body string `valid:"max:10000|fun"`
}

func main() {
	// Add custom string rule "fun" that can be used on any string field
	// in any struct.
	govalid.Rule("fun", func(v any) error {
		switch tv := v.(type) {
		case string:
			if float64(strings.Count(tv, "!"))/float64(utf8.RuneCountInString(tv)) > 0.001 {
				return nil
			}
			// return a validation error with govalid.Error
			return govalid.NewValidationError("must contain more exclamation marks")
		default:
			// return a non validation (internal) error
			return errors.New("fun constraint must be applied to string only")
		}
	})
	fmt.Println(govalid.Validate(&Post{
		ID:    5,
		Title: "Hi",
		Body:  "Hello world!",
	}))
}
```

## Error Values
When you call `govalid.Validate` to validate a struct, it returns an error if the validation rules are not met. This error may either be a validation-specific error (an implementation of `govalid.ValidationError`) or a different error indicating a problem in processing the validation. This allows you to distinguish between errors caused by invalid data and those caused by issues in your validation logic, such as setting the `valid` tag to `max:not-a-number`.

```go
if err := govalid.Validate(value); err != nil {
	if verr, ok := err.(govalid.ValidationError); ok {
		fmt.Println("validation error", verr)
	} else {
		fmt.Println("some other error", err)
	}
}
```

## Dive Usage
The `dive` rule is used to apply validation rules to elements within pointers, slices, arrays, and structs. When the `dive` rule is encountered, it instructs the validator to "dive" into the elements of the collection or the value pointed to by a pointer and apply the remaining rules to each element or the dereferenced value.

### Notes
- **Pointers**: The `dive` rule will dereference the pointer and apply the remaining rules to the value it points to.
- **Slices/Arrays**: The `dive` rule will iterate over each element in the slice or array and apply the remaining rules to each element.
- **Structs**: The `dive` rule will validate the struct according to its own field tags. The remaining rules after `dive` have no meaning for structs.

### Examples

#### Pointers

```go
type Example struct {
    Field *string `valid:"req|dive|min:3"`
}
```
In this example, the Field must be a non-nil pointer to a string, and the string must be at least 3 characters long.

#### Slices/Arrays
```go
type Example struct {
    Field []string `valid:"req|dive|min:3"`
}
```
In this example, the Field must be a non-nil slice of strings, and each string in the slice must be at least 3 characters long.

#### Structs
```go
type Inner struct {
    Name string `valid:"req"`
}

type Outer struct {
    InnerStruct Inner `valid:"dive"`
}
```
In this example, the InnerStruct field will be validated according to the validation tags defined in the Inner struct.

## In Rule

The `in` rule validates that a value is one of a specified set of values. Values are comma-separated and whitespace is trimmed. The rule is case-sensitive for strings.

```go
type Example struct {
    // Status must be one of: active, inactive, or pending
    Status string `valid:"in:active,inactive,pending"`

    // Code must be 1, 2, or 3
    Code int `valid:"in:1,2,3"`
}
```

The `in` rule works with strings, all integer types (int, int8-64), and all unsigned integer types (uint, uint8-64).


## Contribute

Make a pull request.


govalid

Validators and sanitizers for strings, numerics, slices and structs

govalidator

Validate Golang request data with simple rules. Highly inspired by Laravel's request validation

![govalidator](govalidator.png)

[![Build Status](https://travis-ci.org/thedevsaddam/govalidator.svg?branch=master)](https://travis-ci.org/thedevsaddam/govalidator)
[![Project status](https://img.shields.io/badge/version-1.9-green.svg)](https://github.com/thedevsaddam/govalidator/releases)
[![Go Report Card](https://goreportcard.com/badge/github.com/thedevsaddam/govalidator)](https://goreportcard.com/report/github.com/thedevsaddam/govalidator)
[![Coverage Status](https://coveralls.io/repos/github/thedevsaddam/govalidator/badge.svg?branch=master)](https://coveralls.io/github/thedevsaddam/govalidator?branch=master)
[![GoDoc](https://godoc.org/github.com/thedevsaddam/govalidator?status.svg)](https://godoc.org/github.com/thedevsaddam/govalidator)
[![License](https://img.shields.io/dub/l/vibe-d.svg)](https://github.com/thedevsaddam/govalidator/blob/dev/LICENSE.md)

Validate golang request data with simple rules. Highly inspired by Laravel's request validation.


### Installation

Install the package using
```go
$ go get github.com/thedevsaddam/govalidator
// or
$ go get gopkg.in/thedevsaddam/govalidator.v1
```

### Usage

To use the package import it in your `*.go` code
```go
import "github.com/thedevsaddam/govalidator"
// or
import "gopkg.in/thedevsaddam/govalidator.v1"
```

### Example

***Validate `form-data`, `x-www-form-urlencoded` and `query params`***

```go

package main

import (
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/thedevsaddam/govalidator"
)

func handler(w http.ResponseWriter, r *http.Request) {
	rules := govalidator.MapData{
		"username": []string{"required", "between:3,8"},
		"email":    []string{"required", "min:4", "max:20", "email"},
		"web":      []string{"url"},
		"phone":    []string{"digits:11"},
		"agree":    []string{"bool"},
		"dob":      []string{"date"},
	}

	messages := govalidator.MapData{
		"username": []string{"required:আপনাকে অবশ্যই ইউজারনেম দিতে হবে", "between:ইউজারনেম অবশ্যই ৩-৮ অক্ষর হতে হবে"},
		"phone":    []string{"digits:ফোন নাম্বার অবশ্যই ১১ নম্বারের হতে হবে"},
	}

	opts := govalidator.Options{
		Request:         r,        // request object
		Rules:           rules,    // rules map
		Messages:        messages, // custom message map (Optional)
		RequiredDefault: true,     // all the field to be pass the rules
	}
	v := govalidator.New(opts)
	e := v.Validate()
	err := map[string]interface{}{"validationError": e}
	w.Header().Set("Content-type", "application/json")
	json.NewEncoder(w).Encode(err)
}

func main() {
	http.HandleFunc("/", handler)
	fmt.Println("Listening on port: 9000")
	http.ListenAndServe(":9000", nil)
}

```

Send request to the server using curl or postman: `curl GET "http://localhost:9000?web=&phone=&zip=&dob=&agree="`


***Response***
```json
{
    "validationError": {
        "agree": [
            "The agree may only contain boolean value, string or int 0, 1"
        ],
        "dob": [
            "The dob field must be a valid date format. e.g: yyyy-mm-dd, yyyy/mm/dd etc"
        ],
        "email": [
            "The email field is required",
            "The email field must be a valid email address"
        ],
        "phone": [
            "ফোন নাম্বার অবশ্যই ১১ নম্বারের হতে হবে"
        ],
        "username": [
            "আপনাকে অবশ্যই ইউজারনেম দিতে হবে",
            "ইউজারনেম অবশ্যই ৩-৮ অক্ষর হতে হবে"
        ],
        "web": [
            "The web field format is invalid"
        ]
    }
}
```

### More examples

***Validate file***

* [Validate file](doc/FILE_VALIDATION.md)

***Validate `application/json` or `text/plain` as raw body***

* [Validate JSON to simple struct](doc/SIMPLE_STRUCT_VALIDATION.md)
* [Validate JSON to map](doc/MAP_VALIDATION.md)
* [Validate JSON to nested struct](doc/NESTED_STRUCT.md)
* [Validate using custom rule](doc/CUSTOM_RULE.md)

***Validate struct directly***

* [Validate Struct](doc/STRUCT_VALIDATION.md)

### Validation Rules
* `alpha` The field under validation must be entirely alphabetic characters.
* `alpha_dash` The field under validation may have alpha-numeric characters, as well as dashes and underscores.
* `alpha_space` The field under validation may have alpha-numeric characters, as well as dashes, underscores and space.
* `alpha_num` The field under validation must be entirely alpha-numeric characters.
* `between:numeric,numeric` The field under validation check the length of characters/ length of array, slice, map/ range between two integer or float number etc.
* `numeric` The field under validation must be entirely numeric characters.
* `numeric_between:numeric,numeric` The field under validation must be a numeric value between the range.
   e.g: `numeric_between:18,65` may contains numeric value like `35`, `55` . You can also pass float value to check. Moreover, both bounds can be omitted to create an unbounded minimum (e.g: `numeric_between:,65`) or an unbounded maximum (e.g: `numeric_between:-1,`).
* `bool` The field under validation must be able to be cast as a boolean. Accepted input are `true, false, 1, 0, "1" and "0"`.
* `credit_card` The field under validation must have a valid credit card number. Accepted cards are `Visa, MasterCard, American Express, Diners Club, Discover and JCB card`
* `coordinate` The field under validation must have a value of valid coordinate.
* `css_color` The field under validation must have a value of valid CSS color. Accepted colors are `hex, rgb, rgba, hsl, hsla` like `#909, #00aaff, rgb(255,122,122)`
* `date` The field under validation must have a valid date of format yyyy-mm-dd or yyyy/mm/dd.
* `date:dd-mm-yyyy` The field under validation must have a valid date of format dd-mm-yyyy.
* `digits:int` The field under validation must be numeric and must have an exact length of value.
* `digits_between:int,int` The field under validation must be numeric and must have length between the range.
   e.g: `digits_between:3,5` may contains digits like `2323`, `12435`
* `in:foo,bar` The field under validation must have one of the values. e.g: `in:admin,manager,user` must contain the values (admin or manager or user)
* `not_in:foo,bar` The field under validation must have one value except foo,bar. e.g: `not_in:admin,manager,user` must not contain the values (admin or manager or user)
* `email` The field under validation must have a valid email.
* `float` The field under validation must have a valid float number.
* `mac_address` The field under validation must have be a valid Mac Address.
* `min:numeric` The field under validation must have a min length of characters for string, items length for slice/map, value for integer or float.
   e.g: `min:3` may contains characters minimum length of 3 like `"john", "jane", "jane321"` but not `"mr", "xy"`
* `max:numeric` The field under validation must have a max length of characters for string, items length for slice/map, value for integer or float.
   e.g: `max:6` may contains characters maximum length of 6 like `"john doe", "jane doe"` but not `"john", "jane"`
* `len:numeric` The field under validation must have an exact length of characters, exact integer or float value, exact size of map/slice.
   e.g: `len:4` may contains characters exact length of 4 like `Food, Mood, Good`
* `ip` The field under validation must be a valid IP address.
* `ip_v4` The field under validation must be a valid IP V4 address.
* `ip_v6` The field under validation must be a valid IP V6 address.
* `json` The field under validation must be a valid JSON string.
* `lat` The field under validation must be a valid latitude.
* `lon` The field under validation must be a valid longitude.
* `regex:regular expression` The field under validation validate against the regex. e.g: `regex:^[a-zA-Z]+$` validate the letters.
* `required` The field under validation must be present in the input data and not empty. A field is considered "empty" if one of the following conditions are true: 1) The value is null. 2)The value is an empty string. 3) Zero length of map, slice. 4) Zero value for integer or float
* `size:integer` The field under validation validate a file size only in form-data ([see example](doc/FILE_VALIDATION.md))
* `ext:jpg,png` The field under validation validate a file extension ([see example](doc/FILE_VALIDATION.md))
* `mime:image/jpg,image/png` The field under validation validate a file mime type ([see example](doc/FILE_VALIDATION.md))
* `url` The field under validation must be a valid URL.
* `uuid` The field under validation must be a valid UUID.
* `uuid_v3` The field under validation must be a valid UUID V3.
* `uuid_v4` The field under validation must be a valid UUID V4.
* `uuid_v5` The field under validation must be a valid UUID V5.

### Add Custom Rules

```go
func init() {
	// simple example
	govalidator.AddCustomRule("must_john", func(field string, rule string, message string, value interface{}) error {
		val := value.(string)
		if val != "john" || val != "John" {
			return fmt.Errorf("The %s field must be John or john", field)
		}
		return nil
	})

	// custom rules to take fixed length word.
	// e.g: word:5 will throw error if the field does not contain exact 5 word
	govalidator.AddCustomRule("word", func(field string, rule string, message string, value interface{}) error {
		valSlice := strings.Fields(value.(string))
		l, _ := strconv.Atoi(strings.TrimPrefix(rule, "word:")) //handle other error
		if len(valSlice) != l {
			return fmt.Errorf("The %s field must be %d word", field, l)
		}
		return nil
	})

}
```
Note: Array, map, slice can be validated by adding custom rules.

### Custom Message/ Localization
If you need to translate validation message you can pass messages as options.

```go
messages := govalidator.MapData{
	"username": []string{"required:You must provide username", "between:The username field must be between 3 to 8 chars"},
	"zip":      []string{"numeric:Please provide zip field as numeric"},
}

opts := govalidator.Options{
	Messages:        messages,
}
```

### Contribution
If you are interested to make the package better please send pull requests or create an issue so that others can fix.
[Read the contribution guide here](CONTRIBUTING.md)

### Contributors

- [Jun Kimura](https://github.com/bluele)
- [Steve HIll](https://github.com/stevehill1981)
- [ErickSkrauch](https://github.com/erickskrauch)
- [Sakib Sami](https://github.com/s4kibs4mi)
- [Rip](https://github.com/ripbandit)
- [Jose Nazario](https://github.com/paralax)

### See all [contributors](https://github.com/thedevsaddam/govalidator/graphs/contributors)

### See [benchmarks](doc/BENCHMARK.md)
### Read [API documentation](https://godoc.org/github.com/thedevsaddam/govalidator)

### **License**
The **govalidator** is an open-source software licensed under the [MIT License](LICENSE.md).


jio is a json schema validator similar to [joi](https://github.com/hapijs/joi)

<h1 align="center">jio</h1>

<p align="center">
    <img src="jio.jpg" width="240" height="240" border="0" alt="jio">
</p>
<p align="center">Make validation simple and efficient !</p>

<p align="center">
    <a href="https://travis-ci.org/faceair/jio"><img src="https://img.shields.io/travis/faceair/jio/master.svg" alt="Travis branch"></a>
    <a href="https://coveralls.io/github/faceair/jio?branch=master"><img src="https://coveralls.io/repos/github/faceair/jio/badge.svg?branch=master" alt="Coverage Status"></a>
    <a href="https://goreportcard.com/report/github.com/faceair/jio"><img src="https://goreportcard.com/badge/github.com/faceair/jio" alt="Go Report Card"></a>
    <a href="https://github.com/avelino/awesome-go"><img src="https://awesome.re/mentioned-badge.svg" alt="License"></a>
    <a href="https://godoc.org/github.com/faceair/jio"><img src="https://godoc.org/github.com/faceair/jio?status.svg" alt="GoDoc"></a>
    <a href="https://raw.githubusercontent.com/faceair/jio/master/LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License"></a>
</p>

[中文文档](README.zh.md)

## Why use jio?

Parameter validation in Golang is really a cursing problem. Defining tags on structs is not easy to extend rules, handwritten validation code makes logic code cumbersome, and the initial zero value of the struct field will also interfere with the validation.

jio tries validate json raw data before deserialization to avoid these problems. Defining validation rules as Schema is easy to read and easy to extend (Inspired by Hapi.js joi library). Rules within Schema can be validated in the order of registration, and context can be used to exchange data between rules, and can access other field data even within a single rule, etc.

jio provides a flexible enough way to make your validation simple and efficient!

## How to use?

### Validate json string

```go
package main

import (
    "log"

    "github.com/faceair/jio"
)

func main() {
    data := []byte(`{
        "debug": "on",
        "window": {
            "title": "Sample Widget",
            "size": [500, 500]
        }
    }`)
    _, err := jio.ValidateJSON(&data, jio.Object().Keys(jio.K{
        "debug": jio.Bool().Truthy("on").Required(),
        "window": jio.Object().Keys(jio.K{
            "title": jio.String().Min(3).Max(18),
            "size":  jio.Array().Items(jio.Number().Integer()).Length(2).Required(),
        }).Without("name", "title").Required(),
    }))
    if err != nil {
        panic(err)
    }
    log.Printf("%s", data) // {"debug":true,"window":{"size":[500,500],"title":"Sample Widget"}}
}
```

The above schema defines the following constraints:
* `debug`
    * not empty, must be a boolean value when validation end
    * allow `on` string instead of `true`
* `window`
    * not empty, object
    * not allowed for both `name` and `title`
    * The following elements exist
        * `title`
            * string, can be empty
            * length is between 3 and 18 when not empty
        * `size`
            * array, not empty
            * there are two child elements of the integer type

### Using middleware to validate request body

Take [chi](https://github.com/go-chi/chi) as an example, the other frameworks are similar.

```go
package main

import (
    "io/ioutil"
    "net/http"

    "github.com/faceair/jio"
    "github.com/go-chi/chi"
)

func main() {
    r := chi.NewRouter()
    r.Route("/people", func(r chi.Router) {
        r.With(jio.ValidateBody(jio.Object().Keys(jio.K{
            "name":  jio.String().Min(3).Max(10).Required(),
            "age":   jio.Number().Integer().Min(0).Max(100).Required(),
            "phone": jio.String().Regex(`^1[34578]\d{9}$`).Required(),
        }), jio.DefaultErrorHandler)).Post("/", func(w http.ResponseWriter, r *http.Request) {
            body, err := ioutil.ReadAll(r.Body)
            if err != nil {
                panic(err)
            }
            w.Header().Set("Content-Type", "application/json; charset=utf-8")
            w.WriteHeader(http.StatusOK)
            w.Write(body)
        })
    })
    http.ListenAndServe(":8080", r)
}
```
The second parameter of `jio.ValidateBody` is called for error handling when the validation fails.

### Validate the query parameter with middleware

```go
package main

import (
    "encoding/json"
    "net/http"

    "github.com/faceair/jio"
    "github.com/go-chi/chi"
)

func main() {
    r := chi.NewRouter()
    r.Route("/people", func(r chi.Router) {
        r.With(jio.ValidateQuery(jio.Object().Keys(jio.K{
            "keyword":  jio.String(),
            "is_adult": jio.Bool().Truthy("true", "yes").Falsy("false", "no"),
            "starts_with": jio.Number().ParseString().Integer(),
        }), jio.DefaultErrorHandler)).Get("/", func(w http.ResponseWriter, r *http.Request) {
            query := r.Context().Value(jio.ContextKeyQuery).(map[string]interface{})
            body, err := json.Marshal(query)
            if err != nil {
                panic(err)
            }
            w.Header().Set("Content-Type", "application/json; charset=utf-8")
            w.WriteHeader(http.StatusOK)
            w.Write(body)
        })
    })
    http.ListenAndServe(":8080", r)
}
```
Note that the original value of the query parameter is string, you may need to convert the value type first (for example, `jio.Number().ParseString()` or `jio.Bool().Truthy(values)`).

## API Documentation

[https://godoc.org/github.com/faceair/jio](https://godoc.org/github.com/faceair/jio)

## Advanced usage

### Workflow

Each Schema is made up of a series of rules, for example:

```go
jio.String().Min(5).Max(10).Alphanum().Lowercase()
```

In this example, String Schema has 4 rules, which are `Min(5)` `Max(10)` `Alphanum()` `Lowercase()`, will also validate in order `Min(5) ` `Max(10)` `Alphanum()` `Lowercase()`. If a rule validation fails, the Schema's validation stops and throws an error.

In order to improve the readability of the code, these three built-in rules will validate first.

* `Required()`
* `Optional()`
* `Default(value)`

For example:

```go
jio.String().Min(5).Max(10).Alphanum().Lowercase().Required()
```

The actual validation order will be `Required()` `Min(5)` `Max(10)` `Alphanum()` `Lowercase()`.

After validate all the rules, finally we check if the basic type of the data is the type of Schema. If not, the Schema will throw an error.

### Validator Context

Data transfer in the workflow depends on context, the structure is like this:

```go
Type Context struct {
    Value interface{} // Raw data, you can also reassign to change the result
}
func (ctx *Context) Ref(refPath string) (value interface{}, ok bool) { // Reference other field data
}
func (ctx *Context) Abort(err error) { // Terminate the validation and throw an error
  ...
}
func (ctx *Context) Skip() { // Skip subsequent rules
  ...
}
```

Let's try to customize a validation rule. Add a rule to use the `Transform` method:

```go
jio.String().Transform(func(ctx *jio.Context) {
    If ctx.Value != "faceair" {
        ctx.Abort(errors.New("you are not faceair"))
    }
})
```

The custom rule we added means throwing a `you are not faceair` error when the original data is not equal to `faceair`.

In fact, the built-in validation rules work in a similar way. For example, the core code of `Optional()` is:

```go
If ctx.Value == nil {
  ctx.Skip()
}
```

You can also reassign ctx.Value to change the original data. For example, the built-in `Lowercase()` converts the original string to lowercase. The core code is:

```go
ctx.Value = strings.ToLower(ctx.Value)
```

### References and Priority

In most cases, the rules only use the data of the current field, but sometimes it needs to work with other fields. For example:

```
{
    "type": "ip", // enumeration value, `ip` or `domain`
    "value": "8.8.8.8"
}
```

The validation rules of this `value` is determined by the value of `type` and can be written as

```go
jio.Object().Keys(jio.K{
        "type": jio.String().Valid("ip", "domain").SetPriority(1).Default("ip"),
        "value": jio.String().
            When("type", "ip", jio.String().Regex(`^\d+\.\d+\.\d+\.\d+$`)).
            When("type", "domain", jio.String().Regex(`^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0 -9]\.[a-zA-Z]{2,}$`)).Required(),
})
```

The `When` function can reference other field data, and if it is successful, apply the new validation rule to the current data.

In addition, you may notice that there is a `SetPriority` method in the rules of `type`. If the input data is:

```json
{
    "value": "8.8.8.8"
}
```

When the priority is not set, the validation rule of `value` may be executed first. At this time, the value of the reference `type` will be null, and the validation will fail.
Because there are validation rules that refer to each other, there may be a validation sequence requirement. When we want a field under the same Object to be validated first, we can set it to a larger priority value (default value 0).

If you want to reference data from other fields in your custom rules, you can use the `Ref` method on the context. If the referenced data is a nested object, the path to the referenced field needs to be concatenated with `.` . For example, if you want to reference `name` under `people` object then the reference path is `people.name`:

```json
{
    "type": "people",
    "people": {
        "name": "faceair"
    }
}
```

## License

[MIT](LICENSE)


Supports validation of various data types (structs, strings, maps, slices, etc.) with configurable and extensible validation rules specified in usual code constructs instead of struct tags

ozzo-validation

Go package for data validation and filtering. support validate Map, Struct, Request(Form, JSON, url.Values, Uploaded Files) data and more features

validate

Go Struct and Field validation, including Cross Field, Cross Struct, Map, Slice and Array diving

validator

A lightweight model validator written in Go.Contains VFs:Min, Max, MinLength, MaxLength, Length, Enum, Regex

# validator

A lightweight model validator written in Go.

[![CircleCI](https://circleci.com/gh/go-the-way/validator/tree/main.svg?style=shield)](https://circleci.com/gh/go-the-way/validator/tree/main)
![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/go-the-way/validator)
[![codecov](https://codecov.io/gh/go-the-way/validator/branch/main/graph/badge.svg?token=8MAR3J959H)](https://codecov.io/gh/go-the-way/validator)
[![Go Report Card](https://goreportcard.com/badge/github.com/go-the-way/validator)](https://goreportcard.com/report/github.com/go-the-way/validator)
[![GoDoc](https://pkg.go.dev/badge/github.com/go-the-way/validator?status.svg)](https://pkg.go.dev/github.com/go-the-way/validator?tab=doc)
[![Release](https://img.shields.io/github/release/go-the-way/validator.svg?style=flat-square)](https://github.com/go-the-way/validator/releases)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go#validation)

## Features
- Supports multiple language.

## quickstart

```go
package main

import (
	"fmt"
	v "github.com/go-the-way/validator"
)

func main() {
	result := v.New(&struct {
		int `validate:"min(10,fail)"`
	}{}).Validate()
	fmt.Println(result.Passed)
	fmt.Println(result.Messages())
}
```

## Custom validation implementation

```go
package main

import (
	"fmt"
	v "github.com/go-the-way/validator"
	"reflect"
)

func main() {
	v.Custom("mycustom", func(value reflect.Value) (bool, string) { return false, "mycustom validation." })
	vv := v.New(&struct {
		Name string `validate:"custom(mycustom)"`
	}{}).Validate()
	fmt.Println(vv.Passed)
	fmt.Println(vv.Messages())
}
```

## Validators

| Name         | Support                                                                         | Example                             | Description                                                                                                                      |
|--------------|---------------------------------------------------------------------------------|-------------------------------------|----------------------------------------------------------------------------------------------------------------------------------|
| Min          | `([])(*)uint{8,64}`, `([])(*)int{8,64}`, `([])(*)float{32,64}`                  | validate:"min(N,invalid)"           | `Every value` must be `>= N`                                                                                                     |
| Max          | `([])(*)uint{8,64}`, `([])(*)int{8,64}`, `([])(*)float{32,64}`                  | validate:"max(N,invalid)"           | `Every value` must be `<= N`                                                                                                     |
| Length       | `(*)string`, `(*)Array[(*)string]`, `(*)Slice[(*)string]`                       | validate:"length(N,invalid)"        | `(*)string`: `Value's Len` must be `== N`<br/>`(*)Array[(*)string]` or `(*)Slice[(*)string]`: `Every Value's Len` must be `== N` |
| ArrLength    | `(*)Array[(*)Any]`, `(*)Slice[(*)Any]`                                          | validate:"arr_length(N,invalid)"    | `(*)Array[(*)Any]` or `(*)Slice[(*)Any]`: `Array` or `Slice's Len` must be `== N`                                                |
| MinLength    | `(*)string`, `(*)Array[(*)string]`, `(*)Slice[(*)string]`                       | validate:"minlength(N,invalid)"     | `(*)string`: `Value's Len` must be `>= N`<br/>`(*)Array[(*)string]` or `(*)Slice[(*)string]`: `Every Value's Len` must be `>= N` |
| ArrMinLength | `(*)Array[(*)Any]`, `(*)Slice[(*)Any]`                                          | validate:"arr_minlength(N,invalid)" | `(*)Array[(*)Any]` or `(*)Slice[(*)Any]`: `Array` or `Slice's Len` must be `>= N`                                                |
| MaxLength    | `(*)string`, `(*)Array[(*)string]`, `(*)Slice[(*)string]`                       | validate:"maxlength(N,invalid)"     | `(*)string`: `Value's Len` must be `<= N`<br/>`(*)Array[(*)string]` or `(*)Slice[(*)string]`: `Every Value's Len` must be `<= N` |
| ArrMaxLength | `(*)Array[(*)Any]`, `(*)Slice[(*)Any]`                                          | validate:"arr_maxlength(N,invalid)" | `(*)Array[(*)Any]` or `(*)Slice[(*)Any]`: `Array` or `Slice's Len` must be `<= N`                                                |
| Enum         | `([])(*)uint{8,64}`, `([])(*)int{8,64}`, `([])(*)float{32,64}`, `([])(*)string` | validate:"enum(O,invalid)"          | `Every value` must be one of `O`                                                                                                 |
| Regex        | `([])(*)string`                                                                 | validate:"regex(RE,invalid)"        | `Every value` must be match `RE`                                                                                                 |
| Valid        | `*struct{}`                                                                     | validate:"valid(T,invalid)"         | `Value` must be not `nil`                                                                                                        |
| Custom       | `any`                                                                           | validate:"custom(CUSTOM)"           | `CUSTOM` validation                                                                                                       |


Validator

A [Zod](https://github.com/colinhacks/zod) inspired schema builder for runtime value parsing and validation

<div align="center">
    <br />
    <a href="https://github.com/Oudwins/zog">
     <img src="https://raw.githubusercontent.com/Oudwins/zog/master/assets/zog-banner.png" alt="Zog, a Zod-like schema parser & validator" />
    </a>
</div>

# ZOG - A Zod & Yup like Schema Parser & Validator for GO

[![Coverage Status](https://coveralls.io/repos/github/Oudwins/zog/badge.svg?branch=master)](https://coveralls.io/github/Oudwins/zog?branch=master)
[![Go Report Card](https://goreportcard.com/badge/Oudwins/zog)](https://goreportcard.com/report/github.com/Oudwins/zog)
[![GitHub tag](https://img.shields.io/github/tag/Oudwins/zog?include_prereleases=&sort=semver&color=blue)](https://github.com/Oudwins/zog/releases/)
<a href="https://pkg.go.dev/github.com/Oudwins/zog"><img src="https://pkg.go.dev/badge/github.com//github.com/Oudwins/tailwind-merge-go.svg" alt="Go Reference" /></a>
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![Mentioned in Awesome Templ](https://awesome.re/mentioned-badge-flat.svg)](https://github.com/templ-go/awesome-templ)
[![stars - zog](https://img.shields.io/github/stars/Oudwins/zog?style=social)](https://github.com/Oudwins/zog)

[![view - Documentation](https://img.shields.io/badge/view-Documentation-blue?style=for-the-badge)](https://zog.dev)

Zog is a schema builder for runtime value parsing and validation. Define a schema, transform a value to match, assert the shape of an existing value, or both. Zog schemas are extremely expressive and allow modeling complex, interdependent validations, or value transformations.

Killer Features:

- Concise yet expressive schema interface, equipped to model simple to complex data models
- **[Zod](https://github.com/colinhacks/zod)-like API**, use method chaining to build schemas in a typesafe manner
- **Extensible**: add your own Tests and Schemas
- **Rich errors** with detailed context, make debugging a breeze
- **Fast**: Zog is one of the fastest Go validation libraries. We are just behind the goplayground/validator for most of the [govalidbench](https://github.com/Oudwins/govalidbench/tree/master) benchmarks.
- **Built-in coercion** support for most types
- Zero dependencies!
- **Four Helper Packages**
  - **zenv**: parse environment variables
  - **zhttp**: parse http forms & query params
  - **zjson**: parse json
  - **i18n**: Opinionated solution to good i18n zog errors

> **API Stability:**
>
> - I will consider the API stable when we reach v1.0.0
> - However, I believe very little API changes will happen from the current implementation. The APIs most likely to change are the **data providers** (please don't make your own if possible use the helpers whose APIs will not change meaningfully) and the z.Ctx most other APIs should remain the same. I could be wrong but I don't expect many breaking changes.
> - Although we want to keep breaking changes to a minimum, Zog is still in version 0 and will have breaking changes in the minor versions as per semver. So please be careful when upgrading minor versions.

## Introduction

#### **0. Read the docs at [zog.dev](https://zog.dev)**

Or don't, below is the quickstart guide

#### **1 Install**

```bash
go get github.com/Oudwins/zog
```

#### **2 Create a user schema and its struct**

```go
import (
	z "github.com/Oudwins/zog"
)

type User struct {
	Name string
	Age  int
}

var userSchema = z.Struct(z.Shape{
	// its very important that schema keys like "name" match the struct field name NOT the input data
	"name": z.String().Min(3, z.Message("Override default message")).Max(10),
	"age":  z.Int().GT(18),
})
```

#### **3 Validate your schema**

**Using [schema.Parse()](https://zog.dev/core-concepts/parsing)**

```go
func main() {
	u := User{}
	m := map[string]string{
		"name": "Zog",
		"age":  "", // won't return an error because fields are optional by default
	}
	errs := userSchema.Parse(m, &u)
	if errs != nil {
		// handle errors -> see Errors section
	}
	u.Name // "Zog"
	// note that this might look weird but we didn't say age was required so Zog just skipped the empty string and we are left with the uninitialized int
	// If we need 0 to be a valid value for age we can use a pointer to an int which will be nil if the value was not present in the input data
	u.Age // 0
}
```

**Using [schema.Validate()](https://zog.dev/core-concepts/validate)**

```go
func main() {
	u := User{
		Name: "Zog",
		Age:  0, // wont return an error because fields are optional by default otherwise it will error
	}
	errs := userSchema.Validate(&u)
	if errs != nil {
		// handle errors -> see Errors section
	}
}
```

#### **4. Its easy to use with http & json**

The [zhttp package](https://zog.dev/packages/zhttp) has you covered for JSON, Forms and Query Params, just do:

```go
import (
	zhttp "github.com/Oudwins/zog/zhttp"
)

err := userSchema.Parse(zhttp.Request(r), &user)
```

If you are receiving json some other way you can use the [zjson package](https://zog.dev/packages/zjson)

```go
import (
	zjson "github.com/Oudwins/zog/zjson"
)

err := userSchema.Parse(zjson.Decode(bytes.NewReader(jsonBytes)), &user)
```

#### **5. Or to validate your environment variables**

The [zenv package](https://zog.dev/packages/zenv) has you covered, just do:

```go
import (
	zenv "github.com/Oudwins/zog/zenv"
)

err := envSchema.Parse(zenv.NewDataProvider(), &envs)
```

#### **6. You can also parse individual fields**

```go
var t = time.Time
// All schemas now return ZogIssueList
errs := Time().Required().Parse("2020-01-01T00:00:00Z", &t)
```

#### **7 Transform Data without limits**

```go
var dest []string
schema := z.Preprocess(func(data any, ctx z.Ctx) ([]string, error) {
	s := data.(string) // don't do this, actually check the type
	return strings.Split(s, ","), nil
}, z.Slice(z.String().Trim().Email().Required()))
errs := schema.Parse("foo@bar.com,bar@foo.com", &dest) // dest = [foo@bar.com bar@foo.com]
```

## Roadmap

These are some of the things I want to add to zog before v1.0.0

- Support for schema.Clone()
- support for catch & default for structs & slices
- Struct generation from the schemas

## Acknowledgments

- Big thank you to @AlexanderArvidsson for being there to talk about architecture and design decisions. It helped a lot to have someone to bounce ideas off of
- Credit for all the inspiration goes to /colinhacks/zod & /jquense/yup
- Credit for the initial idea goes to anthony (@anthonyGG) -> /anthdm/superkit he made a hacky version of this idea that I used as a starting point, I was never happy with it so I inspired me to rewrite it from scratch. I owe him a lot
- Credit for the zod logo goes to /colinhacks/zod

## License

This project is licensed under the MIT License -
see the [LICENSE](LICENSE) file for details.


Provide check digit algorithms (Luhn, Verhoeff, Damm) and calculators (ISBN, EAN, JAN, UPC, etc.)

# checkdigit

[![CI](https://github.com/osamingo/checkdigit/actions/workflows/actions.yml/badge.svg)](https://github.com/osamingo/checkdigit/actions/workflows/actions.yml)
[![codecov](https://codecov.io/gh/osamingo/checkdigit/branch/master/graph/badge.svg)](https://codecov.io/gh/osamingo/checkdigit)
[![Go Report Card](https://goreportcard.com/badge/osamingo/checkdigit)](https://goreportcard.com/report/osamingo/checkdigit)
[![GoDoc](https://godoc.org/github.com/osamingo/checkdigit?status.svg)](https://godoc.org/github.com/osamingo/checkdigit)
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/osamingo/checkdigit/master/LICENSE)

## About

Provide check digit algorithms and calculators written by Go.

## Provided methods

### Algorithms

- [Luhn](https://en.wikipedia.org/wiki/Luhn_algorithm)
- [Verhoeff](https://en.wikipedia.org/wiki/Verhoeff_algorithm)
- [Damm](https://en.wikipedia.org/wiki/Damm_algorithm)

### Calculators

- [ISBN-10](https://en.wikipedia.org/wiki/International_Standard_Book_Number)
- [ISBN-13](https://en.wikipedia.org/wiki/International_Standard_Book_Number)
- [EAN-8](https://en.wikipedia.org/wiki/EAN-8)
- [EAN-13](https://en.wikipedia.org/wiki/EAN-13)
- [JAN-8](https://en.wikipedia.org/wiki/Japanese_Article_Number)
- [JAN-13](https://en.wikipedia.org/wiki/Japanese_Article_Number)
- [ITF](https://en.wikipedia.org/wiki/Interleaved_2_of_5)
- [UPC](https://en.wikipedia.org/wiki/Universal_Product_Code)
- [SSCC](https://en.wikipedia.org/wiki/Serial_Shipping_Container_Code)

## Usage

See [examples](https://godoc.org/github.com/osamingo/checkdigit#pkg-examples).

## License

Released under the [MIT License](https://github.com/osamingo/checkdigit/blob/master/LICENSE).


checkdigit

This package provides a framework for writing validations for Go applications

# github.com/gobuffalo/validate
[![Build Status](https://travis-ci.org/gobuffalo/validate.svg?branch=master)](https://travis-ci.org/gobuffalo/validate) [![Actions Status](https://github.com/gobuffalo/validate/workflows/Tests/badge.svg)](https://github.com/gobuffalo/validate/actions) [![GoDoc](https://godoc.org/github.com/gobuffalo/validate?status.svg)](https://godoc.org/github.com/gobuffalo/validate)

This package provides a framework for writing validations for Go applications. It does provide you with few validators, but if you need others you can easly build them.

## Installation

```bash
$ go get github.com/gobuffalo/validate
```

## Usage

Using validate is pretty easy, just define some `Validator` objects and away you go.

Here is a pretty simple example:

```go
package main

import (
	"log"

	v "github.com/gobuffalo/validate"
)

type User struct {
	Name  string
	Email string
}

func (u *User) IsValid(errors *v.Errors) {
	if u.Name == "" {
		errors.Add("name", "Name must not be blank!")
	}
	if u.Email == "" {
		errors.Add("email", "Email must not be blank!")
	}
}

func main() {
	u := User{Name: "", Email: ""}
	errors := v.Validate(&u)
	log.Println(errors.Errors)
  // map[name:[Name must not be blank!] email:[Email must not be blank!]]
}
```

In the previous example I wrote a single `Validator` for the `User` struct. To really get the benefit of using go-validator, as well as the Go language, I would recommend creating distinct validators for each thing you want to validate, that way they can be run concurrently.

```go
package main

import (
	"fmt"
	"log"
	"strings"

	v "github.com/gobuffalo/validate"
)

type User struct {
	Name  string
	Email string
}

type PresenceValidator struct {
	Field string
	Value string
}

func (v *PresenceValidator) IsValid(errors *v.Errors) {
	if v.Value == "" {
		errors.Add(strings.ToLower(v.Field), fmt.Sprintf("%s must not be blank!", v.Field))
	}
}

func main() {
	u := User{Name: "", Email: ""}
	errors := v.Validate(&PresenceValidator{"Email", u.Email}, &PresenceValidator{"Name", u.Name})
	log.Println(errors.Errors)
        // map[name:[Name must not be blank!] email:[Email must not be blank!]]
}
```

That's really it. Pretty simple and straight-forward Just a nice clean framework for writing your own validators. Use in good health.

## Built-in Validators

To make it even simpler, this package has a children package with some nice built-in validators.

```go
package main

import (
	"log"

	"github.com/gobuffalo/validate"
	"github.com/gobuffalo/validate/validators"
)

type User struct {
	Name  string
	Email string
}


func main() {
	u := User{Name: "", Email: ""}
	errors := validate.Validate(
		&validators.EmailIsPresent{Name: "Email", Field: u.Email, Message: "Mail is not in the right format."},
		&validators.StringIsPresent{Field: u.Name, Name: "Name"},
	)
	log.Println(errors.Errors)
	// map[name:[Name can not be blank.] email:[Mail is not in the right format.]]
}
```

All fields are required for each validators, except Message (every validator has a default error message).

### Available Validators

A full list of available validators can be found at [https://pkg.go.dev/github.com/gobuffalo/validate/v3/validators](https://pkg.go.dev/github.com/gobuffalo/validate/v3/validators).


The Best Go Libraries For Validation (13)

go-validator

gody

govalid

govalidator

govalidator

jio

ozzo-validation

validate

validator

Validator

Zog

checkdigit

validate