How to unmarshal JSON with a generic interface as a field

I have a generic Response object with the following struct:

type Response struct {
	Data          Data   `json:"data"`
	Error         string `json:"error,omitempty"`
	NextPageToken string `json:"next_page_token,omitempty"`
}

The Data type is an interface, with many implementations (think PingResponse, etc). How do I unmarshal the Response into its underlying type? The full example is below, which always triggers the error error: json: cannot unmarshal object into Go struct field Response.data of type main.Data
:

type Response struct {
	Data          Data   `json:"data"`
	Error         string `json:"error,omitempty"`
	NextPageToken string `json:"next_page_token,omitempty"`
}

type Data interface{
    Foo()
}

type TypeA struct {
	Field1 string `json:"field1"`
	Field2 int    `json:"field2"`
}

func (a *TypeA) Foo() {}

type TypeB struct {
	Field3 float64 `json:"field3"`
}

func (b *TypeB) Foo() {}

func main() {
	jsonStr := `{
		"data": {
			"field1": "some string",
			"field2": 123
		},
		"error": "",
		"next_page_token": ""
	}`

	var response Response
	err := json.Unmarshal([]byte(jsonStr), &response)
	if err != nil {
		fmt.Println("error:", err)
		return
	}

	switch data := response.Data.(type) {
	case *TypeA:
		fmt.Println("TypeA:", data.Field1, data.Field2)
	case *TypeB:
		fmt.Println("TypeB:", data.Field3)
	default:
		fmt.Println("Unknown type")
	}
}

You have to tell encoding/json which concrete type to unmarshal to. The package can not do it for you.

Let's assume that TypeA and TypeB are defined as:

type TypeA struct {
	FieldA string `json:"field"`
}

type TypeB struct {
	FieldB string `json:"field"`
}

There is no way to decide which type to unmarshal to in this case.

Regarding your example, we can tell encoding/json which type to unmarshal to like this:

- var response Response
+ response := Response{Data: &TypeA{}}

If you don't know the type beforehand, you can marshal it into map[string]interface{}:

 type Response struct {
-	Data          Data                   `json:"data"`
+	Data          map[string]interface{} `json:"data"`
 	Error         string                 `json:"error,omitempty"` 
 	NextPageToken string                 `json:"next_page_token,omitempty"`
 }

And determine the type like this:

if field1, ok := response.Data["field1"]; ok {
	fmt.Println("TypeA:", field1, response.Data["field2"])
} else {
	if field3, ok := response.Data["field3"]; ok {
		fmt.Println("TypeB:", field3)
	} else {
		fmt.Println("Unknown type")
	}
}

Another solution is to embed the type information in the json:

 jsonStr := `{
     "data": {
         "field1": "some string",
         "field2": 123
     },
+    type": "A",
     "error": "",
     "next_page_token": ""
 }`

 type Response struct {
-	Data          Data            `json:"data"`
+	Data          json.RawMessage `json:"data"`
+	Type          string          `json:"type"`
 	Error         string          `json:"error,omitempty"`
 	NextPageToken string          `json:"next_page_token,omitempty"`
 }

And then decode response.Data according to the value of response.Type. See the example provided by encoding/json: https://pkg.go.dev/encoding/json#example-RawMessage-Unmarshal.