Getting EOF for a valid json when doing a gin.Context.ShouldBind()

I'm getting a weird error which previously didn't appear for my code, which might be caused by my JWT implementation that I didn't test thoroughly tbh. So I have this current code:

ginGine.POST("/edge_device_info", func(ctx *gin.Context) {
	reqMap := helpers.GetJSONFromReqBody(ctx.Request.Body, ctx)
	accessToken := fmt.Sprintf("%v", reqMap["access_token"])

	tokenValid, jwtErr := srvHelpers.ValidateJWTToken(accessToken)

	if jwtErr != nil || !tokenValid {
		fmt.Println("invalid token")
		ctx.JSON(http.StatusBadRequest, gin.H{
			"error0": jwtErr.Error(),
		})
		return
	}
	
	// reqBody, err := json.Marshal(reqMap)
	// if err != nil {
	// 	ctx.JSON(http.StatusBadRequest, gin.H{
	// 		"error10": err.Error(),
	// 	})
	// 	return
	// }

	var edge_device_info models.EdgeDeviceInfo

	// err = json.Unmarshal(reqBody, &edge_device_info)
	err := ctx.ShouldBind(&edge_device_info)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{
			"error1": err.Error(),
		})
		return
	}

	// more code
})

This API endpoint gets sent this similar looking json:

{
    "name": "Some text",
    "description": "Another bunch of text",
    "access_token": "SOME_JWT_TOKEN"
}

Now, this json looks fine, right? But ShouldBind() doesn't like that and would return an EOF. If you check the top part of my code, I'm converting the received JSON body to a map then use the access_token, which is a JWT token, to validate the user's access. I'm not quite sure if that process somehow made that issue, and that's what I wanted to know. That's the reason I made this question. I already found the workaround, which is the commented code above. Which is quite weird as creating the map in the first place means that the request body's JSON was valid.

As correctly pointed out by @Zeke Lu, you should use the method ShouldBindBodyWith on the gin.Context struct. I've written a small example for you to use.

package main

import (
	"fmt"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
)

type Todo struct {
	Description string `json:"description" binding:"required"`
}

func Todos(c *gin.Context) {
	// read the body the first time
	var todo Todo
	if err := c.ShouldBindBodyWith(&todo, binding.JSON); err != nil {
		c.JSON(http.StatusBadRequest, err)
		return
	}
	fmt.Println("first time:", todo)

	// read the body again
	var todoSecondTime Todo
	if err := c.ShouldBindBodyWith(&todoSecondTime, binding.JSON); err != nil {
		c.JSON(http.StatusBadRequest, err)
		return
	}
	fmt.Println("second time:", todoSecondTime)
}

func main() {
	gin.SetMode(gin.DebugMode)
	r := gin.Default()

	r.POST("/todos", Todos)

	r.Run(":8080")
}

The code is pretty simple but it's purpose is to just provide a valuable example. If you're going to read the body more than once, like in your scenario, you should rely on this method as it does a copy of the request payload into the context. Thanks to this, the subsequent calls will use that body stream for binding it again.
> Please note that, if you're going to read the body only once, you should rely on the ShouldBindWith method due to performance reasons.

Let me know if this example clarifies your doubts, thanks!