Add httperr sub package

Author: roeldev

httperr/handler.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2026, Roel Schut. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httperr
+
+import (
+	"log/slog"
+	"net/http"
+
+	"github.com/go-pogo/serv/response"
+)
+
+type ErrHandler interface {
+	HandleError(err error)
+}
+
+type ErrHandlerFunc func(err error)
+
+func (fn ErrHandlerFunc) HandleError(err error) { fn(err) }
+
+func Log(l *slog.Logger) ErrHandlerFunc {
+	return func(err error) {
+		if l == nil {
+			l = slog.Default()
+		}
+		l.Error("handler error", slog.Any("err", err))
+	}
+}
+
+const panicNilNextHandler = "httperr: next handler should not be nil"
+
+// HandleError returns an [http.Handler] which wraps the [Handler] next and
+// handles any returned errors by it using the provided [ErrHandlerFunc].
+func HandleError(next Handler, handleErr ErrHandlerFunc) http.Handler {
+	if next == nil {
+		panic(panicNilNextHandler)
+	}
+	if handleErr == nil {
+		handleErr = func(err error) { panic(err) }
+	}
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := next.ServeHTTPError(w, r); err != nil {
+			handleErr.HandleError(err)
+		}
+	})
+}
+
+func WriteJSONError(next Handler) http.Handler {
+	return http.HandlerFunc(func(wri http.ResponseWriter, req *http.Request) {
+		if err := next.ServeHTTPError(wri, req); err != nil {
+			_ = response.WriteJSONError(wri, err)
+		}
+	})
+}

httperr/handler_test.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2026, Roel Schut. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httperr
+
+import (
+	"log"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/go-pogo/errors"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHandleError(t *testing.T) {
+	const wantErr errors.Msg = "some error"
+	handler := HandlerFunc(func(wri http.ResponseWriter, req *http.Request) error {
+		return wantErr
+	})
+
+	t.Run("with nil handler", func(t *testing.T) {
+		var out strings.Builder
+
+		srv := httptest.NewServer(HandleError(handler, nil))
+		srv.Config.ErrorLog = log.New(&out, "", 0)
+		_, _ = srv.Client().Get(srv.URL)
+
+		// close server before getting the output string to prevent a race condition
+		srv.Close()
+
+		have := out.String()
+		assert.Contains(t, have, "http: panic serving")
+		assert.Contains(t, have, wantErr.String())
+	})
+
+	t.Run("with slog handler", func(t *testing.T) {
+		var out strings.Builder
+		logger := slog.New(slog.NewTextHandler(&out, &slog.HandlerOptions{}))
+
+		srv := httptest.NewServer(HandleError(handler, Log(logger)))
+		_, _ = srv.Client().Get(srv.URL)
+		srv.Close()
+
+		have := out.String()
+		assert.Contains(t, have, `level=ERROR`)
+		assert.Contains(t, have, `msg="handler error"`)
+		assert.Contains(t, have, `err="some error"`)
+	})
+
+	t.Run("with err handler", func(t *testing.T) {
+		var have error
+		h := func(err error) { have = err }
+
+		srv := httptest.NewServer(HandleError(handler, h))
+		_, _ = srv.Client().Get(srv.URL)
+		srv.Close()
+
+		assert.Equal(t, wantErr, have)
+	})
+
+	t.Run("panic on nil handler", func(t *testing.T) {
+		assert.PanicsWithValue(t, panicNilNextHandler, func() {
+			HandleError(nil, nil)
+		})
+	})
+}

httperr/httperr.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2026, Roel Schut. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httperr
+
+import "net/http"
+
+// A Handler responds to an HTTP request the same way an [http.Handler] does
+// with the difference of it being able to return an error.
+type Handler interface {
+	ServeHTTPError(http.ResponseWriter, *http.Request) error
+}
+
+// The HandlerFunc type is an adapter to allow the use of ordinary functions as
+// HTTP handlers, the same way as [http.HandlerFunc]. The difference is that
+// HandlerFunc may return an error.
+type HandlerFunc func(http.ResponseWriter, *http.Request) error
+
+// ServeHTTPError calls f(w, r).
+func (f HandlerFunc) ServeHTTPError(w http.ResponseWriter, r *http.Request) error {
+	return f(w, r)
+}

httperr/wrap.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2026, Roel Schut. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httperr
+
+import (
+	"net/http"
+
+	"github.com/go-pogo/errors"
+	"github.com/go-pogo/serv/middleware"
+)
+
+// Wrap wraps the [http.HandlerFunc] next with middleware that catches any
+// possible panics and returns them as the error result of the returned
+// [Handler].
+func Wrap(next http.HandlerFunc) Handler {
+	if next == nil {
+		panic(panicNilNextHandler)
+	}
+	return HandlerFunc(func(wri http.ResponseWriter, req *http.Request) (err error) {
+		defer errors.CatchPanic(&err)
+		next.ServeHTTP(wri, req)
+		return
+	})
+}
+
+// WrapWith wraps the [Handler] next with an [http.Handler] which is passed to
+// the wrap function, which further wraps the next handlers. Any error returned
+// by next is kept and eventually returned by the resulting [Handler].
+func WrapWith(next Handler, wrap middleware.Wrapper) Handler {
+	if next == nil {
+		panic(panicNilNextHandler)
+	}
+	if wrap == nil {
+		return next
+	}
+	return &wrapper{next: next, wrap: wrap}
+}
+
+var (
+	_ http.Handler = (*wrapper)(nil)
+	_ Handler      = (*wrapper)(nil)
+)
+
+type wrapper struct {
+	next Handler
+	wrap middleware.Wrapper
+}
+
+func (b *wrapper) ServeHTTP(wri http.ResponseWriter, req *http.Request) {
+	b.wrap(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := b.next.ServeHTTPError(w, r); err != nil {
+			panic(err) // http.Server catches panics and handles the error
+		}
+	})).ServeHTTP(wri, req)
+}
+
+func (b *wrapper) ServeHTTPError(wri http.ResponseWriter, req *http.Request) error {
+	var err error
+	b.wrap(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		err = b.next.ServeHTTPError(w, r)
+	})).ServeHTTP(wri, req)
+	return err
+}

httperr/wrap_test.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2026, Roel Schut. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httperr
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/go-pogo/errors"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWrap(t *testing.T) {
+	t.Run("panic on nil handler", func(t *testing.T) {
+		assert.PanicsWithValue(t, panicNilNextHandler, func() {
+			Wrap(nil)
+		})
+	})
+
+	t.Run("error from panic", func(t *testing.T) {
+		const wantErr errors.Msg = "some panic"
+		haveErr := Wrap(func(_ http.ResponseWriter, _ *http.Request) {
+			panic(wantErr)
+		}).ServeHTTPError(nil, nil)
+
+		// todo: in toekomst PanicError.Value testen
+		assert.Contains(t, haveErr.Error(), wantErr.String())
+	})
+}