How to parse wrapped json object - json

Question

some API endpoint may return successful result or error like this:
// ok
{
"status": "ok",
"payload": {
"id": 10,
"title": "Sample"
},
"request_id": "lx-VHr4OLm"
}
// error
{
"status": "error",
"payload": {
"message": "internal error"
},
"trace_id": "lx-VHr4OLm"
}
I'm trying to find elegant way to parse with Go, something like this
.... some code
if status == "ok" {
struct := AppStruct{} // AppStruct contains 2 fields: id and title
_ := json.Unmarshall(payloadBody, &struct)
return struct
} else {
errorStruct := ErrorStruct{} // contains 1 field for message.
_ := json.Unmarshall(payloadBody, &errorStruct)
return nil, errors.New(errorStruct.Message)
}
My current code not works for success payload:
var result map[string]interface{}
jsonErr := json.Unmarshal(body, &result)
if jsonErr != nil {
return nil, jsonErr
}
if result["status"] == "error" {
errorPayload := result["payload"].(map[string]string)
return nil, errors.New(errorPayload["message"])
} else if result["status"] == "ok" {
apiResponse := AppInfo{}
jsonErr := json.Unmarshal([]byte(result["payload"].(string)), &apiResponse)
if jsonErr != nil {
return nil, jsonErr
}
return &apiResponse, nil
}
And I got runtime error on line json.Unmarshal([]byte(result["payload"].(string)), &apiResponse)
http: panic serving [::1]:51091: interface conversion: interface {} is
map[string]interface {}, not string
Surely, I may have 2 structs: for success response and for error one but I assume it's too complicated way to solve my problem.
How to parse this JSON in elegant way?

Answer 1

I'm really not sure what the problem is. The standard encoding/json doesn't require the struct to match all fields in the JSON data. It's quite easy to handle this with a single, simple type:
type Payload struct {
ID int `json:"id"`
Title string `json:"title"`
Message string `json:"message"`
}
type Response struct {
Status string `json:"status"`
ID string `json:"request_id"`
TraceID string `json:"trace_id"`
Payload Payload `json:"payload"`
}
Then just unmarshal the response in the Response struct:
var resp Response
if err := json.Unmarshal(body, &resp); err != nil {
return err
}
Then you can simply check the Status field, and work out what to do next. For example:
if resp.Status == "error" {
return fmt.Errorf("invalid response: %s - %s", resp.TraceID, resp.Payload.Message)
}
// handle resp.Payload.ID and resp.Payload.Title fields
return nil
You could move those checks for the status field to receiver functions on the response object, depending on the complexity and your specific needs.
Perhaps it's worth using pointer fields for those fields that aren't set in the normal response, and tag them with the omitempty option:
type Payload struct {
ID int `json:"id"`
Title string `json:"title"`
Message *string `json:"message,omitempty"`
}
type Response struct {
Status string `json:"status"`
ID string `json:"request_id"`
TraceID *string `json:"trace_id,omitempty"`
Payload Payload `json:"payload"`
}
With types like this, no longer have to rely on hard-coded string constants to check for errors. Instead, you can easily implement a more generic check like so:
func (r Response) IsError() bool {
return (r.TraceID == nil) // will be set in case of an error response
}
Update
As you pointed out in the comments, the response body is actually substantially larger than the 2 fields in the example. Of course, copy-pasting the struct definitions, or writing mapping functions to map the Payload onto the type you already have is a bit pointless.
The answer here is: composition.
type Payload struct {
AppStruct // embedded the AppStruct type
Message *string `json:"message"`
}
The Response type stays as it is. If the response is successful, you can get the AppStruct directly from the response like so:
appStruct := resp.Payload.AppStruct
This works because the type is embedded. Note that there aren't any json tags there. The embedded struct, at least as far as the unmarshalling is concerned, is a part of the Payload struct. Therefore, all the exported fields in that type will be unmarshalled directly into the struct.

Answer 2

Thanks https://stackoverflow.com/users/965900/mkopriva for idea to use json.RawMessage
My final solution:
func parsePayload(response []byte, successPayload interface{}) error {
var result map[string]json.RawMessage
jsonErr := json.Unmarshal(response, &result)
if jsonErr != nil {
return jsonErr
}
var status string
jsonErr = json.Unmarshal(result["status"], &status)
if jsonErr != nil {
return jsonErr
}
if status == "ok" {
jsonErr = json.Unmarshal(result["payload"], &successPayload)
if jsonErr != nil {
return jsonErr
}
return nil
} else if status == "error" {
errorPayload := ErrorPayload{}
jsonErr = json.Unmarshal(result["payload"], &errorPayload)
if jsonErr != nil {
return jsonErr
}
return errors.New(errorPayload.Message)
}
log.Printf("Unknown http result status: %s", status)
return errors.New("internal error")
}
type ErrorPayload struct {
Message string `json:"message"`
}
//usage
type AppInfo struct {
Id int `json:"app_id"`
Title string `json:"app_title"`
}
body := ... // read body
appInfo := AppInfo{}
parseErr := parsePayload(body, &appInfo)
if parseErr != nil {
return nil, parseErr
}
log.Printf("Parsed app %v", appInfo)
return &appInfo, nil