validator

type (
	User struct {
		ID   string
		Name string
	}
	Request struct {
		User    *User
		Options []string
	}
)

var requestValidator = validator.Struct(func(s validator.StructRule, r *Request) {
	validator.AddField(s, &r.User, "user", validator.Struct(func(s validator.StructRule, u *User) {
		validator.AddField(s, &u.ID, "id", validator.Length[string](5, 10))
		validator.AddField(s, &u.Name, "name", validator.Required[string]())
	}))
	validator.AddField(s, &r.Options, "options",
		validator.Slice(validator.In("option1", "option2")))
})

var r Request
r.Options = []string{"option3"}
err := requestValidator.Validate(context.Background(), &r)
fmt.Println(err)

Output:

user: name: cannot be the zero value
user: id: the length must be in range(5 ... 10)
options: must be a valid value in [option1 option2]

package main

import (
	"context"
	"fmt"

	"github.com/lufia/go-validator"
	"golang.org/x/text/language"
	"golang.org/x/text/message"
)

func init() {
	message.SetString(language.English, "must be of length %[1]d to %[2]d", "must be of length %[1]d to %[2]d")
	message.SetString(language.Japanese, "must be of length %[1]d to %[2]d", "%[1]d文字以上%[2]d文字以内で入力してください")
}

func main() {
	type Data struct {
		Num  int
		Name string
	}
	v := validator.Struct(func(s validator.StructRule, r *Data) {
		validator.AddField(s, &r.Name, "name",
			validator.Length[string](3, 100).WithFormat("must be of length %[1]d to %[2]d", validator.ByName("min"), validator.ByName("max")),
		)
	})
	p := message.NewPrinter(language.English)
	ctx := validator.WithPrinter(context.Background(), p)
	err := v.Validate(ctx, &Data{
		Num:  10,
		Name: "xx",
	})
	fmt.Println(err)
}

Output:

name: must be of length 3 to 100

package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/lufia/go-validator"
)

type CreateUserRequest struct {
	Name                 string
	Password             string
	ConfirmationPassword string
}

var (
	usernameValidator = validator.New(func(v string) bool {
		// find non-alnum or non-ascii character
		i := strings.IndexFunc(v, func(c rune) bool {
			switch {
			default:
				return true
			case c >= 'a' && c <= 'z':
				return false
			case c >= 'A' && c <= 'Z':
				return false
			case c >= '0' && c <= '9':
				return false
			}
		})
		return i < 0
	}).WithFormat("does not allow not-alphabets or not-digits")

	passwordValidator = validator.New(func(r *CreateUserRequest) bool {
		return r.Password == r.ConfirmationPassword
	}).WithFormat("passwords does not match")
)

var createUserRequestValidator = validator.Join(
	validator.Struct(func(s validator.StructRule, r *CreateUserRequest) {
		validator.AddField(s, &r.Name, "name",
			validator.Length[string](5, 20),
			usernameValidator)
		validator.AddField(s, &r.Password, "password",
			validator.MinLength[string](8))
		validator.AddField(s, &r.ConfirmationPassword, "confirmation-password",
			validator.MinLength[string](8))
	}),
	passwordValidator,
)

func main() {
	ctx := context.Background()
	err := createUserRequestValidator.Validate(ctx, &CreateUserRequest{
		Name:                 ".adm",
		Password:             "1234",
		ConfirmationPassword: "abcd",
	})
	fmt.Println(err)
}

Output:

name: the length must be in range(5 ... 20)
name: does not allow not-alphabets or not-digits
password: the length must be no less than 8
confirmation-password: the length must be no less than 8
passwords does not match

type (
	User struct {
		ID   string
		Name string
	}
	Request struct {
		User    *User
		Options []string
	}
)

var requestValidator = validator.Struct(func(s validator.StructRule, r *Request) {
	validator.AddField(s, &r.User, "user", validator.Struct(func(s validator.StructRule, u *User) {
		validator.AddField(s, &u.ID, "id", validator.Length[string](5, 10))
		validator.AddField(s, &u.Name, "name", validator.Required[string]())
	}))
	validator.AddField(s, &r.Options, "options",
		validator.Slice(validator.In("option1", "option2")))
})

p := message.NewPrinter(language.Japanese, message.Catalog(validator.DefaultCatalog))
ctx := validator.WithPrinter(context.Background(), p)

var r Request
r.Options = []string{"option3"}
err := requestValidator.Validate(ctx, &r)
fmt.Println(err)

Output:

user: name: 必須です
user: id: 長さは5以上10以内の制限があります
options: [option1 option2]のいずれかでなければなりません

type (
	User struct {
		ID   string
		Name string
	}
	Request struct {
		User    *User
		Options []string
	}
)

var (
	userValidator = validator.Struct(func(s validator.StructRule, u *User) {
		validator.AddField(s, &u.ID, "id", validator.Length[string](5, 10))
		validator.AddField(s, &u.Name, "name", validator.Required[string]())
	})
	requestValidator = validator.Struct(func(s validator.StructRule, r *Request) {
		validator.AddField(s, &r.User, "user", userValidator)
		validator.AddField(s, &r.Options, "options", validator.Slice(
			validator.In("option1", "option2"),
		))
		validator.AddField(s, &r.Options, "options", validator.Slice(
			validator.In("option1", "option2"),
		))
	})
)

var r Request
err := requestValidator.Validate(context.Background(), &r)
fmt.Println(err)

Output:

user: name: cannot be the zero value
user: id: the length must be in range(5 ... 10)