Response should implement http.Flusher and http.Hijacker to work with older libraries that do not use http.NewResponseController()

Author: aldas

response.go

@@ -4,8 +4,11 @@
 package echo
 
 import (
+	"bufio"
 	"errors"
+	"fmt"
 	"log/slog"
+	"net"
 	"net/http"
 )
 
@@ -72,6 +75,30 @@ func (r *Response) Write(b []byte) (n int, err error) {
 	return
 }
 
+// Flush implements the http.Flusher interface to allow an HTTP handler to flush
+// buffered data to the client.
+// See [http.Flusher](https://golang.org/pkg/net/http/#Flusher)
+func (r *Response) Flush() {
+	err := http.NewResponseController(r.ResponseWriter).Flush()
+	if err != nil && errors.Is(err, http.ErrNotSupported) {
+		panic(fmt.Errorf("echo: response writer %T does not support flushing (http.Flusher interface)", r.ResponseWriter))
+	}
+}
+
+// Hijack implements the http.Hijacker interface to allow an HTTP handler to
+// take over the connection.
+// This method is relevant to Websocket connection upgrades, proxis, and other advanced use cases.
+// See [http.Hijacker](https://golang.org/pkg/net/http/#Hijacker)
+func (r *Response) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	// newer code should do response hijacking like that
+	// http.NewResponseController(responseWriter).Hijack()
+	//
+	// but there are older libraries that are not aware of `http.NewResponseController` and try to hijack directly
+	// `hj, ok := resp.(http.Hijacker)` <-- which would fail without Response directly implementing Hijack method
+	// so for that purpose we need to implement http.Hijacker interface
+	return http.NewResponseController(r.ResponseWriter).Hijack()
+}
+
 // Unwrap returns the original http.ResponseWriter.
 // ResponseController can be used to access the original http.ResponseWriter.
 // See [https://go.dev/blog/go1.20]

response_test.go

@@ -73,3 +73,45 @@ func TestResponse_Unwrap(t *testing.T) {
 
 	assert.Equal(t, rec, res.Unwrap())
 }
+
+func TestResponse_isHijacker(t *testing.T) {
+	var resp http.ResponseWriter = &Response{}
+
+	_, ok := resp.(http.Hijacker)
+	assert.True(t, ok)
+}
+
+func TestResponse_Flush(t *testing.T) {
+	e := New()
+	rec := httptest.NewRecorder()
+	res := NewResponse(rec, e.Logger)
+
+	res.Write([]byte("test"))
+	res.Flush()
+	assert.True(t, rec.Flushed)
+}
+
+type testResponseWriter struct {
+}
+
+func (w *testResponseWriter) WriteHeader(statusCode int) {
+}
+
+func (w *testResponseWriter) Write([]byte) (int, error) {
+	return 0, nil
+}
+
+func (w *testResponseWriter) Header() http.Header {
+	return nil
+}
+
+func TestResponse_FlushPanics(t *testing.T) {
+	e := New()
+	rw := new(testResponseWriter)
+	res := NewResponse(rw, e.Logger)
+
+	// we test that we behave as before unwrapping flushers - flushing writer that does not support it causes panic
+	assert.PanicsWithError(t, "echo: response writer *echo.testResponseWriter does not support flushing (http.Flusher interface)", func() {
+		res.Flush()
+	})
+}