How to unmarshal a recursive json with type

I've got a JSON with the following form:

{
  "Filter": {
    "Filters": [
      {
        "Filter": {
           "someKey": "someValue1",
        },
        "FilterType": "trait"
      },
      {
        "Filter": {
           "someKey": "someValue2",
        },
        "FilterType": "trait"
      }
    ]
  },
  "FilterType": "and" // this can be an or too
}

Each filter has a type which maps to a particular struct I've got in code. As you can see this has a recursive nature: a filter can be and with multiple subfilters (which can also be ands or ors, etc).

So, depending on the type, I need to recursively map it to the correct struct. Any recommendations? I looked into using mapstructure but even then the code becomes pretty nasty.

Note, this example only uses and and trait filters but assume there are more like or

In the absence of clarifying feature specifications this is the struct you need to represent something close to the JSON you posted in your question.

type FilterContainer struct {
	Filter     map[string]interface{} `json:"Filter,omitempty"`
	Filters    []FilterContainer `json:"Filters,omitempty"`
	FilterType string `json:"FilterType"`
}

Your filters would be initialized in Go like this

f := FilterContainer{
	Filters: []FilterContainer{
		{
			Filter:     map[string]interface{}{"someKey": "someValue1"},
			FilterType: "trait",
		},
		{
			Filter:     map[string]interface{}{"someKey": "someValue2"},
			FilterType: "trait",
		},
	},
	FilterType: "and",
}

When the filters get marshaled to JSON and pretty printed they look like this

{
  "Filters": [
    {
      "Filter": {
        "someKey": "someValue1"
      },
      "FilterType": "trait"
    },
    {
      "Filter": {
        "someKey": "someValue2"
      },
      "FilterType": "trait"
    }
  ],
  "FilterType": "and"
}

The above JSON doesn't exactly match the JSON in your question; it lacks the top-level Filter field. I think the struct I propose in this answer will simplify both the implementation as well as the mental model.

Give it a try in the Go Playground at https://go.dev/play/p/6cLPT28DG2O

If you really, really need to match the JSON in your question

here's the struct you'll need

type FilterContainer struct {
	Filter     interface{} `json:"Filter,omitempty"` // Either a map[string]interface{} or a FilterContainer
	Filters    []FilterContainer `json:"Filters,omitempty"`
	FilterType string `json:"FilterType,omitempty"`
}

and it is populated this way

f := FilterContainer{
	Filter: FilterContainer{
		Filters: []FilterContainer{
			{
				Filter:     map[string]interface{}{"someKey": "someValue1"},
				FilterType: "trait",
			},
			{
				Filter:     map[string]interface{}{"someKey": "someValue2"},
				FilterType: "trait",
			},
		},
	},
	FilterType: "and",
}

Try it out in Go Playground at https://go.dev/play/p/uB_LmJc6NGH

This type of polymorphic JSON is common, and usually not easy to deal with. What I explain here is one way of doing it using a separate struct that is only used for marshaling, and relies on post-processing to construct the filters.

You can define a FilterMarshal struct that contains all possible fields of a filter:

type FilterMarshal struct {
   FilterType string `json:"FilterType"`
   Filters []*FilterMarshal `json:"Filters"`
   Filter   *FilterMarshal `json:"Filter"`
   SomeKey  string `json:"someKey"`
   ...
}

This implementation assumes that there are no name clashes. For instance, if a filter type has Filter field as one type, and another type has Filter field as an incompatible type, this will not work and you have to use other methods.

When you unmarshal the JSON in a FilterMarshal, you will get an object tree matching the input JSON. Then, you can construct the actual filter structure:

func unmarshalFilter(input *FilterMarshal) Filter {
   switch input.FilterType {
     case "and": 
        // process input.Filters recursively
       return AndFilter{Filters: processFilters(input.Filters))
     case "trait": 
       return TraitFilter{SomeKey: input.SomeKey}
   }
}