Add new GraphQLSchema.get_field method

Replicates graphql/graphql-js@69e1554

Author: Cito

src/graphql/execution/execute.py

@@ -50,9 +50,6 @@
     GraphQLResolveInfo,
     GraphQLSchema,
     GraphQLTypeResolver,
-    SchemaMetaFieldDef,
-    TypeMetaFieldDef,
-    TypeNameMetaFieldDef,
     assert_valid_schema,
     is_abstract_type,
     is_leaf_type,
@@ -71,7 +68,6 @@
     "default_type_resolver",
     "execute",
     "execute_sync",
-    "get_field_def",
     "ExecutionResult",
     "ExecutionContext",
     "FormattedExecutionResult",
@@ -501,7 +497,8 @@ def execute_field(
         calling its resolve function, then calls complete_value to await coroutine
         objects, serialize scalars, or execute the sub-selection-set for objects.
         """
-        field_def = get_field_def(self.schema, parent_type, field_nodes[0])
+        field_name = field_nodes[0].name.value
+        field_def = self.schema.get_field(parent_type, field_name)
         if not field_def:
             return Undefined
 
@@ -1130,31 +1127,6 @@ def assert_valid_execution_arguments(
         )
 
 
-def get_field_def(
-    schema: GraphQLSchema, parent_type: GraphQLObjectType, field_node: FieldNode
-) -> GraphQLField:
-    """Get field definition.
-
-    This method looks up the field on the given type definition. It has special casing
-    for the three introspection fields, ``__schema``, ``__type`, and ``__typename``.
-    ``__typename`` is special because it can always be queried as a field, even in
-    situations where no other fields are allowed, like on a Union. ``__schema`` and
-    ``__type`` could get automatically added to the query type, but that would require
-    mutating type definitions, which would cause issues.
-
-    For internal use only.
-    """
-    field_name = field_node.name.value
-
-    if field_name == "__schema" and schema.query_type == parent_type:
-        return SchemaMetaFieldDef
-    elif field_name == "__type" and schema.query_type == parent_type:
-        return TypeMetaFieldDef
-    elif field_name == "__typename":
-        return TypeNameMetaFieldDef
-    return parent_type.fields.get(field_name)
-
-
 def invalid_return_type_error(
     return_type: GraphQLObjectType, result: Any, field_nodes: List[FieldNode]
 ) -> GraphQLError:

src/graphql/execution/subscribe.py

@@ -8,7 +8,6 @@
     ExecutionResult,
     assert_valid_execution_arguments,
     execute,
-    get_field_def,
 )
 from ..execution.values import get_argument_values
 from ..language import DocumentNode
@@ -179,10 +178,10 @@ async def execute_subscription(context: ExecutionContext) -> AsyncIterable[Any]:
         context.operation.selection_set,
     )
     response_name, field_nodes = next(iter(root_fields.items()))
-    field_def = get_field_def(schema, root_type, field_nodes[0])
+    field_name = field_nodes[0].name.value
+    field_def = schema.get_field(root_type, field_name)
 
     if not field_def:
-        field_name = field_nodes[0].name.value
         raise GraphQLError(
             f"The subscription field '{field_name}' is not defined.", field_nodes
         )

src/graphql/type/schema.py

@@ -8,6 +8,8 @@
 from ..pyutils import inspect, is_collection, is_description
 from .definition import (
     GraphQLAbstractType,
+    GraphQLCompositeType,
+    GraphQLField,
     GraphQLInterfaceType,
     GraphQLNamedType,
     GraphQLObjectType,
@@ -20,7 +22,12 @@
     is_wrapping_type,
 )
 from .directives import GraphQLDirective, is_directive, specified_directives
-from .introspection import introspection_types
+from .introspection import (
+    SchemaMetaFieldDef,
+    TypeMetaFieldDef,
+    TypeNameMetaFieldDef,
+    introspection_types,
+)
 
 
 try:
@@ -387,6 +394,35 @@ def get_directive(self, name: str) -> Optional[GraphQLDirective]:
                 return directive
         return None
 
+    def get_field(
+        self, parent_type: GraphQLCompositeType, field_name: str
+    ) -> Optional[GraphQLField]:
+        """Get field of a given type with the given name.
+
+        This method looks up the field on the given type definition.
+        It has special casing for the three introspection fields, `__schema`,
+        `__type` and `__typename`.
+
+        `__typename` is special because it can always be queried as a field, even
+        in situations where no other fields are allowed, like on a Union.
+
+        `__schema` and `__type` could get automatically added to the query type,
+        but that would require mutating type definitions, which would cause issues.
+        """
+        if field_name == "__schema":
+            return SchemaMetaFieldDef if self.query_type is parent_type else None
+        if field_name == "__type":
+            return TypeMetaFieldDef if self.query_type is parent_type else None
+        if field_name == "__typename":
+            return TypeNameMetaFieldDef
+
+        # this function is part of a "hot" path inside executor and to assume presence
+        # of 'fields' is faster than to use `not is_union_type`
+        try:
+            return parent_type.fields[field_name]  # type: ignore
+        except (AttributeError, KeyError):
+            return None
+
     @property
     def validation_errors(self) -> Optional[List[GraphQLError]]:
         return self._validation_errors

src/graphql/utilities/type_info.py

@@ -27,16 +27,12 @@
     GraphQLOutputType,
     GraphQLSchema,
     GraphQLType,
-    SchemaMetaFieldDef,
-    TypeMetaFieldDef,
-    TypeNameMetaFieldDef,
     get_named_type,
     get_nullable_type,
     is_composite_type,
     is_enum_type,
     is_input_object_type,
     is_input_type,
-    is_interface_type,
     is_list_type,
     is_object_type,
     is_output_type,
@@ -54,7 +50,7 @@
 
 
 GetFieldDefFn: TypeAlias = Callable[
-    [GraphQLSchema, GraphQLType, FieldNode], Optional[GraphQLField]
+    [GraphQLSchema, GraphQLCompositeType, FieldNode], Optional[GraphQLField]
 ]
 
 
@@ -264,24 +260,9 @@ def leave_enum_value(self) -> None:
 
 
 def get_field_def(
-    schema: GraphQLSchema, parent_type: GraphQLType, field_node: FieldNode
+    schema: GraphQLSchema, parent_type: GraphQLCompositeType, field_node: FieldNode
 ) -> Optional[GraphQLField]:
-    """Get field definition.
-
-    Not exactly the same as the executor's definition of
-    :func:`graphql.execution.get_field_def`, in this statically evaluated environment
-    we do not always have an Object type, and need to handle Interface and Union types.
-    """
-    name = field_node.name.value
-    if name == "__schema" and schema.query_type is parent_type:
-        return SchemaMetaFieldDef
-    if name == "__type" and schema.query_type is parent_type:
-        return TypeMetaFieldDef
-    if name == "__typename" and is_composite_type(parent_type):
-        return TypeNameMetaFieldDef
-    if is_object_type(parent_type) or is_interface_type(parent_type):
-        return parent_type.fields.get(name)
-    return None
+    return schema.get_field(parent_type, field_node.name.value)
 
 
 class TypeInfoVisitor(Visitor):

tests/type/test_schema.py

@@ -26,6 +26,10 @@
     GraphQLSchema,
     GraphQLString,
     GraphQLType,
+    GraphQLUnionType,
+    SchemaMetaFieldDef,
+    TypeMetaFieldDef,
+    TypeNameMetaFieldDef,
     specified_directives,
 )
 from graphql.utilities import build_schema, lexicographic_sort_schema, print_schema
@@ -293,6 +297,60 @@ def preserves_the_order_of_user_provided_types():
         copy_schema = GraphQLSchema(**schema.to_kwargs())
         assert list(copy_schema.type_map) == type_names
 
+    def describe_get_field():
+        pet_type = GraphQLInterfaceType("Pet", {"name": GraphQLField(GraphQLString)})
+        cat_type = GraphQLObjectType(
+            "Cat", {"name": GraphQLField(GraphQLString)}, [pet_type]
+        )
+        dog_type = GraphQLObjectType(
+            "Dog", {"name": GraphQLField(GraphQLString)}, [pet_type]
+        )
+        cat_or_dog = GraphQLUnionType("CatOrDog", [cat_type, dog_type])
+        query_type = GraphQLObjectType("Query", {"catOrDog": GraphQLField(cat_or_dog)})
+        mutation_type = GraphQLObjectType("Mutation", {})
+        subscription_type = GraphQLObjectType("Subscription", {})
+        schema = GraphQLSchema(query_type, mutation_type, subscription_type)
+
+        _get_field = schema.get_field
+
+        def returns_known_field():
+            assert _get_field(pet_type, "name") == pet_type.fields["name"]
+            assert _get_field(cat_type, "name") == cat_type.fields["name"]
+
+            assert _get_field(query_type, "catOrDog") == query_type.fields["catOrDog"]
+
+        def returns_none_for_unknown_fields():
+            assert _get_field(cat_or_dog, "name") is None
+
+            assert _get_field(query_type, "unknown") is None
+            assert _get_field(pet_type, "unknown") is None
+            assert _get_field(cat_type, "unknown") is None
+            assert _get_field(cat_or_dog, "unknown") is None
+
+        def handles_introspection_fields():
+            assert _get_field(query_type, "__typename") == TypeNameMetaFieldDef
+            assert _get_field(mutation_type, "__typename") == TypeNameMetaFieldDef
+            assert _get_field(subscription_type, "__typename") == TypeNameMetaFieldDef
+
+            assert _get_field(pet_type, "__typename") is TypeNameMetaFieldDef
+            assert _get_field(cat_type, "__typename") is TypeNameMetaFieldDef
+            assert _get_field(dog_type, "__typename") is TypeNameMetaFieldDef
+            assert _get_field(cat_or_dog, "__typename") is TypeNameMetaFieldDef
+
+            assert _get_field(query_type, "__type") is TypeMetaFieldDef
+            assert _get_field(query_type, "__schema") is SchemaMetaFieldDef
+
+        def returns_non_for_introspection_fields_in_wrong_location():
+            assert _get_field(pet_type, "__type") is None
+            assert _get_field(dog_type, "__type") is None
+            assert _get_field(mutation_type, "__type") is None
+            assert _get_field(subscription_type, "__type") is None
+
+            assert _get_field(pet_type, "__schema") is None
+            assert _get_field(dog_type, "__schema") is None
+            assert _get_field(mutation_type, "__schema") is None
+            assert _get_field(subscription_type, "__schema") is None
+
     def describe_validity():
         def describe_when_not_assumed_valid():
             def configures_the_schema_to_still_needing_validation():

tests/utilities/test_type_info.py

@@ -1,3 +1,5 @@
+from typing import List, Optional, Tuple
+
 from graphql.language import (
     FieldNode,
     NameNode,
@@ -10,7 +12,14 @@
     print_ast,
     visit,
 )
-from graphql.type import GraphQLSchema, get_named_type, is_composite_type
+from graphql.type import (
+    GraphQLSchema,
+    SchemaMetaFieldDef,
+    TypeMetaFieldDef,
+    TypeNameMetaFieldDef,
+    get_named_type,
+    is_composite_type,
+)
 from graphql.utilities import TypeInfo, TypeInfoVisitor, build_schema
 
 from ..fixtures import kitchen_sink_query  # noqa: F401
@@ -39,9 +48,13 @@
       name(surname: Boolean): String
     }
 
+    union HumanOrAlien = Human | Alien
+
     type QueryRoot {
       human(id: ID): Human
       alien: Alien
+      humanOrAlien: HumanOrAlien
+      pet: Pet
     }
 
     schema {
@@ -140,6 +153,77 @@ def leave(self, *args):
 
         assert test_visitor.args == wrapped_visitor.args
 
+    def supports_introspection_fields():
+        type_info = TypeInfo(test_schema)
+
+        ast = parse(
+            """
+            {
+              __typename
+              __type(name: "Cat") { __typename }
+              __schema {
+                __typename # in object type
+              }
+              humanOrAlien {
+                __typename # in union type
+              }
+              pet {
+                __typename # in interface type
+              }
+              someUnknownType {
+                __typename # unknown
+              }
+              pet {
+                __type # unknown
+                __schema # unknown
+              }
+            }
+            """
+        )
+
+        visited_fields: List[Tuple[Optional[str], Optional[str]]] = []
+
+        class TestVisitor(Visitor):
+            @staticmethod
+            def enter_field(self, node: OperationDefinitionNode, *_args):
+                parent_type = type_info.get_parent_type()
+                type_name = getattr(type_info.get_parent_type(), "name", None)
+                field_def = type_info.get_field_def()
+                fields = getattr(parent_type, "fields", {})
+                fields = dict(
+                    **fields,
+                    __type=TypeMetaFieldDef,
+                    __typename=TypeNameMetaFieldDef,
+                    __schema=SchemaMetaFieldDef,
+                )
+                for name, field in fields.items():
+                    if field is field_def:
+                        field_name = name
+                        break
+                else:
+                    field_name = None
+                visited_fields.append((type_name, field_name))
+
+        test_visitor = TestVisitor()
+        assert visit(ast, TypeInfoVisitor(type_info, test_visitor))
+
+        assert visited_fields == [
+            ("QueryRoot", "__typename"),
+            ("QueryRoot", "__type"),
+            ("__Type", "__typename"),
+            ("QueryRoot", "__schema"),
+            ("__Schema", "__typename"),
+            ("QueryRoot", "humanOrAlien"),
+            ("HumanOrAlien", "__typename"),
+            ("QueryRoot", "pet"),
+            ("Pet", "__typename"),
+            ("QueryRoot", None),
+            (None, None),
+            ("QueryRoot", "pet"),
+            ("Pet", None),
+            ("Pet", None),
+        ]
+
     def maintains_type_info_during_visit():
         visited = []