Refactor ResolverMiddleware to FieldMiddleware

This will allow us to include DirectiveMiddleware in the same middleware
setup, that will run after Resolver middlewares.

codegen/templates/field.gotpl

@@ -46,7 +46,7 @@
 			rctx.PushField(field.Alias)
 			defer rctx.Pop()
 		{{- end }}
-			resTmp, err := ec.ResolverMiddleware(ctx, func(ctx context.Context) (interface{}, error) {
+			resTmp := ec.FieldMiddleware(ctx, func(ctx context.Context) (interface{}, error) {
 				{{- if $field.IsResolver }}
 					return ec.resolvers.{{ $field.ShortInvocation }}
 				{{- else if $field.GoVarName }}
@@ -59,10 +59,6 @@
 					{{- end }}
 				{{- end }}
 			})
-			if err != nil {
-				ec.Error(ctx, err)
-				return graphql.Null
-			}
 			if resTmp == nil {
 				return graphql.Null
 			}

graphql/context.go

@@ -10,7 +10,7 @@ import (
 )
 
 type Resolver func(ctx context.Context) (res interface{}, err error)
-type ResolverMiddleware func(ctx context.Context, next Resolver) (res interface{}, err error)
+type FieldMiddleware func(ctx context.Context, next Resolver) (res interface{}, err error)
 type RequestMiddleware func(ctx context.Context, next func(ctx context.Context) []byte) []byte
 
 type RequestContext struct {
@@ -19,10 +19,11 @@ type RequestContext struct {
 	Doc       *ast.QueryDocument
 	// ErrorPresenter will be used to generate the error
 	// message from errors given to Error().
-	ErrorPresenter     ErrorPresenterFunc
-	Recover            RecoverFunc
-	ResolverMiddleware ResolverMiddleware
-	RequestMiddleware  RequestMiddleware
+	ErrorPresenter      ErrorPresenterFunc
+	Recover             RecoverFunc
+	ResolverMiddleware  FieldMiddleware
+	DirectiveMiddleware FieldMiddleware
+	RequestMiddleware   RequestMiddleware
 
 	errorsMu sync.Mutex
 	Errors   gqlerror.List
@@ -32,19 +33,33 @@ func DefaultResolverMiddleware(ctx context.Context, next Resolver) (res interfac
 	return next(ctx)
 }
 
+func DefaultDirectiveMiddleware(ctx context.Context, next Resolver) (res interface{}, err error) {
+	return next(ctx)
+}
+
 func DefaultRequestMiddleware(ctx context.Context, next func(ctx context.Context) []byte) []byte {
 	return next(ctx)
 }
 
+func (c *RequestContext) FieldMiddleware(ctx context.Context, next Resolver) interface{} {
+	res, err := c.ResolverMiddleware(ctx, next)
+	if err != nil {
+		c.Error(ctx, err)
+		return nil
+	}
+	return res
+}
+
 func NewRequestContext(doc *ast.QueryDocument, query string, variables map[string]interface{}) *RequestContext {
 	return &RequestContext{
-		Doc:                doc,
-		RawQuery:           query,
-		Variables:          variables,
-		ResolverMiddleware: DefaultResolverMiddleware,
-		RequestMiddleware:  DefaultRequestMiddleware,
-		Recover:            DefaultRecover,
-		ErrorPresenter:     DefaultErrorPresenter,
+		Doc:                 doc,
+		RawQuery:            query,
+		Variables:           variables,
+		ResolverMiddleware:  DefaultResolverMiddleware,
+		DirectiveMiddleware: DefaultDirectiveMiddleware,
+		RequestMiddleware:   DefaultRequestMiddleware,
+		Recover:             DefaultRecover,
+		ErrorPresenter:      DefaultErrorPresenter,
 	}
 }
 

handler/graphql.go

@@ -24,7 +24,7 @@ type Config struct {
 	upgrader       websocket.Upgrader
 	recover        graphql.RecoverFunc
 	errorPresenter graphql.ErrorPresenterFunc
-	resolverHook   graphql.ResolverMiddleware
+	resolverHook   graphql.FieldMiddleware
 	requestHook    graphql.RequestMiddleware
 }
 
@@ -74,7 +74,7 @@ func ErrorPresenter(f graphql.ErrorPresenterFunc) Option {
 
 // ResolverMiddleware allows you to define a function that will be called around every resolver,
 // useful for tracing and logging.
-func ResolverMiddleware(middleware graphql.ResolverMiddleware) Option {
+func ResolverMiddleware(middleware graphql.FieldMiddleware) Option {
 	return func(cfg *Config) {
 		if cfg.resolverHook == nil {
 			cfg.resolverHook = middleware

opentracing/opentracing.go

@@ -10,7 +10,7 @@ import (
 	"github.com/vektah/gqlgen/graphql"
 )
 
-func ResolverMiddleware() graphql.ResolverMiddleware {
+func ResolverMiddleware() graphql.FieldMiddleware {
 	return func(ctx context.Context, next graphql.Resolver) (interface{}, error) {
 		rctx := graphql.GetResolverContext(ctx)
 		span, ctx := opentracing.StartSpanFromContext(ctx, rctx.Object+"_"+rctx.Field.Name,