Returning A Singleton Middleware Handler Breaks Routing

[mmmmmrob]

Middlewares register with chi by providing a func(next http.Handler) http.Handler function that returns a http.Handler that is expected to call the given next argument to pass the request on.

When using .Group(…), chi calls the given middleware function multiple times to create copies of the middleware stack for the group, the godoc says "Group creates a new inline-Mux with a copy of middleware stack."

Returning the same instance of http.Handler for each call results in all routing being broken and all requests being passed to the last group that was registered. The request is passed to a handler within the final group even if the path does not match.

Expected behaviour: The same instance of http.Handler can be returned and the routing will be correct.

Reproduction:

Run the following server and request http://localhost/, http://localhost/foo, and http://localhost/bar.

The expected responses would be Hello World!, Hello Foo!, and Hello Bar! but all responses are Hello Bar!.

package main

import (
	"fmt"
	"net/http"

	"github.com/go-chi/chi/v5"
)

func hello(text string) func(http.ResponseWriter, *http.Request) {
	output := fmt.Sprintf("Hello %s\n", text)
	return func(w http.ResponseWriter, r *http.Request) {
		fmt.Println(output)
		w.Header().Add("Content-Type", "text/plain")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(output))
	}
}

type middleware struct {
	next http.Handler
}

func (m *middleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	m.next.ServeHTTP(w, r)
}

var singleton = middleware{}

func Middleware(next http.Handler) http.Handler {
	singleton.next = next
	return &singleton
}

func main() {

	roothandler := chi.NewRouter()

	roothandler.Group(func(topgroup chi.Router) {
		topgroup.Use(Middleware)

		topgroup.Get("/", hello("World!"))

		topgroup.Group(func(foogroup chi.Router) {
			foogroup.Get("/foo", hello("Foo!"))
		})

		topgroup.Group(func(bargroup chi.Router) {
			bargroup.Get("/bar", hello("Bar!"))
		})
	})

	server := http.Server{
		Handler: roothandler,
	}

	server.ListenAndServe()
}

[ljluestc]

package main


import (
	"fmt"
	"net/http"

	"github.com/go-chi/chi/v5"
)

// hello creates a handler that outputs "Hello <text>"
func hello(text string) func(http.ResponseWriter, *http.Request) {
	output := fmt.Sprintf("Hello %s\n", text)
	return func(w http.ResponseWriter, r *http.Request) {
		fmt.Println(output)
		w.Header().Add("Content-Type", "text/plain")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(output))
	}
}

// middleware is a struct that holds the next handler
type middleware struct {
	next http.Handler
}

// ServeHTTP calls the next handler in the chain
func (m *middleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	m.next.ServeHTTP(w, r)
}

// Middleware creates a new middleware instance for each invocation
func Middleware(next http.Handler) http.Handler {
	return &middleware{next: next}
}

func main() {
	roothandler := chi.NewRouter()

	roothandler.Group(func(topgroup chi.Router) {
		topgroup.Use(Middleware)

		topgroup.Get("/", hello("World!"))

		topgroup.Group(func(foogroup chi.Router) {
			foogroup.Get("/foo", hello("Foo!"))
		})

		topgroup.Group(func(bargroup chi.Router) {
			bargroup.Get("/bar", hello("Bar!"))
		})
	})

	server := http.Server{
		Addr:    ":8080", // Explicitly set port for clarity
		Handler: roothandler,
	}

	fmt.Println("Server listening on :8080")
	if err := server.ListenAndServe(); err != nil {
		fmt.Printf("Server error: %v\n", err)
	}
}

[mmmmmrob]

@ljluestc Thank you for the reply, I should have been clearer in my initial post…

I understand what's happening and how to fix it by returning a new middleware instance each time the func is called, but that is non-obvious, and returning a singleton breaks things in unexpected ways.

topgroup.Use(Middleware) is only passed in one place and it's non-obvious that it will be called multiple times to create copies of the middleware stack for each of the nested groups.

Expected behaviour:

Either that routing works correctly with a singleton, or that some form of error occurs if the same middleware instance is returned for different groups.