validation

package main

import (
	"context"
	"fmt"
	"net/url"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

type Webstore struct {
	Name  string
	URL   string
	Items WebstoreItems
}

func (w Webstore) Validate(ctx context.Context, validator *validation.Validator) error {
	domain := ""
	u, err := url.Parse(w.URL)
	if err == nil {
		domain = u.Host
	}

	return validator.Validate(
		ctx,
		validation.StringProperty("name", w.Name, it.IsNotBlank(), it.HasMaxLength(100)),
		validation.StringProperty("url", w.URL, it.IsNotBlank(), it.IsURL()),
		validation.CountableProperty("items", len(w.Items), it.IsNotBlank(), it.HasMaxCount(20)),
		validation.ValidProperty(
			"items",
			validation.ValidatableFunc(func(ctx context.Context, validator *validation.Validator) error {
				// passing context value by callback function
				return w.Items.Validate(ctx, validator, domain)
			}),
		),
	)
}

type WebstoreItem struct {
	Name  string
	URL   string
	Price int
}

func (w WebstoreItem) Validate(ctx context.Context, validator *validation.Validator, webstoreDomain string) error {
	return validator.Validate(
		ctx,
		validation.StringProperty("name", w.Name, it.IsNotBlank(), it.HasMaxLength(100)),
		validation.NumberProperty[int]("price", w.Price, it.IsNotBlankNumber[int](), it.IsLessThan[int](10000)),
		validation.StringProperty(
			"url", w.URL,
			it.IsNotBlank(),
			// using webstore domain passed as a function parameter
			it.IsURL().WithHosts(webstoreDomain).WithProhibitedMessage(
				`Webstore item URL domain must match "{{ webstoreDomain }}".`,
				validation.TemplateParameter{Key: "{{ webstoreDomain }}", Value: webstoreDomain},
			),
		),
	)
}

type WebstoreItems []WebstoreItem

func (items WebstoreItems) Validate(ctx context.Context, validator *validation.Validator, webstoreDomain string) error {
	violations := validation.NewViolationList()

	for i, item := range items {
		// passing context value to each item
		err := violations.AppendFromError(item.Validate(ctx, validator.AtIndex(i), webstoreDomain))
		if err != nil {
			return err
		}
	}

	return violations.AsError()
}

func main() {
	store := Webstore{
		Name: "Acme store",
		URL:  "https://acme.com/homepage",
		Items: []WebstoreItem{
			{
				Name:  "Book",
				URL:   "https://acme.com/items/the-book",
				Price: 100,
			},
			{
				Name:  "Notepad",
				URL:   "https://store.com/items/notepad",
				Price: 1000,
			},
		},
	}

	err := validator.Validate(context.Background(), validation.Valid(store))

	if violations, ok := validation.UnwrapViolationList(err); ok {
		violations.ForEach(func(i int, violation validation.Violation) error {
			fmt.Println(violation)
			return nil
		})
	}
}

Output:

violation at "items[1].url": "Webstore item URL domain must match "acme.com"."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	books := []struct {
		Title string
	}{
		{Title: ""},
	}

	err := validator.At(validation.PropertyName("books"), validation.ArrayIndex(0)).Validate(
		context.Background(),
		validation.StringProperty("title", books[0].Title, it.IsNotBlank()),
	)

	violation := err.(*validation.ViolationList).First()
	fmt.Println("property path:", violation.PropertyPath().String())
}

Output:

property path: books[0].title

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	books := []struct {
		Title string
	}{
		{Title: ""},
	}

	err := validator.AtIndex(0).Validate(
		context.Background(),
		validation.StringProperty("title", books[0].Title, it.IsNotBlank()),
	)

	violation := err.(*validation.ViolationList).First()
	fmt.Println("property path:", violation.PropertyPath().String())
}

Output:

property path: [0].title

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	book := struct {
		Title string
	}{
		Title: "",
	}

	err := validator.AtProperty("book").Validate(
		context.Background(),
		validation.StringProperty("title", book.Title, it.IsNotBlank()),
	)

	violation := err.(*validation.ViolationList).First()
	fmt.Println("property path:", violation.PropertyPath().String())
}

Output:

property path: book.title

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/muonsoft/validation"
)

func main() {
	validator, err := validation.NewValidator()
	if err != nil {
		log.Fatal(err)
	}
	errClient := errors.New("client error")

	violation := validator.BuildViolation(context.Background(), errClient, "Client message with {{ parameter }}.").
		WithParameter("{{ parameter }}", "value").
		Create()

	fmt.Println(violation.Message())
}

Output:

Client message with value.

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/muonsoft/language"
	"github.com/muonsoft/validation"
	"golang.org/x/text/message/catalog"
)

func main() {
	validator, err := validation.NewValidator(
		validation.Translations(map[language.Tag]map[string]catalog.Message{
			language.Russian: {
				"The operation is only possible for the {{ role }}.": catalog.String("Операция возможна только для {{ role }}."),
				"administrator role": catalog.String("роли администратора"),
			},
		}),
	)
	if err != nil {
		log.Fatal(err)
	}
	errClient := errors.New("client error")

	violation := validator.WithLanguage(language.Russian).
		BuildViolation(context.Background(), errClient, "The operation is only possible for the {{ role }}.").
		WithParameters(validation.TemplateParameter{
			Key:              "{{ role }}",
			Value:            "administrator role",
			NeedsTranslation: true,
		}).
		Create()

	fmt.Println(violation.Message())
}

Output:

Операция возможна только для роли администратора.

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/muonsoft/validation"
)

func main() {
	validator, err := validation.NewValidator()
	if err != nil {
		log.Fatal(err)
	}
	errFirst := errors.New("error 1")
	errSecond := errors.New("error 2")

	builder := validator.BuildViolationList(context.Background())
	builder.BuildViolation(errFirst, "Client message with {{ parameter 1 }}.").
		WithParameter("{{ parameter 1 }}", "value 1").
		AtProperty("properties").AtIndex(0).
		Add()
	builder.BuildViolation(errSecond, "Client message with {{ parameter 2 }}.").
		WithParameter("{{ parameter 2 }}", "value 2").
		AtProperty("properties").AtIndex(1).
		Add()
	violations := builder.Create()

	violations.ForEach(func(i int, violation validation.Violation) error {
		fmt.Println(violation.Error())
		return nil
	})
	fmt.Println("errors.Is(violations, errFirst) =", errors.Is(violations, errFirst))
	fmt.Println("errors.Is(violations, errSecond) =", errors.Is(violations, errSecond))
}

Output:

violation at "properties[0]": "Client message with value 1."
violation at "properties[1]": "Client message with value 2."
errors.Is(violations, errFirst) = true
errors.Is(violations, errSecond) = true

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/muonsoft/validation"
)

func main() {
	validator, err := validation.NewValidator()
	if err != nil {
		log.Fatal(err)
	}
	errClient := errors.New("client error")

	violation := validator.CreateViolation(
		context.Background(),
		errClient,
		"Client message.",
		validation.PropertyName("properties"),
		validation.ArrayIndex(1),
	)

	fmt.Println(violation.Error())
}

Output:

violation at "properties[1]": "Client message."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	document := struct {
		Title    string
		Keywords []string
	}{
		Title:    "",
		Keywords: []string{"", "book", "fantasy", "book"},
	}

	err := validator.Validate(
		context.Background(),
		validation.StringProperty("title", document.Title, it.IsNotBlank()),
		validation.CountableProperty("keywords", len(document.Keywords), it.HasCountBetween(5, 10)),
		validation.ComparablesProperty[string]("keywords", document.Keywords, it.HasUniqueValues[string]()),
		validation.EachStringProperty("keywords", document.Keywords, it.IsNotBlank()),
	)

	if violations, ok := validation.UnwrapViolationList(err); ok {
		for violation := violations.First(); violation != nil; violation = violation.Next() {
			fmt.Println(violation)
		}
	}
}

Output:

violation at "title": "This value should not be blank."
violation at "keywords": "This collection should contain 5 elements or more."
violation at "keywords": "This collection should contain only unique elements."
violation at "keywords[0]": "This value should not be blank."

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
)

func main() {
	validator, err := validation.NewValidator()
	if err != nil {
		log.Fatal(err)
	}

	s := ""
	err = validator.Validate(context.Background(), validation.String(s, it.IsNotBlank()))

	fmt.Println(err)
	fmt.Println("errors.Is(err, validation.ErrIsBlank) =", errors.Is(err, validation.ErrIsBlank))
}

Output:

violation: "This value should not be blank."
errors.Is(err, validation.ErrIsBlank) = true

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	notes := []struct {
		Title    string
		IsPublic bool
		Text     string
	}{
		{Title: "published note", IsPublic: true, Text: "text of published note"},
		{Title: "draft note", IsPublic: true, Text: ""},
	}

	for i, note := range notes {
		err := validator.Validate(
			context.Background(),
			validation.StringProperty("name", note.Title, it.IsNotBlank()),
			validation.StringProperty("text", note.Text, it.IsNotBlank().When(note.IsPublic)),
		)
		if violations, ok := validation.UnwrapViolationList(err); ok {
			for violation := violations.First(); violation != nil; violation = violation.Next() {
				fmt.Printf("error on note %d: %s", i, violation)
			}
		}
	}

}

Output:

error on note 1: violation at "text": "This value should not be blank."

package main

import (
	"context"
	"errors"
	"fmt"
	"regexp"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

var ErrNotNumeric = errors.New("not numeric")

type NumericConstraint struct {
	matcher *regexp.Regexp
}

// it is recommended to use semantic constructors for constraints.
func IsNumeric() NumericConstraint {
	return NumericConstraint{matcher: regexp.MustCompile("^[0-9]+$")}
}

func (c NumericConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error {
	// usually, you should ignore empty values
	// to check for an empty value you should use it.NotBlankConstraint
	if value == nil || *value == "" {
		return nil
	}

	if c.matcher.MatchString(*value) {
		return nil
	}

	// use the validator to build violation with translations
	return validator.CreateViolation(ctx, ErrNotNumeric, "This value should be numeric.")
}

func main() {
	s := "alpha"

	err := validator.Validate(
		context.Background(),
		validation.String(s, it.IsNotBlank(), IsNumeric()),
	)

	fmt.Println(err)
	fmt.Println("errors.Is(err, ErrNotNumeric) =", errors.Is(err, ErrNotNumeric))
}

Output:

violation: "This value should be numeric."
errors.Is(err, ErrNotNumeric) = true

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	s := ""

	err := validator.Validate(
		context.Background(),
		validation.String(s, it.IsNotBlank().WithMessage("this value is required")),
	)

	fmt.Println(err)
}

Output:

violation: "this value is required"

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/http/httptest"
	"strings"

	"github.com/muonsoft/language"
	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/message/translations/russian"
)

type Book struct {
	Title    string   `json:"title"`
	Author   string   `json:"author"`
	Keywords []string `json:"keywords"`
}

func (b Book) Validate(ctx context.Context, validator *validation.Validator) error {
	return validator.Validate(
		ctx,
		validation.StringProperty("title", b.Title, it.IsNotBlank()),
		validation.StringProperty("author", b.Author, it.IsNotBlank()),
		validation.CountableProperty("keywords", len(b.Keywords), it.HasCountBetween(1, 10)),
		validation.EachStringProperty("keywords", b.Keywords, it.IsNotBlank()),
	)
}

func HandleBooks(writer http.ResponseWriter, request *http.Request) {
	var book Book
	err := json.NewDecoder(request.Body).Decode(&book)
	if err != nil {
		http.Error(writer, "invalid request", http.StatusBadRequest)
		return
	}

	// setting up validator
	validator, err := validation.NewValidator(validation.Translations(russian.Messages))
	if err != nil {
		http.Error(writer, err.Error(), http.StatusInternalServerError)
		return
	}

	err = validator.Validate(request.Context(), validation.Valid(book))
	if err != nil {
		violations, ok := validation.UnwrapViolationList(err)
		if ok {
			response, err := json.Marshal(violations)
			if err != nil {
				log.Fatal(err)
			}
			writer.WriteHeader(http.StatusUnprocessableEntity)
			writer.Header().Set("Content-Type", "application/json")
			writer.Write(response)
			return
		}

		http.Error(writer, err.Error(), http.StatusInternalServerError)
		return
	}

	// handle valid book

	writer.WriteHeader(http.StatusCreated)
	writer.Write([]byte("ok"))
}

func main() {
	var handler http.Handler
	handler = http.HandlerFunc(HandleBooks)
	// middleware set up: we need to set supported languages
	// detected language will be passed via request context
	handler = language.NewMiddleware(handler, language.SupportedLanguages(language.English, language.Russian))

	// creating request with the language-specific header
	request := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{}`))
	request.Header.Set("Accept-Language", "ru")

	recorder := httptest.NewRecorder()
	handler.ServeHTTP(recorder, request)

	// recorded response should contain array of violations
	fmt.Println(recorder.Body.String())
}

Output:

[{"error":"is blank","message":"Значение не должно быть пустым.","propertyPath":"title"},{"error":"is blank","message":"Значение не должно быть пустым.","propertyPath":"author"},{"error":"too few elements","message":"Эта коллекция должна содержать 1 элемент или больше.","propertyPath":"keywords"}]

package main

import (
	"bytes"
	"context"
	"fmt"
	"path/filepath"
	"strings"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

type File struct {
	Name string
	Data []byte
}

// This validation will always check that file is valid.
// Partial validation will be applied by AllowedFileExtensionConstraint
// and AllowedFileSizeConstraint.
func (f File) Validate(ctx context.Context, validator *validation.Validator) error {
	return validator.Validate(
		ctx,
		validation.StringProperty("name", f.Name, it.HasLengthBetween(5, 50)),
	)
}

type FileUploadRequest struct {
	Section string
	File    *File
}

type FileConstraint interface {
	ValidateFile(ctx context.Context, validator *validation.Validator, file *File) error
}

func ValidFile(file *File, constraints ...FileConstraint) validation.ValidatorArgument {
	return validation.NewArgument(func(ctx context.Context, validator *validation.Validator) (*validation.ViolationList, error) {
		violations := validation.NewViolationList()

		for _, constraint := range constraints {
			err := violations.AppendFromError(constraint.ValidateFile(ctx, validator, file))
			if err != nil {
				return nil, err
			}
		}

		return violations, nil
	})
}

// AllowedFileExtensionConstraint used to check that file has one of allowed extensions.
// This constraint can be used for partial validation.
type AllowedFileExtensionConstraint struct {
	extensions []string
}

func FileHasAllowedExtension(extensions ...string) AllowedFileExtensionConstraint {
	return AllowedFileExtensionConstraint{extensions: extensions}
}

func (c AllowedFileExtensionConstraint) ValidateFile(ctx context.Context, validator *validation.Validator, file *File) error {
	if file == nil {
		return nil
	}

	extension := strings.ReplaceAll(filepath.Ext(file.Name), ".", "")

	return validator.AtProperty("name").Validate(
		ctx,
		validation.Comparable[string](
			extension,
			it.IsOneOf(c.extensions...).WithMessage("Not allowed extension. Must be one of: {{ choices }}."),
		),
	)
}

// AllowedFileSizeConstraint used to check that file has limited size.
// This constraint can be used for partial validation.
type AllowedFileSizeConstraint struct {
	minSize int
	maxSize int
}

func FileHasAllowedSize(min, max int) AllowedFileSizeConstraint {
	return AllowedFileSizeConstraint{minSize: min, maxSize: max}
}

func (c AllowedFileSizeConstraint) ValidateFile(ctx context.Context, validator *validation.Validator, file *File) error {
	if file == nil {
		return nil
	}

	size := len(file.Data)

	return validator.Validate(
		ctx,
		validation.Number[int](
			size,
			it.IsGreaterThan(c.minSize).WithMessage("File size is too small."),
			it.IsLessThan(c.maxSize).WithMessage("File size is too large."),
		),
	)
}

func main() {
	// this constraints will be applied to all files uploaded as avatars
	avatarConstraints := []FileConstraint{
		FileHasAllowedExtension("jpeg", "jpg", "gif"),
		FileHasAllowedSize(100, 1000),
	}
	// this constraints will be applied to all files uploaded as documents
	documentConstraints := []FileConstraint{
		FileHasAllowedExtension("doc", "pdf", "txt"),
		FileHasAllowedSize(1000, 100000),
	}

	requests := []FileUploadRequest{
		{
			Section: "avatars",
			File:    &File{Name: "avatar.png", Data: bytes.Repeat([]byte{0}, 99)},
		},
		{
			Section: "documents",
			File:    &File{Name: "sheet.xls", Data: bytes.Repeat([]byte{0}, 100001)},
		},
	}

	for _, request := range requests {
		switch request.Section {
		case "avatars":
			err := validator.Validate(
				context.Background(),
				// common validation of validatable
				validation.Valid(request.File),
				// specific validation for file storage section
				ValidFile(request.File, avatarConstraints...),
			)
			fmt.Println(err)
		case "documents":
			err := validator.Validate(
				context.Background(),
				// common validation of validatable
				validation.Valid(request.File),
				// specific validation for file storage section
				ValidFile(request.File, documentConstraints...),
			)
			fmt.Println(err)
		}
	}

}

Output:

violations: #0 at "name": "Not allowed extension. Must be one of: jpeg, jpg, gif."; #1: "File size is too small."
violations: #0 at "name": "Not allowed extension. Must be one of: doc, pdf, txt."; #1: "File size is too large."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	s := ""

	err := validator.Validate(
		context.Background(),
		validation.String(s, it.IsNotBlank()).At(
			validation.PropertyName("properties"),
			validation.ArrayIndex(1),
			validation.PropertyName("tag"),
		),
	)

	violation := err.(*validation.ViolationList).First()
	fmt.Println("property path:", violation.PropertyPath().String())
}

Output:

property path: properties[1].tag

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	s := ""

	err := validator.Validate(
		context.Background(),
		// this is an alias for
		// validation.String(s, it.IsNotBlank()).At(validation.PropertyName("property")),
		validation.StringProperty("property", s, it.IsNotBlank()),
	)

	violation := err.(*validation.ViolationList).First()
	fmt.Println("property path:", violation.PropertyPath().String())
}

Output:

property path: property

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	s := ""

	err := validator.
		AtProperty("properties").
		AtIndex(1).
		AtProperty("tag").
		Validate(context.Background(), validation.String(s, it.IsNotBlank()))

	violation := err.(*validation.ViolationList).First()
	fmt.Println("property path:", violation.PropertyPath().String())
}

Output:

property path: properties[1].tag

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	s := ""

	err := validator.Validate(context.Background(), validation.String(s, it.IsNotBlank()))

	fmt.Println(err)
}

Output:

violation: "This value should not be blank."

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/muonsoft/language"
	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"golang.org/x/text/feature/plural"
	"golang.org/x/text/message/catalog"
)

func main() {
	const customMessage = "tags should contain more than {{ limit }} element(s)"
	validator, err := validation.NewValidator(
		validation.Translations(map[language.Tag]map[string]catalog.Message{
			language.Russian: {
				customMessage: plural.Selectf(1, "",
					plural.One, "теги должны содержать {{ limit }} элемент и более",
					plural.Few, "теги должны содержать более {{ limit }} элемента",
					plural.Other, "теги должны содержать более {{ limit }} элементов"),
			},
		}),
	)
	if err != nil {
		log.Fatal(err)
	}

	var tags []string
	err = validator.WithLanguage(language.Russian).Validate(
		context.Background(),
		validation.Countable(len(tags), it.HasMinCount(1).WithMinMessage(customMessage)),
	)

	fmt.Println(err)
}

Output:

violation: "теги должны содержать 1 элемент и более"

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/muonsoft/language"
	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/message/translations/russian"
)

func main() {
	validator, err := validation.NewValidator(
		validation.Translations(russian.Messages),
	)
	if err != nil {
		log.Fatal(err)
	}

	s := ""
	ctx := language.WithContext(context.Background(), language.Russian)
	err = validator.Validate(
		ctx,
		validation.String(s, it.IsNotBlank()),
	)

	fmt.Println(err)
}

Output:

violation: "Значение не должно быть пустым."

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/muonsoft/language"
	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/message/translations/russian"
)

func main() {
	validator, err := validation.NewValidator(
		validation.Translations(russian.Messages),
	)
	if err != nil {
		log.Fatal(err)
	}

	s := ""
	err = validator.WithLanguage(language.Russian).Validate(
		context.Background(),
		validation.String(s, it.IsNotBlank()),
	)

	fmt.Println(err)
}

Output:

violation: "Значение не должно быть пустым."

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/muonsoft/language"
	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/message/translations/russian"
)

func main() {
	validator, err := validation.NewValidator(
		validation.Translations(russian.Messages),
		validation.DefaultLanguage(language.Russian),
	)
	if err != nil {
		log.Fatal(err)
	}

	s := ""
	err = validator.Validate(context.Background(), validation.String(s, it.IsNotBlank()))

	fmt.Println(err)
}

Output:

violation: "Значение не должно быть пустым."

package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

var ErrNestingLimitReached = errors.New("nesting limit reached")

// It is recommended to make a custom constraint to check for nesting limit.
type NestingLimitConstraint struct {
	limit int
}

func (c NestingLimitConstraint) ValidateProperty(ctx context.Context, validator *validation.Validator, property *Property) error {
	level, ok := ctx.Value(nestingLevelKey).(int)
	if !ok {
		// Don't forget to handle missing value.
		return fmt.Errorf("nesting level not found in context")
	}

	if level >= c.limit {
		return validator.CreateViolation(ctx, ErrNestingLimitReached, "Maximum nesting level reached.")
	}

	return nil
}

func ItIsNotDeeperThan(limit int) NestingLimitConstraint {
	return NestingLimitConstraint{limit: limit}
}

// Properties can be nested.
type Property struct {
	Name       string
	Properties []Property
}

// You can declare you own constraint interface to create custom constraints.
type PropertyConstraint interface {
	ValidateProperty(ctx context.Context, validator *validation.Validator, property *Property) error
}

// To create your own functional argument for validation simply create a function with
// a typed value and use the validation.NewArgument constructor.
func ValidProperty(property *Property, constraints ...PropertyConstraint) validation.ValidatorArgument {
	return validation.NewArgument(func(ctx context.Context, validator *validation.Validator) (*validation.ViolationList, error) {
		violations := validation.NewViolationList()

		for i := range constraints {
			err := violations.AppendFromError(constraints[i].ValidateProperty(ctx, validator, property))
			if err != nil {
				return nil, err
			}
		}

		return violations, nil
	})
}

type recursionKey string

const nestingLevelKey recursionKey = "nestingLevel"

func (p Property) Validate(ctx context.Context, validator *validation.Validator) error {
	return validator.Validate(
		// Incrementing nesting level in context with special function.
		contextWithNextNestingLevel(ctx),
		// Executing validation for maximum nesting level of properties.
		ValidProperty(&p, ItIsNotDeeperThan(3)),
		validation.StringProperty("name", p.Name, it.IsNotBlank()),
		// This should run recursive validation for properties.
		validation.ValidSliceProperty("properties", p.Properties),
	)
}

// This function increments current nesting level.
func contextWithNextNestingLevel(ctx context.Context) context.Context {
	level, ok := ctx.Value(nestingLevelKey).(int)
	if !ok {
		level = -1
	}

	return context.WithValue(ctx, nestingLevelKey, level+1)
}

func main() {
	properties := []Property{
		{
			Name: "top",
			Properties: []Property{
				{
					Name: "middle",
					Properties: []Property{
						{
							Name: "low",
							Properties: []Property{
								// This property should cause a violation.
								{Name: "limited"},
							},
						},
					},
				},
			},
		},
	}

	err := validator.Validate(context.Background(), validation.ValidSlice(properties))

	fmt.Println(err)
	fmt.Println("errors.Is(err, ErrNestingLimitReached) =", errors.Is(err, ErrNestingLimitReached))
}

Output:

violation at "[0].properties[0].properties[0].properties[0]": "Maximum nesting level reached."
errors.Is(err, ErrNestingLimitReached) = true

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := false
	err := validator.ValidateBool(context.Background(), v, it.IsTrue())
	fmt.Println(err)
}

Output:

violation: "This value should be true."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	s := []string{"a", "b"}
	err := validator.ValidateCountable(context.Background(), len(s), it.HasMinCount(3))
	fmt.Println(err)
}

Output:

violation: "This collection should contain 3 elements or more."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := []string{""}
	err := validator.ValidateEachString(context.Background(), v, it.IsNotBlank())
	fmt.Println(err)
}

Output:

violation at "[0]": "This value should not be blank."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := 5.5
	err := validator.ValidateFloat(context.Background(), v, it.IsGreaterThan(6.5))
	fmt.Println(err)
}

Output:

violation: "This value should be greater than 6.5."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := 5
	err := validator.ValidateInt(context.Background(), v, it.IsGreaterThan(5))
	fmt.Println(err)
}

Output:

violation: "This value should be greater than 5."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

type Person struct {
	Name    string
	Surname string
	Age     int
}

func (p Person) Validate(ctx context.Context, validator *validation.Validator) error {
	return validator.Validate(ctx,
		validation.StringProperty("name", p.Name, it.IsNotBlank(), it.HasMaxLength(50)),
		validation.StringProperty("surname", p.Surname, it.IsNotBlank(), it.HasMaxLength(100)),
		validation.NumberProperty[int]("age", p.Age, it.IsBetween(18, 100)),
	)
}

func main() {
	persons := []Person{
		{
			Name:    "John",
			Surname: "Doe",
			Age:     23,
		},
		{
			Name:    "",
			Surname: "",
			Age:     0,
		},
	}

	for i, person := range persons {
		err := validator.ValidateIt(context.Background(), person)
		if violations, ok := validation.UnwrapViolationList(err); ok {
			fmt.Println("person", i, "is not valid:")
			for violation := violations.First(); violation != nil; violation = violation.Next() {
				fmt.Println(violation)
			}
		}
	}

}

Output:

person 1 is not valid:
violation at "name": "This value should not be blank."
violation at "surname": "This value should not be blank."
violation at "age": "This value should be between 18 and 100."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

var ErrModificationProhibited = validation.NewError(
	"modification is prohibited",
	"Modification of resource is prohibited.",
)

type AccessViolation struct {
	validation.Violation
	UserID     int
	Permission string
}

func (err *AccessViolation) Error() string {
	return err.Violation.Error()
}

type Blog struct {
	Name    string
	Entries BlogEntries
}

func (b Blog) Validate(ctx context.Context, validator *validation.Validator, userID int) error {
	return validator.Validate(
		ctx,
		validation.StringProperty("name", b.Name, it.IsNotBlank(), it.HasMaxLength(50)),
		validation.ValidProperty(
			"entries",
			validation.ValidatableFunc(func(ctx context.Context, validator *validation.Validator) error {
				// passing user id further
				return b.Entries.Validate(ctx, validator, userID)
			}),
		),
	)
}

type BlogEntry struct {
	AuthorID int
	Title    string
	Text     string
}

func (e BlogEntry) Validate(ctx context.Context, validator *validation.Validator, userID int) error {
	// creating violation with domain payload
	if e.AuthorID != userID {
		return &AccessViolation{
			Violation:  validator.CreateViolation(ctx, ErrModificationProhibited, ErrModificationProhibited.Message()),
			UserID:     userID,
			Permission: "edit",
		}
	}

	return validator.Validate(
		ctx,
		validation.StringProperty("title", e.Title, it.IsNotBlank(), it.HasMaxLength(100)),
		validation.StringProperty("text", e.Text, it.IsNotBlank(), it.HasMaxLength(10000)),
	)
}

type BlogEntries []BlogEntry

func (entries BlogEntries) Validate(ctx context.Context, validator *validation.Validator, userID int) error {
	violations := validation.NewViolationList()

	for i, entry := range entries {
		err := violations.AppendFromError(entry.Validate(ctx, validator.AtIndex(i), userID))
		if err != nil {
			return err
		}
	}

	return violations.AsError()
}

func main() {
	blog := Blog{
		Name: "News blog",
		Entries: []BlogEntry{
			{
				AuthorID: 123,
				Title:    "Good weather",
				Text:     "Good weather is coming!",
			},
			{
				AuthorID: 321,
				Title:    "Secret entry",
				Text:     "This should not be edited!",
			},
		},
	}

	userID := 123 // user id from session
	err := validator.ValidateIt(
		context.Background(),
		validation.ValidatableFunc(func(ctx context.Context, validator *validation.Validator) error {
			return blog.Validate(ctx, validator, userID)
		}),
	)

	if violations, ok := validation.UnwrapViolationList(err); ok {
		violations.ForEach(func(i int, violation validation.Violation) error {
			fmt.Println(violation)
			// unwrap concrete violation from chain
			if accessError, ok := violation.(*AccessViolation); ok {
				fmt.Println("user id:", accessError.UserID)
				fmt.Println("permission:", accessError.Permission)
			}
			return nil
		})
	}
}

Output:

violation at "entries[1]": "Modification of resource is prohibited."
user id: 123
permission: edit

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.ValidateString(context.Background(), "", it.IsNotBlank())

	fmt.Println(err)
}

Output:

violation: "This value should not be blank."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := []string{"foo", "bar", "baz", "foo"}
	err := validator.ValidateStrings(context.Background(), v, it.HasUniqueValues[string]())
	fmt.Println(err)
}

Output:

violation: "This collection should contain only unique elements."

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	t := time.Now()
	compared, _ := time.Parse(time.RFC3339, "2006-01-02T15:00:00Z")
	err := validator.ValidateTime(context.Background(), t, it.IsEarlierThan(compared))
	fmt.Println(err)
}

Output:

violation: "This value should be earlier than 2006-01-02T15:00:00Z."

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

type User struct {
	Email    string
	Password string
	City     string
}

func (u User) Validate(ctx context.Context, validator *validation.Validator) error {
	return validator.Validate(
		ctx,
		validation.StringProperty(
			"email",
			u.Email,
			it.IsNotBlank().WhenGroups("registration"),
			it.IsEmail().WhenGroups("registration"),
		),
		validation.StringProperty(
			"password",
			u.Password,
			it.IsNotBlank().WhenGroups("registration"),
			it.HasMinLength(7).WhenGroups("registration"),
		),
		validation.StringProperty(
			"city",
			u.City,
			it.HasMinLength(2), // this constraint belongs to the default group
		),
	)
}

func main() {
	user := User{
		Email:    "invalid email",
		Password: "1234",
		City:     "Z",
	}

	err1 := validator.WithGroups("registration").Validate(context.Background(), validation.Valid(user))
	err2 := validator.Validate(context.Background(), validation.Valid(user))

	if violations, ok := validation.UnwrapViolationList(err1); ok {
		fmt.Println("violations for registration group:")
		for violation := violations.First(); violation != nil; violation = violation.Next() {
			fmt.Println(violation)
		}
	}
	if violations, ok := validation.UnwrapViolationList(err2); ok {
		fmt.Println("violations for default group:")
		for violation := violations.First(); violation != nil; violation = violation.Next() {
			fmt.Println(violation)
		}
	}

}

Output:

violations for registration group:
violation at "email": "This value is not a valid email address."
violation at "password": "This value is too short. It should have 7 characters or more."
violations for default group:
violation at "city": "This value is too short. It should have 2 characters or more."

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/muonsoft/language"
	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/message/translations/russian"
)

func main() {
	validator, err := validation.NewValidator(validation.Translations(russian.Messages))
	if err != nil {
		log.Fatal(err)
	}

	s := ""
	err = validator.WithLanguage(language.Russian).Validate(
		context.Background(),
		validation.String(s, it.IsNotBlank()),
	)

	fmt.Println(err)
}

Output:

violation: "Значение не должно быть пустым."

package main

import (
	"errors"
	"fmt"

	"github.com/muonsoft/validation"
)

func main() {
	violations := validation.NewViolationList()
	err := errors.New("error")

	appendErr := violations.AppendFromError(err)

	fmt.Println("append error:", appendErr)
	fmt.Println("violations length:", violations.Len())
}

Output:

append error: error
violations length: 0

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/validator"
)

func main() {
	violations := validation.NewViolationList()
	err := validator.BuildViolation(context.Background(), validation.ErrNotValid, "foo").Create()

	appendErr := violations.AppendFromError(err)

	fmt.Println("append error:", appendErr)
	fmt.Println("violations:", violations)
}

Output:

append error: <nil>
violations: violation: "foo"

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/validator"
)

func main() {
	violations := validation.NewViolationList()
	err := validation.NewViolationList(
		validator.BuildViolation(context.Background(), validation.ErrNotValid, "foo").Create(),
		validator.BuildViolation(context.Background(), validation.ErrNotValid, "bar").Create(),
	)

	appendErr := violations.AppendFromError(err)

	fmt.Println("append error:", appendErr)
	fmt.Println("violations:", violations)
}

Output:

append error: <nil>
violations: violations: #0: "foo"; #1: "bar"

package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/validator"
)

func main() {
	violations := validation.NewViolationList(
		validator.BuildViolation(context.Background(), validation.ErrNotValid, "foo").Create(),
		validator.BuildViolation(context.Background(), validation.ErrNotValid, "bar").Create(),
	)

	for violation := violations.First(); violation != nil; violation = violation.Next() {
		fmt.Println(violation)
	}
}

Output:

violation: "foo"
violation: "bar"

package main

import (
	"context"
	"fmt"
	"regexp"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "123"
	err := validator.Validate(
		context.Background(),
		validation.When(true).
			Then(validation.String(v, it.Matches(regexp.MustCompile(`^\w+$`)))).
			Else(validation.String(v, it.Matches(regexp.MustCompile(`^\d+$`)))),
	)
	fmt.Println(err)
}

Output:

<nil>

package main

import (
	"context"
	"fmt"
	"regexp"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo"
	err := validator.Validate(
		context.Background(),
		validation.When(true).Then(
			validation.String(v, it.Matches(regexp.MustCompile(`^\w+$`))),
		),
	)
	fmt.Println(err)
}

Output:

<nil>