Allow use of Validate with Context

[khash]

Playground Validator, like some other validators allows context.Context to be passed into the validation method. For example, Playground Validator has both Struct and StructCtx methods with the only difference being a first ctx parameter.

This is useful when there is a need to customize validation as per context. For example, the ID field might be required for POST but not for PATCH (just an example). Allowing context to be passed in will open up some flexibility in the validation part. This can be achieved by extending the Validator interface to allow ValidateCtx(ctx context.Context, i interface{}) error as well.

Here is a sample:

func (cv *EntityValidator) ValidateCtx(ctx context.Context, i interface{}) error {
	if err := cv.Validator.StructCtx(ctx, i); err != nil {
		if _, ok := err.(*validator.InvalidValidationError); ok {
			log.Error().Err(err).Msg("InvalidValidationError")
			return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
		} else {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error())
		}
	}
	return nil
}

[aldas]

We can not change interfaces in v4

Let me propose some other ways:

I see you have EntityValidator I assume this is not trivial application and there are plenty of business logic therefore probably different business domains could have their own packages

I propose that you compose your own custom validator into "controller"like struct and use it like that:

package users

import (
	"context"
	"github.com/labstack/echo/v4"
	"net/http"
)

// this could have its own package if there are a lot of complex logic. ATM it is here to avoid cyclic imports
type validator interface {
	ValidateCtx(ctx context.Context, i interface{}) error
}

type ctrl struct {
	validator validator
}

func RegisterRoutes(root *echo.Group, validator validator) {
	users := root.Group("/users")

	c := ctrl{validator: validator}
	users.POST("/", c.createUser)
}

func (ctrl *ctrl) createUser(c echo.Context) (err error) {
	type User struct {
		Name  string `json:"name" validate:"required"`
		Email string `json:"email" validate:"required,email"`
	}
	u := new(User)
	if err = c.Bind(u); err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
	}
	if err = ctrl.validator.ValidateCtx(c.Request().Context(), u); err != nil {
		return err
	}
	return c.JSON(http.StatusOK, u)
}

and in your "top" level package. Could be main could be something else ala pkg/application. You would register all your business domains by calling their RegisterRoutes functions.

func main() {
	e := echo.New()

	cValidator := &CV{validator: validator.New()}
	e.Validator = cValidator

	api := e.Group("/api")

	users.RegisterRoutes(api, cValidator)
	//groups.RegisterRoutes(api, cValidator)

	e.Logger.Fatal(e.Start(":1323"))
}


// ------------------ this validator part could be its own package --------------------------------------

type CV struct {
	validator *validator.Validate
}

func (cv *CV) Validate(i interface{}) error {
	if err := cv.validator.Struct(i); err != nil {
		// Optionally, you could return the error to give each route more control over the status code
		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
	}
	return nil
}

func (cv *CV) ValidateCtx(ctx context.Context, i interface{}) error {
	if err := cv.validator.StructCtx(ctx, i); err != nil {
		if _, ok := err.(*validator.InvalidValidationError); ok {
			return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
		} else {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error())
		}
	}
	return nil
}

[aldas]

We could change

echo/context.go

Lines 442 to 447 in 6b09f3f

	func (c *context) Validate(i interface{}) error {
	if c.echo.Validator == nil {
	return ErrValidatorNotRegistered
	}
	return c.echo.Validator.Validate(i)
	}

implementation so that is checks if that validator instance supports method with context and if it does - it calls validator by that method instead.

type validatorCtx interface {
	ValidateCtx(ctx stdContext.Context, i interface{}) error
}

func (c *context) Validate(i interface{}) error {
	if c.echo.Validator == nil {
		return ErrValidatorNotRegistered
	}
	if val, ok := c.echo.Validator.(validatorCtx); ok {
		return val.ValidateCtx(c.request.Context(), i)
	}
	return c.echo.Validator.Validate(i)
}

[aldas]

My own personal experience - I have never used c.Validate(payload) in any of my developed applications as I always move my validation checks more into business layer side.

I use handlers only to extract data from request to DTOs and pass them to business side. My business services run validation on their inputs. That way I can support multiple transport layers HTTP, async pub/sub stuff (ala NATS/MQTT)

[khash]

I think we should do the same and move validations into the domain specific services. However as for the change in the Validate function, that would be a great help for simple use cases.