Allow providing custom default type resolver

Replicates graphql/graphql-js@fd308ce

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
 
 The current version 1.0.2 of GraphQL-core-next is up-to-date with GraphQL.js version
-14.1.1. All parts of the API are covered by an extensive test suite of currently 1724
+14.1.1. All parts of the API are covered by an extensive test suite of currently 1725
 unit tests.
 
 

graphql/__init__.py

@@ -257,6 +257,7 @@
 from .execution import (
     execute,
     default_field_resolver,
+    default_type_resolver,
     response_path_as_list,
     get_directive_values,
     # Types
@@ -558,6 +559,7 @@
     "InputObjectTypeExtensionNode",
     "execute",
     "default_field_resolver",
+    "default_type_resolver",
     "response_path_as_list",
     "get_directive_values",
     "ExecutionContext",

graphql/execution/__init__.py

@@ -7,6 +7,7 @@
 from .execute import (
     execute,
     default_field_resolver,
+    default_type_resolver,
     response_path_as_list,
     ExecutionContext,
     ExecutionResult,
@@ -18,6 +19,7 @@
 __all__ = [
     "execute",
     "default_field_resolver",
+    "default_type_resolver",
     "response_path_as_list",
     "ExecutionContext",
     "ExecutionResult",

graphql/execution/execute.py

@@ -41,6 +41,7 @@
     GraphQLSchema,
     GraphQLSkipDirective,
     GraphQLFieldResolver,
+    GraphQLTypeResolver,
     GraphQLResolveInfo,
     ResponsePath,
     SchemaMetaFieldDef,
@@ -59,6 +60,7 @@
     "add_path",
     "assert_valid_execution_arguments",
     "default_field_resolver",
+    "default_type_resolver",
     "execute",
     "get_field_def",
     "response_path_as_list",
@@ -111,6 +113,7 @@ def execute(
     variable_values: Dict[str, Any] = None,
     operation_name: str = None,
     field_resolver: GraphQLFieldResolver = None,
+    type_resolver: GraphQLTypeResolver = None,
     middleware: Middleware = None,
     execution_context_class: Type["ExecutionContext"] = None,
 ) -> MaybeAwaitable[ExecutionResult]:
@@ -140,6 +143,7 @@ def execute(
         variable_values,
         operation_name,
         field_resolver,
+        type_resolver,
         middleware,
     )
 
@@ -173,6 +177,7 @@ class ExecutionContext:
     operation: OperationDefinitionNode
     variable_values: Dict[str, Any]
     field_resolver: GraphQLFieldResolver
+    type_resolver: GraphQLTypeResolver
     middleware_manager: Optional[MiddlewareManager]
     errors: List[GraphQLError]
 
@@ -185,6 +190,7 @@ def __init__(
         operation: OperationDefinitionNode,
         variable_values: Dict[str, Any],
         field_resolver: GraphQLFieldResolver,
+        type_resolver: GraphQLTypeResolver,
         middleware_manager: Optional[MiddlewareManager],
         errors: List[GraphQLError],
     ) -> None:
@@ -195,6 +201,7 @@ def __init__(
         self.operation = operation
         self.variable_values = variable_values
         self.field_resolver = field_resolver  # type: ignore
+        self.type_resolver = type_resolver  # type: ignore
         self.middleware_manager = middleware_manager
         self.errors = errors
         self._subfields_cache: Dict[
@@ -211,6 +218,7 @@ def build(
         raw_variable_values: Dict[str, Any] = None,
         operation_name: str = None,
         field_resolver: GraphQLFieldResolver = None,
+        type_resolver: GraphQLTypeResolver = None,
         middleware: Middleware = None,
     ) -> Union[List[GraphQLError], "ExecutionContext"]:
         """Build an execution context
@@ -290,6 +298,7 @@ def build(
             operation,
             variable_values,
             field_resolver or default_field_resolver,
+            type_resolver or default_type_resolver,
             middleware_manager,
             errors,
         )
@@ -390,6 +399,7 @@ async def await_and_set_result(results, response_name, result):
                     )
                     return awaited_results
 
+                # noinspection PyTypeChecker
                 results = await_and_set_result(
                     cast(Awaitable, results), response_name, result
                 )
@@ -399,6 +409,7 @@ async def set_result(results, response_name, result):
                     results[response_name] = await result
                     return results
 
+                # noinspection PyTypeChecker
                 results = set_result(results, response_name, result)
             else:
                 results[response_name] = result
@@ -860,8 +871,8 @@ def complete_abstract_value(
         Complete a value of an abstract type by determining the runtime object type of
         that value, then complete the value for that type.
         """
-        resolve_type_fn = return_type.resolve_type or default_resolve_type_fn
-        runtime_type = resolve_type_fn(result, info, return_type)
+        resolve_type_fn = return_type.resolve_type or self.type_resolver
+        runtime_type = resolve_type_fn(result, info, return_type)  # type: ignore
 
         if isawaitable(runtime_type):
 
@@ -1086,12 +1097,12 @@ def invalid_return_type_error(
     )
 
 
-def default_resolve_type_fn(
+def default_type_resolver(
     value: Any, info: GraphQLResolveInfo, abstract_type: GraphQLAbstractType
 ) -> MaybeAwaitable[Optional[Union[GraphQLObjectType, str]]]:
     """Default type resolver function.
 
-    If a resolveType function is not given, then a default resolve behavior is used
+    If a resolve_type function is not given, then a default resolve behavior is used
     which attempts two strategies:
 
     First, See if the provided value has a `__typename` field defined, if so, use that
@@ -1100,7 +1111,6 @@ def default_resolve_type_fn(
     Otherwise, test each possible type for the abstract type by calling `is_type_of`
     for the object being coerced, returning the first type that matches.
     """
-
     # First, look for `__typename`.
     type_name = (
         value.get("__typename")

graphql/graphql.py

@@ -1,12 +1,17 @@
 from asyncio import ensure_future
 from inspect import isawaitable
-from typing import Any, Awaitable, Callable, Dict, Union, Type, cast
+from typing import Any, Awaitable, Dict, Union, Type, cast
 
 from .error import GraphQLError
 from .execution import execute, ExecutionResult, ExecutionContext, Middleware
 from .language import parse, Source
 from .pyutils import MaybeAwaitable
-from .type import GraphQLSchema, validate_schema
+from .type import (
+    GraphQLFieldResolver,
+    GraphQLSchema,
+    GraphQLTypeResolver,
+    validate_schema,
+)
 
 __all__ = ["graphql", "graphql_sync"]
 
@@ -18,7 +23,8 @@ async def graphql(
     context_value: Any = None,
     variable_values: Dict[str, Any] = None,
     operation_name: str = None,
-    field_resolver: Callable = None,
+    field_resolver: GraphQLFieldResolver = None,
+    type_resolver: GraphQLTypeResolver = None,
     middleware: Middleware = None,
     execution_context_class: Type[ExecutionContext] = ExecutionContext,
 ) -> ExecutionResult:
@@ -55,6 +61,10 @@ async def graphql(
       A resolver function to use when one is not provided by the schema.
       If not provided, the default field resolver is used (which looks for a value
       or method on the source value with the field's name).
+    :arg type_resolver:
+      A type resolver function to use when none is provided by the schema.
+      If not provided, the default type resolver is used (which looks for a
+      `__typename` field or alternatively calls the `isTypeOf` method).
     :arg middleware:
       The middleware to wrap the resolvers with
     :arg execution_context_class:
@@ -69,6 +79,7 @@ async def graphql(
         variable_values,
         operation_name,
         field_resolver,
+        type_resolver,
         middleware,
         execution_context_class,
     )
@@ -86,7 +97,8 @@ def graphql_sync(
     context_value: Any = None,
     variable_values: Dict[str, Any] = None,
     operation_name: str = None,
-    field_resolver: Callable = None,
+    field_resolver: GraphQLFieldResolver = None,
+    type_resolver: GraphQLTypeResolver = None,
     middleware: Middleware = None,
     execution_context_class: Type[ExecutionContext] = ExecutionContext,
 ) -> ExecutionResult:
@@ -105,6 +117,7 @@ def graphql_sync(
         variable_values,
         operation_name,
         field_resolver,
+        type_resolver,
         middleware,
         execution_context_class,
     )
@@ -125,6 +138,7 @@ def graphql_impl(
     variable_values,
     operation_name,
     field_resolver,
+    type_resolver,
     middleware,
     execution_context_class,
 ) -> MaybeAwaitable[ExecutionResult]:
@@ -159,6 +173,7 @@ def graphql_impl(
         variable_values,
         operation_name,
         field_resolver,
+        type_resolver,
         middleware,
         execution_context_class,
     )

graphql/utilities/build_ast_schema.py

@@ -173,7 +173,7 @@ def get_operation_types(
     return op_types
 
 
-def default_type_resolver(type_name: str) -> NoReturn:
+def default_type_resolver(type_name: str, *_args) -> NoReturn:
     """Type resolver that always throws an error."""
     raise TypeError(f"Type '{type_name}' not found in document.")
 

tests/execution/test_executor.py

@@ -8,16 +8,17 @@
 from graphql.language import parse, OperationDefinitionNode, FieldNode
 from graphql.pyutils import inspect
 from graphql.type import (
-    GraphQLSchema,
-    GraphQLObjectType,
-    GraphQLString,
-    GraphQLField,
     GraphQLArgument,
+    GraphQLBoolean,
+    GraphQLField,
     GraphQLInt,
+    GraphQLInterfaceType,
     GraphQLList,
     GraphQLNonNull,
-    GraphQLBoolean,
+    GraphQLObjectType,
     GraphQLResolveInfo,
+    GraphQLSchema,
+    GraphQLString,
     ResponsePath,
 )
 
@@ -854,3 +855,32 @@ def field_resolver(source_, info):
 
         result = execute(schema, document, field_resolver=field_resolver)
         assert result == ({"foo": "foo"}, None)
+
+    def uses_a_custom_type_resolver():
+        document = parse("{ foo { bar } }")
+
+        foo_interface = GraphQLInterfaceType(
+            "FooInterface", {"bar": GraphQLField(GraphQLString)}
+        )
+
+        foo_object = GraphQLObjectType(
+            "FooObject", {"bar": GraphQLField(GraphQLString)}, [foo_interface]
+        )
+
+        schema = GraphQLSchema(
+            GraphQLObjectType("Query", {"foo": GraphQLField(foo_interface)}),
+            types=[foo_object],
+        )
+
+        def type_resolver(_source, info, abstract_type):
+            # Resolver should be able to figure out all possible types on its own
+            nonlocal possible_types
+            possible_types = info.schema.get_possible_types(abstract_type)
+            return "FooObject"
+
+        possible_types = None
+        root_value = {"foo": {"bar": "bar"}}
+        result = execute(schema, document, root_value, type_resolver=type_resolver)
+
+        assert result == ({"foo": {"bar": "bar"}}, None)
+        assert possible_types == [foo_object]