How can I take advantage of url matching/parsing in middleware?

[squee1945]

Imagine that I have an application router that handles URLs like this:

    router := chi.NewRouter()
    router.Get("/", IndexHandler)
    router.Get("/articles/{id}", ArticleHandler)
    http.ListenAndServe(":3000", router)

Now imagine that I want to add a middleware that will do some work before those URLs, but that the work it does is dependent on the url itself. For example, imagine that the middleware needs the article ID to check for authorization. Further, assume that the above code cannot be adjusted - other than to inject a middleware.

I'm imagining a middleware that duplicates the URLs of interest (yes, the duplication is actually desirable in this case), does the work, then on success, passes control to the next middleware (which is the application router above).

So you might have middleware code that looks something like:

func AuthMiddleware(next http.Handler) http.Handler {
    router := chi.NewRouter()
    router.Get("/", BasicAuthCheck)
    router.Get("/articles/{id}", ArticleAuthCheck)

    fn := func(w http.ResponseWriter, r *http.Request) {
        // Match() doesn't return the handler for the matched path, but imagine it did.
        handler := router.Match(chi.RouteContext(r.Context()), r.Method, r.URL.Path)
        if handler == nil {
            w.WriteHeader(401)
            return
        }

        // Now it's a bit tricky - I want to call the auth "handler", which is sandwiched into an http.HandlerFunc, so it's a bit weird.
        // Basically I'd like to attach some callable function to the matched path, so I can take advantage of the matching
        // and the regex captures.
        // TODO: somehow call the auth "handler". Below is just fake, awkward code that isn't even possible (e.g., I can't 
        // access `w.status` to check if a non-200 status was set.)
        handler(w, r)
        if w.status != 200 {
            w.WriteHeader(w.status)
            return
        }

        // And if the handler succeeds, I just want to let the request continue, 
        // which will arrive eventually at the IndexHandler, ArticleHandler
        next.ServeHTTP(w, r)
    }
    return http.HandlerFn(fn)
}

I guess I'm trying to figure out how to add a url-specific middleware (like Chi's With()), but set it up away from the main application router, e.g., set it up in some other middleware that operates before the main application router.

Thanks for any ideas!

[mfridman]

Given the modular nature of chi there are a few ways to do this. Some ideas..

Create an articles package and have it return a chi.Router. When composing the router can do something like this:

r.Mount("/articles", articles.Routes()).

A chi.Router can be used anywhere that takes an http.Handler. Here's a full example
*note the chiCtx values between this example and the other one are slightly different.

package main

import (
	"fmt"
	"log"
	"net/http"

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

func main() {
	r := chi.NewRouter()
	r.Mount("/articles", newArticleRouter())
	log.Fatal(http.ListenAndServe("localhost:9090", r))
}

func newArticleRouter() chi.Router {
	r := chi.NewRouter()
	r.Use(articleAuthCheck)
	r.Get("/{id}", articleHandler)
	return r
}

func articleAuthCheck(next http.Handler) http.Handler {
	fn := func(w http.ResponseWriter, r *http.Request) {
		chiCtx := chi.RouteContext(r.Context())
		fmt.Println(chiCtx.RouteMethod)      // GET
		fmt.Println(chiCtx.RoutePath)        // /987
		fmt.Println(chiCtx.RoutePatterns)    // [/articles/*]
		fmt.Println(chiCtx.URLParams.Values) // []
		// All information available in this middleware to do auth checks.
		next.ServeHTTP(w, r)
	}
	return http.HandlerFunc(fn)
}

func articleHandler(w http.ResponseWriter, r *http.Request) {
	articleID := chi.URLParam(r, "id")
	w.Write([]byte("article_" + articleID))
}

Another option (even in combination with the above), would be to group routes together inline with with specific middleware for that group, here's a full working example:

package main

import (
	"fmt"
	"log"
	"net/http"

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

func main() {
	r := chi.NewRouter()
	r.Group(func(r chi.Router) {
		r.Use(articleAuthCheck)
		r.Get("/articles/{id}", articleHandler)
	})
	log.Fatal(http.ListenAndServe("localhost:9090", r))
}

func articleAuthCheck(next http.Handler) http.Handler {
	fn := func(w http.ResponseWriter, r *http.Request) {
		chiCtx := chi.RouteContext(r.Context())
		fmt.Println(chiCtx.RouteMethod)      // GET
		fmt.Println(chiCtx.RoutePath)        //
		fmt.Println(chiCtx.RoutePatterns)    // [/articles/{id}]
		fmt.Println(chiCtx.URLParams.Values) // [123]
		// All information available in this middleware to do auth checks.
		next.ServeHTTP(w, r)
	}
	return http.HandlerFunc(fn)
}

func articleHandler(w http.ResponseWriter, r *http.Request) {
	articleID := chi.URLParam(r, "id")
	w.Write([]byte("article_" + articleID))
}

There's probably other ways, but figured this might be a good start?

[squee1945]

Thanks for the detailed response!

I was hoping to do everything in a single middleware that wrapped everything - at the expense of walking the url tree twice, once in my middleware and again in the main router. Imagine that I'm unable to adjust the main router code at all, other than a r.Use(MyMiddleware) at the start, so the main router code might look something like:

func Listen(middlewares ...func(http.Handler) http.Handler) error {
    r := chi.NewRouter()
    for _, m := range middlewares {
        r.Use(m)
    }

    r.Get("/", IndexHandler)
    r.Get("/articles/{id}", ArticleHandler)
    ...
    return http.ListenAndServe(":3000", r)
}

I think I'm trying to utilize the path matching/capture parts of Chi only, but I need to associate some kind of function, probably with a middleware signature (i.e., a way to pass control next on success) to each path/method to process the url-specific logic.

It may not possible; indeed I'm even having a difficult time describing it.