ozzo-validation

Some validation rules depend dynamically on a context. To use them, implement the validation.RuleWithContext interface.

To validate an arbitrary value with a context, use validation.ValidateWithContext(). The context.Context parameter is passed to rules implementing validation.RuleWithContext. If a rule only implements validation.Rule, that standard implementation is used instead.

To validate struct fields with a context, use validation.ValidateStructWithContext().

You can convert a function into a context-aware rule using validation.WithContext().

rule := validation.WithContext(func(ctx context.Context, value interface{}) error {
	if ctx.Value("secret") == value.(string) {
	    return nil
	}
	return errors.New("value incorrect")
})
value := "xyz"
ctx := context.WithValue(context.Background(), "secret", "example")
err := validation.ValidateWithContext(ctx, value, rule)
fmt.Println(err)
// Output: value incorrect

To create a custom rule, implement the validation.Rule interface (which requires a Validate(value interface{}) error method).

If you have a function with the signature func(interface{}) error, you can convert it into a rule using validation.By(yourFunc).

For rules requiring parameters, use a closure that returns a validation.RuleFunc.

// Using validation.By with a simple function
func checkAbc(value interface{}) error {
	s, _ := value.(string)
	if s != "abc" {
		return errors.New("must be abc")
	}
	return nil
}
err := validation.Validate("xyz", validation.By(checkAbc))

// Using a closure for parameterized rules
func stringEquals(str string) validation.RuleFunc {
	return func(value interface{}) error {
		s, _ := value.(string)
	    if s != str {
			return errors.New("unexpected string")
		}
		return nil
	}
}
err := validation.Validate("xyz", validation.By(stringEquals("abc")))

In version 3.x, StructRules is deprecated. Use validation.ValidateStruct() instead. This new method requires a pointer to the struct and a list of validation.Field() calls that map the struct field to its rules.

// 2.x usage
err := validation.StructRules{}.
	Add("Street", validation.Required, validation.Length(5, 50)).
	Add("City", validation.Required, validation.Length(5, 50)).
	Add("State", validation.Required, validation.Match(regexp.MustCompile("^[A-Z]{2}$"))).
	Add("Zip", validation.Required, validation.Match(regexp.MustCompile("^[0-9]{5}$"))).
	Validate(a)

// 3.x usage
err := validation.ValidateStruct(&a,
	validation.Field(&a.Street, validation.Required, validation.Length(5, 50)),
	validation.Field(&a.City, validation.Required, validation.Length(5, 50)),
	validation.Field(&a.State, validation.Required, validation.Match(regexp.MustCompile("^[A-Z]{2}$"))),
	validation.Field(&a.Zip, validation.Required, validation.Match(regexp.MustCompile("^[0-9]{5}$"))),
)

For dynamic data in maps, use validation.Map() within validation.Validate(). You can define rules for specific keys using validation.Key(). Keys are validated in the order specified, and validation continues to the next key even if a rule fails for the current one.

c := map[string]interface{}{
	"Name":  "Qiang Xue",
	"Email": "q",
	"Address": map[string]interface{}{
		"Street": "123",
		"City":   "Unknown",
		"State":  "Virginia",
		"Zip":    "12345",
	},
}

err := validation.Validate(c,
	validation.Map(
		// Name cannot be empty, and the length must be between 5 and 20.
		validation.Key("Name", validation.Required, validation.Length(5, 20)),
		// Email cannot be empty and should be in a valid email format.
		validation.Key("Email", validation.Required, is.Email),
		// Validate Address using its own validation rules
		validation.Key("Address", validation.Map(
			validation.Key("Street", validation.Required, validation.Length(5, 50)),
			validation.Key("City", validation.Required, validation.Length(5, 50)),
			validation.Key("State", validation.Required, validation.Match(regexp.MustCompile("^[A-Z]{2}$"))),
			validation.Key("Zip", validation.Required, validation.Match(regexp.MustCompile("^[0-9]{5}$"))),
		)),
	),
)

To validate the fields of a struct, use validation.ValidateStruct().

Important Requirements:

• Pass a pointer to the struct to ValidateStruct.
• Use a pointer to the struct field when calling validation.Field.

Rules are evaluated in the order specified. If a field's rule fails, an error is recorded for that field, and validation continues with the next field.

type Address struct {
	Street string
	City   string
	State  string
	Zip    string
}

func (a Address) Validate() error {
	return validation.ValidateStruct(&a,
		// Street cannot be empty, and the length must between 5 and 50
		validation.Field(&a.Street, validation.Required, validation.Length(5, 50)),
		// City cannot be empty, and the length must between 5 and 50
		validation.Field(&a.City, validation.Required, validation.Length(5, 50)),
		// State cannot be empty, and must be a string consisting of two letters in upper case
		validation.Field(&a.State, validation.Required, validation.Match(regexp.MustCompile("^[A-Z]{2}$"))),
		// State cannot be empty, and must be a string consisting of five digits
		validation.Field(&a.Zip, validation.Required, validation.Match(regexp.MustCompile("^[0-9]{5}$"))),
	)
}

When validating an iterable (map, slice, or array) where the elements implement validation.Validatable, validation.Validate will automatically call Validate() on every non-nil element. Errors are returned as validation.Errors, mapping the element's key or index to its specific validation error.

To apply specific rules to every element in an iterable, use the validation.Each rule.

// Validating a slice of validatables
addresses := []Address{
	Address{State: "MD", Zip: "12345"},
	Address{Street: "123 Main St", City: "Vienna", State: "VA", Zip: "12345"},
	Address{City: "Unknown", State: "NC", Zip: "123"},
}
err := validation.Validate(addresses)
// Output: 0: (City: cannot be blank; Street: cannot be blank.); 2: (Street: cannot be blank; Zip: must be in a valid format.).

// Using Each to validate elements of a slice
type Customer struct {
    Name      string
    Emails    []string
}

func (c Customer) Validate() error {
    return validation.ValidateStruct(&c,
		validation.Field(&c.Name, validation.Required, validation.Length(5, 20)),
		validation.Field(&c.Emails, validation.Each(is.Email)),
    )
}