Batching integration (#63)

* renamed NetworkQueryer to SingleRequestQueryer

* applying network middlewares works on any QueryerWithMiddlewares

* planner's QueryerFactory now takes the planning context

* renamed configurator to option

* added type declaration for queryer factory

* fixed comments

* added test for passing queryer factory

* cleanup

* comments

* more comment tidying

Author: AlecAivazis

execute.go

@@ -205,7 +205,7 @@ func executeStep(
 	// if we have middlewares
 	if len(ctx.RequestMiddlewares) > 0 {
 		// if the queryer is a network queryer
-		if nQueryer, ok := queryer.(*graphql.NetworkQueryer); ok {
+		if nQueryer, ok := queryer.(graphql.QueryerWithMiddlewares); ok {
 			queryer = nQueryer.WithMiddlewares(ctx.RequestMiddlewares)
 		}
 	}

execute_test.go

@@ -729,10 +729,7 @@ func TestExecutor_appliesRequestMiddlewares(t *testing.T) {
 							},
 							QueryString: `hello`,
 							// return a known value we can test against
-							Queryer: &graphql.NetworkQueryer{
-								URL:    "hello",
-								Client: httpClient,
-							},
+							Queryer: graphql.NewSingleRequestQueryer("hello").WithHTTPClient(httpClient),
 						},
 					},
 				},

gateway.go

@@ -11,19 +11,18 @@ import (
 	"github.com/nautilus/graphql"
 )
 
-type contextKey int
-
 // Gateway is the top level entry for interacting with a gateway. It is responsible for merging a list of
 // remote schemas into one, generating a query plan to execute based on an incoming request, and following
 // that plan
 type Gateway struct {
-	sources     []*graphql.RemoteSchema
-	schema      *ast.Schema
-	planner     QueryPlanner
-	executor    Executor
-	merger      Merger
-	middlewares MiddlewareList
-	queryFields []*QueryField
+	sources        []*graphql.RemoteSchema
+	schema         *ast.Schema
+	planner        QueryPlanner
+	executor       Executor
+	merger         Merger
+	middlewares    MiddlewareList
+	queryFields    []*QueryField
+	queryerFactory *QueryerFactory
 
 	// group up the list of middlewares at startup to avoid it during execution
 	requestMiddlewares  []graphql.NetworkMiddleware
@@ -94,7 +93,7 @@ func (g *Gateway) internalSchema() *ast.Schema {
 }
 
 // New instantiates a new schema with the required stuffs.
-func New(sources []*graphql.RemoteSchema, configs ...Configurator) (*Gateway, error) {
+func New(sources []*graphql.RemoteSchema, configs ...Option) (*Gateway, error) {
 	// if there are no source schemas
 	if len(sources) == 0 {
 		return nil, errors.New("a gateway must have at least one schema")
@@ -109,11 +108,19 @@ func New(sources []*graphql.RemoteSchema, configs ...Configurator) (*Gateway, er
 		queryFields: []*QueryField{nodeField},
 	}
 
-	// pass the gateway through any configurators
+	// pass the gateway through any Options
 	for _, config := range configs {
 		config(gateway)
 	}
 
+	// if we have a queryer factory to assign
+	if gateway.queryerFactory != nil {
+		// if the planner can accept the factory
+		if planner, ok := gateway.planner.(PlannerWithQueryerFactory); ok {
+			gateway.planner = planner.WithQueryerFactory(gateway.queryerFactory)
+		}
+	}
+
 	internal := gateway.internalSchema()
 	// find the field URLs before we merge schemas. We need to make sure to include
 	// the fields defined by the gateway's internal schema
@@ -174,45 +181,53 @@ func New(sources []*graphql.RemoteSchema, configs ...Configurator) (*Gateway, er
 	return gateway, nil
 }
 
-// Configurator is a function to be passed to New that configures the
+// Option is a function to be passed to New that configures the
 // resulting schema
-type Configurator func(*Gateway)
+type Option func(*Gateway)
 
-// WithPlanner returns a Configurator that sets the planner of the gateway
-func WithPlanner(p QueryPlanner) Configurator {
+// WithPlanner returns an Option that sets the planner of the gateway
+func WithPlanner(p QueryPlanner) Option {
 	return func(g *Gateway) {
 		g.planner = p
 	}
 }
 
-// WithExecutor returns a Configurator that sets the executor of the gateway
-func WithExecutor(e Executor) Configurator {
+// WithExecutor returns an Option that sets the executor of the gateway
+func WithExecutor(e Executor) Option {
 	return func(g *Gateway) {
 		g.executor = e
 	}
 }
 
-// WithMerger returns a Configurator that sets the merger of the gateway
-func WithMerger(m Merger) Configurator {
+// WithMerger returns an Option that sets the merger of the gateway
+func WithMerger(m Merger) Option {
 	return func(g *Gateway) {
 		g.merger = m
 	}
 }
 
-// WithMiddlewares returns a Configurator that adds middlewares to the gateway
-func WithMiddlewares(middlewares ...Middleware) Configurator {
+// WithMiddlewares returns an Option that adds middlewares to the gateway
+func WithMiddlewares(middlewares ...Middleware) Option {
 	return func(g *Gateway) {
 		g.middlewares = append(g.middlewares, middlewares...)
 	}
 }
 
-// WithQueryFields returns a Configurator that adds the given query fields to the gateway
-func WithQueryFields(fields ...*QueryField) Configurator {
+// WithQueryFields returns an Option that adds the given query fields to the gateway
+func WithQueryFields(fields ...*QueryField) Option {
 	return func(g *Gateway) {
 		g.queryFields = append(g.queryFields, fields...)
 	}
 }
 
+// WithQueryerFactory returns an Option that changes the queryer used by the planner
+// when generating plans that interact with remote services.
+func WithQueryerFactory(factory *QueryerFactory) Option {
+	return func(g *Gateway) {
+		g.queryerFactory = factory
+	}
+}
+
 var nodeField = &QueryField{
 	Name: "node",
 	Type: ast.NamedType("Node", &ast.Position{}),

gateway_test.go

@@ -81,7 +81,7 @@ func TestGateway(t *testing.T) {
 		}
 	})
 
-	t.Run("Variadic Configuration", func(t *testing.T) {
+	t.Run("Options", func(t *testing.T) {
 		// create a new schema with the sources and some configuration
 		gateway, err := New([]*graphql.RemoteSchema{sources[0]}, func(schema *Gateway) {
 			schema.sources = append(schema.sources, sources[1])
@@ -96,6 +96,37 @@ func TestGateway(t *testing.T) {
 		assert.Len(t, gateway.sources, 2)
 	})
 
+	t.Run("WithPlanner", func(t *testing.T) {
+		// the planner we will assign
+		planner := &MockPlanner{}
+
+		gateway, err := New(sources, WithPlanner(planner))
+		if err != nil {
+			t.Error(err.Error())
+			return
+		}
+
+		assert.Equal(t, planner, gateway.planner)
+	})
+
+	t.Run("WithQueryerFactory", func(t *testing.T) {
+		// the planner we will assign
+		planner := &MinQueriesPlanner{}
+
+		factory := QueryerFactory(func(ctx *PlanningContext, url string) graphql.Queryer {
+			return ctx.Gateway
+		})
+
+		// instantiate the gateway
+		gateway, err := New(sources, WithPlanner(planner), WithQueryerFactory(&factory))
+		if err != nil {
+			t.Error(err.Error())
+			return
+		}
+
+		assert.Equal(t, &factory, gateway.planner.(*MinQueriesPlanner).QueryerFactory)
+	})
+
 	t.Run("fieldURLs ignore introspection", func(t *testing.T) {
 		locations := fieldURLs(sources, true)
 
@@ -111,19 +142,6 @@ func TestGateway(t *testing.T) {
 		}
 	})
 
-	t.Run("Configurator WithPlanner", func(t *testing.T) {
-		// the planner we will assign
-		planner := &MockPlanner{}
-
-		gateway, err := New(sources, WithPlanner(planner))
-		if err != nil {
-			t.Error(err.Error())
-			return
-		}
-
-		assert.Equal(t, planner, gateway.planner)
-	})
-
 	t.Run("Response Middleware Error", func(t *testing.T) {
 		// create a new schema with the sources and some configuration
 		gateway, err := New(sources,

go.mod

@@ -7,15 +7,14 @@ require (
 	github.com/hashicorp/golang-lru v0.5.0 // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/mitchellh/mapstructure v1.1.2
-	github.com/nautilus/graphql v0.0.0-20190208193207-6bb377f3952a
-	github.com/opentracing/opentracing-go v1.0.2 // indirect
+	github.com/nautilus/graphql v0.0.0-20190220053332-42ac2d2a1f98
 	github.com/sirupsen/logrus v1.3.0
 	github.com/spf13/cobra v0.0.3
 	github.com/spf13/pflag v1.0.3 // indirect
 	github.com/stretchr/testify v1.3.0
 	github.com/vektah/gqlparser v1.1.0
 	golang.org/x/crypto v0.0.0-20190130090550-b01c7a725664 // indirect
-	golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3
+	golang.org/x/net v0.0.0-20190213061140-3a22650c66bd
 	golang.org/x/sys v0.0.0-20190130150945-aca44879d564 // indirect
 	golang.org/x/tools v0.0.0-20190208185513-a3f91d6be4f3 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect

go.sum

@@ -10,6 +10,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/graph-gophers/dataloader v5.0.0+incompatible h1:R+yjsbrNq1Mo3aPG+Z/EKYrXrXXUNJHOgbRt+U6jOug=
+github.com/graph-gophers/dataloader v5.0.0+incompatible/go.mod h1:jk4jk0c5ZISbKaMe8WsVopGB5/15GvGHMdMdPtwlRp4=
 github.com/graph-gophers/graphql-go v0.0.0-20190108123631-d5b7dc6be53b h1:hrePtAgLPsHHKUv6l9EDI+QSH5cjPIYYzoIsIWfZ6qY=
 github.com/graph-gophers/graphql-go v0.0.0-20190108123631-d5b7dc6be53b/go.mod h1:aRnZGurV3LlZ1Y+ygyx1mAV6OUfq+nu6OgpJ6jKgZ3g=
 github.com/graphql-go/graphql v0.7.7 h1:nwEsJGwPq9N6cElOO+NYyoWuELAQZ4GuJks0Rlco5og=
@@ -30,6 +32,10 @@ github.com/nautilus/graphql v0.0.0-20190206230122-a60d56409fd3 h1:Ck8Xk1aJF/M7ms
 github.com/nautilus/graphql v0.0.0-20190206230122-a60d56409fd3/go.mod h1:aw58+1WuROPKYEN337vjRRaH9LfiiJKu6RwwFuF1wzw=
 github.com/nautilus/graphql v0.0.0-20190208193207-6bb377f3952a h1:7sDoVtsm6RWyGTlJyoIMxC1uVIUgBgscUVcCslus1y8=
 github.com/nautilus/graphql v0.0.0-20190208193207-6bb377f3952a/go.mod h1:aw58+1WuROPKYEN337vjRRaH9LfiiJKu6RwwFuF1wzw=
+github.com/nautilus/graphql v0.0.0-20190220052332-1ec821cfd939 h1:dIhr36omlDy2IMlwbEDSQj6aEWR5BzQq8hmrY0UgGZc=
+github.com/nautilus/graphql v0.0.0-20190220052332-1ec821cfd939/go.mod h1:58l1aeXqmU+gAfwagVHqTUv8C6LBfa63mZ6VHj1dbXQ=
+github.com/nautilus/graphql v0.0.0-20190220053332-42ac2d2a1f98 h1:xz+MM8U50sjgNR1qjvh7iO4SH9zF3+fbL/kZtEjtces=
+github.com/nautilus/graphql v0.0.0-20190220053332-42ac2d2a1f98/go.mod h1:58l1aeXqmU+gAfwagVHqTUv8C6LBfa63mZ6VHj1dbXQ=
 github.com/opentracing/opentracing-go v1.0.2 h1:3jA2P6O1F9UOrWVpwrIo17pu01KWvNWg4X946/Y5Zwg=
 github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -54,6 +60,8 @@ golang.org/x/crypto v0.0.0-20190130090550-b01c7a725664 h1:YbZJ76lQ1BqNhVe7dKTSB6
 golang.org/x/crypto v0.0.0-20190130090550-b01c7a725664/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3 h1:ulvT7fqt0yHWzpJwI57MezWnYDVpCAYBVuYst/L+fAY=
 golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd h1:HuTn7WObtcDo9uEEU7rEqL0jYthdXAmZ6PP+meazmaU=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33 h1:I6FyU15t786LL7oL/hn43zqTuEGr4PN7F4XJ1p4E3Y8=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190130150945-aca44879d564 h1:o6ENHFwwr1TZ9CUPQcfo1HGvLP1OPsPOTB7xCIOPNmU=

plan.go

@@ -55,16 +55,31 @@ type QueryPlanner interface {
 	Plan(*PlanningContext) ([]*QueryPlan, error)
 }
 
+// PlannerWithQueryerFactory is an interface for planners with configurable queryer factories
+type PlannerWithQueryerFactory interface {
+	WithQueryerFactory(*QueryerFactory) QueryPlanner
+}
+
+// QueryerFactory is a function that returns the queryer to use depending on the context
+type QueryerFactory func(ctx *PlanningContext, url string) graphql.Queryer
+
 // Planner is meant to be embedded in other QueryPlanners to share configuration
 type Planner struct {
-	QueryerFactory func(url string) graphql.Queryer
+	QueryerFactory *QueryerFactory
+	queryerCache   map[string]graphql.Queryer
 }
 
 // MinQueriesPlanner does the most basic level of query planning
 type MinQueriesPlanner struct {
 	Planner
 }
 
+// WithQueryerFactory returns a version of the planner with the factory set
+func (p *MinQueriesPlanner) WithQueryerFactory(factory *QueryerFactory) QueryPlanner {
+	p.Planner.QueryerFactory = factory
+	return p
+}
+
 // PlanningContext is the input struct to the Plan method
 type PlanningContext struct {
 	Query     string
@@ -864,11 +879,11 @@ func (p *Planner) GetQueryer(ctx *PlanningContext, url string) graphql.Queryer {
 	// if there is a queryer factory defined
 	if p.QueryerFactory != nil {
 		// use the factory
-		return p.QueryerFactory(url)
+		return (*p.QueryerFactory)(ctx, url)
 	}
 
-	// otherwise return a network queryer
-	return graphql.NewNetworkQueryer(url)
+	// return the queryer for the url
+	return graphql.NewSingleRequestQueryer(url)
 }
 
 func plannerBuildQuery(parentType string, variables ast.VariableDefinitionList, selectionSet ast.SelectionSet, fragmentDefinitions ast.FragmentDefinitionList) *ast.QueryDocument {

plan_test.go

@@ -46,8 +46,8 @@ func TestPlanQuery_singleRootField(t *testing.T) {
 	rootField := graphql.SelectedFields(root.SelectionSet)[0]
 
 	// make sure that the first step is pointed at the right place
-	queryer := root.Queryer.(*graphql.NetworkQueryer)
-	assert.Equal(t, location, queryer.URL)
+	queryer := root.Queryer.(*graphql.SingleRequestQueryer)
+	assert.Equal(t, location, queryer.URL())
 
 	// we need to be asking for Query.foo
 	assert.Equal(t, rootField.Name, "foo")
@@ -363,10 +363,10 @@ func TestPlanQuery_nestedInlineFragmentsSameLocation(t *testing.T) {
 	// find the steps
 	for _, step := range steps {
 		// look at the queryer to figure out where the request is going
-		if queryer, ok := step.Queryer.(*graphql.NetworkQueryer); ok {
-			if queryer.URL == loc1 {
+		if queryer, ok := step.Queryer.(*graphql.SingleRequestQueryer); ok {
+			if queryer.URL() == loc1 {
 				loc1Step = step
-			} else if queryer.URL == loc2 {
+			} else if queryer.URL() == loc2 {
 				loc2Step = step
 			}
 		} else {
@@ -500,8 +500,8 @@ func TestPlanQuery_singleRootObject(t *testing.T) {
 	rootField := graphql.SelectedFields(rootStep.SelectionSet)[0]
 
 	// make sure that the first step is pointed at the right place
-	queryer := rootStep.Queryer.(*graphql.NetworkQueryer)
-	assert.Equal(t, location, queryer.URL)
+	queryer := rootStep.Queryer.(*graphql.SingleRequestQueryer)
+	assert.Equal(t, location, queryer.URL())
 
 	// we need to be asking for allUsers
 	assert.Equal(t, rootField.Name, "allUsers")
@@ -617,8 +617,8 @@ func TestPlanQuery_subGraphs(t *testing.T) {
 	}
 	firstField := graphql.SelectedFields(firstStep.SelectionSet)[0]
 	// it is resolved against the user service
-	queryer := firstStep.Queryer.(*graphql.NetworkQueryer)
-	assert.Equal(t, userLocation, queryer.URL)
+	queryer := firstStep.Queryer.(*graphql.SingleRequestQueryer)
+	assert.Equal(t, userLocation, queryer.URL())
 
 	// make sure it is for allUsers
 	assert.Equal(t, "allUsers", firstField.Name)
@@ -655,8 +655,8 @@ func TestPlanQuery_subGraphs(t *testing.T) {
 	// make sure we are grabbing values off of User since we asked for User.catPhotos
 	assert.Equal(t, "User", secondStep.ParentType)
 	// we should be going to the catePhoto servie
-	queryer = secondStep.Queryer.(*graphql.NetworkQueryer)
-	assert.Equal(t, catLocation, queryer.URL)
+	queryer = secondStep.Queryer.(*graphql.SingleRequestQueryer)
+	assert.Equal(t, catLocation, queryer.URL())
 	// we should only want one field selected
 	if len(secondStep.SelectionSet) != 1 {
 		t.Errorf("Did not have the right number of subfields of User.catPhotos: %v", len(secondStep.SelectionSet))
@@ -687,8 +687,8 @@ func TestPlanQuery_subGraphs(t *testing.T) {
 	// make sure we are grabbing values off of User since we asked for User.catPhotos
 	assert.Equal(t, "CatPhoto", thirdStep.ParentType)
 	// we should be going to the catePhoto service
-	queryer = thirdStep.Queryer.(*graphql.NetworkQueryer)
-	assert.Equal(t, userLocation, queryer.URL)
+	queryer = thirdStep.Queryer.(*graphql.SingleRequestQueryer)
+	assert.Equal(t, userLocation, queryer.URL())
 	// make sure we will insert the step in the right place
 	assert.Equal(t, []string{"allUsers", "catPhotos"}, thirdStep.InsertionPoint)
 
@@ -1031,7 +1031,7 @@ func TestPlanQuery_nodeField(t *testing.T) {
 	var url1Step *QueryPlanStep
 	var url2Step *QueryPlanStep
 	for _, step := range internalStep.Then {
-		if queryer, ok := step.Queryer.(*graphql.NetworkQueryer); ok && queryer.URL == "url1" {
+		if queryer, ok := step.Queryer.(*graphql.SingleRequestQueryer); ok && queryer.URL() == "url1" {
 			url1Step = step
 		} else {
 			url2Step = step