Parse JSON having sibling dynamic keys alongside with static in Go

I need to parse this json

{
	"version": "1.1.29-snapshot",
	"linux-amd64": {
		"url": "https://origin/path",
		"size": 7794688,
		"sha256": "14b3c3ad05e3a98d30ee7e774646aec7ffa8825a1f6f4d9c01e08bf2d8a08646"
	},
	"windows-amd64": {
		"url": "https://origin/path",
		"size": 8102400,
		"sha256": "01b8b927388f774bdda4b5394e381beb592d8ef0ceed69324d1d42f6605ab56d"
	}
}

Keys like linux-amd64 are dynamic and theirs amount is arbitrary. I tried something like that to describe it and unmarshal. Obviously it doesn't work. Items is always empty.

type FileInfo struct {
	Url    string `json:"url"`
	Size   int64  `json:"size"`
	Sha256 string `json:"sha256"`
}

type UpdateInfo struct {
	Version string `json:"version"`
	Items   map[string]FileInfo
}

It's similar to this use case, but has no parent key items. I suppose I can use 3rd party library or map[string]interface{} approach, but I'm interested in knowing how to achieve this with explicitly declared types.

The rest of the parsing code is:

func parseUpdateJson(jsonStr []byte) (UpdateInfo, error) {
	var allInfo = UpdateInfo{Items: make(map[string]FileInfo)}
	var err = json.Unmarshal(jsonStr, &allInfo)
	return allInfo, err
}

Look at the link I attached and you will realize that is not that simple as you think. Also I pointed that I interested in typed approach. Ok, how to declare this map[string]FileInfo to get parsed?

You can create a json.Unmarshaller to decode the json into a map, then apply those values to your struct: https://play.golang.org/p/j1JXMpc4Q9u

type FileInfo struct {
	Url    string `json:"url"`
	Size   int64  `json:"size"`
	Sha256 string `json:"sha256"`
}

type UpdateInfo struct {
	Version string `json:"version"`
	Items   map[string]FileInfo
}

func (i *UpdateInfo) UnmarshalJSON(d []byte) error {
	tmp := map[string]json.RawMessage{}
	err := json.Unmarshal(d, &tmp)
	if err != nil {
		return err
	}

	err = json.Unmarshal(tmp["version"], &i.Version)
	if err != nil {
		return err
	}
	delete(tmp, "version")

	i.Items = map[string]FileInfo{}

	for k, v := range tmp {
		var item FileInfo
		err := json.Unmarshal(v, &item)
		if err != nil {
			return err
		}

		i.Items[k] = item
	}
	return nil
}

This answer is adapted from this recipe in my YouTube video on advanced JSON handling in Go.

func (u *UpdateInfo) UnmarshalJSON(d []byte) error {
    var x struct {
        UpdateInfo
        UnmarshalJSON struct{}
    }
    if err := json.Unmarshal(d, &x); err != nil {
        return err
    }
    var y map[string]json.RawMessage{}
    if err := json.Unsmarshal(d, &y); err != nil {
        return err
    }


    delete(y, "version"_ // We don't need this in the map
    *u = x.UpdateInfo
    u.Items = make(map[string]FileInfo, len(y))
    for k, v := range y {
        var info FileInfo
        if err := json.Unmarshal(v, &info); err != nil {
            return err
        }
        u.Items[k] = info
    }
    return nil
}

It:

1. Unmarshals the JSON into the struct directly, to get the struct fields.
2. It re-unmarshals into a map of map[string]json.RawMessage to get the arbitrary keys. This is necessary since the value of version is not of type FileInfo, and trying to unmarshal directly into map[string]FileInfo will thus error.
3. It deletes the keys we know we already got in the struct fields.
4. It then iterates through the map of string to json.RawMessage, and finally unmarshals each value into the FileInfo type, and stores it in the final object.

<hr>

If you really don't want to unmarshal multiple times, your next best option is to iterate over the JSON tokens in your input by using the json.Decoder type. I've done this in a couple of performance-sensitive bits of code, but it makes your code INCREDIBLY hard to read, and in almost all cases is not worth the effort.