How to validate entities in GO?

How to validate in GO?

all results on the internet suggest me to use github.com/go-playground/validator/v10

but the problem whenever I pass the struct to another layer or functions, to make sure it is valid, I have to call validator.Struct() again and again.

I think about validate directly in the struct (that the way I usually do in c#), to implement it I create a constructor for the struct, make all fields private and using getter and setter (the validation logic will be inside the setter and constructor), but the problem is I can not use gorm or mongodb to map entity to table, because all the fields are private and those libs can not read private fields, but if I don't make them private, I can accidently create an struct without using constructor or setter

how do you deal with entity validation in GO?

You could make the struct private, but have its fields exported. That way, people need to call the exported constructor of the package with that private struct, to get an instance of it.

For example, you have a store package that defines the struct type, but unexported. Additionally, you create an exported constructor.

package store

type foo struct { Name string }

func NewFoo(name string) foo { return foo{name} }

That way, users of your package, need to call the constructor to get an instance of the struct.

package main

import "myorg.com/app/store"

func main() {
  f := store.NewFoo("gopher")
  fmt.Println(f.Name)
}

This is not 100% foolproof, as you still can mess up within that store package, and also users of your struct can change the name after calling the constructor.

If you also want to enforce validation via setter, you probably don't get around some kind of helper struct.

In my opinion:

Perhaps your idea is too defensive. I am usually fine with validating user input. Within my program, I am not constantly validating myself.

Another thing to consider is that you probably want abstractions and loose coupling. For example, a struct with gorm specific tags, may only be known to your storage layer and not get passed around the entire app. In that sense, your validation could go into store.CreateUser() or similar. Perhaps it could also take such a helper struct as mentioned above.

If you want to use struct validation without using GoValidator you can build your own custom validation. Check the code below:

1 - Define your struct with private fields and validation tags:

type MyStruct struct {
    field1 string `validate:"required"`
    field2 int    `validate:"gte=0"`
}

2- Create getter and setter methods for each field:

func (s *MyStruct) GetField1() string {
    return s.field1
}

func (s *MyStruct) SetField1(value string) error {
    // Validate the value using your custom validation logic or a validation library
    if len(value) == 0 {
        return errors.New("field1 is required")
    }

    // Set the value if it passes validation
    s.field1 = value
    return nil
}

func (s *MyStruct) GetField2() int {
    return s.field2
}

func (s *MyStruct) SetField2(value int) error {
    // Validate the value using your custom validation logic or a validation library
    if value < 0 {
        return errors.New("field2 must be greater than or equal to 0")
    }

    // Set the value if it passes validation
    s.field2 = value
    return nil
}

3- Use these getter and setter methods throughout your code to access and modify the struct fields. This ensures that validation logic is always applied when setting values.

obj := MyStruct{}
err := obj.SetField1("value1")
if err != nil {
    // Handle validation error
}

err = obj.SetField2(10)
if err != nil {
    // Handle validation error
}

// Access field values
value1 := obj.GetField1()
value2 := obj.GetField2()