can I centralize the response before commit?

[Knorway]

if i write a response in handler like this,

e.GET("/", func(ctx echo.Context) error {
	return ctx.String(http.StatusOK, data)
})

this is how it'd be look like.

{
    "go": "echo"
}

is there any middleware or options that i can format or pre-process the body of the response returned from handler before it is being sent to the client using echo like below?

{
    "size": ...,
    "extraInfo": ....,
    "data": {
        "go": "echo"
    }
}

i'm new to both go and echo and hope this question doesn't look too silly. thank you in advance!

[aldas]

It depends mostly what behavior this response "container" should have. Does that size field must be size of bytes of data field? Is extraInfo some arbitrary map of something?

What you are looking for is JSON marshalling and struct tags + some helper function. You can make that responseDTO.Data field to be of type interface{} and for each handler set your handler specific struct there (having tags for json fields)

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

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

	e.GET("/", func(ctx echo.Context) error {
		type dataDTO struct {
			Go string `json:"go"`
		}

		type responseDTO = struct {
			Size      int64             `json:"size"`
			ExtraInfo map[string]string `json:"extraInfo"`
			Data      dataDTO           `json:"data"`
		}

		resp := responseDTO{
			Size: 999,
			ExtraInfo: map[string]string{
				"key": "value",
			},
			Data: dataDTO{
				Go: "echo",
			},
		}
		return ctx.JSON(http.StatusOK, resp)
	})

	if err := e.Start(":8080"); err != http.ErrServerClosed {
		e.Logger.Fatal(err)
	}
}

[Knorway]

I was definitely looking for some kind of filter or interceptor that places right before/after the handler and was trying to hijack the written body to implement mine to rewrite it. Body dump looked right place for it in first glance but failed. it seems echo or net/http in general it’s not idiomatic and not supported. Maybe I need to go to your dto solution or return pre process function.

func preProcess(ctx echo.Context, payload string) error {
	return ctx.JSON(ctx.Response().Status, map[string]interface{}{
		"size":      len(payload),
		"status":    ctx.Response().Status,
		"timeStamp": time.Now(),
		"data":      payload,
	})
}

e.GET("/b", func(ctx echo.Context) error {
	ctx.Response().Status = http.StatusCreated
	return preProcess(ctx, "hello world!")
})

Guess I need to learn how net/http exactly works first 😂. Thank you for your answer!

[aldas]

@Knorway why do you need that size field? Do you know that HTTP responses have Content Length header. Although it is not size for data field but depending on the need maybe it would do.

but if this is what you need. You could use JSON package custom MarshalJSON for stuct functionality as such

import (
	"bytes"
	"encoding/json"
	"github.com/labstack/echo/v4"
	"net/http"
	"strconv"
	"time"
)

type Resp struct {
	ExtraInfo map[string]interface{}
	Data      interface{}
}

func (r Resp) MarshalJSON() ([]byte, error) {
	buf := new(bytes.Buffer)

	dataBytes, err := json.Marshal(r.Data)
	if err != nil {
		return nil, err
	}
	buf.WriteString(`{"size":`)
	buf.WriteString(strconv.Itoa(len(dataBytes)))

	if len(r.ExtraInfo) > 0 {
		extraInfoBytes, err := json.Marshal(r.ExtraInfo)
		if err != nil {
			return nil, err
		}
		buf.WriteString(`,"extraInfo":`)
		buf.Write(extraInfoBytes)
	}
	buf.WriteString(`,"data":`)
	buf.Write(dataBytes)
	buf.WriteString(`}`)

	return buf.Bytes(), nil
}

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

	e.GET("/", func(c echo.Context) error {
		type dataDTO struct {
			Go string `json:"go"`
		}

		response := Resp{
			ExtraInfo: map[string]interface{}{
				"key":  "value",
				"time": time.Now(),
			},
			Data: dataDTO{Go: "echo"},
		}
		return c.JSON(http.StatusOK, response)
	})

	if err := e.Start(":8080"); err != http.ErrServerClosed {
		e.Logger.Fatal(err)
	}
}

[Knorway]

First of all, thank you for your time and introducing how to customize MarshalJSON for this case.
size property doesn’t actually matter I should have come up with more practical example. i just wanted know if I can build so called interceptor(one place for customizing all response like pre -> handler -> post) kind of pipe line with echo.

I’ve expected somewhat express like approach as well as below:

`pseudo code`

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

	e.GET("/", func(ctx echo.Context) error {
		return ctx.String(http.StatusOK, "hello world!")
	})

	e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(ctx echo.Context) error {
				payload := ctx.Response().Payload // -> I expected something like this
			return ctx.JSON(ctx.Response().Status, map[string]interface{}{
				"status": ctx.Response().Status,
				"timeStamp": time.Now(),
				"data": payload,
			})
		}
	})

	e.Logger.Fatal(e.Start(":8090"))
}

But apparently it is not achievable nor idiomatic. I will definitely try your suggestions.