Refactor middleware naming

We have a mix of "Middleware" and "Handler" names. Let's standardise on
"Handler" everywhere, as it's more conventional.

Author: kevinmcconnell

internal/compression_guard_middleware.go internal/compression_guard_handler.gointernal/compression_guard_middleware.go renamed to internal/compression_guard_handler.go

@@ -9,7 +9,7 @@ import (
 	"github.com/klauspost/compress/gzhttp"
 )
 
-func NewCompressionGuardMiddleware(next http.Handler) http.Handler {
+func NewCompressionGuardHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Check for user-specific headers in the request
 		if hasUserSpecificRequestHeaders(r) {

…nal/compression_guard_middleware_test.go …ternal/compression_guard_handler_test.gointernal/compression_guard_middleware_test.go renamed to internal/compression_guard_handler_test.go internal/compression_guard_middleware_test.go renamed to internal/compression_guard_handler_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCompressionGuardMiddleware(t *testing.T) {
+func TestCompressionGuardHandler(t *testing.T) {
 	tests := []struct {
 		name           string
 		requestHeaders map[string]string
@@ -85,7 +85,7 @@ func TestCompressionGuardMiddleware(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			handler := NewCompressionGuardMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			handler := NewCompressionGuardHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 				for k, v := range tt.responseHeader {
 					w.Header().Set(k, v)
 				}

internal/handler.go

@@ -26,7 +26,7 @@ func NewHandler(options HandlerOptions) http.Handler {
 	handler := NewProxyHandler(options.targetUrl, options.badGatewayPage, options.forwardHeaders)
 	handler = NewCacheHandler(options.cache, options.maxCacheableResponseBody, handler)
 	handler = NewSendfileHandler(options.xSendfileEnabled, handler)
-	handler = NewRequestStartMiddleware(handler)
+	handler = NewRequestStartHandler(handler)
 
 	if options.gzipCompressionEnabled {
 		var wrapper func(http.Handler) http.HandlerFunc
@@ -54,7 +54,7 @@ func NewHandler(options HandlerOptions) http.Handler {
 		gzipHandler := wrapper(handler)
 
 		if options.gzipCompressionDisableOnAuth {
-			handler = NewCompressionGuardMiddleware(gzipHandler)
+			handler = NewCompressionGuardHandler(gzipHandler)
 		} else {
 			handler = gzipHandler
 		}
@@ -65,7 +65,7 @@ func NewHandler(options HandlerOptions) http.Handler {
 	}
 
 	if options.logRequests {
-		handler = NewLoggingMiddleware(slog.Default(), handler)
+		handler = NewLoggingHandler(slog.Default(), handler)
 	}
 
 	return handler

internal/logging_middleware.go internal/logging_handler.gointernal/logging_middleware.go renamed to internal/logging_handler.go

@@ -9,19 +9,19 @@ import (
 	"time"
 )
 
-type LoggingMiddleware struct {
+type LoggingHandler struct {
 	logger *slog.Logger
 	next   http.Handler
 }
 
-func NewLoggingMiddleware(logger *slog.Logger, next http.Handler) *LoggingMiddleware {
-	return &LoggingMiddleware{
+func NewLoggingHandler(logger *slog.Logger, next http.Handler) *LoggingHandler {
+	return &LoggingHandler{
 		logger: logger,
 		next:   next,
 	}
 }
 
-func (h *LoggingMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (h *LoggingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	writer := newResponseWriter(w)
 
 	started := time.Now()

internal/logging_middleware_test.go internal/logging_handler_test.gointernal/logging_middleware_test.go renamed to internal/logging_handler_test.go

@@ -14,10 +14,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestMiddleware_LoggingMiddleware(t *testing.T) {
+func TestLoggingHandler(t *testing.T) {
 	out := &strings.Builder{}
 	logger := slog.New(slog.NewJSONHandler(out, nil))
-	middleware := NewLoggingMiddleware(logger, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	handler := NewLoggingHandler(logger, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("X-Cache", "miss")
 		w.Header().Set("Content-Type", "text/html")
 		w.WriteHeader(http.StatusCreated)
@@ -29,7 +29,7 @@ func TestMiddleware_LoggingMiddleware(t *testing.T) {
 	req.Header.Set("User-Agent", "Robot/1")
 	req.Header.Set("Content-Type", "application/json")
 
-	middleware.ServeHTTP(httptest.NewRecorder(), req)
+	handler.ServeHTTP(httptest.NewRecorder(), req)
 
 	logline := struct {
 		Path              string `json:"path"`

internal/request_start_middleware.go internal/request_start_handler.gointernal/request_start_middleware.go renamed to internal/request_start_handler.go

@@ -6,7 +6,7 @@ import (
 	"time"
 )
 
-func NewRequestStartMiddleware(next http.Handler) http.Handler {
+func NewRequestStartHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Header.Get("X-Request-Start") == "" {
 			timestamp := time.Now().UnixMilli()

internal/request_start_middleware_test.go internal/request_start_handler_test.gointernal/request_start_middleware_test.go renamed to internal/request_start_handler_test.go

@@ -10,18 +10,18 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestRequestStartMiddleware(t *testing.T) {
+func TestRequestStartHandler(t *testing.T) {
 	var capturedHeader string
 	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		capturedHeader = r.Header.Get("X-Request-Start")
 	})
 
-	middleware := NewRequestStartMiddleware(nextHandler)
+	handler := NewRequestStartHandler(nextHandler)
 
 	before := time.Now().UnixMilli()
 	req := httptest.NewRequest("GET", "/", nil)
 	w := httptest.NewRecorder()
-	middleware.ServeHTTP(w, req)
+	handler.ServeHTTP(w, req)
 	after := time.Now().UnixMilli()
 
 	assert.NotEmpty(t, capturedHeader)
@@ -34,19 +34,19 @@ func TestRequestStartMiddleware(t *testing.T) {
 	assert.LessOrEqual(t, timestamp, after)
 }
 
-func TestRequestStartMiddlewareDoesNotOverwriteExistingHeader(t *testing.T) {
+func TestRequestStartHandlerDoesNotOverwriteExistingHeader(t *testing.T) {
 	existingHeader := "t=1234567890"
 	var capturedHeader string
 	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		capturedHeader = r.Header.Get("X-Request-Start")
 	})
 
-	middleware := NewRequestStartMiddleware(nextHandler)
+	handler := NewRequestStartHandler(nextHandler)
 
 	req := httptest.NewRequest("GET", "/", nil)
 	req.Header.Set("X-Request-Start", existingHeader)
 	w := httptest.NewRecorder()
-	middleware.ServeHTTP(w, req)
+	handler.ServeHTTP(w, req)
 
 	assert.Equal(t, existingHeader, capturedHeader)
 }