Suggestion: add before hook in echo.Response?

[cgyy]

Before allows for a function to be called before the ResponseWriter has been written to. This is
useful for setting headers or any other operations that must happen before a response has been written

type (
    Response struct {
        writer    http.ResponseWriter
        status    int
        size      int64
        committed bool
        beforeFuncs []BeforeFunc
    }
)
type BeforeFunc func(ResponseWriter)


func (r *Response) Before(before HandlerFunc) {
    r.beforeFuncs = append(r.beforeFuncs, before)
}


func (r *Response) WriteHeader(code int) {
    if r.committed {
        // TODO: Warning
        log.Printf("echo => %s", color.Yellow("response already committed"))
        return
    }
    for i := len(r.beforeFuncs) - 1; i >= 0; i-- {
        r.beforeFuncs[i](r)
    }

    r.status = code
    r.writer.WriteHeader(code)
    r.committed = true
}

For, example, If want to save session in middleware, could write code like this:

func Sessions(name string, store Store) echo.MiddlewareFunc {
    return func(h echo.HandlerFunc) echo.HandlerFunc {
        return func(c *echo.Context) error {
            s := &session{name, c.Request(), store, nil, false, c.Response()}
            c.Set(DefaultKey, s)

            c.Response.Before(func(echo.Response) {
                if s.Written() {
                    s.Session().Save(s.request, s.writer)
                }
            })

            // and no need to define another response writer like this
            //sw := SessionWriter{s, c.Response().Writer()}
            //c.Response().SetWriter(&sw)

            defer context.Clear(c.Request())
            return h(c)
        }
    }
}   

[ansel1]

I've also got a use case like this. Just before headers are written, we calculate a total request handling time, and put that into a header in the response, so clients can calculate network latency.

We do it now by hijacking the ResponseWriter in middleware outside the echo.Router.