Accessing validation tag parameters of other fields in go-playground/validator

Question

I'm using the go-playground/validator package to validate a struct in Go. Here is my struct definition:

GetLogRequest struct {
    CreatedAtMin      string `query:"created_at_min" validate:"omitempty,datetime=2006-01-02"`
    CreatedAtMax      string `query:"created_at_max" validate:"omitempty,datetime=2006-01-02,date_greater_than=CreatedAtMin"`
}

As you can see, the CreatedAtMin and CreatedAtMax fields have a custom date validation that defines the date format with the datetime tag. I'd like to use this same date format in another custom validation function. Here is the skeleton of my custom validation function:

func validateDateGreaterThan(fl validator.FieldLevel) bool {
    dateMax, err := time.Parse("2006-01-02", fl.Field().String())
    if err != nil {
        return false
    }

    dateMin, err := time.Parse("2006-01-02", fl.Parent().FieldByName(fl.Param()).String())
    if err != nil {
        return false
    }

    return dateMin.After(dateMax)
}

Is there a way to access the parameter of the datetime validation tag of another field from within my custom validation function, such that I can use that format instead of having to hard-code it into the time.Parse function?

Any help or direction would be greatly appreciated. Thank you.

Answer 1

The github.com/go-playground/validator package does not export the parameter of other validation tags. So you have to read and parse the tag yourself. Below is a demo showing how to do that (see the getFormat func).

package main

import (
    "fmt"
    "reflect"
    "strings"
    "time"

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

func validateDateGreaterThan(fl validator.FieldLevel) bool {
    fallback := "2006-01-02"
    f := getFormat(fl.Parent().Type(), fl.StructFieldName(), fallback)
    dateMax, err := time.Parse(f, fl.Field().String())
    if err != nil {
        return false
    }

    minField, kind, _, found := fl.GetStructFieldOK2()
    if !found {
        panic("field not found")
    }
    if kind != reflect.String {
        panic("unsupported type")
    }
    f = getFormat(fl.Parent().Type(), fl.Param(), fallback)
    dateMin, err := time.Parse(f, minField.String())
    if err != nil {
        return false
    }

    return dateMax.After(dateMin)
}

func getFormat(typ reflect.Type, fieldName, fallback string) string {
    df, ok := typ.FieldByName(fieldName)
    if !ok {
        return fallback
    }

    tag := df.Tag.Get("validate")
    if tag == "" {
        return fallback
    }

    datetime := "datetime="
    values := strings.Split(tag, ",")
    for _, v := range values {
        if strings.HasPrefix(v, datetime) {
            return strings.TrimSpace(v[len(datetime):])
        }
    }

    return fallback
}

type GetLogRequest struct {
    CreatedAtMin string `query:"created_at_min" validate:"omitempty,datetime=2006-01-02"`
    CreatedAtMax string `query:"created_at_max" validate:"omitempty,datetime=2006-01-02,date_greater_than=CreatedAtMin"`
}

var validate *validator.Validate

func main() {
    validate = validator.New()
    if err := validate.RegisterValidation("date_greater_than", validateDateGreaterThan); err != nil {
        panic(err)
    }

    request := GetLogRequest{
        CreatedAtMin: "2023-06-07",
        CreatedAtMax: "2023-06-08",
    }

    fmt.Printf("validate error: %+v\n", validate.Struct(request))
}

Answer 2

It's a shame that validations from other tags couldn't be used, as this would allow for chaining validations, at least the custom ones. Given the need for a quick solution, here's what I did:

GetLogRequest struct {
    CreatedAtMin      string `query:"created_at_min" validate:"omitempty,datetime=2006-01-02"`
    CreatedAtMax      string `query:"created_at_max" validate:"omitempty,datetime=2006-01-02,date_greater_than=CreatedAtMin;2006-01-02"`
}

func validateDateGreaterThan(fl validator.FieldLevel) bool {
    params := strings.Split(fl.Param(), ";")
    fieldName := params[0]
    dateFormat := params[1]

    dateMax, err := time.Parse(dateFormat, fl.Field().String())
    if err != nil {
        return false
    }

    dateMin, err := time.Parse(dateFormat, fl.Parent().FieldByName(fieldName).String())
    if err != nil {
        return false
    }

    return dateMax.After(dateMin)
}

In this way, I pass the field and the format to use in the validation to the tag.