Use __typename detection only if resolveType and isTypeOf missing.

Author: IvanGoncharov

src/execution/execute.js

@@ -1047,9 +1047,9 @@ function completeAbstractValue(
   path: ResponsePath,
   result: mixed
 ): mixed {
-  const runtimeType = exeContext.typeResolver(
-    result, exeContext, info, returnType
-  );
+  const runtimeType = returnType.resolveType ?
+    returnType.resolveType(result, exeContext.contextValue, info) :
+    defaultResolveTypeFn(result, exeContext, info, returnType);
 
   const promise = getPromise(runtimeType);
   if (promise) {
@@ -1215,10 +1215,11 @@ function collectAndExecuteSubfields(
  */
 function defaultResolveTypeFn(
   value: mixed,
-  context: mixed,
+  exeContext: ExecutionContext,
   info: GraphQLResolveInfo,
   abstractType: GraphQLAbstractType
-): ?GraphQLObjectType | Promise<?GraphQLObjectType> {
+): ?GraphQLObjectType | string | Promise<?GraphQLObjectType | string> {
+  const context = exeContext.contextValue;
   const possibleTypes = info.schema.getPossibleTypes(abstractType);
   const promisedIsTypeOfResults = [];
 
@@ -1246,6 +1247,8 @@ function defaultResolveTypeFn(
       }
     });
   }
+
+  return exeContext.typeResolver(value, context, info);
 }
 
 /**
@@ -1267,14 +1270,14 @@ function (source, args, context, info) {
 };
 
 export const defaultTypeResolver: GraphQLTypeResolver<any, *> =
-function (result, context, info, returnType) {
-  if (result && result.__typename) {
-    return result.__typename;
+function (result, context, info) {
+  if (typeof result === 'object' && result.__typename) {
+    const typename = result.__typename;
+    if (typeof typename === 'function') {
+      return result.__typename(context, info);
+    }
+    return typename;
   }
-
-  return returnType.resolveType ?
-    returnType.resolveType(result, context.contextValue, info) :
-    defaultResolveTypeFn(result, context.contextValue, info, returnType);
 };
 
 /**

src/type/__tests__/validation-test.js

@@ -968,26 +968,6 @@ describe('Type System: Interface types must be resolvable', () => {
     );
   });
 
-  it('rejects an Interface type not defining resolveType with implementing type not defining isTypeOf', () => {
-    expect(() => {
-      const InterfaceTypeWithoutResolveType = new GraphQLInterfaceType({
-        name: 'InterfaceTypeWithoutResolveType',
-        fields: { f: { type: GraphQLString } }
-      });
-
-      schemaWithFieldType(new GraphQLObjectType({
-        name: 'SomeObject',
-        interfaces: [ InterfaceTypeWithoutResolveType ],
-        fields: { f: { type: GraphQLString } }
-      }));
-    }).to.throw(
-      'Interface Type InterfaceTypeWithoutResolveType does not provide a ' +
-      '"resolveType" function and implementing Type SomeObject does not ' +
-      'provide a "isTypeOf" function. ' +
-      'There is no way to resolve this implementing type during execution.'
-    );
-  });
-
 });
 
 
@@ -1034,19 +1014,6 @@ describe('Type System: Union types must be resolvable', () => {
     );
   });
 
-  it('rejects a Union type not defining resolveType of Object types not defining isTypeOf', () => {
-    expect(() =>
-      schemaWithFieldType(new GraphQLUnionType({
-        name: 'SomeUnion',
-        types: [ SomeObjectType ],
-      }))
-    ).to.throw(
-      'Union type "SomeUnion" does not provide a "resolveType" function and ' +
-      'possible type "SomeObject" does not provide an "isTypeOf" function. ' +
-      'There is no way to resolve this possible type during execution.'
-    );
-  });
-
 });
 
 

src/type/definition.js

@@ -501,15 +501,6 @@ function defineInterfaces(
       `${type.name} may declare it implements ${iface.name} only once.`
     );
     implementedTypeNames[iface.name] = true;
-    if (typeof iface.resolveType !== 'function') {
-      invariant(
-        typeof type.isTypeOf === 'function',
-        `Interface Type ${iface.name} does not provide a "resolveType" ` +
-        `function and implementing Type ${type.name} does not provide a ` +
-        '"isTypeOf" function. There is no way to resolve this implementing ' +
-        'type during execution.'
-      );
-    }
   });
   return interfaces;
 }
@@ -614,8 +605,7 @@ export type GraphQLObjectTypeConfig<TSource, TContext> = {
 export type GraphQLTypeResolver<TSource, TContext> = (
   value: TSource,
   context: TContext,
-  info: GraphQLResolveInfo,
-  returnValue: any
+  info: GraphQLResolveInfo
 ) => ?GraphQLObjectType | string | Promise<?GraphQLObjectType | string>;
 
 export type GraphQLIsTypeOfFn<TSource, TContext> = (
@@ -862,15 +852,6 @@ function defineTypes(
       `${unionType.name} can include ${objType.name} type only once.`
     );
     includedTypeNames[objType.name] = true;
-    if (typeof unionType.resolveType !== 'function') {
-      invariant(
-        typeof objType.isTypeOf === 'function',
-        `Union type "${unionType.name}" does not provide a "resolveType" ` +
-        `function and possible type "${objType.name}" does not provide an ` +
-        '"isTypeOf" function. There is no way to resolve this possible type ' +
-        'during execution.'
-      );
-    }
   });
 
   return types;

src/utilities/buildASTSchema.js

@@ -398,7 +398,6 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
       description: getDescription(def),
       fields: () => makeFieldDefMap(def),
       astNode: def,
-      resolveType: cannotExecuteSchema,
     });
   }
 
@@ -424,7 +423,6 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
       name: def.name.value,
       description: getDescription(def),
       types: def.types.map(t => produceObjectType(t)),
-      resolveType: cannotExecuteSchema,
       astNode: def,
     });
   }
@@ -516,9 +514,3 @@ function leadingSpaces(str) {
   }
   return i;
 }
-
-function cannotExecuteSchema() {
-  throw new Error(
-    'Generated Schema cannot use Interface or Union types for execution.'
-  );
-}

src/utilities/extendSchema.js

@@ -479,7 +479,6 @@ export function extendSchema(
       description: getDescription(typeNode),
       fields: () => buildFieldMap(typeNode),
       astNode: typeNode,
-      resolveType: cannotExecuteExtendedSchema,
     });
   }
 
@@ -489,7 +488,6 @@ export function extendSchema(
       description: getDescription(typeNode),
       types: typeNode.types.map(getObjectTypeFromAST),
       astNode: typeNode,
-      resolveType: cannotExecuteExtendedSchema,
     });
   }
 
@@ -608,9 +606,3 @@ export function extendSchema(
     return getOutputTypeFromAST(typeNode);
   }
 }
-
-function cannotExecuteExtendedSchema() {
-  throw new Error(
-    'Extended Schema cannot use Interface or Union types for execution.'
-  );
-}