Merge pull request #363 from ccbrown/error-spec-catchup

Implement June 2018 error spec

Author: chris-ramon

abstract_test.go

@@ -507,8 +507,17 @@ func TestResolveTypeOnInterfaceYieldsUsefulError(t *testing.T) {
 		},
 		Errors: []gqlerrors.FormattedError{
 			{
-				Message:   `Runtime Object type "Human" is not a possible type for "Pet".`,
-				Locations: []location.SourceLocation{},
+				Message: `Runtime Object type "Human" is not a possible type for "Pet".`,
+				Locations: []location.SourceLocation{
+					{
+						Line:   2,
+						Column: 7,
+					},
+				},
+				Path: []interface{}{
+					"pets",
+					2,
+				},
 			},
 		},
 	}
@@ -625,8 +634,17 @@ func TestResolveTypeOnUnionYieldsUsefulError(t *testing.T) {
 		},
 		Errors: []gqlerrors.FormattedError{
 			{
-				Message:   `Runtime Object type "Human" is not a possible type for "Pet".`,
-				Locations: []location.SourceLocation{},
+				Message: `Runtime Object type "Human" is not a possible type for "Pet".`,
+				Locations: []location.SourceLocation{
+					{
+						Line:   2,
+						Column: 7,
+					},
+				},
+				Path: []interface{}{
+					"pets",
+					2,
+				},
 			},
 		},
 	}

definition.go

@@ -1288,3 +1288,24 @@ func assertValidName(name string) error {
 		`Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "%v" does not.`, name)
 
 }
+
+type responsePath struct {
+	Prev *responsePath
+	Key  interface{}
+}
+
+// WithKey returns a new responsePath containing the new key.
+func (p *responsePath) WithKey(key interface{}) *responsePath {
+	return &responsePath{
+		Prev: p,
+		Key:  key,
+	}
+}
+
+// AsArray returns an array of path keys.
+func (p *responsePath) AsArray() []interface{} {
+	if p == nil {
+		return nil
+	}
+	return append(p.Prev.AsArray(), p.Key)
+}

executor.go

@@ -224,6 +224,7 @@ type executeFieldsParams struct {
 	ParentType       *Object
 	Source           interface{}
 	Fields           map[string][]*ast.Field
+	Path             *responsePath
 }
 
 // Implements the "Evaluating selection sets" section of the spec for "write" mode.
@@ -237,7 +238,8 @@ func executeFieldsSerially(p executeFieldsParams) *Result {
 
 	finalResults := make(map[string]interface{}, len(p.Fields))
 	for responseName, fieldASTs := range p.Fields {
-		resolved, state := resolveField(p.ExecutionContext, p.ParentType, p.Source, fieldASTs)
+		fieldPath := p.Path.WithKey(responseName)
+		resolved, state := resolveField(p.ExecutionContext, p.ParentType, p.Source, fieldASTs, fieldPath)
 		if state.hasNoFieldDefs {
 			continue
 		}
@@ -261,7 +263,8 @@ func executeFields(p executeFieldsParams) *Result {
 
 	finalResults := make(map[string]interface{}, len(p.Fields))
 	for responseName, fieldASTs := range p.Fields {
-		resolved, state := resolveField(p.ExecutionContext, p.ParentType, p.Source, fieldASTs)
+		fieldPath := p.Path.WithKey(responseName)
+		resolved, state := resolveField(p.ExecutionContext, p.ParentType, p.Source, fieldASTs, fieldPath)
 		if state.hasNoFieldDefs {
 			continue
 		}
@@ -459,31 +462,25 @@ type resolveFieldResultState struct {
 	hasNoFieldDefs bool
 }
 
+func handleFieldError(r interface{}, fieldNodes []ast.Node, path *responsePath, returnType Output, eCtx *executionContext) {
+	err := NewLocatedErrorWithPath(r, fieldNodes, path.AsArray())
+	// send panic upstream
+	if _, ok := returnType.(*NonNull); ok {
+		panic(err)
+	}
+	eCtx.Errors = append(eCtx.Errors, gqlerrors.FormatError(err))
+}
+
 // Resolves the field on the given source object. In particular, this
 // figures out the value that the field returns by calling its resolve function,
 // then calls completeValue to complete promises, serialize scalars, or execute
 // the sub-selection-set for objects.
-func resolveField(eCtx *executionContext, parentType *Object, source interface{}, fieldASTs []*ast.Field) (result interface{}, resultState resolveFieldResultState) {
+func resolveField(eCtx *executionContext, parentType *Object, source interface{}, fieldASTs []*ast.Field, path *responsePath) (result interface{}, resultState resolveFieldResultState) {
 	// catch panic from resolveFn
 	var returnType Output
 	defer func() (interface{}, resolveFieldResultState) {
 		if r := recover(); r != nil {
-
-			var err error
-			if r, ok := r.(string); ok {
-				err = NewLocatedError(
-					fmt.Sprintf("%v", r),
-					FieldASTsToNodeASTs(fieldASTs),
-				)
-			}
-			if r, ok := r.(error); ok {
-				err = gqlerrors.FormatError(r)
-			}
-			// send panic upstream
-			if _, ok := returnType.(*NonNull); ok {
-				panic(gqlerrors.FormatError(err))
-			}
-			eCtx.Errors = append(eCtx.Errors, gqlerrors.FormatError(err))
+			handleFieldError(r, FieldASTsToNodeASTs(fieldASTs), path, returnType, eCtx)
 			return result, resultState
 		}
 		return result, resultState
@@ -533,38 +530,32 @@ func resolveField(eCtx *executionContext, parentType *Object, source interface{}
 	})
 
 	if resolveFnError != nil {
-		panic(gqlerrors.FormatError(resolveFnError))
+		panic(resolveFnError)
 	}
 
-	completed := completeValueCatchingError(eCtx, returnType, fieldASTs, info, result)
+	completed := completeValueCatchingError(eCtx, returnType, fieldASTs, info, path, result)
 	return completed, resultState
 }
 
-func completeValueCatchingError(eCtx *executionContext, returnType Type, fieldASTs []*ast.Field, info ResolveInfo, result interface{}) (completed interface{}) {
+func completeValueCatchingError(eCtx *executionContext, returnType Type, fieldASTs []*ast.Field, info ResolveInfo, path *responsePath, result interface{}) (completed interface{}) {
 	// catch panic
 	defer func() interface{} {
 		if r := recover(); r != nil {
-			//send panic upstream
-			if _, ok := returnType.(*NonNull); ok {
-				panic(r)
-			}
-			if err, ok := r.(gqlerrors.FormattedError); ok {
-				eCtx.Errors = append(eCtx.Errors, err)
-			}
+			handleFieldError(r, FieldASTsToNodeASTs(fieldASTs), path, returnType, eCtx)
 			return completed
 		}
 		return completed
 	}()
 
 	if returnType, ok := returnType.(*NonNull); ok {
-		completed := completeValue(eCtx, returnType, fieldASTs, info, result)
+		completed := completeValue(eCtx, returnType, fieldASTs, info, path, result)
 		return completed
 	}
-	completed = completeValue(eCtx, returnType, fieldASTs, info, result)
+	completed = completeValue(eCtx, returnType, fieldASTs, info, path, result)
 	return completed
 }
 
-func completeValue(eCtx *executionContext, returnType Type, fieldASTs []*ast.Field, info ResolveInfo, result interface{}) interface{} {
+func completeValue(eCtx *executionContext, returnType Type, fieldASTs []*ast.Field, info ResolveInfo, path *responsePath, result interface{}) interface{} {
 
 	resultVal := reflect.ValueOf(result)
 	for resultVal.IsValid() && resultVal.Type().Kind() == reflect.Func {
@@ -580,11 +571,12 @@ func completeValue(eCtx *executionContext, returnType Type, fieldASTs []*ast.Fie
 	// If field type is NonNull, complete for inner type, and throw field error
 	// if result is null.
 	if returnType, ok := returnType.(*NonNull); ok {
-		completed := completeValue(eCtx, returnType.OfType, fieldASTs, info, result)
+		completed := completeValue(eCtx, returnType.OfType, fieldASTs, info, path, result)
 		if completed == nil {
-			err := NewLocatedError(
+			err := NewLocatedErrorWithPath(
 				fmt.Sprintf("Cannot return null for non-nullable field %v.%v.", info.ParentType, info.FieldName),
 				FieldASTsToNodeASTs(fieldASTs),
+				path.AsArray(),
 			)
 			panic(gqlerrors.FormatError(err))
 		}
@@ -598,7 +590,7 @@ func completeValue(eCtx *executionContext, returnType Type, fieldASTs []*ast.Fie
 
 	// If field type is List, complete each item in the list with the inner type
 	if returnType, ok := returnType.(*List); ok {
-		return completeListValue(eCtx, returnType, fieldASTs, info, result)
+		return completeListValue(eCtx, returnType, fieldASTs, info, path, result)
 	}
 
 	// If field type is a leaf type, Scalar or Enum, serialize to a valid value,
@@ -613,15 +605,15 @@ func completeValue(eCtx *executionContext, returnType Type, fieldASTs []*ast.Fie
 	// If field type is an abstract type, Interface or Union, determine the
 	// runtime Object type and complete for that type.
 	if returnType, ok := returnType.(*Union); ok {
-		return completeAbstractValue(eCtx, returnType, fieldASTs, info, result)
+		return completeAbstractValue(eCtx, returnType, fieldASTs, info, path, result)
 	}
 	if returnType, ok := returnType.(*Interface); ok {
-		return completeAbstractValue(eCtx, returnType, fieldASTs, info, result)
+		return completeAbstractValue(eCtx, returnType, fieldASTs, info, path, result)
 	}
 
 	// If field type is Object, execute and complete all sub-selections.
 	if returnType, ok := returnType.(*Object); ok {
-		return completeObjectValue(eCtx, returnType, fieldASTs, info, result)
+		return completeObjectValue(eCtx, returnType, fieldASTs, info, path, result)
 	}
 
 	// Not reachable. All possible output types have been considered.
@@ -636,7 +628,7 @@ func completeValue(eCtx *executionContext, returnType Type, fieldASTs []*ast.Fie
 
 // completeAbstractValue completes value of an Abstract type (Union / Interface) by determining the runtime type
 // of that value, then completing based on that type.
-func completeAbstractValue(eCtx *executionContext, returnType Abstract, fieldASTs []*ast.Field, info ResolveInfo, result interface{}) interface{} {
+func completeAbstractValue(eCtx *executionContext, returnType Abstract, fieldASTs []*ast.Field, info ResolveInfo, path *responsePath, result interface{}) interface{} {
 
 	var runtimeType *Object
 
@@ -669,11 +661,11 @@ func completeAbstractValue(eCtx *executionContext, returnType Abstract, fieldAST
 		))
 	}
 
-	return completeObjectValue(eCtx, runtimeType, fieldASTs, info, result)
+	return completeObjectValue(eCtx, runtimeType, fieldASTs, info, path, result)
 }
 
 // completeObjectValue complete an Object value by executing all sub-selections.
-func completeObjectValue(eCtx *executionContext, returnType *Object, fieldASTs []*ast.Field, info ResolveInfo, result interface{}) interface{} {
+func completeObjectValue(eCtx *executionContext, returnType *Object, fieldASTs []*ast.Field, info ResolveInfo, path *responsePath, result interface{}) interface{} {
 
 	// If there is an isTypeOf predicate function, call it with the
 	// current result. If isTypeOf returns false, then raise an error rather
@@ -715,6 +707,7 @@ func completeObjectValue(eCtx *executionContext, returnType *Object, fieldASTs [
 		ParentType:       returnType,
 		Source:           result,
 		Fields:           subFieldASTs,
+		Path:             path,
 	}
 	results := executeFields(executeFieldsParams)
 
@@ -732,7 +725,7 @@ func completeLeafValue(returnType Leaf, result interface{}) interface{} {
 }
 
 // completeListValue complete a list value by completing each item in the list with the inner type
-func completeListValue(eCtx *executionContext, returnType *List, fieldASTs []*ast.Field, info ResolveInfo, result interface{}) interface{} {
+func completeListValue(eCtx *executionContext, returnType *List, fieldASTs []*ast.Field, info ResolveInfo, path *responsePath, result interface{}) interface{} {
 	resultVal := reflect.ValueOf(result)
 	parentTypeName := ""
 	if info.ParentType != nil {
@@ -751,7 +744,8 @@ func completeListValue(eCtx *executionContext, returnType *List, fieldASTs []*as
 	completedResults := make([]interface{}, 0, resultVal.Len())
 	for i := 0; i < resultVal.Len(); i++ {
 		val := resultVal.Index(i).Interface()
-		completedItem := completeValueCatchingError(eCtx, itemType, fieldASTs, info, val)
+		fieldPath := path.WithKey(i)
+		completedItem := completeValueCatchingError(eCtx, itemType, fieldASTs, info, fieldPath, val)
 		completedResults = append(completedResults, completedItem)
 	}
 	return completedResults