Return error from middleware with json body

[ghost]

How can i return an error from middleware that contains a json body and halts the chain, terminating the request flow?

I initially tried just returning json with an error http code (typeof errs is url.Values):

  if len(errs) > 0 {
    // c is the context
    return c.JSON(
      http.StatusBadRequest, errs)
  }

But this wasn't halting the chain and terminating the request flow. So instead I make the call to the context JSON func and then return the error like so:

  if len(errs) > 0 {
    // c is the context
    _ = c.JSON(
      http.StatusBadRequest, errs)
    return echo.ErrBadRequest
  }

Which works, but each time this happens, a warning is written to the console to explain that the response has already been sent.

So my question is: is there a better way of doing this? I've had a look around and haven't managed to find anything.

[aldas]

just return error and do not use c.JSON. c.JSON() sends response to the client. You should just return error from middleware and handle error in global error handler and there send response to the client.

[ghost]

Ok, thanks for letting me know. So in the case of validation errors, I should add them to the context, return echo.ErrBadRequest and then return the errors from the context in the global error handler?

[aldas]

Okey, I see. you have built validator middleware.

I do not know how your middleware is implemented but if you do not call next then handler chain is stopped and execution stops and we rewind the handler chain back upwards.

Here:

	e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			test := c.QueryParam("test")
			if test == "invalid" {
				return c.JSON(http.StatusBadRequest, map[string]string{ "message": "INVALID"}) // stop and bubble error up in chain
			}
			return next(c) // go deeper in handler chain
		}
	})

In that case you could use c.JSON() but it is not that often that middleware does that but it is fine.

Another take would to have your own custom error type that you handle in your global error handler. In that case middlewares up in handler chain could act on that error that is bubbling up and even override it.

type myCustomError struct {
	Code   int      `json:"-"`
	Errors []string `json:"messages"`
}

func (e myCustomError) Error() string {
	return strings.Join(e.Errors, ". ")
}

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

	e.Use(middleware.Logger())
	e.Use(middleware.Recover())

	e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			test := c.QueryParam("test")
			if test == "invalid" {
				return myCustomError{
					Code: http.StatusBadRequest,
					Errors: []string{
						"name must be filled",
						"email must be unique",
					},
				}
			}
			return next(c)
		}
	})

	e.HTTPErrorHandler = func(err error, c echo.Context) {
		if c.Response().Committed {
			return
		}

		// check if error is known type to be handled differently
		if myErr, ok := err.(myCustomError); ok {
			if err := c.JSON(myErr.Code, myErr); err != nil {
				e.Logger.Error(err)
			}
			return
		}
		// use default error handler functionality
		e.DefaultHTTPErrorHandler(err, c)
	}

	e.GET("/", func(c echo.Context) error {
		return c.JSON(http.StatusOK, map[string]string{"message": "OK"})
	})

	if err := e.Start(":8080"); err != http.ErrServerClosed {
		log.Fatal(err)
	}
}

Output:

x@x:~/code$ curl -v http://localhost:8080/?test=invalid
*   Trying 127.0.0.1:8080...
* TCP_NODELAY set
* Connected to localhost (127.0.0.1) port 8080 (#0)
> GET /?test=invalid HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.68.0
> Accept: */*
> 
* Mark bundle as not supporting multiuse
< HTTP/1.1 400 Bad Request
< Content-Type: application/json; charset=UTF-8
< Date: Thu, 19 Aug 2021 19:22:57 GMT
< Content-Length: 60
< 
{"messages":["name must be filled","email must be unique"]}
* Connection #0 to host localhost left intact

[ghost]

Thanks a lot. That really helps. I can't mark it it as an answer just yet as github is giving me a 422 error whenever I try to. I'll check back again tomorrow.