separate query, mutation, subscription resolver

for the purpose of modular resolver if include subscription resolver

Author: agungdwiprasetyo

.gitignore

@@ -1,3 +1,4 @@
 /internal/validation/testdata/graphql-js
 /internal/validation/testdata/node_modules
 /vendor
+subscription/

go.mod

@@ -1,5 +1,8 @@
 module github.com/agungdwiprasetyo/graphql-go
 
-require github.com/opentracing/opentracing-go v1.1.0
+require (
+	github.com/opentracing/opentracing-go v1.1.0
+	github.com/stretchr/testify v1.4.0 // indirect
+)
 
 go 1.13

go.sum

@@ -1,2 +1,13 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

graphql.go

@@ -158,7 +158,7 @@ func (s *Schema) Validate(queryString string) []*errors.QueryError {
 // without a resolver. If the context get cancelled, no further resolvers will be called and a
 // the context error will be returned as soon as possible (not immediately).
 func (s *Schema) Exec(ctx context.Context, queryString string, operationName string, variables map[string]interface{}) *Response {
-	if s.res.Resolver == (reflect.Value{}) {
+	if s.res.ResolverQuery == (reflect.Value{}) {
 		panic("schema created without resolver, can not exec")
 	}
 	return s.exec(ctx, queryString, operationName, variables, s.res)

internal/exec/exec.go

@@ -45,7 +45,16 @@ func (r *Request) Execute(ctx context.Context, s *resolvable.Schema, op *query.O
 	func() {
 		defer r.handlePanic(ctx)
 		sels := selected.ApplyOperation(&r.Request, s, op)
-		r.execSelections(ctx, sels, nil, s, s.Resolver, &out, op.Type == query.Mutation)
+		var resolver reflect.Value
+		switch op.Type {
+		case query.Query:
+			resolver = s.ResolverQuery
+		case query.Mutation:
+			resolver = s.ResolverMutation
+		case query.Subscription:
+			resolver = s.ResolverSubscription
+		}
+		r.execSelections(ctx, sels, nil, s, resolver, &out, op.Type == query.Mutation)
 	}()
 
 	if err := ctx.Err(); err != nil {

internal/exec/resolvable/resolvable.go

@@ -11,13 +11,23 @@ import (
 	"github.com/agungdwiprasetyo/graphql-go/internal/schema"
 )
 
+type QueryResolver interface {
+	Query() interface{}
+}
+
+type MutationResolver interface {
+	Mutation() interface{}
+}
+
+type SubscriptionResolver interface {
+	Subscription() interface{}
+}
+
 type Schema struct {
 	*Meta
 	schema.Schema
-	Query        Resolvable
-	Mutation     Resolvable
-	Subscription Resolvable
-	Resolver     reflect.Value
+	Query, Mutation, Subscription                         Resolvable
+	ResolverQuery, ResolverMutation, ResolverSubscription reflect.Value
 }
 
 type Resolvable interface {
@@ -70,20 +80,33 @@ func ApplyResolver(s *schema.Schema, resolver interface{}) (*Schema, error) {
 
 	var query, mutation, subscription Resolvable
 
+	queryResolver := resolver
+	if r, ok := resolver.(QueryResolver); ok {
+		queryResolver = r.Query()
+	}
+	mutationResolver := resolver
+	if r, ok := resolver.(MutationResolver); ok {
+		mutationResolver = r.Mutation()
+	}
+	subscriptionResolver := resolver
+	if r, ok := resolver.(SubscriptionResolver); ok {
+		subscriptionResolver = r.Subscription()
+	}
+
 	if t, ok := s.EntryPoints["query"]; ok {
-		if err := b.assignExec(&query, t, reflect.TypeOf(resolver)); err != nil {
+		if err := b.assignExec(&query, t, reflect.TypeOf(queryResolver)); err != nil {
 			return nil, err
 		}
 	}
 
 	if t, ok := s.EntryPoints["mutation"]; ok {
-		if err := b.assignExec(&mutation, t, reflect.TypeOf(resolver)); err != nil {
+		if err := b.assignExec(&mutation, t, reflect.TypeOf(mutationResolver)); err != nil {
 			return nil, err
 		}
 	}
 
 	if t, ok := s.EntryPoints["subscription"]; ok {
-		if err := b.assignExec(&subscription, t, reflect.TypeOf(resolver)); err != nil {
+		if err := b.assignExec(&subscription, t, reflect.TypeOf(subscriptionResolver)); err != nil {
 			return nil, err
 		}
 	}
@@ -93,12 +116,14 @@ func ApplyResolver(s *schema.Schema, resolver interface{}) (*Schema, error) {
 	}
 
 	return &Schema{
-		Meta:         newMeta(s),
-		Schema:       *s,
-		Resolver:     reflect.ValueOf(resolver),
-		Query:        query,
-		Mutation:     mutation,
-		Subscription: subscription,
+		Meta:                 newMeta(s),
+		Schema:               *s,
+		ResolverQuery:        reflect.ValueOf(queryResolver),
+		ResolverMutation:     reflect.ValueOf(mutationResolver),
+		ResolverSubscription: reflect.ValueOf(subscriptionResolver),
+		Query:                query,
+		Mutation:             mutation,
+		Subscription:         subscription,
 	}, nil
 }
 

internal/exec/subscribe.go

@@ -29,7 +29,7 @@ func (r *Request) Subscribe(ctx context.Context, s *resolvable.Schema, op *query
 
 		sels := selected.ApplyOperation(&r.Request, s, op)
 		var fields []*fieldToExec
-		collectFieldsToResolve(sels, s, s.Resolver, &fields, make(map[string]*fieldToExec))
+		collectFieldsToResolve(sels, s, s.ResolverSubscription, &fields, make(map[string]*fieldToExec))
 
 		// TODO: move this check into validation.Validate
 		if len(fields) != 1 {

subscriptions.go

@@ -21,7 +21,7 @@ import (
 // further resolvers will be called. The context error will be returned as soon
 // as possible (not immediately).
 func (s *Schema) Subscribe(ctx context.Context, queryString string, operationName string, variables map[string]interface{}) (<-chan interface{}, error) {
-	if s.res.Resolver == (reflect.Value{}) {
+	if s.res.ResolverSubscription == (reflect.Value{}) {
 		return nil, errors.New("schema created without resolver, can not subscribe")
 	}
 	if _, ok := s.schema.EntryPoints["subscription"]; !ok {