Creating Map From Changelog With Path in Slice of Strings (Maybe append to map!?)

I have a slice of changes that looks like this:

type Change struct {
	Type string      // The type of change detected; can be one of create, update or delete
	Path []string    // The path of the detected change; will contain any field name or array index that was part of the traversal
	From interface{} // The original value that was present in the "from" structure
	To   interface{} // The new value that was detected as a change in the "to" structure
}

I'm trying to take this and create a new map[string]interface{} from this.

I realized looping through path I'd need to build upon the prior path but I'm unsure how to do this. E.g. Path with this: {"one": {"two": {"three": "value"}}} would have []string{"one", "two", "three"}

Right now I have this code:

for _, change := range changeLog {

	for i, _ := range change.Path {
		changeMap[change.Path[i]] = make(map[string]interface{})
	

		if i == len(change.Path)-1 {
			if castMap, ok := change.To.(map[string]interface{}); ok {
				changeMap
 = castMap
			}
		}

	}
}

But this doesn't account for the parents hence the result is a flat structure. How do I achieve what I'm trying to achieve.

If you want to transverse your slice of Change to a tree struct based on maps, you should use some node struct to hold the tree data, because a variable cannot hold a map and an interface (the To value) at the same time. I make this sample that works and build you a tree based on your changelog slice.

package main
import (
"fmt"
"strings"
)
type Change struct {
Type string      // The type of change detected; can be one of create, update or delete
Path []string    // The path of the detected change; will contain any field name or array index that was part of the traversal
From interface{} // The original value that was present in the "from" structure
To   interface{} // The new value that was detected as a change in the "to" structure
}
type Node struct {
Children map[string]*Node
To       interface{}
}
//Helper for printing the tree
func (n Node) Print(ident int) {
id := strings.Repeat(" ", ident)
fmt.Println(id+"To:", n.To)
for key, value := range n.Children {
fmt.Println(id + "[" + key + "]")
value.Print(ident + 2)
}
}
func main() {
changeLog := make([]Change, 0)
changeLog = append(changeLog, Change{
Type: "update",
Path: []string{"a", "b"},
From: 1,
To:   2,
})
changeLog = append(changeLog, Change{
Type: "update",
Path: []string{"a", "c"},
From: 3,
To:   4,
})
var node *Node
root := &Node{
Children: make(map[string]*Node),
To:       nil,
}
for _, change := range changeLog {
node = root
for _, p := range change.Path {
if _, found := node.Children
; !found {
node.Children
 = &Node{
Children: make(map[string]*Node),
To:       nil,
}
}
node = node.Children

}
node.To = change.To
}
//Note: if you try to get a non-exist path this way, the following will panic!
//You should make a func to get the value of a path or get nil back if path not exists.
fmt.Println(root.Children["a"].Children["b"].To)
fmt.Println(root.Children["a"].Children["c"].To)
root.Print(0)
}

Try it on goplay.space

Output:

To: <nil>
[a]
To: <nil>
[b]
To: 2
[c]
To: 4