Move getTypeOf to execute.js and rename to defaultResolveTypeFn to mirror defaultResolveFn

Related GraphQL-js commit: graphql/graphql-js@edc405a

Author: syrusakbary

graphql/execution/executor.py

@@ -301,23 +301,33 @@ def complete_abstract_value(exe_context, return_type, field_asts, info, result):
     Complete an value of an abstract type by determining the runtime type of that value, then completing based
     on that type.
     """
-    # Field type must be Object, Interface or Union and expect sub-selections.
     runtime_type = None
 
+    # Field type must be Object, Interface or Union and expect sub-selections.
     if isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
-        runtime_type = return_type.resolve_type(result, info)
-        if runtime_type and not return_type.is_possible_type(runtime_type):
-            raise GraphQLError(
-                u'Runtime Object type "{}" is not a possible type for "{}".'.format(runtime_type, return_type),
-                field_asts
-            )
+        if return_type.resolve_type:
+            runtime_type = return_type.resolve_type(result, info)
+            if runtime_type and not return_type.is_possible_type(runtime_type):
+                raise GraphQLError(
+                    u'Runtime Object type "{}" is not a possible type for "{}".'.format(runtime_type, return_type),
+                    field_asts
+                )
+        else:
+            runtime_type = get_default_resolve_type_fn(result, info, return_type)
 
     if not runtime_type:
         return None
 
     return complete_object_value(exe_context, runtime_type, field_asts, info, result)
 
 
+def get_default_resolve_type_fn(value, info, abstract_type):
+    possible_types = abstract_type.get_possible_types()
+    for type in possible_types:
+        if callable(type.is_type_of) and type.is_type_of(value, info):
+            return type
+
+
 def complete_object_value(exe_context, return_type, field_asts, info, result):
     """
     Complete an Object value by evaluating all sub-selections.

graphql/type/definition.py

@@ -278,7 +278,7 @@ def define_interfaces(type, interfaces):
             '{} may only implement Interface types, it cannot implement: {}.'.format(type, interface)
         )
 
-        if not callable(interface.type_resolver):
+        if not callable(interface.resolve_type):
             assert callable(type.is_type_of), (
                 'Interface Type {} does not provide a "resolve_type" function '
                 'and implementing Type {} does not provide a "is_type_of" '
@@ -360,7 +360,7 @@ class GraphQLInterfaceType(GraphQLType):
                 'name': GraphQLField(GraphQLString),
             })
     """
-    __slots__ = 'name', 'description', 'type_resolver', '_fields', '_impls', '_field_map', '_possible_type_names'
+    __slots__ = 'name', 'description', 'resolve_type', '_fields', '_impls', '_field_map', '_possible_type_names'
 
     def __init__(self, name, fields=None, resolve_type=None, description=None):
         assert name, 'Type must be named.'
@@ -371,7 +371,7 @@ def __init__(self, name, fields=None, resolve_type=None, description=None):
         if resolve_type is not None:
             assert callable(resolve_type), '{} must provide "resolve_type" as a function.'.format(self)
 
-        self.type_resolver = resolve_type
+        self.resolve_type = resolve_type
         self._fields = fields
 
         self._impls = []
@@ -394,19 +394,6 @@ def is_possible_type(self, type):
             )
         return type.name in self._possible_type_names
 
-    def resolve_type(self, value, info):
-        if self.type_resolver:
-            return self.type_resolver(value, info)
-
-        return get_type_of(value, info, self)
-
-
-def get_type_of(value, info, abstract_type):
-    possible_types = abstract_type.get_possible_types()
-    for type in possible_types:
-        if callable(type.is_type_of) and type.is_type_of(value, info):
-            return type
-
 
 class GraphQLUnionType(GraphQLType):
     """Union Type Definition
@@ -426,7 +413,7 @@ def resolve_type(self, value):
                 if isinstance(value, Cat):
                     return CatType()
     """
-    __slots__ = 'name', 'description', '_resolve_type', '_types', '_possible_type_names', '_possible_types'
+    __slots__ = 'name', 'description', 'resolve_type', '_types', '_possible_type_names', '_possible_types'
 
     def __init__(self, name, types=None, resolve_type=None, description=None):
         assert name, 'Type must be named.'
@@ -437,7 +424,7 @@ def __init__(self, name, types=None, resolve_type=None, description=None):
         if resolve_type is not None:
             assert callable(resolve_type), '{} must provide "resolve_type" as a function.'.format(self)
 
-        self._resolve_type = resolve_type
+        self.resolve_type = resolve_type
         self._types = types
         self._possible_types = None
         self._possible_type_names = None
@@ -456,20 +443,14 @@ def is_possible_type(self, type):
 
         return type.name in self._possible_type_names
 
-    def resolve_type(self, value, info):
-        if self._resolve_type:
-            return self._resolve_type(value, info)
-
-        return get_type_of(value, info, self)
-
 
 def define_types(union_type, types):
     if callable(types):
         types = types()
 
     assert isinstance(types, (list, tuple)) and len(
         types) > 0, 'Must provide types for Union {}.'.format(union_type.name)
-    has_resolve_type_fn = callable(union_type._resolve_type)
+    has_resolve_type_fn = callable(union_type.resolve_type)
 
     for type in types:
         assert isinstance(type, GraphQLObjectType), (