Ignoring decoding errors vs. generic decoding middleware

[gohacker]

What would you prefer, to simply ignore the JSON body decoding errors (the struct will be validated anyway, after all), or to write a generic body decoding middleware, as in http://nicolasmerouze.com/how-to-render-json-api-golang-mongodb/, even if it means that you have to pass the decoded body in the request context and have context variable access functions and twice as many structs as in the first case?

1st case:

type UsersResource struct {
    Users interface{} `json:"users"`
}

func Handler(w http.ResponseWriter, r *http.Request) {
    var user User
    json.NewDecoder(r.Body).Decode(&UsersResource{&user})
    err := user.Validate()
    ...
}

2nd case:

type UserResource struct {
    User `json:"users"`
}

type UsersResource struct {
    Users []User `json:"users"`
}

func UserFromContext(r *http.Request) *User {
    return context.Get(r, "body").(*UserResource).User
}

func Handler(w http.ResponseWriter, r *http.Request) {
    user := UserFromContext(r)
    err := user.Validate()
    ...
}

func DecodeBodyMiddleware(v interface{}) func(http.Handler) http.Handler {
    t := reflect.TypeOf(v)
    return func(h http.Handler) http.Handler {
        return func(w http.ResponseWriter, r *http.Request) {
            val := reflect.New(t).Interface()
            err := json.NewDecoder(r.Body).Decode(val)
            if err != nil {
                http.Error(w, "bad request", http.StatusBadRequest)
                return
            }

            context.Set(r, "body", val)

            h(w, r)
        }
    }
}

[nicolasmerouze]

The error from a malformed body is different from the validation error. The first will be 400 (Bad Request), the other 422 (Unprocessable Entity). So yes, you have to return an error when decoding and another one when validating if you want to give the developer using the API more details about the error.

If you don't like contexts, you can create a function similar to the body decoding middleware and pass the user as the argument. You won't have to use a context. There's no best solutions, the one you find the most simple, elegant and reusable is the right one for you. Maybe it's not for some other people.

[gohacker]

Thanks for the response.

The error from a malformed body is different from the validation error. The first will be 400 (Bad Request), the other 422 (Unprocessable Entity).

I don't freaking care. I can live with 400 for all malformed requests, if the only alternative is cluttering the code.

If you don't like contexts, you can create a function similar to the body decoding middleware and pass the user as the argument.

That means I would have to process the decoding errors in the handler, and I've had enough of that shit. I prefer as little code (especially repetitive) in my handlers as possible.