Binding path parameters and complete body using same struct

[cm0x4D]

Maybe I did not understand the documentation right, but what I want to do is to bind some path parameters and the whole body to a struct. Lets assume the struct like this:

type DataPoint struct {
    Name  string      `json:"name" validate:"required"`
    Type  string      `json:"type" validate:"required"`
    Value interface{} `json:"value" validate:"required"`
}

type Options struct {
    EndpointID  string      `param:"endpointID"`
    ApplianceID string      `param:"applianceID"`
    ServiceURI  string      `param:"serviceURI"`
    Body        []DataPoint `json:"???"`
}

The body contains a list of DataPoint objects, I want to bind them to the Body field of the struct.

I tested many things in the place of the question marks, but nothing worked. Is there a way to bind the complete body to the Body field in the Options struct. I managed to get it working using 2 separate bindings, but I find that less elegant.

If it is not possible yet, it might be convenient to add a possibility to do such binding. I use that case frequently during REST API development and I think a lot of people would appreciate such a function too.

[aldas]

You can not specify to where body is bound. It is always bound directly to object referenced as.Bind() argument.

---

At the moment I think shortest way to bind is:

import (
	"encoding/json"
	"errors"
	"github.com/labstack/echo/v4"
	"log"
	"net/http"
)

func main() {
	e := echo.New()

	e.POST("/:serviceURI/:endpointID/:applianceID", func(c echo.Context) error {
		type DataPoint struct {
			Name  string      `json:"name" validate:"required"`
			Type  string      `json:"type" validate:"required"`
			Value interface{} `json:"value" validate:"required"`
		}

		type Options struct {
			EndpointID  string `param:"endpointID"`
			ApplianceID string `param:"applianceID"`
			ServiceURI  string `param:"serviceURI"`
			Body        []DataPoint
		}

		var opts Options
		if err := json.NewDecoder(c.Request().Body).Decode(&opts.Body); err != nil {
			return err
		}

		// we need to use BindPathParams because json.Decoder has already read the body
		if err := (&echo.DefaultBinder{}).BindPathParams(c, &opts); err != nil {
			return err
		}

		return c.JSON(http.StatusOK, opts)
	})

	if err := e.Start(":8080"); err != nil && !errors.Is(err, http.ErrServerClosed) {
		log.Fatal(err)
	}
}

curl -v -X POST http://localhost:8080/serv/endp/applid -H 'Content-Type: application/json' -d '[{"name":"n1", "type":"t1", "value": true},{"name":"n2", "type":"t2", "value": "true"}]'

---

But if you want to do same thing shorter you could create Binder like that

type Binder struct {
	binder echo.DefaultBinder
	c      echo.Context
	
	err error
}

func NewBinder(c echo.Context) *Binder {
	return &Binder{
		c:      c,
		binder: echo.DefaultBinder{},
	}
}

func (b *Binder) Error() error {
	return b.err
}

func (b *Binder) BindPathParams(i interface{}) *Binder {
	if b.err == nil {form+body)
		b.err = b.binder.BindPathParams(b.c, i)
	}
	return b
}

func (b *Binder) BindBody(i interface{}) *Binder {
	if b.err == nil {
		// fixme: there should be check if we have not already read the request body (by double calling bindBody or binding 
		b.err = b.binder.BindBody(b.c, i)
	}
	return b
}

and use it like that

func main() {
	e := echo.New()

	e.POST("/:serviceURI/:endpointID/:applianceID", func(c echo.Context) error {
		type DataPoint struct {
			Name  string      `json:"name" validate:"required"`
			Type  string      `json:"type" validate:"required"`
			Value interface{} `json:"value" validate:"required"`
		}

		type Options struct {
			EndpointID  string `param:"endpointID"`
			ApplianceID string `param:"applianceID"`
			ServiceURI  string `param:"serviceURI"`
			Body        []DataPoint
		}

		var opts Options
		if err := NewBinder(c).BindPathParams(&opts).BindBody(&opts.Body).Error(); err != nil {
			return err
		}

		return c.JSON(http.StatusOK, opts)
	})

	if err := e.Start(":8080"); err != nil && !errors.Is(err, http.ErrServerClosed) {
		log.Fatal(err)
	}
}

[aldas]

I think we could add binder like that to chain binding sources. Meanwhile just copy paste that example if you like and use it for your endpoints.

[cm0x4D]

Thank you @aldas for your assistance. I did manage to do what I wanted by using explicit binding for body and parameters. This works fine, but it is a bit less elegant. Intuitively I tried achieve it with json:"$" (JSON-Path for current context), but that did not work. I never worked with Go annotations, so I cannot estimate the work required to implement such behavior and at the time I am quite busy to finish the API itself. If I find the time I might investigate if it would be possible to implement such a feature if you think that it would make sense to have such functionality and others could benefit from it.

[aldas]

About json:"$" - Echo does not implement JSON unmarshalling. This struct tag json is actually from Go standard library. Here is https://pkg.go.dev/encoding/json#Marshal part here struct tag syntax and special cases are documented.

---

Just for information: Code related to binding request body can be found here

echo/bind.go

Line 59 in 29aab27

func (b *DefaultBinder) BindBody(c Context, i interface{}) (err error) {

---

I am personally not very excited about allowing binding whole body to specific field as it introduces many questions/problems that need to be solved:

• should you be able to bind body to multiple fields? This would mean buffering or reading body multiple times.
• what happens with JSON request when there is a field meant to bind body and another field with JSON tag.

   	type Root struct {
   		Name string                 `param:"serviceURI" json:"name"`
   		Body map[string]interface{} `echo:"body"` // lets say this is our "body" binding special tag
   	}

  Should we make sure that only Root.Body is bound or we let potentially Root.Name to be bound from request body also?

[cm0x4D]

Good points. Maybe too many questions to integrate it into the framework itself.

I developed a custom binder doing that. Maybe adding it to the documentation would be enough?

It does:

• If a field with the name body is present, it unmarshalls the body into it, otherwise it will fallback to the normal operation with json tags.
• If the field with the name Body is present, the json tags of the main struct are ignored.

type bodyBinder struct {
	baseBinder *echo.DefaultBinder
}

func NewBodyBinder() echo.Binder {
	return &bodyBinder{
		baseBinder: new(echo.DefaultBinder),
	}
}

func (b *bodyBinder) Bind(i interface{}, c echo.Context) error {

	// Bind the request to the struct as usual
	if err := b.baseBinder.BindPathParams(c, i); err != nil {
		return err
	}
	if err := b.baseBinder.BindQueryParams(c, i); err != nil {
		return err
	}
	if err := b.baseBinder.BindHeaders(c, i); err != nil {
		return err
	}

	// If the passed interface is a pointer, get the value it points to
	v := reflect.ValueOf(i)
	if v.Kind() == reflect.Interface {
		v = v.Elem()
	}

	if v.Kind() == reflect.Ptr && !v.IsNil() {
		v = v.Elem()
	}

	// Check if there is a field named "Body" in the struct
	field := v.FieldByName("Body")
	if !field.IsValid() {
		return b.baseBinder.BindBody(c, i)
	}

	// Ensure the field is a struct and is settable
	if field.Kind() != reflect.Struct && field.Kind() != reflect.Map && field.Kind() != reflect.Slice {
		return fmt.Errorf("field Body is not a struct, map or slice")
	}
	if !field.CanSet() {
		return fmt.Errorf("field Body is not settable")
	}

	// Bind the request body to the field "Body"
	body := reflect.New(field.Type()).Interface()
	err := b.baseBinder.BindBody(c, &body)
	if err != nil {
		return err
	}
	field.Set(reflect.ValueOf(body).Elem())
	return nil
}