Feature Request: Conveniece Method for Allowing HEAD Requests

[jonnyreeves]

Description

HEAD
Asks for the response identical to the one that would correspond to a GET request, but without the response body. This is useful for retrieving meta-information written in response headers, without having to transport the entire content.

I would like to be able to configure echo in such a way that every time I register a Get handler, a Head handler is automatically added, ie:

server.go

e := echo.New()
e.Get("/", func(c echo.Context) error {
    return c.String(http.StatusOK, "Hello, World!")
})
e.Run(standard.New(":1323"))

curl command

# make a HEAD request
jonny$ curl -I http://localhost:1323/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Date: Sat, 10 Sep 2016 13:12:36 GMT

# make a GET request
jonny$ curl http://localhost:1323/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Date: Sat, 10 Sep 2016 13:12:36 GMT

Hello, World!

[jonnyreeves]

My thinking is to add a new Setter on Echo to allow HEAD requests; this would then automatically reigster a Head handler alongside a Get handler.

Let me know what you think to this approach; happy to cut a PR for it.

[jonnyreeves]

Ah to be fair, I just fixed this in my own project (using echo_v1) with some custom Middleware:

// AllowHeadRequestsMiddleware allows HEAD requests to be made against valid routes without
// the need to explicitally register a handler for each one.
func AllowHeadRequestsMiddleware() echo.MiddlewareFunc {
    return func(wrapped echo.HandlerFunc) echo.HandlerFunc {
        return func(ectx *echo.Context) error {
            err := wrapped(ectx)
            if err != nil && ectx.Request().Method == echo.HEAD && err.Error() == http.StatusText(http.StatusMethodNotAllowed) {
                return ectx.NoContent(http.StatusOK)
            }
            return err
        }
    }
}

Feel free to close this issue unless you would like to extend the public API.

[Wilfred]

FWIW using echo v2 I did something similar:

// AllowHeadRequestsMiddleware allows HEAD requests to be made against valid routes without
// the need to explicitly register a handler for each one.
//
// Loosely based on https://github.com/labstack/echo/issues/654
func AllowHeadRequestsMiddleware(h *Handler) echo.MiddlewareFunc {
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			err := next(c)
			if err == nil {
				return nil
			}

			// If it's a HEAD request that we haven't explicitly
			// handled,
			if c.Request().Method() == echo.HEAD && err.Error() == http.StatusText(http.StatusMethodNotAllowed) {
				// and if we have a route configured for this path,
				uri := c.Request().URI()
				if isRouted(h, uri) {
					// then return an empty HTTP 200.
					return c.NoContent(http.StatusOK)
				}
			}

			return err
		}
	}
}

Where isRouted is custom code to look up the URI in a route map I've defined.

[HenryQW]

Hello from 2024, here is what I did to achieve the goal.

func HeadToGetMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		if c.Request().Method == http.MethodHead {
			// Set the method to GET temporarily to reuse the handler
			c.Request().Method = http.MethodGet

			defer func() {
				c.Request().Method = http.MethodHead
			}() // Restore method after

			// Call the next handler and then clear the response body
			if err := next(c); err != nil {
				if err.Error() == echo.ErrMethodNotAllowed.Error() {
					return c.NoContent(http.StatusOK) //nolint:errcheck
				}

				return err
			}
		}

		return next(c)
	}
}

[iMartyn]

Note from 2025: Using HenryQW's code strips all the headers generated in the Get route, which means things like E-Tag and Last-Modified are wasted, which are pretty much the main reason for using HEAD methods. I tried iterating over c.Response().Header() and transferring them back, but to no avail. Using Middleware for eTag is problematic too because if you then use a Head() route, you get a different eTag for HEAD than GET :( Perhaps this issue should be reopened?

[nOw-Ay]

Working fix :

func HeadToGetMiddleware() echo.MiddlewareFunc {
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			if c.Request().Method == http.MethodHead {
				originalWriter := c.Response().Writer
				c.Response().Writer = &headResponseWriter{ResponseWriter: originalWriter}
				c.Request().Method = http.MethodGet
				err := next(c)
				c.Request().Method = http.MethodHead
				c.Response().Writer = originalWriter
				return err
			}
			return next(c)
		}
	}
}

type headResponseWriter struct {
	http.ResponseWriter
}

func (w *headResponseWriter) Write(b []byte) (int, error) {
	return len(b), nil
}

...

e.Pre(HeadToGetMiddleware())

But I, too, think it would be good to have a real option in echo to automatically handle HEAD requests when GET handlers are defined.