Concurrently resolve fields

definition.go

@@ -120,6 +120,9 @@ var _ Output = (*NonNull)(nil)
 // Composite interface for types that may describe the parent context of a selection set.
 type Composite interface {
 	Name() string
+	Description() string
+	String() string
+	Error() error
 }
 
 var _ Composite = (*Object)(nil)

directives.go

@@ -1,15 +1,39 @@
 package graphql
 
 const (
+	// Operations
 	DirectiveLocationQuery              = "QUERY"
 	DirectiveLocationMutation           = "MUTATION"
 	DirectiveLocationSubscription       = "SUBSCRIPTION"
 	DirectiveLocationField              = "FIELD"
 	DirectiveLocationFragmentDefinition = "FRAGMENT_DEFINITION"
 	DirectiveLocationFragmentSpread     = "FRAGMENT_SPREAD"
 	DirectiveLocationInlineFragment     = "INLINE_FRAGMENT"
+
+	// Schema Definitions
+	DirectiveLocationSchema               = "SCHEMA"
+	DirectiveLocationScalar               = "SCALAR"
+	DirectiveLocationObject               = "OBJECT"
+	DirectiveLocationFieldDefinition      = "FIELD_DEFINITION"
+	DirectiveLocationArgumentDefinition   = "ARGUMENT_DEFINITION"
+	DirectiveLocationInterface            = "INTERFACE"
+	DirectiveLocationUnion                = "UNION"
+	DirectiveLocationEnum                 = "ENUM"
+	DirectiveLocationEnumValue            = "ENUM_VALUE"
+	DirectiveLocationInputObject          = "INPUT_OBJECT"
+	DirectiveLocationInputFieldDefinition = "INPUT_FIELD_DEFINITION"
 )
 
+// DefaultDeprecationReason Constant string used for default reason for a deprecation.
+const DefaultDeprecationReason = "No longer supported"
+
+// SpecifiedRules The full list of specified directives.
+var SpecifiedDirectives = []*Directive{
+	IncludeDirective,
+	SkipDirective,
+	DeprecatedDirective,
+}
+
 // Directive structs are used by the GraphQL runtime as a way of modifying execution
 // behavior. Type system creators will usually not create these directly.
 type Directive struct {
@@ -76,7 +100,7 @@ func NewDirective(config DirectiveConfig) *Directive {
 	return dir
 }
 
-// IncludeDirective is used to conditionally include fields or fragments
+// IncludeDirective is used to conditionally include fields or fragments.
 var IncludeDirective = NewDirective(DirectiveConfig{
 	Name: "include",
 	Description: "Directs the executor to include this field or fragment only when " +
@@ -94,7 +118,7 @@ var IncludeDirective = NewDirective(DirectiveConfig{
 	},
 })
 
-// SkipDirective Used to conditionally skip (exclude) fields or fragments
+// SkipDirective Used to conditionally skip (exclude) fields or fragments.
 var SkipDirective = NewDirective(DirectiveConfig{
 	Name: "skip",
 	Description: "Directs the executor to skip this field or fragment when the `if` " +
@@ -111,3 +135,22 @@ var SkipDirective = NewDirective(DirectiveConfig{
 		DirectiveLocationInlineFragment,
 	},
 })
+
+// DeprecatedDirective  Used to declare element of a GraphQL schema as deprecated.
+var DeprecatedDirective = NewDirective(DirectiveConfig{
+	Name:        "deprecated",
+	Description: "Marks an element of a GraphQL schema as no longer supported.",
+	Args: FieldConfigArgument{
+		"reason": &ArgumentConfig{
+			Type: String,
+			Description: "Explains why this element was deprecated, usually also including a " +
+				"suggestion for how to access supported similar data. Formatted" +
+				"in [Markdown](https://daringfireball.net/projects/markdown/).",
+			DefaultValue: DefaultDeprecationReason,
+		},
+	},
+	Locations: []string{
+		DirectiveLocationFieldDefinition,
+		DirectiveLocationEnumValue,
+	},
+})

directives_test.go

@@ -342,9 +342,6 @@ func TestDirectivesWorksOnInlineFragmentIfFalseOmitsInlineFragment(t *testing.T)
             b
           }
         }
-        fragment Frag on TestType {
-          b
-        }
 	`
 	expected := &graphql.Result{
 		Data: map[string]interface{}{
@@ -368,9 +365,6 @@ func TestDirectivesWorksOnInlineFragmentIfTrueIncludesInlineFragment(t *testing.
             b
           }
         }
-        fragment Frag on TestType {
-          b
-        }
 	`
 	expected := &graphql.Result{
 		Data: map[string]interface{}{
@@ -395,9 +389,6 @@ func TestDirectivesWorksOnInlineFragmentUnlessFalseIncludesInlineFragment(t *tes
             b
           }
         }
-        fragment Frag on TestType {
-          b
-        }
 	`
 	expected := &graphql.Result{
 		Data: map[string]interface{}{
@@ -422,9 +413,6 @@ func TestDirectivesWorksOnInlineFragmentUnlessTrueIncludesInlineFragment(t *test
             b
           }
         }
-        fragment Frag on TestType {
-          b
-        }
 	`
 	expected := &graphql.Result{
 		Data: map[string]interface{}{

executor.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+	"sync"
 
 	"github.com/graphql-go/graphql/gqlerrors"
 	"github.com/graphql-go/graphql/language/ast"
@@ -48,8 +49,8 @@ func Execute(p ExecuteParams) (result *Result) {
 			if r, ok := r.(error); ok {
 				err = gqlerrors.FormatError(r)
 			}
-			exeContext.Errors = append(exeContext.Errors, gqlerrors.FormatError(err))
-			result.Errors = exeContext.Errors
+			exeContext.AppendError(err)
+			result.Errors = exeContext.Errors()
 		}
 	}()
 
@@ -76,12 +77,39 @@ type ExecutionContext struct {
 	Root           interface{}
 	Operation      ast.Definition
 	VariableValues map[string]interface{}
-	Errors         []gqlerrors.FormattedError
 	Context        context.Context
+
+	errLock sync.RWMutex
+	errors  []gqlerrors.FormattedError
+}
+
+func (eCtx *ExecutionContext) AppendError(errs ...error) {
+	formattedErrors := []gqlerrors.FormattedError{}
+	for _, err := range errs {
+		formattedErrors = append(formattedErrors, gqlerrors.FormatError(err))
+	}
+	eCtx.errLock.Lock()
+	eCtx.errors = append(eCtx.errors, formattedErrors...)
+	eCtx.errLock.Unlock()
+}
+
+func (eCtx *ExecutionContext) Errors() (res []gqlerrors.FormattedError) {
+	eCtx.errLock.RLock()
+	res = eCtx.errors
+	eCtx.errLock.RUnlock()
+	return res
+}
+
+func (eCtx *ExecutionContext) SetErrors(errors []gqlerrors.FormattedError) {
+	eCtx.errLock.Lock()
+	eCtx.errors = errors
+	eCtx.errLock.Unlock()
 }
 
 func buildExecutionContext(p BuildExecutionCtxParams) (*ExecutionContext, error) {
-	eCtx := &ExecutionContext{}
+	eCtx := &ExecutionContext{
+		errLock: sync.RWMutex{},
+	}
 	var operation *ast.OperationDefinition
 	fragments := map[string]ast.Definition{}
 
@@ -122,7 +150,7 @@ func buildExecutionContext(p BuildExecutionCtxParams) (*ExecutionContext, error)
 	eCtx.Root = p.Root
 	eCtx.Operation = operation
 	eCtx.VariableValues = variableValues
-	eCtx.Errors = p.Errors
+	eCtx.SetErrors(p.Errors)
 	eCtx.Context = p.Context
 	return eCtx, nil
 }
@@ -233,7 +261,7 @@ func executeFieldsSerially(p ExecuteFieldsParams) *Result {
 
 	return &Result{
 		Data:   finalResults,
-		Errors: p.ExecutionContext.Errors,
+		Errors: p.ExecutionContext.Errors(),
 	}
 }
 
@@ -246,18 +274,42 @@ func executeFields(p ExecuteFieldsParams) *Result {
 		p.Fields = map[string][]*ast.Field{}
 	}
 
-	finalResults := map[string]interface{}{}
+	// concurrently resolve fields
+	wg := sync.WaitGroup{}
+	mtx := sync.Mutex{}
+	finalResults := make(map[string]interface{}, len(p.Fields))
+	panics := make(chan interface{}, len(p.Fields))
 	for responseName, fieldASTs := range p.Fields {
-		resolved, state := resolveField(p.ExecutionContext, p.ParentType, p.Source, fieldASTs)
-		if state.hasNoFieldDefs {
-			continue
-		}
-		finalResults[responseName] = resolved
+		wg.Add(1)
+		go func(responseName string, fieldASTs []*ast.Field) {
+			defer func() {
+				if r := recover(); r != nil {
+					panics <- r
+				}
+				wg.Done()
+			}()
+			resolved, state := resolveField(p.ExecutionContext, p.ParentType, p.Source, fieldASTs)
+			if state.hasNoFieldDefs {
+				return
+			}
+			mtx.Lock()
+			finalResults[responseName] = resolved
+			mtx.Unlock()
+		}(responseName, fieldASTs)
+	}
+
+	// wait for all routines to complete and then perform clean up
+	wg.Wait()
+	close(panics)
+
+	// re-panic if a goroutine panicked
+	for p := range panics {
+		panic(p)
 	}
 
 	return &Result{
 		Data:   finalResults,
-		Errors: p.ExecutionContext.Errors,
+		Errors: p.ExecutionContext.Errors(),
 	}
 }
 
@@ -266,6 +318,7 @@ type CollectFieldsParams struct {
 	RuntimeType          *Object // previously known as OperationType
 	SelectionSet         *ast.SelectionSet
 	Fields               map[string][]*ast.Field
+	FieldOrder           []string
 	VisitedFragmentNames map[string]bool
 }
 
@@ -480,7 +533,6 @@ func resolveField(eCtx *ExecutionContext, parentType *Object, source interface{}
 	var returnType Output
 	defer func() (interface{}, resolveFieldResultState) {
 		if r := recover(); r != nil {
-
 			var err error
 			if r, ok := r.(string); ok {
 				err = NewLocatedError(
@@ -495,7 +547,7 @@ func resolveField(eCtx *ExecutionContext, parentType *Object, source interface{}
 			if _, ok := returnType.(*NonNull); ok {
 				panic(gqlerrors.FormatError(err))
 			}
-			eCtx.Errors = append(eCtx.Errors, gqlerrors.FormatError(err))
+			eCtx.AppendError(err)
 			return result, resultState
 		}
 		return result, resultState
@@ -545,7 +597,8 @@ func resolveField(eCtx *ExecutionContext, parentType *Object, source interface{}
 	})
 
 	if resolveFnError != nil {
-		panic(gqlerrors.FormatError(resolveFnError))
+		eCtx.AppendError(resolveFnError)
+		return nil, resultState
 	}
 
 	completed := completeValueCatchingError(eCtx, returnType, fieldASTs, info, result)
@@ -561,7 +614,7 @@ func completeValueCatchingError(eCtx *ExecutionContext, returnType Type, fieldAS
 				panic(r)
 			}
 			if err, ok := r.(gqlerrors.FormattedError); ok {
-				eCtx.Errors = append(eCtx.Errors, err)
+				eCtx.AppendError(err)
 			}
 			return completed
 		}
@@ -664,7 +717,9 @@ func completeAbstractValue(eCtx *ExecutionContext, returnType Abstract, fieldAST
 	}
 
 	err := invariant(runtimeType != nil,
-		fmt.Sprintf(`Could not determine runtime type of value "%v" for field %v.%v.`, result, info.ParentType, info.FieldName),
+		fmt.Sprintf(`Abstract type %v must resolve to an Object type at runtime `+
+			`for field %v.%v with value "%v", received "%v".`,
+			returnType, info.ParentType, info.FieldName, result, runtimeType),
 	)
 	if err != nil {
 		panic(err)
@@ -755,13 +810,34 @@ func completeListValue(eCtx *ExecutionContext, returnType *List, fieldASTs []*as
 		panic(gqlerrors.FormatError(err))
 	}
 
+	// concurrently resolve list elements
 	itemType := returnType.OfType
-	completedResults := []interface{}{}
+	wg := sync.WaitGroup{}
+	completedResults := make([]interface{}, resultVal.Len())
+	panics := make(chan interface{}, resultVal.Len())
 	for i := 0; i < resultVal.Len(); i++ {
-		val := resultVal.Index(i).Interface()
-		completedItem := completeValueCatchingError(eCtx, itemType, fieldASTs, info, val)
-		completedResults = append(completedResults, completedItem)
+		wg.Add(1)
+		go func(j int) {
+			defer func() {
+				if r := recover(); r != nil {
+					panics <- r
+				}
+				wg.Done()
+			}()
+			val := resultVal.Index(j).Interface()
+			completedResults[j] = completeValueCatchingError(eCtx, itemType, fieldASTs, info, val)
+		}(i)
+	}
+
+	// wait for all routines to complete and then perform clean up
+	wg.Wait()
+	close(panics)
+
+	// re-panic if a goroutine panicked
+	for p := range panics {
+		panic(p)
 	}
+
 	return completedResults
 }