graphqlc

graphqlc

Package graphqlc provides a GraphQL client implementation.

• graphqlc
  • Installation
  • Usage
    • Query
      • Simple Query
      • Arguments and Variables
    • Mutations
    • Subscription

Installation

go get -u github.com/solid-wang/graphqlc

Usage

Construct a GraphQL client, specifying the GraphQL server URL. Then, you can use it to make GraphQL queries、 mutations and subscription.

client, _ := graphqlc.NewClient("https://example.com/graphql")
// Use client...

Query

Simple Query

For example, to make the following GraphQL query:

query {
	me {
		name
	}
}

You can define this graphql request:

req := NewGraphRequest(`
    query Me {
        me {
            name
        }
    }
`, nil)

You also need to define the struct：

type Me struct {
    Name          string
}
type Response struct {
    Me Me
}

Then do request, you need passing a pointer to resp:

var resp Response
err := client.Body(req).QueryOrMutate().Do(context.Background()).Decode(&resp)
if err != nil {
	// Handle error.
}
fmt.Println(query.Me.Name)

// Output: Luke Skywalker

Arguments and Variables

Often, you'll want to specify arguments on some fields.

For example, to make the following GraphQL query:

{
	human(id: "1000") {
		name
		height(unit: METER)
	}
}

You can define this graphql request:

req := NewGraphRequest(`
    {
        human(id: "1000") {
            name
            height(unit: METER)
        }
    }
`, nil)

Usually, you might want to use:

req := NewGraphRequest(`
    query Human($id: ID!, $unit: LengthUnit) {
        human(id: $id) {
            name
            height(unit: $unit)
        }
    }
`, map[string]any{"id": "1000", "unit": "METER"})

You also need to define the struct：

type Human struct {
    Name          string
	height          string
}
type Response struct {
    Human Human
}

Then do request:

var resp Response
err := client.Body(req).QueryOrMutate().Do(context.Background()).Decode(&resp)
if err != nil {
	// Handle error.
}
fmt.Println(q.Human.Name)
fmt.Println(q.Human.Height)

// Output:
// Luke Skywalker
// 1.72

Mutations

Mutations often require information that you can only find out by performing a query first. Let's suppose you've already done that.

For example, to make the following GraphQL mutation:

mutation($ep: Episode!, $review: ReviewInput!) {
	createReview(episode: $ep, review: $review) {
		stars
		commentary
	}
}
variables {
	"ep": "JEDI",
	"review": {
		"stars": 5,
		"commentary": "This is a great movie!"
	}
}

You can define:

req := NewGraphRequest(`
    mutation($ep: Episode!, $review: ReviewInput!) {
        createReview(episode: $ep, review: $review) {
            stars
            commentary
        }
    }
`, map[string]any{"ep": "JEDI", "review": map[string]any{"start": 5, "commentary": "This is a great movie!"}})

You also need to define the struct：

type CreateReview struct {
    stars          int
    commentary     string
}
type Response struct {
    CreateReview CreateReview
}

Then do request:

var resp Response
err = client.Body(req).QueryOrMutate().Do(context.Background()).Decode(&resp)
if err != nil {
	// Handle error.
}
fmt.Printf("Created a %v star review: %v\n", m.CreateReview.Stars, m.CreateReview.Commentary)

// Output:
// Created a 5 star review: This is a great movie!

Subscription

For example, to make the following GraphQL query:

subscription {
	me {
		name
	}
}

You can define this graphql request:

req := NewGraphRequest(`
    subscription {
        me {
            name
        }
    }
`, nil)

You also need to define the struct：

type Me struct {
    Name          string
}
type Response struct {
    Me Me
}

Then run subscribe, passing a pointer to it:

subscribe := client.Body(req).Subscription()
go subscribe.Run(context.Background())
defer subscribe.Stop()
for {
    decoder := <-subscribe.ResultChan()
    var resp Response
    err := decoder.Decode(&resp)
    if err != nil {
        // Handle error.
    return
    }
}