Using Go Validator for Efficient Data Validation in Go Applications

Data validation is an essential aspect of software development. It ensures that the data you process adheres to specific criteria or formats, thus maintaining data integrity and preventing potential bugs or security issues. If you're working with Go, one of the prominent packages for this task is go-validator. In this blog post, we'll delve into the workings of this package, showcasing its capabilities and providing examples of how to use it efficiently.

What is Go Validator?

Go Validator is an open-source package that provides a way to use tags on struct fields to specify validation rules. This means that you can enforce rules like "required," "minimum length," "email format," and many more directly in the data structure definition.

Getting Started

To use go-validator, first, install the package:

go get github.com/go-playground/validator/v10

Then, import it in your Go file:

import "github.com/go-playground/validator/v10"

Basic Usage

Let's dive into an example. Suppose we have a User struct, and we want to validate the data before saving it to a database:

type User struct {
    FirstName string `validate:"required"`
    LastName  string `validate:"required"`
    Email     string `validate:"required,email"`
    Age       int    `validate:"gte=18"`
}

In the example above, the FirstName and LastName fields are required, the Email field must be a valid email address, and the Age field must be greater than or equal to 18.

How do you validate a struct in Go?

validate := validator.New()

user := &User{
    FirstName: "John",
    LastName:  "Doe",
    Email:     "john.doe@example.com",
    Age:       17,
}

err := validate.Struct(user)
if err != nil {
    // handle the error
}

In the example, validation will fail because the age is less than 18.

Custom Validators

While go-validator comes with many built-in validations, there may be instances when you need custom validation rules. Fortunately, this package allows for custom validation functions. Here's a basic example:

func validateOdd(fl validator.FieldLevel) bool {
    return fl.Field().Int() % 2 == 1
}

// Registering the custom validator
validate.RegisterValidation("odd", validateOdd)

type CustomData struct {
    OddNumber int `validate:"odd"`
}

In the example above, the custom validator ensures that the number is odd.

Error Handling

When validation fails, the error returned provides a list of FieldError structures, which can be used to extract detailed information about each error. This is especially useful for sending structured error responses or for internationalization purposes.

package main

import (
	"fmt"
	"github.com/go-playground/validator/v10"
)

type User struct {
	FirstName string `validate:"required"`
	LastName  string `validate:"required"`
	Email     string `validate:"required,email"`
	Age       int    `validate:"gte=18"`
}

func main() {
	validate := validator.New()

	user := &User{
		FirstName: "John",
		LastName:  "",
		Email:     "invalid-email",
		Age:       17,
	}

	err := validate.Struct(user)
	if err != nil {
		if validationErrors, ok := err.(validator.ValidationErrors); ok {
			for _, vErr := range validationErrors {
				// Translate each error one at a time
				fmt.Println("Field:", vErr.Field())
				fmt.Println("Tag:", vErr.Tag())
				fmt.Println("Actual Value:", vErr.Value())
				fmt.Println("Namespace:", vErr.Namespace())
				fmt.Println("Struct Namespace:", vErr.StructNamespace())
				fmt.Println("------")
			}
		}
	}
}

This will produce the following output:

Field: LastName
Tag: required
Actual Value: 
Namespace: User.LastName
Struct Namespace: User.LastName
------
Field: Email
Tag: email
Actual Value: invalid-email
Namespace: User.Email
Struct Namespace: User.Email
------
Field: Age
Tag: gte
Actual Value: 17
Namespace: User.Age
Struct Namespace: User.Age
------

Go Validator offers a robust and flexible way to validate data in Go applications. By leveraging struct tags, it seamlessly integrates validation into the data model, providing a clean and efficient approach to data validation. With custom validators and extensive error handling, it addresses a wide range of use-cases, making it an essential tool in every Go developer's toolkit.

Remember, validation is just one layer of defense. Always ensure that you have other security measures in place, especially when dealing with user-generated data.