Validation

rules := validation.Rules{
    "name":  {validation.Required(), validation.Min(3)},
    "email": {validation.Required(), validation.Email(), validation.Unique("users", "email")},
}

rules := validation.Rules{"name": {validation.Required()}}

rules := validation.Rules{
    "middle_name": {validation.Nullable(), validation.String()},
    "bio":         {validation.Filled()},
    "opt_in":      {validation.Present()},
}

rules := validation.Rules{
    "password": {validation.Min(8)},
    "bio":      {validation.Max(500)},
    "zip_code": {validation.Size(5)},
    "age":      {validation.Numeric(), validation.Between(18, 65)},
}

rules := validation.Rules{
    "password":         {validation.Required(), validation.Confirmed()},
    "password_confirm": {validation.Same("password")},
    "alt_email":        {validation.Different("email")},
}

rules := validation.Rules{
    "role":     {validation.In("admin", "user", "moderator")},
    "username": {validation.NotIn("admin", "root", "system")},
}

rules := validation.Rules{"terms": {validation.Accepted()}}

rules := validation.Rules{
    "phone":    {validation.RequiredIf("contact", "phone")},
    "company":  {validation.RequiredUnless("type", "personal")},
    "shipping": {validation.RequiredWith("address")},
    "sku":      {validation.RequiredWithout("gtin")},
}

rules := validation.Rules{
    "billing_zip": {validation.RequiredWith("billing_street", "billing_city")},
}

rules := validation.Rules{
    "max_price": {validation.Numeric(), validation.Gt("min_price")}, // field reference
    "qty":       {validation.Numeric(), validation.Lte("100")},      // numeric literal
}

rules := validation.Rules{
    "pw": {validation.Required(), validation.Password()},            // >= 8, all classes
    "pw": {validation.Required(), validation.Password().MinLength(12)}, // >= 12
}

rules := validation.Rules{"sku": {validation.Regex(`^[A-Z]{3}-\d{4}$`)}}

rules := validation.Rules{
    "avatar":   {validation.Image(), validation.Max(2048)},
    "document": {validation.File(), validation.Mimes("pdf", "docx")},
    "logo":     {validation.Image().AllowSVG()},
    "asset":    {validation.Mimes("jpg", "svg").AllowSVG()},
}

rules := validation.Rules{
    "email":   {validation.Required(), validation.Email(), validation.Unique("users", "email")},
    "team_id": {validation.Required(), validation.Exists("teams", "id")},
}

// On update, exclude the current row. Except accepts any integer, unsigned
// integer, or string kind (including named types such as `type UserID int64`)
// and any fmt.Stringer; the value is converted once, at construction.
rules = validation.Rules{
    "email": {
        validation.Required(),
        validation.Email(),
        validation.Unique("users", "email").Except(user.ID),
    },
}

// Match Except against a column other than "id":
validation.Unique("users", "email").Except(tenantID).IDColumn("tenant_id")

func handler(c *router.Context) error {
    rules := validation.Rules{
        "email": {validation.Required(), validation.Email()},
        "name":  {validation.Required(), validation.String()},
    }

    result, err := validation.CheckW(c.Response, c.Request, rules)
    if err != nil {
        return err
    }
    if result.HasErrors() {
        return c.JSON(422, map[string]interface{}{
            "errors": result.Messages(),
        })
    }
    // ... bind and continue
    return nil
}

data := map[string]interface{}{"email": "user@example.com", "age": 25}
result, err := validation.CheckData(data, validation.Rules{
    "email": {validation.Required(), validation.Email()},
    "age":   {validation.Required(), validation.Numeric(), validation.Gte("18")},
})
if err != nil {
    return err // malformed rule set
}
if err := result.Err(); err != nil {
    // err wraps validation.ErrValidationFailed and unwraps to ValidationErrors
    return err
}

import (
    "github.com/velocitykode/velocity/orm"
    "github.com/velocitykode/velocity/validation/dbrules"
)

// c.DB() returns the stdlib-only contract.Database; recover the wider
// orm.Database with the supported type assertion.
db, _ := c.DB().(orm.Database)

result, err := dbrules.CheckWithDBW(c.Response, c.Request, rules, db)

func (c *Context) Validate(rules contract.ValidationRuleSet, messages ...contract.ValidationMessages) error

func (h *Handler) Store(ctx *router.Context) error {
    if err := ctx.Validate(validation.Rules{
        "name":  {validation.Required()},
        "email": {validation.Required(), validation.Email(), validation.Unique("users", "email")},
    }); err != nil {
        return err
    }
    // only reaches here if valid
    return nil
}

type Validatable interface {
    Rules() contract.ValidationRuleSet
}

type UpdateProfile struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

func (r *UpdateProfile) Rules() validation.Rules {
    return validation.Rules{
        "name":  {validation.Required(), validation.Min(2)},
        "email": {validation.Required(), validation.Email(), validation.Unique("users", "email")},
    }
}

func (h *Handler) Update(c *router.Context) error {
    var req UpdateProfile
    if err := c.BindValid(&req); err != nil {
        return err
    }
    // ...
    return nil
}

var ve validation.ValidationErrors
if errors.As(result.Err(), &ve) {
    ve.Count()                      // total error count
    ve.HasError("email")            // bool
    ve.First("email")               // first message
    ve.All()                        // map[string][]string
    ve.HasRule("email", "required") // bool, prefer over substring match
    ve.RulesFor("email")            // []string of rule names that failed
}

type Validator interface {
    Validate(data interface{}, rules ValidationRuleSet) (*ValidatedData, error)
    ValidateValue(value interface{}, rules ...ValidationRule) error
    SetMessages(messages ValidationMessages)
}

v := validation.NewValidator()

if err := v.ValidateValue("not-an-email", validation.Required(), validation.Email()); err != nil {
    // err is a validation.ValidationErrors describing the "value" field,
    // or wraps ErrInvalidRule when the rule list is malformed.
}

import (
    "fmt"
    "unicode"

    "github.com/velocitykode/velocity/validation"
)

// The returned value IS the rule's identity: declare it once at package level
// and reuse it wherever the rule applies. Two distinct Custom values sharing a
// name inside one rule set are rejected during normalization, because nothing
// could decide which handler wins.
var StrongPassword = validation.Custom("strong_password", func(
    field string,
    value interface{},
    params []string,
    data map[string]interface{},
) error {
    pw, ok := value.(string)
    if !ok {
        return fmt.Errorf("The %s field must be a string.", field)
    }

    var hasUpper, hasLower, hasNumber, hasSpecial bool
    for _, r := range pw {
        switch {
        case unicode.IsUpper(r):
            hasUpper = true
        case unicode.IsLower(r):
            hasLower = true
        case unicode.IsNumber(r):
            hasNumber = true
        case unicode.IsPunct(r) || unicode.IsSymbol(r):
            hasSpecial = true
        }
    }
    if !hasUpper || !hasLower || !hasNumber || !hasSpecial {
        return fmt.Errorf("The %s must contain uppercase, lowercase, number, and special character.", field)
    }
    return nil
})

// Usage: identical to any built-in.
rules := validation.Rules{
    "password": {validation.Required(), validation.Min(8), StrongPassword},
}

type RuleHandler func(field string, value interface{}, params []string, data map[string]interface{}) error

messages := validation.Messages{
    {Field: "email", Rule: "required"}:    "Email is required",
    {Field: "email", Rule: "email"}:       "Invalid email format",
    {Field: "password", Rule: "required"}: "Password is required",
    {Field: "password", Rule: "min"}:      "Password must be at least 8 characters",
}

result, err := validation.CheckW(c.Response, c.Request, rules, messages)

func (r *SignupRequest) ValidationMessages() validation.Messages {
    return validation.Messages{
        {Field: "email", Rule: "required"}: "We need your email.",
    }
}

func CreateUser(c *router.Context) error {
    result, err := validation.CheckW(c.Response, c.Request, validation.Rules{
        "email": {validation.Required(), validation.Email()},
        "name":  {validation.Required(), validation.String()},
    })
    if err != nil {
        return err
    }
    if result.HasErrors() {
        return c.JSON(422, map[string]interface{}{
            "errors": result.Messages(),
        })
    }
    // ... bind + business logic
    return nil
}

result, err := validation.CheckW(c.Response, c.Request, rules)
if err != nil {
    return err // 500: ErrInvalidRule, not user-facing
}
if result.HasErrors() {
    return c.JSON(422, map[string]interface{}{"errors": result.Messages()})
}

messages := validation.Messages{
    {Field: "email", Rule: "email"}:     "Please enter a valid email address",
    {Field: "password", Rule: "min"}:    "Your password needs to be at least 8 characters",
    {Field: "terms", Rule: "accepted"}:  "You must accept the terms of service",
}

rules := validation.Rules{
    // Good: required first, then type, then constraints.
    "age": {validation.Required(), validation.Numeric(), validation.Gte("18"), validation.Lte("120")},
}

var (
    EmailRules    = []validation.Rule{validation.Required(), validation.Email()}
    PasswordRules = []validation.Rule{validation.Required(), validation.Min(8), StrongPassword}
    PhoneRules    = []validation.Rule{validation.Required(), validation.Numeric(), validation.Size(10)}
)

rules := validation.Rules{
    "email":    EmailRules,
    "password": PasswordRules,
    "phone":    PhoneRules,
}

package handlers

import (
    "github.com/velocitykode/velocity/orm"
    "github.com/velocitykode/velocity/router"
    "github.com/velocitykode/velocity/validation"
    "github.com/velocitykode/velocity/validation/dbrules"
)

type UserHandler struct{}

func (uc *UserHandler) Register(c *router.Context) error {
    rules := validation.Rules{
        "name":                  {validation.Required(), validation.String(), validation.Min(2), validation.Max(100)},
        "email":                 {validation.Required(), validation.Email(), validation.Unique("users", "email")},
        "password":              {validation.Required(), validation.Min(8), validation.Confirmed()},
        "password_confirmation": {validation.Required()},
        "age":                   {validation.Required(), validation.Numeric(), validation.Gte("18")},
        "terms":                 {validation.Required(), validation.Accepted()},
        "newsletter":            {validation.Nullable(), validation.Boolean()},
    }

    messages := validation.Messages{
        {Field: "name", Rule: "required"}:      "Please tell us your name",
        {Field: "name", Rule: "min"}:           "Name must be at least 2 characters",
        {Field: "email", Rule: "required"}:     "We need your email address",
        {Field: "email", Rule: "email"}:        "Please enter a valid email address",
        {Field: "email", Rule: "unique"}:       "That email is already registered",
        {Field: "password", Rule: "required"}:  "Password is required",
        {Field: "password", Rule: "min"}:       "Password must be at least 8 characters",
        {Field: "password", Rule: "confirmed"}: "Passwords do not match",
        {Field: "age", Rule: "required"}:       "Please provide your age",
        {Field: "age", Rule: "gte"}:            "You must be at least 18 years old",
        {Field: "terms", Rule: "accepted"}:     "You must accept the terms of service",
    }

    db, _ := c.DB().(orm.Database)

    result, err := dbrules.CheckWithDBW(c.Response, c.Request, rules, db, messages)
    if err != nil {
        // Malformed rule set: a bug here, not bad input.
        return err
    }
    if result.HasErrors() {
        return c.JSON(422, map[string]interface{}{
            "message": "Validation failed",
            "errors":  result.Messages(),
        })
    }

    var input struct {
        Name, Email, Password string
        Age                   int
        Newsletter            bool
    }
    if err := c.BindAuto(&input); err != nil {
        return err
    }

    user := &User{
        Name:            input.Name,
        Email:           input.Email,
        Password:        hashPassword(input.Password),
        Age:             input.Age,
        NewsletterOptIn: input.Newsletter,
    }
    if err := user.Save(); err != nil {
        return c.JSON(500, map[string]string{"error": "Failed to create user"})
    }

    return c.JSON(201, map[string]interface{}{
        "message": "Registration successful",
        "user":    user,
    })
}

func TestValidation(t *testing.T) {
    data := map[string]interface{}{
        "email":    "user@example.com",
        "password": "secret12",
        "age":      25,
    }

    rules := validation.Rules{
        "email":    {validation.Required(), validation.Email()},
        "password": {validation.Required(), validation.Min(8)},
        "age":      {validation.Required(), validation.Numeric(), validation.Gte("18")},
    }

    result, err := validation.CheckData(data, rules)
    require.NoError(t, err)
    assert.False(t, result.HasErrors())
}

func TestValidationErrors(t *testing.T) {
    data := map[string]interface{}{
        "email": "invalid-email",
        "age":   "not-a-number",
    }

    rules := validation.Rules{
        "email": {validation.Required(), validation.Email()},
        "age":   {validation.Required(), validation.Numeric()},
    }

    result, err := validation.CheckData(data, rules)
    require.NoError(t, err)
    assert.True(t, result.HasErrors())

    var ve validation.ValidationErrors
    require.True(t, errors.As(result.Err(), &ve))
    assert.True(t, ve.HasRule("email", "email"))
    assert.True(t, ve.HasRule("age", "numeric"))
    assert.Equal(t, 2, ve.Count())
}

import vtesting "github.com/velocitykode/velocity/validation/testing"

func TestEmailRule(t *testing.T) {
    // Applies the rules to every key in the input map.
    // expectedErr=true means the input is expected to fail.
    vtesting.RuleAssertion(t, map[string]interface{}{"email": "bad"}, true,
        validation.Required(), validation.Email())

    v := vtesting.NewTestValidator()
    _, err := v.Validate(map[string]interface{}{"email": ""}, validation.Rules{
        "email": {validation.Required(), validation.Email()},
    })

    // Asserts the field failed the NAMED rule, not just "something failed".
    vtesting.AssertErrorRule(t, err, "email", "required")

    // Use only where the exact wording is load-bearing.
    vtesting.AssertErrorMessage(t, err, "email", "is required")
}