Merge remote-tracking branch 'upstream/master' into annotations

Author: clintwood (Office)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql",
-  "version": "0.4.18",
+  "version": "0.5.0-beta.1",
   "description": "A Query Language and Runtime which can target any service.",
   "contributors": [
     "Lee Byron <[email protected]> (http://leebyron.com/)",

src/execution/__tests__/directives-test.js

@@ -268,47 +268,28 @@ describe('Execute: handles directives', () => {
     });
   });
 
-  describe('works on fragment', () => {
-    it('if false omits fragment', async () => {
-      const q = `
-        query Q {
-          a
-          ...Frag
-        }
-        fragment Frag on TestType @include(if: false) {
-          b
-        }
-      `;
-      return expect(await executeTestQuery(q)).to.deep.equal({
-        data: { a: 'a' }
+  describe('works with skip and include directives', () => {
+    it('include and no skip', async () => {
+      return expect(
+        await executeTestQuery('{ a, b @include(if: true) @skip(if: false) }')
+      ).to.deep.equal({
+        data: { a: 'a', b: 'b' }
       });
     });
-    it('if true includes fragment', async () => {
-      const q = `
-        query Q {
-          a
-          ...Frag
-        }
-        fragment Frag on TestType @include(if: true) {
-          b
-        }
-      `;
-      return expect(await executeTestQuery(q)).to.deep.equal({
-        data: { a: 'a', b: 'b' }
+
+    it('include and skip', async () => {
+      return expect(
+        await executeTestQuery('{ a, b @include(if: true) @skip(if: true) }')
+      ).to.deep.equal({
+        data: { a: 'a' }
       });
     });
-    it('unless false includes fragment', async () => {
-      const q = `
-        query Q {
-          a
-          ...Frag
-        }
-        fragment Frag on TestType @skip(if: false) {
-          b
-        }
-      `;
-      return expect(await executeTestQuery(q)).to.deep.equal({
-        data: { a: 'a', b: 'b' }
+
+    it('no include or skip', async () => {
+      return expect(
+        await executeTestQuery('{ a, b @include(if: false) @skip(if: false) }')
+      ).to.deep.equal({
+        data: { a: 'a' }
       });
     });
   });

src/execution/__tests__/executor-test.js

@@ -183,23 +183,23 @@ describe('Execute: Handles basic execution tasks', () => {
     });
   });
 
-  it('threads context correctly', async () => {
+  it('threads root value context correctly', async () => {
     const doc = 'query Example { a }';
 
     const data = {
       contextThing: 'thing',
     };
 
-    let resolvedContext;
+    let resolvedRootValue;
 
     const schema = new GraphQLSchema({
       query: new GraphQLObjectType({
         name: 'Type',
         fields: {
           a: {
             type: GraphQLString,
-            resolve(context) {
-              resolvedContext = context;
+            resolve(rootValue) {
+              resolvedRootValue = rootValue;
             }
           }
         }
@@ -208,7 +208,7 @@ describe('Execute: Handles basic execution tasks', () => {
 
     await execute(schema, parse(doc), data);
 
-    expect(resolvedContext.contextThing).to.equal('thing');
+    expect(resolvedRootValue.contextThing).to.equal('thing');
   });
 
   it('correctly threads arguments', async () => {

src/execution/execute.js

@@ -409,7 +409,6 @@ function collectFields(
         visitedFragmentNames[fragName] = true;
         const fragment = exeContext.fragments[fragName];
         if (!fragment ||
-            !shouldIncludeNode(exeContext, fragment.directives) ||
             !doesFragmentConditionMatch(exeContext, fragment, runtimeType)) {
           continue;
         }
@@ -444,7 +443,9 @@ function shouldIncludeNode(
       skipAST.arguments,
       exeContext.variableValues
     );
-    return !skipIf;
+    if (skipIf === true) {
+      return false;
+    }
   }
 
   const includeAST = directives && find(
@@ -457,7 +458,9 @@ function shouldIncludeNode(
       includeAST.arguments,
       exeContext.variableValues
     );
-    return Boolean(includeIf);
+    if (includeIf === false) {
+      return false;
+    }
   }
 
   return true;
@@ -817,12 +820,18 @@ function completeAbstractValue(
     returnType.resolveType(result, exeContext.contextValue, info) :
     defaultResolveTypeFn(result, exeContext.contextValue, info, returnType);
 
-  if (!runtimeType) {
-    return null;
-  }
+  invariant(
+    runtimeType,
+    `Could not determine runtime type of value "${result}" for field ${
+      info.parentType}.${info.fieldName}.`
+  );
+  invariant(
+    runtimeType instanceof GraphQLObjectType,
+    `${returnType}.resolveType must return an instance of GraphQLObjectType ` +
+    `for field ${info.parentType}.${info.fieldName}, received "${runtimeType}".`
+  );
 
-  const schema = exeContext.schema;
-  if (runtimeType && !schema.isPossibleType(returnType, runtimeType)) {
+  if (!exeContext.schema.isPossibleType(returnType, runtimeType)) {
     throw new GraphQLError(
       `Runtime Object type "${runtimeType}" is not a possible type ` +
       `for "${returnType}".`,