Add a field to JSON ( struct + interface ) golang

Here's the response interface :

type Response interface{}

It's satisfied by a struct like this :

type CheckResponse struct {
	Status    string `json:"status"`
}

I am getting out []Response as an output which is to be consumed elsewhere.

I want to add a Version string to this JSON, before it's being sent. I've tried using anonymous structs ( but in vain ) :

for _, d := range out {
		outd := struct {
			Resp       Response `json:",inline"`
			Version    string   `json:",inline"`
		}{
			Resp:       d,
			Version: "1.1",
		}
		data, _ := json.Marshal(outd)
		log.Infof("response : %s", data)
	}

The output I am getting is :

response : {"Resp":{"status":"UP"},"Version":"1.1"}

What I want is

{"status":"UP","Version":"1.1"}

i.e. one single flat JSON.

Assert your d to CheckResponse type and then define dynamic struct like this

outd := struct {
			Resp       string `json:"status,inline"`
			Version    string   `json:",inline"`
		}

This is the full code for this.

package main

import (
	"encoding/json"
	"fmt"
)

type Response interface {}

type CheckResponse struct {
	Status    string `json:"status"`
}

func main() {
	out := []Response{
		CheckResponse{Status: "UP"},
	}
	for _, d := range out {
		res, ok := d.(CheckResponse)
		if !ok {
			continue
		}
		outd := struct {
			Resp       string `json:"status,inline"`
			Version    string   `json:",inline"`
		}{
			Resp:       res.Status,
			Version: "1.1",
		}
		data, _ := json.Marshal(outd)
		fmt.Printf("response : %s", data)
	}
}

You can run here

inline tag is not supported by encoding/json and embedding interfaces will also not produce the result you want. You'll have to declare a type for the out value and have that type implement the json.Marshaler interface, you can then customize how its fields are marshaled, for example you could marshal the two fields Resp and Version separately and then "merge the result" into a single json object.

type VersionedResponse struct {
	Resp    Response
	Version string
}

func (r VersionedResponse) MarshalJSON() ([]byte, error) {
	out1, err := json.Marshal(r.Resp)
	if err != nil {
		return nil, err
	}
	out2, err := json.Marshal(struct{ Version string }{r.Version})
	if err != nil {
		return nil, err
	}

    // NOTE: if Resp can hold something that after marshaling
    // produces something other than a json object, you'll have
    // to be more careful about how you gonna merge the two outputs.
    //
    // For example if Resp is nil then out1 will be []byte(`null`)
    // If Resp is a slice then out1 will be []byte(`[ ... ]`)

	out1[len(out1)-1] = ',' // replace '}' with ','
	out2 = out2[1:]         // remove leading '{'

	return append(out1, out2...), nil
}

https://play.golang.org/p/66jIYXGUtWJ

One way that will work for sure is simply use a map[string]interface{}, iterate over fields in Response via reflect or use a library like structs, update your map with response fields, append your version field to map, and then marshal.
Here is an example

package main

import (
	"encoding/json"
	"fmt"
	"github.com/fatih/structs"
)

type Response interface{}

type CheckResponse struct {
	Status string `json:"status"`
}

func main() {
	resp := CheckResponse{Status: "success"}
	m := structs.Map(resp)
	m["Version"] = "0.1"
	out, _ := json.Marshal(m)	
	
	fmt.Println(string(out))
}