Add Client type, remove ctxhttp dependency.

ctxhttp is only useful if you want to support Go <1.7. I removed it
because this package already had a dependency on the stdlib context
package.

Author: broady

README.md

@@ -10,6 +10,13 @@ Low-level GraphQL client for Go.
 * Simple error handling
 
 ```go
+// create a client (safe to share across requests)
+ctx := context.Background()
+client, err := graphql.NewClient(ctx, "https://machinebox.io/graphql")
+if err != nil {
+    log.Fatal(err)
+}
+
 // make a request
 req := graphql.NewRequest(`
     query ($key: String!) {
@@ -24,13 +31,9 @@ req := graphql.NewRequest(`
 // set any variables
 req.Var("key", "value")
 
-// get a context
-ctx := context.Background()
-ctx := graphql.NewContext(ctx, "https://machinebox.io/graphql")
-
 // run it and capture the response
 var respData ResponseStruct
-if err := req.Run(ctx, &respData); err != nil {
-    log.Fatalln(err)
+if err := client.Run(ctx, req, &respData); err != nil {
+    log.Fatal(err)
 }
 ```

client.go

@@ -10,18 +10,41 @@ import (
 	"net/http"
 
 	"github.com/pkg/errors"
-	"golang.org/x/net/context/ctxhttp"
 )
 
-// Client accesses a GraphQL API.
-type client struct {
-	endpoint string
+// Client is a client for accessing a GraphQL dataset.
+type Client struct {
+	endpoint   string
+	httpClient *http.Client
 }
 
-// Do executes a query request and returns the response.
-func (c *client) Do(ctx context.Context, request *Request, response interface{}) error {
-	if err := ctx.Err(); err != nil {
-		return err
+type ClientOption interface {
+	apply(*Client)
+}
+
+func NewClient(ctx context.Context, endpoint string, opts ...ClientOption) (*Client, error) {
+	c := &Client{
+		endpoint: endpoint,
+	}
+	for _, o := range opts {
+		o.apply(c)
+	}
+	if c.httpClient == nil {
+		c.httpClient = http.DefaultClient
+	}
+	return c, nil
+}
+
+// Run executes the query and unmarshals the response from the data field
+// into the response object.
+// Pass in a nil response object to skip response parsing.
+// If the request fails or the server returns an error, the first error
+// will be returned. Use IsGraphQLErr to determine which it was.
+func (c *Client) Run(ctx context.Context, request *Request, response interface{}) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
 	}
 	var requestBody bytes.Buffer
 	writer := multipart.NewWriter(&requestBody)
@@ -66,11 +89,8 @@ func (c *client) Do(ctx context.Context, request *Request, response interface{})
 	}
 	req.Header.Set("Content-Type", writer.FormDataContentType())
 	req.Header.Set("Accept", "application/json")
-	client, ok := ctx.Value(httpclientContextKey).(*http.Client)
-	if !ok {
-		client = http.DefaultClient
-	}
-	res, err := ctxhttp.Do(ctx, client, req)
+	req = req.WithContext(ctx)
+	res, err := c.httpClient.Do(req)
 	if err != nil {
 		return err
 	}
@@ -89,9 +109,17 @@ func (c *client) Do(ctx context.Context, request *Request, response interface{})
 	return nil
 }
 
-// WithClient specifies the http.Client that requests will use.
-func WithClient(ctx context.Context, client *http.Client) context.Context {
-	return context.WithValue(ctx, httpclientContextKey, client)
+type httpClientOption struct {
+	hc *http.Client
+}
+
+func (o httpClientOption) apply(c *Client) {
+	c.httpClient = o.hc
+}
+
+// WithHTTPClient specifies the http.Client that requests will use.
+func WithHTTPClient(client *http.Client) ClientOption {
+	return httpClientOption{client}
 }
 
 type graphErr struct {
@@ -117,19 +145,6 @@ func NewRequest(q string) *Request {
 	return req
 }
 
-// Run executes the query and unmarshals the response from the data field
-// into the response object.
-// Pass in a nil response object to skip response parsing.
-// If the request fails or the server returns an error, the first error
-// will be returned. Use IsGraphQLErr to determine which it was.
-func (req *Request) Run(ctx context.Context, response interface{}) error {
-	client, err := fromContext(ctx)
-	if err != nil {
-		return err
-	}
-	return client.Do(ctx, req, response)
-}
-
 // Var sets a variable.
 func (req *Request) Var(key string, value interface{}) {
 	if req.vars == nil {

client_test.go

@@ -26,11 +26,12 @@ func TestWithClient(t *testing.T) {
 		}),
 	}
 
-	ctx := NewContext(context.Background(), "")
-	ctx = WithClient(ctx, testClient)
+	ctx := context.Background()
+	client, err := NewClient(ctx, "", WithHTTPClient(testClient))
+	is.NoErr(err)
 
 	req := NewRequest(``)
-	req.Run(ctx, nil)
+	client.Run(ctx, req, nil)
 
 	is.Equal(calls, 1) // calls
 }
@@ -50,14 +51,15 @@ func TestDo(t *testing.T) {
 		}`)
 	}))
 	defer srv.Close()
-	c := &client{
-		endpoint: srv.URL,
-	}
+
 	ctx := context.Background()
+	client, err := NewClient(ctx, srv.URL)
+	is.NoErr(err)
+
 	ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
 	defer cancel()
 	var responseData map[string]interface{}
-	err := c.Do(ctx, &Request{q: "query {}"}, &responseData)
+	err = client.Run(ctx, &Request{q: "query {}"}, &responseData)
 	is.NoErr(err)
 	is.Equal(calls, 1) // calls
 	is.Equal(responseData["something"], "yes")
@@ -78,14 +80,15 @@ func TestDoErr(t *testing.T) {
 		}`)
 	}))
 	defer srv.Close()
-	c := &client{
-		endpoint: srv.URL,
-	}
+
 	ctx := context.Background()
+	client, err := NewClient(ctx, srv.URL)
+	is.NoErr(err)
+
 	ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
 	defer cancel()
 	var responseData map[string]interface{}
-	err := c.Do(ctx, &Request{q: "query {}"}, &responseData)
+	err = client.Run(ctx, &Request{q: "query {}"}, &responseData)
 	is.True(err != nil)
 	is.Equal(err.Error(), "graphql: Something went wrong")
 }
@@ -105,13 +108,14 @@ func TestDoNoResponse(t *testing.T) {
 		}`)
 	}))
 	defer srv.Close()
-	c := &client{
-		endpoint: srv.URL,
-	}
+
 	ctx := context.Background()
+	client, err := NewClient(ctx, srv.URL)
+	is.NoErr(err)
+
 	ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
 	defer cancel()
-	err := c.Do(ctx, &Request{q: "query {}"}, nil)
+	err = client.Run(ctx, &Request{q: "query {}"}, nil)
 	is.NoErr(err)
 	is.Equal(calls, 1) // calls
 }
@@ -131,7 +135,9 @@ func TestQuery(t *testing.T) {
 	defer srv.Close()
 	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()
-	ctx = NewContext(ctx, srv.URL)
+
+	client, err := NewClient(ctx, srv.URL)
+	is.NoErr(err)
 
 	req := NewRequest("query {}")
 	req.Var("username", "matryer")
@@ -143,7 +149,7 @@ func TestQuery(t *testing.T) {
 	var resp struct {
 		Value string
 	}
-	err := req.Run(ctx, &resp)
+	err = client.Run(ctx, req, &resp)
 	is.NoErr(err)
 	is.Equal(calls, 1)
 
@@ -173,16 +179,17 @@ func TestFile(t *testing.T) {
 	defer srv.Close()
 	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()
-	ctx = NewContext(ctx, srv.URL)
+
+	client, err := NewClient(ctx, srv.URL)
+	is.NoErr(err)
 
 	f := strings.NewReader(`This is a file`)
 
 	req := NewRequest("query {}")
 	req.File("filename.txt", f)
 
-	err := req.Run(ctx, nil)
+	err = client.Run(ctx, req, nil)
 	is.NoErr(err)
-
 }
 
 type roundTripperFunc func(req *http.Request) (*http.Response, error)

context.go

@@ -1,4 +1,12 @@
 // Package graphql provides a low level GraphQL client.
+//
+//  // create a client (safe to share across requests)
+//  ctx := context.Background()
+//  client, err := graphql.NewClient(ctx, "https://machinebox.io/graphql")
+//  if err != nil {
+//      log.Fatal(err)
+//  }
+//
 //  // make a request
 //  req := graphql.NewRequest(`
 //      query ($key: String!) {
@@ -13,13 +21,9 @@
 //  // set any variables
 //  req.Var("key", "value")
 //
-//  // get a context
-//  ctx := context.Background()
-//  ctx := graphql.NewContext(ctx, "https://machinebox.io/graphql")
-//
 //  // run it and capture the response
 //  var respData ResponseStruct
-//  if err := req.Run(ctx, &respData); err != nil {
-//      log.Fatalln(err)
+//  if err := client.Run(ctx, req, &respData); err != nil {
+//      log.Fatal(err)
 //  }
 package graphql