"binding element must be a struct" introduced with path params binding #1356

andreiavrammsd · 2019-06-27T08:58:22Z

Issue Description

This is simillar to #988 and introduced by 858270f in a specific situation: taking the address of your struct twice and sending it to bind.

u := &user{}
c.Bind(&u)

Because of the newly introduced params binding, when the struct's type is checked, it fails here:

func (b *DefaultBinder) bindData(ptr interface{}, data map[string][]string, tag string) error {
	typ := reflect.TypeOf(ptr).Elem()
	val := reflect.ValueOf(ptr).Elem()

	if typ.Kind() != reflect.Struct {
		return errors.New("binding element must be a struct")
	}

Before the params binding was introduced, bindData was not called for POST/PUT/PATCH, because for these methods you directly decode the body into the given struct.

And a mention: If you have id both as path param and json property in the request body, the value from the body will overwrite the one from the path. This could lead to confusion and bugs in projects.

Checklist

Dependencies installed
No typos
Searched existing issues and docs

Expected behaviour

If this is known and planned for next major version, than it's OK, else compatibility should not be broken.

Actual behaviour

See Expected behaviour

Steps to reproduce

Take the address of the struct sent at bind twice and make a request to a server (see Working code to debug).

curl -X PUT -H "Content-Type: application/json" -d '{"name":"John"}' localhost:8811/users/1

Working code to debug

package main

import (
	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
	"github.com/labstack/gommon/log"
)

type user struct {
	ID int `json:"id" param:"id"`
	Name string `json:"name"`
}

func main() {
	s := echo.New()
	s.Use(middleware.Logger())

	s.PUT("/users/:id", func(c echo.Context) error {
		u := &user{}
		if err := c.Bind(&u); err != nil {
			log.Fatal(err)
		}
		log.Print(u)
		return nil
	})

	s.Start(":8811")
}

Version/commit

858270f

The text was updated successfully, but these errors were encountered:

andreiavrammsd · 2019-06-28T11:18:14Z

Also, binding to slices is returning the same error.

var items []uuid.UUID
c.Bind(&items)

xXLokerXx · 2019-07-08T21:35:07Z

For me this causes to all my inner structures in the field id change to that value and this really made a mess in my projects because this updates all inner structures to zero values (i'm working with gorm and i'm using the save function)

example:

package main

import (
	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
	"github.com/labstack/gommon/log"
)

type user struct {
	ID int `json:"id" param:"id"`
	Name string `json:"name"`
	BranchID uint
	Branch Branch
}

type branch struct {
	ID int
	Name string
}

func main() {
	s := echo.New()
	s.Use(middleware.Logger())

	s.PUT("/users/:id", func(c echo.Context) error {
		u := &user{}
		if err := c.Bind(&u); err != nil {
			log.Fatal(err)
		}
		log.Print(u)
		return nil
	})

	s.Start(":7070")
}

This set the ID in branch relation equals to the ID of user

xXLokerXx · 2019-07-08T21:37:33Z

To me, as a quick fix, just change the name of the parameter to pk insted of id.

I hope this will fix in a couple of days this will helpfull for me.

radaiming · 2019-09-02T10:32:27Z

Also, binding to slices is returning the same error.
var items []uuid.UUID
c.Bind(&items)

Breakage on existing feature really hurts, if couldn't be fixed quickly, maybe a temporary revert and a new version is a good idea?

cdukes · 2019-10-10T14:45:15Z

+1 On this issue. This is a bug that breaks existing functionality and has been an issue since early August. A patch release would be appreciated, so that I don't have to pin at v4.1.6 indefinitely.

Thanks!

ryanking8215 · 2019-11-12T06:13:20Z

This bug exists in 4.1.11 which is the latest release.
And it really stops the general restful api usage, i.e.

package main

import (
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
    "github.com/labstack/gommon/log"
)

func main() {
    s := echo.New()
    s.Use(middleware.Logger())

    s.PUT("/users/:id", func(c echo.Context) error {
        var data interface{}
        if err := c.Bind(&data); err != nil {
            log.Fatal(err)
        }
        log.Print(data)
        return nil
    })

    s.Start(":8811")
}

request:

curl -X PUT -H "Content-Type: application/json" -d '{"name":"John"}' localhost:8811/users/1

I have read the Bind source code.

// Bind implements the `Binder#Bind` function.
func (b *DefaultBinder) Bind(i interface{}, c Context) (err error) {
        req := c.Request()

        names := c.ParamNames()
        values := c.ParamValues()
        params := map[string][]string{}
        for i, name := range names {
                params[name] = []string{values[i]}
        }
        if err := b.bindData(i, params, "param"); err != nil {
                return NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
        }
        if err = b.bindData(i, c.QueryParams(), "query"); err != nil {
                return NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
        }
        if req.ContentLength == 0 {
                return
        }
        ctype := req.Header.Get(HeaderContentType)
        switch {
        case strings.HasPrefix(ctype, MIMEApplicationJSON):
                if err = json.NewDecoder(req.Body).Decode(i); err != nil {
                        if ute, ok := err.(*json.UnmarshalTypeError); ok {
                                return NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unmarshal type error: expected=%v, got=%v, field=%v, offset=%v", ute.Type, ute.Value, ute.Field, ute.Offset)).SetInternal(err)
                        } else if se, ok := err.(*json.SyntaxError); ok {
                                return NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Syntax error: offset=%v, error=%v", se.Offset, se.Error())).SetInternal(err)
                        }
                        return NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
                }    
         ....

if the request has url param and content both, it must be got error because it binds param first.

andreiavrammsd · 2019-11-12T06:49:49Z

@vishr, param binding is a feature that I wanted, but I think it's better if it gets reverted to fix breaking change it introduced. And then planned again for another release.

ryanking8215 · 2019-11-12T08:19:40Z

Is it possible that add a flag to enable or disable param binding feature and disable by default?

EndlessCheng · 2020-01-10T06:35:14Z

I did some tricks to temporary solve the problem by adding c.SetParamNames() before bind.

…o#1356

bxcodec · 2020-03-03T12:46:11Z

Any updates on this? I see that @vishr is assigned on this issue?

stale · 2020-05-02T13:21:27Z

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

cdukes · 2020-05-02T13:27:23Z

Please don't close this! I'm stuck back at version 4.1.6, which was the last release without this bug.

Do not throw an error when binding to a slice, if binding occurs on path- or query-parameters => data is very likely to be found in the body, which will be bound later Should fix labstack#1356, labstack#1448, labstack#1495 (second case), labstack#1565

arigon · 2020-06-02T13:44:47Z

I did some tricks to temporary solve the problem by adding c.SetParamNames() before bind.

This workaround is causing interesting problems! If the c.bind() afterwards fails, other routes using params will suddenly fail with "Not found". Only restarting the echo service resolves this.

I am now using ioutil.ReadAll(c.Request().Body) and Unmarshal it later into the struct.

leefernandes · 2020-06-03T22:49:07Z

Composable Bind implementations would be nice, in the meantime, roll your own Binder I think.

I did not want Bind to involve query or path params.

package util

import (
	"encoding"
	"encoding/json"
	"encoding/xml"
	"errors"
	"fmt"
	"net/http"
	"reflect"
	"strconv"
	"strings"

	"github.com/labstack/echo/v4"
)

type (
	// Binder is the interface that wraps the Bind method.
	Binder interface {
		Bind(i interface{}, c echo.Context) error
	}

	// DefaultBinder is the default implementation of the Binder interface.
	DefaultBinder struct{}

	// BindUnmarshaler is the interface used to wrap the UnmarshalParam method.
	// Types that don't implement this, but do implement encoding.TextUnmarshaler
	// will use that interface instead.
	BindUnmarshaler interface {
		// UnmarshalParam decodes and assigns a value from an form or query param.
		UnmarshalParam(param string) error
	}
)

// Bind implements the `Binder#Bind` function.
func (b *DefaultBinder) Bind(i interface{}, c echo.Context) (err error) {
	req := c.Request()

	ctype := req.Header.Get(echo.HeaderContentType)
	switch {
	case strings.HasPrefix(ctype, echo.MIMEApplicationJSON):
		if err = json.NewDecoder(req.Body).Decode(i); err != nil {
			if ute, ok := err.(*json.UnmarshalTypeError); ok {
				return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unmarshal type error: expected=%v, got=%v, field=%v, offset=%v", ute.Type, ute.Value, ute.Field, ute.Offset)).SetInternal(err)
			} else if se, ok := err.(*json.SyntaxError); ok {
				return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Syntax error: offset=%v, error=%v", se.Offset, se.Error())).SetInternal(err)
			}
			return echo.NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
		}
	case strings.HasPrefix(ctype, echo.MIMEApplicationXML), strings.HasPrefix(ctype, echo.MIMETextXML):
		if err = xml.NewDecoder(req.Body).Decode(i); err != nil {
			if ute, ok := err.(*xml.UnsupportedTypeError); ok {
				return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unsupported type error: type=%v, error=%v", ute.Type, ute.Error())).SetInternal(err)
			} else if se, ok := err.(*xml.SyntaxError); ok {
				return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Syntax error: line=%v, error=%v", se.Line, se.Error())).SetInternal(err)
			}
			return echo.NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
		}
	case strings.HasPrefix(ctype, echo.MIMEApplicationForm), strings.HasPrefix(ctype, echo.MIMEMultipartForm):
		params, err := c.FormParams()
		if err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
		}
		if err = b.bindData(i, params, "form"); err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
		}
	default:
		return echo.ErrUnsupportedMediaType
	}
	return
}

func (b *DefaultBinder) bindData(ptr interface{}, data map[string][]string, tag string) error {
	if ptr == nil || len(data) == 0 {
		return nil
	}
	typ := reflect.TypeOf(ptr).Elem()
	val := reflect.ValueOf(ptr).Elem()

	// Map
	if typ.Kind() == reflect.Map {
		for k, v := range data {
			val.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(v[0]))
		}
		return nil
	}

	// !struct
	if typ.Kind() != reflect.Struct {
		return errors.New("binding element must be a struct")
	}

	for i := 0; i < typ.NumField(); i++ {
		typeField := typ.Field(i)
		structField := val.Field(i)
		if !structField.CanSet() {
			continue
		}
		structFieldKind := structField.Kind()
		inputFieldName := typeField.Tag.Get(tag)

		if inputFieldName == "" {
			inputFieldName = typeField.Name
			// If tag is nil, we inspect if the field is a struct.
			if _, ok := structField.Addr().Interface().(BindUnmarshaler); !ok && structFieldKind == reflect.Struct {
				if err := b.bindData(structField.Addr().Interface(), data, tag); err != nil {
					return err
				}
				continue
			}
		}

		inputValue, exists := data[inputFieldName]
		if !exists {
			// Go json.Unmarshal supports case insensitive binding.  However the
			// url params are bound case sensitive which is inconsistent.  To
			// fix this we must check all of the map values in a
			// case-insensitive search.
			for k, v := range data {
				if strings.EqualFold(k, inputFieldName) {
					inputValue = v
					exists = true
					break
				}
			}
		}

		if !exists {
			continue
		}

		// Call this first, in case we're dealing with an alias to an array type
		if ok, err := unmarshalField(typeField.Type.Kind(), inputValue[0], structField); ok {
			if err != nil {
				return err
			}
			continue
		}

		numElems := len(inputValue)
		if structFieldKind == reflect.Slice && numElems > 0 {
			sliceOf := structField.Type().Elem().Kind()
			slice := reflect.MakeSlice(structField.Type(), numElems, numElems)
			for j := 0; j < numElems; j++ {
				if err := setWithProperType(sliceOf, inputValue[j], slice.Index(j)); err != nil {
					return err
				}
			}
			val.Field(i).Set(slice)
		} else if err := setWithProperType(typeField.Type.Kind(), inputValue[0], structField); err != nil {
			return err

		}
	}
	return nil
}

func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value) error {
	// But also call it here, in case we're dealing with an array of BindUnmarshalers
	if ok, err := unmarshalField(valueKind, val, structField); ok {
		return err
	}

	switch valueKind {
	case reflect.Ptr:
		return setWithProperType(structField.Elem().Kind(), val, structField.Elem())
	case reflect.Int:
		return setIntField(val, 0, structField)
	case reflect.Int8:
		return setIntField(val, 8, structField)
	case reflect.Int16:
		return setIntField(val, 16, structField)
	case reflect.Int32:
		return setIntField(val, 32, structField)
	case reflect.Int64:
		return setIntField(val, 64, structField)
	case reflect.Uint:
		return setUintField(val, 0, structField)
	case reflect.Uint8:
		return setUintField(val, 8, structField)
	case reflect.Uint16:
		return setUintField(val, 16, structField)
	case reflect.Uint32:
		return setUintField(val, 32, structField)
	case reflect.Uint64:
		return setUintField(val, 64, structField)
	case reflect.Bool:
		return setBoolField(val, structField)
	case reflect.Float32:
		return setFloatField(val, 32, structField)
	case reflect.Float64:
		return setFloatField(val, 64, structField)
	case reflect.String:
		structField.SetString(val)
	default:
		return errors.New("unknown type")
	}
	return nil
}

func unmarshalField(valueKind reflect.Kind, val string, field reflect.Value) (bool, error) {
	switch valueKind {
	case reflect.Ptr:
		return unmarshalFieldPtr(val, field)
	default:
		return unmarshalFieldNonPtr(val, field)
	}
}

func unmarshalFieldNonPtr(value string, field reflect.Value) (bool, error) {
	fieldIValue := field.Addr().Interface()
	if unmarshaler, ok := fieldIValue.(BindUnmarshaler); ok {
		return true, unmarshaler.UnmarshalParam(value)
	}
	if unmarshaler, ok := fieldIValue.(encoding.TextUnmarshaler); ok {
		return true, unmarshaler.UnmarshalText([]byte(value))
	}

	return false, nil
}

func unmarshalFieldPtr(value string, field reflect.Value) (bool, error) {
	if field.IsNil() {
		// Initialize the pointer to a nil value
		field.Set(reflect.New(field.Type().Elem()))
	}
	return unmarshalFieldNonPtr(value, field.Elem())
}

func setIntField(value string, bitSize int, field reflect.Value) error {
	if value == "" {
		value = "0"
	}
	intVal, err := strconv.ParseInt(value, 10, bitSize)
	if err == nil {
		field.SetInt(intVal)
	}
	return err
}

func setUintField(value string, bitSize int, field reflect.Value) error {
	if value == "" {
		value = "0"
	}
	uintVal, err := strconv.ParseUint(value, 10, bitSize)
	if err == nil {
		field.SetUint(uintVal)
	}
	return err
}

func setBoolField(value string, field reflect.Value) error {
	if value == "" {
		value = "false"
	}
	boolVal, err := strconv.ParseBool(value)
	if err == nil {
		field.SetBool(boolVal)
	}
	return err
}

func setFloatField(value string, bitSize int, field reflect.Value) error {
	if value == "" {
		value = "0.0"
	}
	floatVal, err := strconv.ParseFloat(value, bitSize)
	if err == nil {
		field.SetFloat(floatVal)
	}
	return err
}

cdukes · 2020-06-04T15:32:50Z

I'm confused about this ticket. The documentation doesn't say that the binding element must be a struct.

On v4.1.6 and before, this worked fine. A change was introduced post-v4.1.6 that broke existing functionality. If this was intentional, then shouldn't the next release have been 5.0.0, following semver? If it wasn't intentional, then shouldn't the change be reverted?

Beyond that, I'm having trouble figuring out why this change happened in the first place. Looking at the v4.1.7 release, I think issue #988 is the only one relevant here, but that ticket also has the binding element issue

benoitmasson · 2020-06-04T15:55:14Z

I'm having trouble figuring out why this change happened in the first place.

The bug comes from this commit (from this PR), to solve this proposal.

What is done is done, but I agree with you, breaking compatibility on such critical functions is not something we expect… unit tests were not complete enough.

PR #1574 includes a quick fix which works in most, common, cases (by ignoring the binding error on the parameter). Let's hope it gets merged soon… If you have any idea or comments to improve it, feel free to tell me about it.

cdukes · 2020-06-04T16:40:24Z

@benoitmasson

Thanks for the reply! Looking at the Bind() code, it seems to:

Try to bind params
Then try to bind query params
Then try to bind JSON/XML/form data, depending on the content type

And an error with any of these exits early, correct? That's a lot, and I think the function is too complicated for its own good. What we're seeing here is an issue with 1 breaking 3, even though param binding wasn't intended for the situation this ticket.

For a 4.1.x/4.2.0 fix, how do you feel about adding BindBody(), BindParams(), and BindQueryParams() methods, so that developers can explicitly state what they're trying to bind? (I also can't imagine a case where you wouldn't know what you're trying to bind.)

That doesn't fix the issue with Bind() overall, but it's a workaround that will only require minor code changes. I'm not sure what the best way to unravel Bind() would be. To be a 4.x.x release, I think it would have to:

Not break any existing implementations
Correctly bind params, query params, and JSON/XML/form data
Handle a map for params/query params and any interface for JSON/XML/form data (that's valid for Unmarshal/Decode)

I'm not sure all 3 are doable. Maybe the function parameters should change in 5.0.0?

benoitmasson · 2020-06-04T19:55:20Z

I think the function is too complicated for its own good.

I totally agree, and also think your suggestion of separate BindBody(), … functions is the most appropriate (along with a generic Bind() if needed, but then this one should allow only struct or map[string]string bindings).

This has already been suggested somewhere (another issue maybe?), but not implemented yet, although it would not be too hard to code… maybe the maintainer could tell us about it, as for me, I don't know what the plans are for the next versions and I don't want to waste time on something which has no chance of getting merged (my own PR is enough for me right now).

arigon · 2020-06-05T18:18:50Z

The description of bind() clearly states:

// Bind binds the request body into provided type `i`. The default binder
// does it based on Content-Type header.

Why is it also parsing Param and QueryParam which are part of the header? Adding the Param and QueryParam parser into the binder was a breaking change and should not have happened. Developers like me expected this function only parsing the body as the description states.

I'm with @cdukes and his suggestion of adding BindParams() and BindQueryParams() but the Bind() should only parse the body like it always did (if added to 4.x).

nxadm · 2020-07-06T13:52:22Z

I did some tricks to temporary solve the problem by adding c.SetParamNames() before bind.

This workaround is causing interesting problems! If the c.bind() afterwards fails, other routes using params will suddenly fail with "Not found". Only restarting the echo service resolves this.

I am now using ioutil.ReadAll(c.Request().Body) and Unmarshal it later into the struct.

Until, the new behaviour is fixed or reverted, I agree that this is the easiest workaround when you only need to read a JSON Body with a non-struct like an array. A more verbose code example:

	b, err := ioutil.ReadAll(c.Request().Body)
	if err != nil {
		return c.NoContent(http.StatusNotAcceptable)
	}

	var req []MyArray // the non-struct body
	if b != nil {
		err := json.Unmarshal(b, &req)
		if err != nil {
			return c.NoContent(http.StatusNotAcceptable)
		}
	} else {
		return c.NoContent(http.StatusNotAcceptable)
	}

      // Do something with req

Do not throw an error when binding to a slice, if binding occurs on path- or query-parameters => data is very likely to be found in the body, which will be bound later Should fix labstack#1356, labstack#1448, labstack#1495 (second case), labstack#1565

stale · 2020-09-05T20:36:03Z

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

nxadm · 2020-09-08T15:29:24Z

I wouldn't like to see this issue automatically close. It's a revision version that broke compatibility.

Julio-Guerra · 2020-09-22T15:29:25Z

Same - I upgraded to v4 yesterday and this broke (Bind on a json array now returning an error).

ajanata · 2020-10-07T00:07:12Z

This is also biting my team.

adrianlungu · 2020-10-07T20:25:46Z

I'm not sure if this is the bug I ran into as well, or it's something similar, but we had unit tests that were complaining about suddenly receiving the wrong status code and apparently reverting to 4.1.6 fixed the issue.

It happened mostly on routes that have a path param and also receive a JSON body.

Is there anything we can help with regarding this ? Quite some time seems to have passed without any update on this.

benoitmasson · 2020-10-08T07:10:29Z

Hi all,

My PR was closed due to inactivity, but if you really need this to work, apply this quick patch and things should work as expected.

adrianlungu · 2020-10-13T08:46:14Z

@benoitmasson yep, I saw it, thanks! At this point it seems as if it would be better to fork the repo and try to keep an up to date version based on this one.

jherman · 2020-10-23T22:54:30Z

This is almost a year and half old and it hasn't been fixed? Why would anyone want to rely on a framework where these basic functionality type of issues aren't resolved?

I also want to note that even using a struct with a PATCH method seems broken.

yves-bourgeois · 2020-10-26T10:10:09Z

Hi,

is there a timeline to get the different solutions offered in different merge requests actually on master?

This is currently quite breaking for us, and many others.

Can this be picked up again?

Thanks!

lammel · 2020-10-29T20:03:38Z

Will try to look into this in the next days. Never touched the bind code before though.
This might be similar to #1638.

adrianlungu · 2020-10-30T08:04:28Z

@lammel there was a previous PR by @benoitmasson that was closed due to inactivity, maybe that one fixes the issue ?

nbourdeau · 2020-12-09T20:32:20Z

Same problem here.
For those of you like me that just want to use the binding for a restful API usage with mainly json request body parsing, I created a simple binder like this:

type RestBinder struct {}

func (b* RestBinder) Bind(i interface{}, c echo.Context) (err error) {
	req := c.Request()
	if req.ContentLength == 0 {
		return
	}
	if err = json.NewDecoder(req.Body).Decode(i); err != nil {
		if ute, ok := err.(*json.UnmarshalTypeError); ok {
			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unmarshal type error: expected=%v, got=%v, field=%v, offset=%v", ute.Type, ute.Value, ute.Field, ute.Offset)).SetInternal(err)
		} else if se, ok := err.(*json.SyntaxError); ok {
			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Syntax error: offset=%v, error=%v", se.Offset, se.Error())).SetInternal(err)
		}
		return echo.NewHTTPError(http.StatusBadRequest, err.Error()).SetInternal(err)
	}
	return
}

e = echo.New()
e.Binder = &RestBinder{}

Can be used to bypass all other fancy logic regarding form binding and such ...

diegoclair · 2021-01-06T20:06:19Z

Hi, an alternative to this problem would be this: https://www.buggger.com/en/rqt/5ecb9ceacb08b

lammel · 2021-03-09T12:56:54Z

Issues with binding should be resolved with echo v4.2 (see release notes) with various PRs merged that are referenced here.

So feedback is welcome, if there are open issues left... Please let us know.

jherman · 2021-03-10T00:56:07Z

Issues with binding should be resolved with echo v4.2 (see release notes) with various PRs merged that are referenced here.

So feedback is welcome, if there are open issues left... Please let us know.

Still getting this error with PATCH method:

github.com/labstack/echo/v4 v4.2.1

dahu33 · 2021-04-19T08:54:07Z

This issue seems fixed by #1835 and was released in v4.2.2.

jherman · 2021-04-19T14:18:44Z

Can confirm this is now working for me in v4.2.2.

lammel · 2021-04-19T15:13:11Z

Thanks for verifying @jherman , @dahu33 .
Closing!

jherman · 2021-04-30T00:00:17Z

@lammel Sorry - I think this may have to be re-opened. I noticed this works fine when using a struct, but if you bind to a map map[string]interface{} and you have parameters in your route, then it will also bind those parameters in your map. For example if I make a webrequest with PATCH, to a route with the following path /tags/:tagKey and the object is { 'hello': 'world' }, it will bind like: `{ hello: 'world', tagKey: 'myUrlTagName' }. I don't believe that is expected, right?

EDIT:
Maybe that is expected. Perhaps I'm suppose to code it like so:

if err = (&echo.DefaultBinder{}).BindBody(c, &tagValue); err != nil {
  return fmt.Errorf("could not parse update: %v", err)
}

This appears do what I expected.

vishr self-assigned this Aug 7, 2019

vishr added the bug label Aug 7, 2019

nono mentioned this issue Aug 19, 2019

Update module labstack/echo/v4 to v4.1.10 cozy/cozy-stack#2015

Closed

1 task

thecampagnards mentioned this issue Sep 4, 2019

Revert "Build(deps): Bump github.com/labstack/echo/v4 from 4.1.6 to 4.1.10 in /server" thecampagnards/docktor#264

Merged

elkrammer added a commit to elkrammer/kegger that referenced this issue Jan 12, 2020

downgrade to echo v4.1.5 cause later versions are broken labstack/ech…

698fa0c

…o#1356

daniel-nichter mentioned this issue Feb 1, 2020

Bind causes panic or false-positive error if path has :param #1495

Closed

stale bot added the wontfix label May 2, 2020

stale bot removed the wontfix label May 2, 2020

benoitmasson mentioned this issue May 19, 2020

Allow bound interface to be a slice of data #1574

Closed

stale bot added the wontfix label Sep 5, 2020

stale bot removed the wontfix label Sep 8, 2020

pedrokiefer mentioned this issue Oct 15, 2020

feat: add bulk purge api tsuru/rpaas-operator#86

Merged

aldas mentioned this issue Nov 6, 2020

c.bind() binds both POST request body and query to given struct causing security vulnerability and problems with slices #1670

Closed

aldas mentioned this issue Nov 13, 2020

separate methods to bind only: query params, route params, request body #1681

Merged

adrianlungu mentioned this issue Nov 19, 2020

Is Echo still maintained ? #1686

Closed

benmarsden mentioned this issue Mar 24, 2021

Fix Echo's Bind behaviour to use the more precise BindBody valocode/bubbly#43

Merged

lammel closed this as completed Apr 19, 2021

aldas mentioned this issue Jul 22, 2021

Unable to bind query parameters after update #1932

Closed

"binding element must be a struct" introduced with path params binding #1356

"binding element must be a struct" introduced with path params binding #1356

Comments

andreiavrammsd commented Jun 27, 2019

Issue Description

Checklist

Expected behaviour

Actual behaviour

Steps to reproduce

Working code to debug

Version/commit

andreiavrammsd commented Jun 28, 2019

xXLokerXx commented Jul 8, 2019

xXLokerXx commented Jul 8, 2019

radaiming commented Sep 2, 2019

cdukes commented Oct 10, 2019

ryanking8215 commented Nov 12, 2019 • edited Loading

andreiavrammsd commented Nov 12, 2019

ryanking8215 commented Nov 12, 2019

EndlessCheng commented Jan 10, 2020 • edited Loading

bxcodec commented Mar 3, 2020 • edited Loading

stale bot commented May 2, 2020

cdukes commented May 2, 2020

arigon commented Jun 2, 2020 • edited Loading

leefernandes commented Jun 3, 2020

cdukes commented Jun 4, 2020

benoitmasson commented Jun 4, 2020

cdukes commented Jun 4, 2020

benoitmasson commented Jun 4, 2020

arigon commented Jun 5, 2020

nxadm commented Jul 6, 2020 • edited Loading

stale bot commented Sep 5, 2020

nxadm commented Sep 8, 2020

Julio-Guerra commented Sep 22, 2020

ajanata commented Oct 7, 2020

adrianlungu commented Oct 7, 2020

benoitmasson commented Oct 8, 2020

adrianlungu commented Oct 13, 2020

jherman commented Oct 23, 2020 • edited Loading

yves-bourgeois commented Oct 26, 2020

lammel commented Oct 29, 2020

adrianlungu commented Oct 30, 2020

nbourdeau commented Dec 9, 2020

diegoclair commented Jan 6, 2021

lammel commented Mar 9, 2021

jherman commented Mar 10, 2021

dahu33 commented Apr 19, 2021

jherman commented Apr 19, 2021

lammel commented Apr 19, 2021

jherman commented Apr 30, 2021 • edited Loading

ryanking8215 commented Nov 12, 2019 •

edited

Loading

EndlessCheng commented Jan 10, 2020 •

edited

Loading

bxcodec commented Mar 3, 2020 •

edited

Loading

arigon commented Jun 2, 2020 •

edited

Loading

nxadm commented Jul 6, 2020 •

edited

Loading

jherman commented Oct 23, 2020 •

edited

Loading

jherman commented Apr 30, 2021 •

edited

Loading