Call isTypeOf during execution for assertion of type.

Also ensures resolution info is provided to isTypeOf function.

Fixes #38

Author: leebyron

src/execution/__tests__/executor.js

@@ -592,4 +592,59 @@ describe('Execute: Handles basic execution tasks', () => {
     });
   });
 
+  it('fails when an isTypeOf check is not met', async () => {
+    class Special {
+      constructor(value) {
+        this.value = value;
+      }
+    }
+
+    class NotSpecial {
+      constructor(value) {
+        this.value = value;
+      }
+    }
+
+    var SpecialType = new GraphQLObjectType({
+      name: 'SpecialType',
+      isTypeOf(obj) {
+        return obj instanceof Special;
+      },
+      fields: {
+        value: { type: GraphQLString }
+      }
+    });
+
+    var schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          specials: {
+            type: new GraphQLList(SpecialType),
+            resolve: rootValue => rootValue.specials
+          }
+        }
+      })
+    });
+
+    var query = parse('{ specials { value } }');
+    var value = {
+      specials: [ new Special('foo'), new NotSpecial('bar') ]
+    };
+    var result = await execute(schema, query, value);
+
+    expect(result.data).to.deep.equal({
+      specials: [
+        { value: 'foo' },
+        null
+      ]
+    });
+    expect(result.errors).to.have.lengthOf(1);
+    expect(result.errors).to.containSubset([
+      { message:
+          'Expected value of type "SpecialType" but got: [object Object].',
+        locations: [ { line: 1, column: 3 } ] }
+    ]);
+  });
+
 });

src/execution/execute.js

@@ -664,6 +664,16 @@ function completeValue(
     return null;
   }
 
+  // If there is an isTypeOf predicate function, call it with the
+  // current result. If isTypeOf returns false, then raise an error rather
+  // than continuing execution.
+  if (objectType.isTypeOf && !objectType.isTypeOf(result, info)) {
+    throw new GraphQLError(
+      `Expected value of type "${objectType}" but got: ${result}.`,
+      fieldASTs
+    );
+  }
+
   // Collect sub-fields to execute to complete this value.
   var subFieldASTs = {};
   var visitedFragmentNames = {};

src/type/definition.js

@@ -260,6 +260,7 @@ export type GraphQLScalarTypeConfig/* <T> */ = {
 export class GraphQLObjectType {
   name: string;
   description: ?string;
+  isTypeOf: ?(value: any, info?: GraphQLResolveInfo) => boolean;
 
   _typeConfig: GraphQLObjectTypeConfig;
   _fields: GraphQLFieldDefinitionMap;
@@ -269,6 +270,7 @@ export class GraphQLObjectType {
     invariant(config.name, 'Type must be named.');
     this.name = config.name;
     this.description = config.description;
+    this.isTypeOf = config.isTypeOf;
     this._typeConfig = config;
     addImplementationToInterfaces(this);
   }
@@ -283,13 +285,6 @@ export class GraphQLObjectType {
       (this._interfaces = defineInterfaces(this._typeConfig.interfaces || []));
   }
 
-  isTypeOf(value: any): ?boolean {
-    var predicate = this._typeConfig.isTypeOf;
-    if (predicate) {
-      return predicate(value);
-    }
-  }
-
   toString(): string {
     return this.name;
   }
@@ -347,7 +342,7 @@ export type GraphQLObjectTypeConfig = {
   name: string;
   interfaces?: GraphQLInterfacesThunk | Array<GraphQLInterfaceType>;
   fields: GraphQLFieldConfigMapThunk | GraphQLFieldConfigMap;
-  isTypeOf?: (value: any) => boolean;
+  isTypeOf?: (value: any, info?: GraphQLResolveInfo) => boolean;
   description?: ?string
 }
 
@@ -474,7 +469,7 @@ export class GraphQLInterfaceType {
 
   resolveType(value: any, info: GraphQLResolveInfo): ?GraphQLObjectType {
     var resolver = this._typeConfig.resolveType;
-    return resolver ? resolver(value, info) : getTypeOf(value, this);
+    return resolver ? resolver(value, info) : getTypeOf(value, info, this);
   }
 
   toString(): string {
@@ -484,13 +479,13 @@ export class GraphQLInterfaceType {
 
 function getTypeOf(
   value: any,
+  info: GraphQLResolveInfo,
   abstractType: GraphQLAbstractType
 ): ?GraphQLObjectType {
   var possibleTypes = abstractType.getPossibleTypes();
   for (var i = 0; i < possibleTypes.length; i++) {
     var type = possibleTypes[i];
-    var isTypeOf = type.isTypeOf(value);
-    if (isTypeOf === undefined) {
+    if (typeof type.isTypeOf !== 'function') {
       // TODO: move this to a JS impl specific type system validation step
       // so the error can be found before execution.
       throw new Error(
@@ -499,7 +494,7 @@ function getTypeOf(
         'isTypeOf. There is no way to determine if a value is of this type.'
       );
     }
-    if (isTypeOf) {
+    if (type.isTypeOf(value, info)) {
       return type;
     }
   }
@@ -589,7 +584,7 @@ export class GraphQLUnionType {
 
   resolveType(value: any, info: GraphQLResolveInfo): ?GraphQLObjectType {
     var resolver = this._typeConfig.resolveType;
-    return resolver ? resolver(value, info) : getTypeOf(value, this);
+    return resolver ? resolver(value, info) : getTypeOf(value, info, this);
   }
 
   toString(): string {