Errors thrown from resolvers have the execution path (#396)

* Errors thrown from resolvers have the execution path

This path is also passed in the `info` object to resolvers.
This information is useful for ease of debugging and more detailed logging.

* Remove PathedError

* rename property executionPath to path

* remove an unnecessary block

* info.executionPath -> info.path

* a minor tweak to make the body of executeFields look closer to executeFieldsSerially

* remove the unnecessary clone of info

* Add a test for a path with non-nullable fields

* stylistic changes

* remove stray property

Author: Slava

src/__tests__/starWarsIntrospection-test.js

@@ -205,6 +205,13 @@ describe('Star Wars Introspection Tests', () => {
                 kind: 'LIST'
               }
             },
+            {
+              name: 'secretBackstory',
+              type: {
+                name: 'String',
+                kind: 'SCALAR'
+              }
+            },
             {
               name: 'primaryFunction',
               type: {
@@ -284,6 +291,14 @@ describe('Star Wars Introspection Tests', () => {
                 }
               }
             },
+            {
+              name: 'secretBackstory',
+              type: {
+                name: 'String',
+                kind: 'SCALAR',
+                ofType: null
+              }
+            },
             {
               name: 'primaryFunction',
               type: {

src/__tests__/starWarsQuery-test.js

@@ -11,6 +11,12 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 import { StarWarsSchema } from './starWarsSchema.js';
 import { graphql } from '../graphql';
+import {
+  GraphQLObjectType,
+  GraphQLNonNull,
+  GraphQLSchema,
+  GraphQLString,
+} from '../type';
 
 // 80+ char lines are useful in describe/it, so ignore in this file.
 /* eslint-disable max-len */
@@ -364,4 +370,162 @@ describe('Star Wars Query Tests', () => {
       expect(result).to.deep.equal({ data: expected });
     });
   });
+
+  describe('Reporting errors raised in resolvers', () => {
+    it('Correctly reports error on accessing secretBackstory', async () => {
+      const query = `
+        query HeroNameQuery {
+          hero {
+            name
+            secretBackstory
+          }
+        }
+      `;
+      const expected = {
+        hero: {
+          name: 'R2-D2',
+          secretBackstory: null
+        }
+      };
+      const expectedErrors = [ 'secretBackstory is secret.' ];
+      const result = await graphql(StarWarsSchema, query);
+      expect(result.data).to.deep.equal(expected);
+      expect(result.errors.map(e => e.message)).to.deep.equal(expectedErrors);
+      expect(
+        result.errors.map(e => e.path)).to.deep.equal(
+          [ [ 'hero', 'secretBackstory' ] ]);
+    });
+
+    it('Correctly reports error on accessing secretBackstory in a list', async () => {
+      const query = `
+        query HeroNameQuery {
+          hero {
+            name
+            friends {
+              name
+              secretBackstory
+            }
+          }
+        }
+      `;
+      const expected = {
+        hero: {
+          name: 'R2-D2',
+          friends: [
+            {
+              name: 'Luke Skywalker',
+              secretBackstory: null,
+            },
+            {
+              name: 'Han Solo',
+              secretBackstory: null,
+            },
+            {
+              name: 'Leia Organa',
+              secretBackstory: null,
+            },
+          ]
+        }
+      };
+      const expectedErrors = [
+        'secretBackstory is secret.',
+        'secretBackstory is secret.',
+        'secretBackstory is secret.',
+      ];
+      const result = await graphql(StarWarsSchema, query);
+      expect(result.data).to.deep.equal(expected);
+      expect(result.errors.map(e => e.message)).to.deep.equal(expectedErrors);
+      expect(
+        result.errors.map(e => e.path)
+      ).to.deep.equal(
+        [
+          [ 'hero', 'friends', 0, 'secretBackstory' ],
+          [ 'hero', 'friends', 1, 'secretBackstory' ],
+          [ 'hero', 'friends', 2, 'secretBackstory' ],
+        ]);
+    });
+
+    it('Correctly reports error on accessing through an alias', async () => {
+      const query = `
+        query HeroNameQuery {
+          mainHero: hero {
+            name
+            story: secretBackstory
+          }
+        }
+      `;
+      const expected = {
+        mainHero: {
+          name: 'R2-D2',
+          story: null,
+        }
+      };
+      const expectedErrors = [
+        'secretBackstory is secret.',
+      ];
+      const result = await graphql(StarWarsSchema, query);
+      expect(result.data).to.deep.equal(expected);
+      expect(result.errors.map(e => e.message)).to.deep.equal(expectedErrors);
+      expect(
+        result.errors.map(e => e.path)
+      ).to.deep.equal([ [ 'mainHero', 'story' ] ]);
+    });
+
+    it('Full response path is included when fields are non-nullable', async () => {
+      const A = new GraphQLObjectType({
+        name: 'A',
+        fields: () => ({
+          nullableA: {
+            type: A,
+            resolve: () => ({}),
+          },
+          nonNullA: {
+            type: new GraphQLNonNull(A),
+            resolve: () => ({}),
+          },
+          throws: {
+            type: new GraphQLNonNull(GraphQLString),
+            resolve: () => { throw new Error('Catch me if you can'); },
+          },
+        }),
+      });
+      const queryType = new GraphQLObjectType({
+        name: 'query',
+        fields: () => ({
+          nullableA: {
+            type: A,
+            resolve: () => ({})
+          }
+        }),
+      });
+      const schema = new GraphQLSchema({
+        query: queryType,
+      });
+
+      const query = `
+        query {
+          nullableA {
+            nullableA {
+              nonNullA {
+                nonNullA {
+                  throws
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      const result = await graphql(schema, query);
+      const expected = {
+        nullableA: {
+          nullableA: null
+        }
+      };
+      expect(result.data).to.deep.equal(expected);
+      expect(
+        result.errors.map(e => e.path)).to.deep.equal(
+          [ [ 'nullableA', 'nullableA', 'nonNullA', 'nonNullA', 'throws' ] ]);
+    });
+  });
 });

src/__tests__/starWarsSchema.js

@@ -102,6 +102,7 @@ const episodeEnum = new GraphQLEnumType({
  *     name: String
  *     friends: [Character]
  *     appearsIn: [Episode]
+ *     secretBackstory: String
  *   }
  */
 const characterInterface = new GraphQLInterfaceType({
@@ -125,6 +126,10 @@ const characterInterface = new GraphQLInterfaceType({
       type: new GraphQLList(episodeEnum),
       description: 'Which movies they appear in.',
     },
+    secretBackstory: {
+      type: GraphQLString,
+      description: 'All secrets about their past.',
+    },
   }),
   resolveType: character => {
     return getHuman(character.id) ? humanType : droidType;
@@ -140,6 +145,7 @@ const characterInterface = new GraphQLInterfaceType({
  *     name: String
  *     friends: [Character]
  *     appearsIn: [Episode]
+ *     secretBackstory: String
  *   }
  */
 const humanType = new GraphQLObjectType({
@@ -168,6 +174,13 @@ const humanType = new GraphQLObjectType({
       type: GraphQLString,
       description: 'The home planet of the human, or null if unknown.',
     },
+    secretBackstory: {
+      type: GraphQLString,
+      description: 'Where are they from and how they came to be who they are.',
+      resolve: () => {
+        throw new Error('secretBackstory is secret.');
+      },
+    },
   }),
   interfaces: [ characterInterface ]
 });
@@ -181,6 +194,7 @@ const humanType = new GraphQLObjectType({
  *     name: String
  *     friends: [Character]
  *     appearsIn: [Episode]
+ *     secretBackstory: String
  *     primaryFunction: String
  *   }
  */
@@ -206,6 +220,13 @@ const droidType = new GraphQLObjectType({
       type: new GraphQLList(episodeEnum),
       description: 'Which movies they appear in.',
     },
+    secretBackstory: {
+      type: GraphQLString,
+      description: 'Construction date and the name of the designer.',
+      resolve: () => {
+        throw new Error('secretBackstory is secret.');
+      },
+    },
     primaryFunction: {
       type: GraphQLString,
       description: 'The primary function of the droid.',

src/error/GraphQLError.js

@@ -20,6 +20,7 @@ export class GraphQLError extends Error {
   source: Source;
   positions: Array<number>;
   locations: any;
+  path: Array<string | number>;
   originalError: ?Error;
 
   constructor(

src/error/locatedError.js

@@ -18,13 +18,15 @@ import { GraphQLError } from './GraphQLError';
  */
 export function locatedError(
   originalError: ?Error,
-  nodes: Array<any>
+  nodes: Array<any>,
+  path: Array<string | number>
 ): GraphQLError {
   const message = originalError ?
     originalError.message || String(originalError) :
     'An unknown error occurred.';
   const stack = originalError ? originalError.stack : null;
   const error = new GraphQLError(message, nodes, stack);
   error.originalError = originalError;
+  error.path = path;
   return error;
 }