Idiomatic JSON object array -> map[string]json.RawMessage

I am trying to unmarshal the results of an HTTP REST API request that, depending on the number of results, returns either an object or an array of objects.

Requests are generic because I'm trying to build a wrapper around a specific REST API and it's called like:

// Function prototype where I am trying to convert the response
func (client *Client) Get(endpoint string, data map[string]string) (map[string]json.RawMessage, error)

// The way the function is called
client.Get("/v1/users", map[string]string{"filter.abc": "lorem ipsum"})

Two examples of response:

[
  {
    "abc": "def",
    "efg": 123
    "hij": [
      {
        "klm": "nop"
      }
    ]
  },
  {
    "abc": "def",
    "efg": 123
    "hij": [
      {
        "klm": "nop"
      }
    ]
  }
]
// RESPONSE 1: Array of JSON objects that have child arrays

{
  "abc": "def",
  "efg": 123
  "hij": [
    {
      "klm": "nop"
    }
  ]
}
// RESPONSE 2: In this case, only one element was returned.

I've achieved to do this for only the response 2 with something like this:

// [...]
byteBody = ioutil.ReadAll(res.Body)
// [...]
var body map[string]json.RawMessage
if err := json.Unmarshal(byteBody, &body); err != nil { [...] }

So, what's the most idiomatic way of parsing this? Is there any way to avoid writing redundant code and parse both responses? I was thinking in giving as an additional parameter the "model" the response should be put into. Is it a good practice? Thank you so much in advance!

Examine the first non-whitespace byte in the JSON document to determine if the document is an array or object.

func decodeArrayOrObject(doc []byte) ([]map[string]json.RawMessage, error) {
	trimmedDoc := bytes.TrimSpace(doc)
	switch {
	case len(trimmedDoc) == 0:
		return nil, errors.New("empty body")
	case trimmedDoc[0] == '{':
		var m map[string]json.RawMessage
		err := json.Unmarshal(doc, &m)
		return []map[string]json.RawMessage{m}, err
	case trimmedDoc[0] == '[':
		var s []map[string]json.RawMessage
		err := json.Unmarshal(doc, &s)
		return s, err
	default:
		return nil, errors.New("unexpected type")
	}
}

Use the reflect package to create a function that works with arbitrary slice types:

func decodeArrayOrObject(doc []byte, slicep interface{}) error {
	trimmedDoc := bytes.TrimSpace(doc)
	switch {
	case len(trimmedDoc) == 0:
		return errors.New("empty document")
	case trimmedDoc[0] == '[':
		return json.Unmarshal(doc, slicep)
	case trimmedDoc[0] == '{':
		s := reflect.ValueOf(slicep).Elem()
		s.Set(reflect.MakeSlice(s.Type(), 1, 1))
		return json.Unmarshal(doc, s.Index(0).Addr().Interface())
	default:
		return errors.New("unexpected type")
	}
}

Call the function with a pointer to a slice of structs or a pointer to a slice of struct pointers.

var v []Example
err := decodeArrayOrObject(body, &v)

Run an example on the playground.

Not sure is idiomatic but this code could be an example.

In short you can try to unmarshal in one format and, if it fails, in the other one

the key function is

func parseStr(data string) ([]Item, error) {
	item := Item{}
	if err := json.Unmarshal([]byte(data), &item); err == nil {
		return []Item{item}, nil
	}

	items := []Item{}
	if err := json.Unmarshal([]byte(data), &items); err != nil {
		return nil, errors.New("invalid JSON data")
	}
	return items, nil

}