midgard

README

midgard

midgard is a collection of Golang http middlewares and helper functionality to use them more elegantly.

Usage

midgard defines a type Middleware that is just a convenience to not always having to write the full definition of what is commonly known as http middlware.

type Middleware func(http.Handler) http.Handler

To ease the pain of stacking different middlwares midgard offsers two functions to facilitate it. StackMiddlewareHandler stacks the given slice of middlewares on top of each other and finally calls the given handler. It generates a new handler that has all the given middlewares prepended:

finalHandler := midgard.StackMiddlewareHandler(
    []midgard.Middleware{
        util.Must(correlation.New()),
        util.Must(access_log.New(
            access_log.WithLogLevel(slog.LevelDebug))),
        util.Must(cors.New(
            cors.WithHeaders(cors.MinimumAllowedHeaders()),
            cors.WithMethods([]string{http.MethodGet}),
            cors.WithOrigins([]string{"*"}))),
        util.Must(method_filter.New(
            method_filter.WithMethods([]string{http.MethodGet}))),
        },
    http.HandlerFunc(HelloHandler),
)

StackMiddleware does basically the same, but without having given a handler. It generates a new middleware:

newMiddleware:= midgard.StackMiddleware(
    []midgard.Middleware{
        util.Must(correlation.New()),
        util.Must(access_log.New(
            access_log.WithLogLevel(slog.LevelDebug))),
        util.Must(cors.New(
            cors.WithHeaders(cors.MinimumAllowedHeaders()),
            cors.WithMethods([]string{http.MethodGet}),
            cors.WithOrigins([]string{"*"}))),
        util.Must(method_filter.New(
            method_filter.WithMethods([]string{http.MethodGet}))),
    })

The native solution for this would be to nest the calls to the middleware like this:

finalHandler := util.Must(correlation.New())(
                    util.Must(access_log.New(
                        access_log.WithLogLevel(slog.LevelDebug)))(
                        util.Must(cors.New(
                            cors.WithHeaders(cors.MinimumAllowedHeaders()),
                            cors.WithMethods([]string{http.MethodGet}),
                            cors.WithOrigins([]string{"*"})))(
                            util.Must(method_filter.New(
                                method_filter.WithMethods([]string{http.MethodGet}))))))

As you see, depending on the number of middlewares, that can be quite confusing. Further one cannot easily dynamially add or remove middlewares.

Documentation

Index

• func StackMiddleware(mw []defs.Middleware) defs.Middleware
• func StackMiddlewareHandler(mw []defs.Middleware, final http.Handler) http.Handler

Functions

func StackMiddleware

func StackMiddleware(mw []defs.Middleware) defs.Middleware

StackMiddleware stacks the given middleware slice to generate a single combined middleware. The middleware at index 0 is the outermost, going step by step to the innermost, e. g. mw[0](mw[1](mw[2]())).

func StackMiddlewareHandler

func StackMiddlewareHandler(mw []defs.Middleware, final http.Handler) http.Handler

StackMiddlewareHandler calls StackMiddleware on mw and applies it to the handler final.