Best way to pass parameter from middleware to handler

[chr1shung]

I saw this comment #782 (comment) said Bind cannot be read again.
I have a use case which the middleware will read the request body and do the authorization, after that the api handler will proceed to do the following work.
Below is an example how I'm doing this currently using echo.Context:

type Request struct {
  id int `json:"id"`
  payload string `json:"payload"`
}

func main() {
	e := echo.New()
        e.POST("/api", Authz(Handler))
	e.Logger.Fatal(e.Start(":1323"))
}


func Authz(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		var req Request
		err := c.Bind(&req)
		if err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error())
		}
		// perform the authorization

		c.Set("request", req)
		return next(c)
	}
}

func Handler(c echo.Context) error {
	req := c.Get("request").(Request)

        // perform the actual request

	return nil
}

I'm wondering if there's any better way/convention to handle this scenario ?
thanks for the help !

[aldas]

When it comes to binding request body I think handlers are more appropriate place for it. c.Set and c.Get are meant to pass data between middlewares and to handler.

but if all your handlers require same middleware and you want to use like you do (when adding the route) - you could just design different handler signature. so instead of Handler(c echo.Context) error just have Handler(c echo.Context, req Request) error and your Authz takes that as an parameter

package main

import (
	"github.com/labstack/echo/v4"
	"net/http"
)

type Request struct {
	ID      int    `json:"id"`
	Payload string `json:"payload"`
}

func main() {
	e := echo.New()
	e.POST("/api", Authz(Handler))
	e.Logger.Fatal(e.Start(":1323"))
}

func Authz(next OurHandler) echo.HandlerFunc {
	return func(c echo.Context) error {
		var req Request
		err := c.Bind(&req)
		if err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error())
		}
		// perform the authorization

		return next(c, req)
	}
}

type OurHandler func(c echo.Context, req Request) error

func Handler(c echo.Context, req Request) error {
	// perform the actual request
	return nil
}

[chr1shung]

@aldas thanks that's brilliant.
I'm wondering if I have many other handlers and each of them depends on different request in the future, how do I implement them in similar way besides using type OurHandler func(c echo.Context, req any) error and do the type casting in each handler ?

[aldas]

I think I have seen people using generics for situations like that. I can give good example but I believe if you google "generic http handler" probably gives you something to start with

p.s. if you have some solution - paste it here.

[chr1shung]

I'm using something like this and works pretty well:

package main

import (
	"github.com/labstack/echo/v4"
	"net/http"
)

type Request struct {
	ID      int    `json:"id"`
	Payload string `json:"payload"`
}

func main() {
	e := echo.New()
	e.POST("/api", Authz(Handler))
	e.Logger.Fatal(e.Start(":1323"))
}

func Authz(next OurHandler[Request]) echo.HandlerFunc {
	return func(c echo.Context) error {
		var req Request
		err := c.Bind(&req)
		if err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error())
		}
		// perform the authorization

		return next(c, req)
	}
}

type OurHandler[In any] func(echo.Context, In) error

func Handler(c echo.Context, req Request) error {
	// perform the actual request
	return nil
}