Validation

# Stop validation on first error (default: false)
VALIDATION_STOP_ON_FIRST=false

# Default locale for error messages
VALIDATION_DEFAULT_LOCALE=en

# Bail on first rule failure per field (default: true)
VALIDATION_BAIL_ON_ERROR=true

rules := validation.Rules{"name": {"required"}}

rules := validation.Rules{
    "middle_name": {"nullable", "string"},
    "bio":         {"filled"},
    "opt_in":      {"present"},
}

rules := validation.Rules{
    "password": {"min:8"},
    "bio":      {"max:500"},
    "zip_code": {"size:5"},
    "age":      {"numeric", "between:18,65"},
}

rules := validation.Rules{
    "password":         {"required", "confirmed"},
    "password_confirm": {"same:password"},
    "alt_email":        {"different:email"},
}

rules := validation.Rules{
    "role":     {"in:admin,user,moderator"},
    "username": {"not_in:admin,root,system"},
}

rules := validation.Rules{"terms": {"accepted"}}

rules := validation.Rules{
    "phone":    {"required_if:contact,phone"},
    "company":  {"required_unless:type,personal"},
    "shipping": {"required_with:address"},
    "sku":      {"required_without:gtin"},
}

rules := validation.Rules{
    "max_price": {"numeric", "gt:min_price"},
    "qty":       {"numeric", "lte:100"},
}

rules := validation.Rules{
    "pw": {"password:12"},                    // length >= 12, all defaults
    "pw": {"password:8,mixed,num,symbol"},    // explicit
}

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

rules := validation.Rules{
    "avatar":   {"image", "max:2048"},
    "document": {"file", "mimes:pdf,docx"},
}

rules := validation.Rules{
    "email":   {"required", "email", "unique:users,email"},
    "team_id": {"required", "exists:teams,id"},
}

// On update, exclude the current row by id:
rules = validation.Rules{
    "email": {"required", "email", "unique:users,email," + userID},
}

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

    result := validation.Check(c.Request, rules)
    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 := validation.CheckData(data, validation.Rules{
    "email": {"required", "email"},
    "age":   {"required", "numeric", "min:18"},
})
if err := result.Err(); err != nil {
    // err wraps validation.ErrValidationFailed and unwraps to ValidationErrors
    return err
}

result := validation.CheckWithDB(c.Request, rules, c.Services.DB)

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
}

import (
    "fmt"
    "unicode"

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

func newAppValidator() validation.Validator {
    v := validation.NewValidator()
    v.RegisterRule("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
    })
    return v
}

// Usage
v := newAppValidator()
result, err := v.Validate(data, validation.Rules{
    "password": {"required", "min:8", "strong_password"},
})

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

result := validation.Check(c.Request, rules, messages)

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

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

rules := validation.Rules{
    // Good: required first, then type, then constraints.
    "age": {"required", "numeric", "min:18", "max:120"},
}

var (
    EmailRules    = []string{"required", "email"}
    PasswordRules = []string{"required", "min:8", "strong_password"}
    PhoneRules    = []string{"required", "numeric", "size:10"}
)

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

package handlers

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

type UserHandler struct{}

func (uc *UserHandler) Register(c *router.Context) error {
    rules := validation.Rules{
        "name":                  {"required", "string", "min:2", "max:100"},
        "email":                 {"required", "email", "unique:users,email"},
        "password":              {"required", "min:8", "confirmed"},
        "password_confirmation": {"required"},
        "age":                   {"required", "numeric", "min:18"},
        "terms":                 {"required", "accepted"},
        "newsletter":            {"nullable", "boolean"},
    }

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

    result := validation.CheckWithDB(c.Request, rules, c.Services.DB, messages)
    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":    {"required", "email"},
        "password": {"required", "min:8"},
        "age":      {"required", "numeric", "min:18"},
    }

    result := validation.CheckData(data, rules)
    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": {"required", "email"},
        "age":   {"required", "numeric"},
    }

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

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