Separate resolvers for queries and mutations

example/starwars/server/server.go

@@ -12,7 +12,7 @@ import (
 var schema *graphql.Schema
 
 func init() {
-	schema = graphql.MustParseSchema(starwars.Schema, &starwars.Resolver{})
+	schema = graphql.MustParseSchema(starwars.Schema, &starwars.RootResolver{})
 }
 
 func main() {

example/starwars/starwars.go

@@ -284,24 +284,34 @@ type review struct {
 
 var reviews = make(map[string][]*review)
 
-type Resolver struct{}
+type RootResolver struct{}
+type QueryResolver struct{}
+type MutationResolver struct{}
 
-func (r *Resolver) Hero(args struct{ Episode string }) *characterResolver {
+func (r *RootResolver) Query() *QueryResolver {
+	return &QueryResolver{}
+}
+
+func (r *RootResolver) Mutation() *MutationResolver {
+	return &MutationResolver{}
+}
+
+func (r *QueryResolver) Hero(args struct{ Episode string }) *characterResolver {
 	if args.Episode == "EMPIRE" {
 		return &characterResolver{&humanResolver{humanData["1000"]}}
 	}
 	return &characterResolver{&droidResolver{droidData["2001"]}}
 }
 
-func (r *Resolver) Reviews(args struct{ Episode string }) []*reviewResolver {
+func (r *QueryResolver) Reviews(args struct{ Episode string }) []*reviewResolver {
 	var l []*reviewResolver
 	for _, review := range reviews[args.Episode] {
 		l = append(l, &reviewResolver{review})
 	}
 	return l
 }
 
-func (r *Resolver) Search(args struct{ Text string }) []*searchResultResolver {
+func (r *QueryResolver) Search(args struct{ Text string }) []*searchResultResolver {
 	var l []*searchResultResolver
 	for _, h := range humans {
 		if strings.Contains(h.Name, args.Text) {
@@ -321,7 +331,7 @@ func (r *Resolver) Search(args struct{ Text string }) []*searchResultResolver {
 	return l
 }
 
-func (r *Resolver) Character(args struct{ ID graphql.ID }) *characterResolver {
+func (r *QueryResolver) Character(args struct{ ID graphql.ID }) *characterResolver {
 	if h := humanData[args.ID]; h != nil {
 		return &characterResolver{&humanResolver{h}}
 	}
@@ -331,28 +341,28 @@ func (r *Resolver) Character(args struct{ ID graphql.ID }) *characterResolver {
 	return nil
 }
 
-func (r *Resolver) Human(args struct{ ID graphql.ID }) *humanResolver {
+func (r *QueryResolver) Human(args struct{ ID graphql.ID }) *humanResolver {
 	if h := humanData[args.ID]; h != nil {
 		return &humanResolver{h}
 	}
 	return nil
 }
 
-func (r *Resolver) Droid(args struct{ ID graphql.ID }) *droidResolver {
+func (r *QueryResolver) Droid(args struct{ ID graphql.ID }) *droidResolver {
 	if d := droidData[args.ID]; d != nil {
 		return &droidResolver{d}
 	}
 	return nil
 }
 
-func (r *Resolver) Starship(args struct{ ID graphql.ID }) *starshipResolver {
+func (r *QueryResolver) Starship(args struct{ ID graphql.ID }) *starshipResolver {
 	if s := starshipData[args.ID]; s != nil {
 		return &starshipResolver{s}
 	}
 	return nil
 }
 
-func (r *Resolver) CreateReview(args *struct {
+func (r *MutationResolver) CreateReview(args *struct {
 	Episode string
 	Review  *reviewInput
 }) *reviewResolver {

graphql_test.go

@@ -61,7 +61,7 @@ func (r *timeResolver) AddHour(args struct{ Time graphql.Time }) graphql.Time {
 	return graphql.Time{Time: args.Time.Add(time.Hour)}
 }
 
-var starwarsSchema = graphql.MustParseSchema(starwars.Schema, &starwars.Resolver{})
+var starwarsSchema = graphql.MustParseSchema(starwars.Schema, &starwars.RootResolver{})
 
 func TestHelloWorld(t *testing.T) {
 	gqltesting.RunTests(t, []*gqltesting.Test{

internal/exec/exec.go

@@ -40,7 +40,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.Resolver, &out, op.Type == query.Mutation)
+		var resolver reflect.Value
+		switch op.Type {
+		case query.Query:
+			resolver = s.QueryResolver
+		case query.Mutation:
+			resolver = s.MutationResolver
+		default:
+			panic("unknown query operation")
+		}
+		r.execSelections(ctx, sels, nil, resolver, &out, op.Type == query.Mutation)
 	}()
 
 	if err := ctx.Err(); err != nil {

internal/exec/resolvable/resolvable.go

@@ -6,16 +6,19 @@ import (
 	"reflect"
 	"strings"
 
+	"errors"
+
 	"github.com/graph-gophers/graphql-go/internal/common"
 	"github.com/graph-gophers/graphql-go/internal/exec/packer"
 	"github.com/graph-gophers/graphql-go/internal/schema"
 )
 
 type Schema struct {
 	schema.Schema
-	Query    Resolvable
-	Mutation Resolvable
-	Resolver reflect.Value
+	Query            Resolvable
+	Mutation         Resolvable
+	QueryResolver    reflect.Value
+	MutationResolver reflect.Value
 }
 
 type Resolvable interface {
@@ -57,16 +60,33 @@ func (*Scalar) isResolvable() {}
 func ApplyResolver(s *schema.Schema, resolver interface{}) (*Schema, error) {
 	b := newBuilder(s)
 
-	var query, mutation Resolvable
+	root := reflect.ValueOf(resolver)
+
+	var (
+		query, mutation                 Resolvable
+		queryResolver, mutationResolver reflect.Value
+	)
 
 	if t, ok := s.EntryPoints["query"]; ok {
-		if err := b.assignExec(&query, t, reflect.TypeOf(resolver)); err != nil {
+		rFunc := root.MethodByName("Query")
+		if !rFunc.IsValid() {
+			return nil, errors.New("not found query resolver")
+		}
+
+		queryResolver = rFunc.Call(nil)[0]
+		if err := b.assignExec(&query, t, queryResolver.Type()); err != nil {
 			return nil, err
 		}
 	}
 
 	if t, ok := s.EntryPoints["mutation"]; ok {
-		if err := b.assignExec(&mutation, t, reflect.TypeOf(resolver)); err != nil {
+		rFunc := root.MethodByName("Mutation")
+		if !rFunc.IsValid() {
+			return nil, errors.New("not found mutation resolver")
+		}
+
+		mutationResolver = rFunc.Call(nil)[0]
+		if err := b.assignExec(&mutation, t, mutationResolver.Type()); err != nil {
 			return nil, err
 		}
 	}
@@ -76,10 +96,11 @@ func ApplyResolver(s *schema.Schema, resolver interface{}) (*Schema, error) {
 	}
 
 	return &Schema{
-		Schema:   *s,
-		Resolver: reflect.ValueOf(resolver),
-		Query:    query,
-		Mutation: mutation,
+		Schema:           *s,
+		QueryResolver:    queryResolver,
+		MutationResolver: mutationResolver,
+		Query:            query,
+		Mutation:         mutation,
 	}, nil
 }
 

relay/relay_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/graph-gophers/graphql-go/relay"
 )
 
-var starwarsSchema = graphql.MustParseSchema(starwars.Schema, &starwars.Resolver{})
+var starwarsSchema = graphql.MustParseSchema(starwars.Schema, &starwars.RootResolver{})
 
 func TestServeHTTP(t *testing.T) {
 	w := httptest.NewRecorder()