GraphQL JSON转Go结构

Question

I have a GraphQL query that looks like this:

{
    actor {
      entitySearch(query: "name LIKE 'SOME_NAME'") {
        results {
          entities {
            guid
          }
        }
      }
    }
  }

I can't figure out how to create the Go struct to hold the returned data. The only thing I care about is the guid field that gets returned.

This clearly doesn't work:

type graphQlResponse struct {
    guid string
}

Any help? Or is there a way I can simply get the guid and store it in a string without a struct?

Here is the whole code. I don't get an error, but guid is an empty string:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/machinebox/graphql"
)

func main() {

    type graphQlResponse struct {
        guid string
    }

    // create a client (safe to share across requests)
    client := graphql.NewClient("GraphQL EndPoint")

    // make a request
    req := graphql.NewRequest(`
    {
        actor {
          entitySearch(query: "name LIKE 'SOME_NAME'") {
            results {
              entities {
                guid
              }
            }
          }
        }
      }
`)

    // set any variables
    //req.Var("key", "value")

    // set header fields
    //req.Header.Set("Cache-Control", "no-cache")
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("API-Key", "KEY_HERE")

    // define a Context for the request
    ctx := context.Background()

    // run it and capture the response
    var respData graphQlResponse
    if err := client.Run(ctx, req, &respData); err != nil {
        log.Fatal(err)
    }

    fmt.Println(respData.guid)
}

Answer 1

I suggest using a map and the json package.

I am unfamiliar with graphQL so I'll make a regular HTTP request and hope you can use it to make sense of your own issue:

response, err := http.Get("https://example.com")
// error checking code omitted
defer response.Body.Close()

// now we want to read the body, easiest way is with the ioutil package,
// this should work with the graphQL response body assuming it satisfies
// the io.Reader interface. This gets us the response body as a byte slice
body, err := ioutil.ReadAll(response.Body)

// next make a destination map, interface can be used in place of string or int
// if you need multiple types
jsonResult := map[string]string{"uuid": ""}

// finally, we use json.Unmarshal to write our byte slice into the map
err = json.Unmarshal(body, &jsonResult)

// now you can access your UUID
fmt.Println(jsonResult["uuid"])

I assume that a REST response and a graphQL response are similar, if that's not the case let me know what type the request body is and I can help you figure out a better fitting solution.