Added support of custom directives

Author: eko

example/caching/server/server.go

@@ -9,6 +9,7 @@ import (
 	"github.com/graph-gophers/graphql-go"
 	"github.com/graph-gophers/graphql-go/example/caching"
 	"github.com/graph-gophers/graphql-go/example/caching/cache"
+	"github.com/graph-gophers/graphql-go/types"
 )
 
 var schema *graphql.Schema
@@ -40,12 +41,12 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	var hint *cache.Hint
 	if cacheable(r) {
 		ctx, hints, done := cache.Hintable(r.Context())
-		response = h.Schema.Exec(ctx, p.Query, p.OperationName, p.Variables)
+		response = h.Schema.Exec(ctx, p.Query, p.OperationName, p.Variables, map[string]types.DirectiveVisitor{})
 		done()
 		v := <-hints
 		hint = &v
 	} else {
-		response = h.Schema.Exec(r.Context(), p.Query, p.OperationName, p.Variables)
+		response = h.Schema.Exec(r.Context(), p.Query, p.OperationName, p.Variables, map[string]types.DirectiveVisitor{})
 	}
 	responseJSON, err := json.Marshal(response)
 	if err != nil {

gqltesting/testing.go

@@ -12,18 +12,20 @@ import (
 
 	graphql "github.com/graph-gophers/graphql-go"
 	"github.com/graph-gophers/graphql-go/errors"
+	"github.com/graph-gophers/graphql-go/types"
 )
 
 // Test is a GraphQL test case to be used with RunTest(s).
 type Test struct {
-	Context        context.Context
-	Schema         *graphql.Schema
-	Query          string
-	OperationName  string
-	Variables      map[string]interface{}
-	ExpectedResult string
-	ExpectedErrors []*errors.QueryError
-	RawResponse    bool
+	Context           context.Context
+	Schema            *graphql.Schema
+	Query             string
+	OperationName     string
+	Variables         map[string]interface{}
+	ExpectedResult    string
+	ExpectedErrors    []*errors.QueryError
+	RawResponse       bool
+	DirectiveVisitors map[string]types.DirectiveVisitor
 }
 
 // RunTests runs the given GraphQL test cases as subtests.
@@ -45,7 +47,7 @@ func RunTest(t *testing.T, test *Test) {
 	if test.Context == nil {
 		test.Context = context.Background()
 	}
-	result := test.Schema.Exec(test.Context, test.Query, test.OperationName, test.Variables)
+	result := test.Schema.Exec(test.Context, test.Query, test.OperationName, test.Variables, test.DirectiveVisitors)
 
 	checkErrors(t, test.ExpectedErrors, result.Errors)
 

graphql.go

@@ -186,14 +186,14 @@ func (s *Schema) ValidateWithVariables(queryString string, variables map[string]
 // Exec executes the given query with the schema's resolver. It panics if the schema was created
 // 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 {
+func (s *Schema) Exec(ctx context.Context, queryString string, operationName string, variables map[string]interface{}, visitors map[string]types.DirectiveVisitor) *Response {
 	if s.res.Resolver == (reflect.Value{}) {
 		panic("schema created without resolver, can not exec")
 	}
-	return s.exec(ctx, queryString, operationName, variables, s.res)
+	return s.exec(ctx, queryString, operationName, variables, visitors, s.res)
 }
 
-func (s *Schema) exec(ctx context.Context, queryString string, operationName string, variables map[string]interface{}, res *resolvable.Schema) *Response {
+func (s *Schema) exec(ctx context.Context, queryString string, operationName string, variables map[string]interface{}, visitors map[string]types.DirectiveVisitor, res *resolvable.Schema) *Response {
 	doc, qErr := query.Parse(queryString)
 	if qErr != nil {
 		return &Response{Errors: []*errors.QueryError{qErr}}
@@ -244,9 +244,10 @@ func (s *Schema) exec(ctx context.Context, queryString string, operationName str
 			Schema:               s.schema,
 			DisableIntrospection: s.disableIntrospection,
 		},
-		Limiter: make(chan struct{}, s.maxParallelism),
-		Tracer:  s.tracer,
-		Logger:  s.logger,
+		Limiter:  make(chan struct{}, s.maxParallelism),
+		Tracer:   s.tracer,
+		Logger:   s.logger,
+		Visitors: visitors,
 	}
 	varTypes := make(map[string]*introspection.Type)
 	for _, v := range op.Vars {

graphql_test.go

@@ -11,6 +11,7 @@ import (
 	gqlerrors "github.com/graph-gophers/graphql-go/errors"
 	"github.com/graph-gophers/graphql-go/example/starwars"
 	"github.com/graph-gophers/graphql-go/gqltesting"
+	"github.com/graph-gophers/graphql-go/types"
 )
 
 type helloWorldResolver1 struct{}
@@ -45,6 +46,27 @@ func (r *helloSnakeResolver2) SayHello(ctx context.Context, args struct{ FullNam
 	return "Hello " + args.FullName + "!", nil
 }
 
+type customDirectiveVisitor struct {
+	beforeWasCalled bool
+}
+
+func (v *customDirectiveVisitor) Before(ctx context.Context, directive *types.Directive, input interface{}) error {
+	v.beforeWasCalled = true
+	return nil
+}
+
+func (v *customDirectiveVisitor) After(ctx context.Context, directive *types.Directive, output interface{}) (interface{}, error) {
+	if v.beforeWasCalled == false {
+		return nil, errors.New("Before directive visitor method wasn't called.")
+	}
+
+	if value, ok := directive.Arguments.Get("customAttribute"); ok {
+		return fmt.Sprintf("Directive '%s' (with arg '%s') modified result: %s", directive.Name.Name, value.String(), output.(string)), nil
+	} else {
+		return fmt.Sprintf("Directive '%s' modified result: %s", directive.Name.Name, output.(string)), nil
+	}
+}
+
 type theNumberResolver struct {
 	number int32
 }
@@ -188,7 +210,6 @@ func TestHelloWorld(t *testing.T) {
 				}
 			`,
 		},
-
 		{
 			Schema: graphql.MustParseSchema(`
 				schema {
@@ -213,6 +234,67 @@ func TestHelloWorld(t *testing.T) {
 	})
 }
 
+func TestCustomDirective(t *testing.T) {
+	t.Parallel()
+
+	gqltesting.RunTests(t, []*gqltesting.Test{
+		{
+			Schema: graphql.MustParseSchema(`
+				directive @customDirective on FIELD_DEFINITION
+
+				schema {
+					query: Query
+				}
+
+				type Query {
+					hello_html: String! @customDirective
+				}
+			`, &helloSnakeResolver1{}),
+			Query: `
+				{
+					hello_html
+				}
+			`,
+			ExpectedResult: `
+				{
+					"hello_html": "Directive 'customDirective' modified result: Hello snake!"
+				}
+			`,
+			DirectiveVisitors: map[string]types.DirectiveVisitor{
+				"customDirective": &customDirectiveVisitor{},
+			},
+		},
+		{
+			Schema: graphql.MustParseSchema(`
+				directive @customDirective(
+					customAttribute: String!
+			    ) on FIELD_DEFINITION
+
+				schema {
+					query: Query
+				}
+
+				type Query {
+					say_hello(full_name: String!): String! @customDirective(customAttribute: hi)
+				}
+			`, &helloSnakeResolver1{}),
+			Query: `
+				{
+					say_hello(full_name: "Johnny")
+				}
+			`,
+			ExpectedResult: `
+				{
+					"say_hello": "Directive 'customDirective' (with arg 'hi') modified result: Hello Johnny!"
+				}
+			`,
+			DirectiveVisitors: map[string]types.DirectiveVisitor{
+				"customDirective": &customDirectiveVisitor{},
+			},
+		},
+	})
+}
+
 func TestHelloSnake(t *testing.T) {
 	t.Parallel()
 
@@ -3728,7 +3810,7 @@ func TestSchema_Exec_without_resolver(t *testing.T) {
 					t.Fail()
 				}
 			}()
-			_ = s.Exec(context.Background(), tt.Args.Query, "", map[string]interface{}{})
+			_ = s.Exec(context.Background(), tt.Args.Query, "", map[string]interface{}{}, map[string]types.DirectiveVisitor{})
 		})
 	}
 }

internal/common/lexer_test.go

@@ -94,21 +94,21 @@ func TestConsume(t *testing.T) {
 	}
 }
 
-var multilineStringTests = []consumeTestCase {
+var multilineStringTests = []consumeTestCase{
 	{
-		description: "Oneline strings are okay",
-		definition: `"Hello World"`,
-		expected: "",
-		failureExpected: false,
-		useStringDescriptions: true,		
+		description:           "Oneline strings are okay",
+		definition:            `"Hello World"`,
+		expected:              "",
+		failureExpected:       false,
+		useStringDescriptions: true,
 	},
 	{
 		description: "Multiline strings are not allowed",
 		definition: `"Hello
 				 World"`,
-		expected: `graphql: syntax error: literal not terminated (line 1, column 1)`,
-		failureExpected: true,
-		useStringDescriptions: true,		
+		expected:              `graphql: syntax error: literal not terminated (line 1, column 1)`,
+		failureExpected:       true,
+		useStringDescriptions: true,
 	},
 }
 
@@ -130,5 +130,5 @@ func TestMultilineString(t *testing.T) {
 				t.Fatalf("Test '%s' failed with error: '%s'", test.description, err.Error())
 			}
 		})
-	}	
+	}
 }

internal/exec/exec.go

@@ -24,6 +24,7 @@ type Request struct {
 	Tracer                   trace.Tracer
 	Logger                   log.Logger
 	SubscribeResolverTimeout time.Duration
+	Visitors                 map[string]types.DirectiveVisitor
 }
 
 func (r *Request) handlePanic(ctx context.Context) {
@@ -206,8 +207,47 @@ func execFieldSelection(ctx context.Context, r *Request, s *resolvable.Schema, f
 			if f.field.ArgsPacker != nil {
 				in = append(in, f.field.PackedArgs)
 			}
+
+			// Before hook directive visitor
+			if len(f.field.Directives) > 0 {
+				for _, directive := range f.field.Directives {
+					if visitor, ok := r.Visitors[directive.Name.Name]; ok {
+						var values = make([]interface{}, 0)
+						for _, inValue := range in {
+							values = append(values, inValue.Interface())
+						}
+
+						if visitorErr := visitor.Before(ctx, directive, values); err != nil {
+							err := errors.Errorf("%s", visitorErr)
+							err.Path = path.toSlice()
+							err.ResolverError = visitorErr
+							return err
+						}
+					}
+				}
+			}
+
+			// Call method
 			callOut := res.Method(f.field.MethodIndex).Call(in)
 			result = callOut[0]
+
+			// After hook directive visitor (when no error is returned from resolver)
+			if !f.field.HasError && len(f.field.Directives) > 0 {
+				for _, directive := range f.field.Directives {
+					if visitor, ok := r.Visitors[directive.Name.Name]; ok {
+						returned, visitorErr := visitor.After(ctx, directive, result.Interface())
+						if err != nil {
+							err := errors.Errorf("%s", visitorErr)
+							err.Path = path.toSlice()
+							err.ResolverError = visitorErr
+							return err
+						} else {
+							result = reflect.ValueOf(returned)
+						}
+					}
+				}
+			}
+
 			if f.field.HasError && !callOut[1].IsNil() {
 				resolverErr := callOut[1].Interface().(error)
 				err := errors.Errorf("%s", resolverErr)

introspection.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/graph-gophers/graphql-go/internal/exec/resolvable"
 	"github.com/graph-gophers/graphql-go/introspection"
+	"github.com/graph-gophers/graphql-go/types"
 )
 
 // Inspect allows inspection of the given schema.
@@ -15,7 +16,7 @@ func (s *Schema) Inspect() *introspection.Schema {
 
 // ToJSON encodes the schema in a JSON format used by tools like Relay.
 func (s *Schema) ToJSON() ([]byte, error) {
-	result := s.exec(context.Background(), introspectionQuery, "", nil, &resolvable.Schema{
+	result := s.exec(context.Background(), introspectionQuery, "", nil, map[string]types.DirectiveVisitor{}, &resolvable.Schema{
 		Meta:   s.res.Meta,
 		Query:  &resolvable.Object{},
 		Schema: *s.schema,

relay/relay.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	graphql "github.com/graph-gophers/graphql-go"
+	"github.com/graph-gophers/graphql-go/types"
 )
 
 func MarshalID(kind string, spec interface{}) graphql.ID {
@@ -58,7 +59,7 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	response := h.Schema.Exec(r.Context(), params.Query, params.OperationName, params.Variables)
+	response := h.Schema.Exec(r.Context(), params.Query, params.OperationName, params.Variables, map[string]types.DirectiveVisitor{})
 	responseJSON, err := json.Marshal(response)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)

types/directive.go

@@ -1,5 +1,7 @@
 package types
 
+import "context"
+
 // Directive is a representation of the GraphQL Directive.
 //
 // http://spec.graphql.org/draft/#sec-Language.Directives
@@ -20,6 +22,11 @@ type DirectiveDefinition struct {
 
 type DirectiveList []*Directive
 
+type DirectiveVisitor interface {
+	Before(ctx context.Context, directive *Directive, input interface{}) error
+	After(ctx context.Context, directive *Directive, output interface{}) (interface{}, error)
+}
+
 // Returns the Directive in the DirectiveList by name or nil if not found.
 func (l DirectiveList) Get(name string) *Directive {
 	for _, d := range l {