refactor: collect_fields to separate utility

Replicates graphql/graphql-js@dab4f44

Author: Cito

src/graphql/execution/collect_fields.py

@@ -0,0 +1,127 @@
+from typing import Any, Dict, List, Set, Union, cast
+
+from ..language import (
+    FieldNode,
+    FragmentDefinitionNode,
+    FragmentSpreadNode,
+    InlineFragmentNode,
+    SelectionSetNode,
+)
+from ..type import (
+    GraphQLAbstractType,
+    GraphQLIncludeDirective,
+    GraphQLObjectType,
+    GraphQLSchema,
+    GraphQLSkipDirective,
+    is_abstract_type,
+)
+from ..utilities.type_from_ast import type_from_ast
+from .values import get_directive_values
+
+__all__ = ["collect_fields"]
+
+
+def collect_fields(
+    schema: GraphQLSchema,
+    fragments: Dict[str, FragmentDefinitionNode],
+    variable_values: Dict[str, Any],
+    runtime_type: GraphQLObjectType,
+    selection_set: SelectionSetNode,
+    fields: Dict[str, List[FieldNode]],
+    visited_fragment_names: Set[str],
+) -> Dict[str, List[FieldNode]]:
+    """Collect fields.
+
+    Given a selection_set, adds all of the fields in that selection to the passed in
+    map of fields, and returns it at the end.
+
+    collect_fields requires the "runtime type" of an object. For a field which
+    returns an Interface or Union type, the "runtime type" will be the actual
+    Object type returned by that field.
+
+    For internal use only.
+    """
+    for selection in selection_set.selections:
+        if isinstance(selection, FieldNode):
+            if not should_include_node(variable_values, selection):
+                continue
+            name = get_field_entry_key(selection)
+            fields.setdefault(name, []).append(selection)
+        elif isinstance(selection, InlineFragmentNode):
+            if not should_include_node(
+                variable_values, selection
+            ) or not does_fragment_condition_match(schema, selection, runtime_type):
+                continue
+            collect_fields(
+                schema,
+                fragments,
+                variable_values,
+                runtime_type,
+                selection.selection_set,
+                fields,
+                visited_fragment_names,
+            )
+        elif isinstance(selection, FragmentSpreadNode):  # pragma: no cover else
+            frag_name = selection.name.value
+            if frag_name in visited_fragment_names or not should_include_node(
+                variable_values, selection
+            ):
+                continue
+            visited_fragment_names.add(frag_name)
+            fragment = fragments.get(frag_name)
+            if not fragment or not does_fragment_condition_match(
+                schema, fragment, runtime_type
+            ):
+                continue
+            collect_fields(
+                schema,
+                fragments,
+                variable_values,
+                runtime_type,
+                fragment.selection_set,
+                fields,
+                visited_fragment_names,
+            )
+    return fields
+
+
+def should_include_node(
+    variable_values: Dict[str, Any],
+    node: Union[FragmentSpreadNode, FieldNode, InlineFragmentNode],
+) -> bool:
+    """Check if node should be included
+
+    Determines if a field should be included based on the @include and @skip
+    directives, where @skip has higher precedence than @include.
+    """
+    skip = get_directive_values(GraphQLSkipDirective, node, variable_values)
+    if skip and skip["if"]:
+        return False
+
+    include = get_directive_values(GraphQLIncludeDirective, node, variable_values)
+    if include and not include["if"]:
+        return False
+
+    return True
+
+
+def does_fragment_condition_match(
+    schema: GraphQLSchema,
+    fragment: Union[FragmentDefinitionNode, InlineFragmentNode],
+    type_: GraphQLObjectType,
+) -> bool:
+    """Determine if a fragment is applicable to the given type."""
+    type_condition_node = fragment.type_condition
+    if not type_condition_node:
+        return True
+    conditional_type = type_from_ast(schema, type_condition_node)
+    if conditional_type is type_:
+        return True
+    if is_abstract_type(conditional_type):
+        return schema.is_sub_type(cast(GraphQLAbstractType, conditional_type), type_)
+    return False
+
+
+def get_field_entry_key(node: FieldNode) -> str:
+    """Implements the logic to compute the key of a given field's entry"""
+    return node.alias.value if node.alias else node.name.value

src/graphql/execution/execute.py

@@ -21,11 +21,8 @@
     DocumentNode,
     FieldNode,
     FragmentDefinitionNode,
-    FragmentSpreadNode,
-    InlineFragmentNode,
     OperationDefinitionNode,
     OperationType,
-    SelectionSetNode,
 )
 from ..pyutils import (
     inspect,
@@ -37,18 +34,15 @@
     Undefined,
 )
 from ..utilities.get_operation_root_type import get_operation_root_type
-from ..utilities.type_from_ast import type_from_ast
 from ..type import (
     GraphQLAbstractType,
     GraphQLField,
-    GraphQLIncludeDirective,
     GraphQLLeafType,
     GraphQLList,
     GraphQLNonNull,
     GraphQLObjectType,
     GraphQLOutputType,
     GraphQLSchema,
-    GraphQLSkipDirective,
     GraphQLFieldResolver,
     GraphQLTypeResolver,
     GraphQLResolveInfo,
@@ -62,8 +56,9 @@
     is_non_null_type,
     is_object_type,
 )
+from .collect_fields import collect_fields
 from .middleware import MiddlewareManager
-from .values import get_argument_values, get_directive_values, get_variable_values
+from .values import get_argument_values, get_variable_values
 
 __all__ = [
     "assert_valid_execution_arguments",
@@ -328,7 +323,15 @@ def execute_operation(
         Implements the "Executing operations" section of the spec.
         """
         type_ = get_operation_root_type(self.schema, operation)
-        fields = self.collect_fields(type_, operation.selection_set, {}, set())
+        fields = collect_fields(
+            self.schema,
+            self.fragments,
+            self.variable_values,
+            type_,
+            operation.selection_set,
+            {},
+            set(),
+        )
 
         path = None
 
@@ -462,96 +465,6 @@ async def get_results() -> Dict[str, Any]:
 
         return get_results()
 
-    def collect_fields(
-        self,
-        runtime_type: GraphQLObjectType,
-        selection_set: SelectionSetNode,
-        fields: Dict[str, List[FieldNode]],
-        visited_fragment_names: Set[str],
-    ) -> Dict[str, List[FieldNode]]:
-        """Collect fields.
-
-        Given a selection_set, adds all of the fields in that selection to the passed in
-        map of fields, and returns it at the end.
-
-        collect_fields requires the "runtime type" of an object. For a field which
-        returns an Interface or Union type, the "runtime type" will be the actual
-        Object type returned by that field.
-
-        For internal use only.
-        """
-        for selection in selection_set.selections:
-            if isinstance(selection, FieldNode):
-                if not self.should_include_node(selection):
-                    continue
-                name = get_field_entry_key(selection)
-                fields.setdefault(name, []).append(selection)
-            elif isinstance(selection, InlineFragmentNode):
-                if not self.should_include_node(
-                    selection
-                ) or not self.does_fragment_condition_match(selection, runtime_type):
-                    continue
-                self.collect_fields(
-                    runtime_type,
-                    selection.selection_set,
-                    fields,
-                    visited_fragment_names,
-                )
-            elif isinstance(selection, FragmentSpreadNode):  # pragma: no cover else
-                frag_name = selection.name.value
-                if frag_name in visited_fragment_names or not self.should_include_node(
-                    selection
-                ):
-                    continue
-                visited_fragment_names.add(frag_name)
-                fragment = self.fragments.get(frag_name)
-                if not fragment or not self.does_fragment_condition_match(
-                    fragment, runtime_type
-                ):
-                    continue
-                self.collect_fields(
-                    runtime_type, fragment.selection_set, fields, visited_fragment_names
-                )
-        return fields
-
-    def should_include_node(
-        self, node: Union[FragmentSpreadNode, FieldNode, InlineFragmentNode]
-    ) -> bool:
-        """Check if node should be included
-
-        Determines if a field should be included based on the @include and @skip
-        directives, where @skip has higher precedence than @include.
-        """
-        skip = get_directive_values(GraphQLSkipDirective, node, self.variable_values)
-        if skip and skip["if"]:
-            return False
-
-        include = get_directive_values(
-            GraphQLIncludeDirective, node, self.variable_values
-        )
-        if include and not include["if"]:
-            return False
-
-        return True
-
-    def does_fragment_condition_match(
-        self,
-        fragment: Union[FragmentDefinitionNode, InlineFragmentNode],
-        type_: GraphQLObjectType,
-    ) -> bool:
-        """Determine if a fragment is applicable to the given type."""
-        type_condition_node = fragment.type_condition
-        if not type_condition_node:
-            return True
-        conditional_type = type_from_ast(self.schema, type_condition_node)
-        if conditional_type is type_:
-            return True
-        if is_abstract_type(conditional_type):
-            return self.schema.is_sub_type(
-                cast(GraphQLAbstractType, conditional_type), type_
-            )
-        return False
-
     def build_resolve_info(
         self,
         field_def: GraphQLField,
@@ -1039,7 +952,10 @@ def collect_subfields(
             for field_node in field_nodes:
                 selection_set = field_node.selection_set
                 if selection_set:
-                    sub_field_nodes = self.collect_fields(
+                    sub_field_nodes = collect_fields(
+                        self.schema,
+                        self.fragments,
+                        self.variable_values,
                         return_type,
                         selection_set,
                         sub_field_nodes,
@@ -1216,11 +1132,6 @@ def get_field_def(
     return parent_type.fields.get(field_name)
 
 
-def get_field_entry_key(node: FieldNode) -> str:
-    """Implements the logic to compute the key of a given field's entry"""
-    return node.alias.value if node.alias else node.name.value
-
-
 def invalid_return_type_error(
     return_type: GraphQLObjectType, result: Any, field_nodes: List[FieldNode]
 ) -> GraphQLError:

src/graphql/subscription/subscribe.py

@@ -9,6 +9,7 @@
 )
 
 from ..error import GraphQLError, located_error
+from ..execution.collect_fields import collect_fields
 from ..execution.execute import (
     assert_valid_execution_arguments,
     execute,
@@ -163,7 +164,15 @@ async def create_source_event_stream(
 async def execute_subscription(context: ExecutionContext) -> AsyncIterable[Any]:
     schema = context.schema
     type_ = get_operation_root_type(schema, context.operation)
-    fields = context.collect_fields(type_, context.operation.selection_set, {}, set())
+    fields = collect_fields(
+        schema,
+        context.fragments,
+        context.variable_values,
+        type_,
+        context.operation.selection_set,
+        {},
+        set(),
+    )
     response_name, field_nodes = next(iter(fields.items()))
     field_def = get_field_def(schema, type_, field_nodes[0])
 

src/graphql/validation/rules/single_field_subscriptions.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, cast
 
 from ...error import GraphQLError
-from ...execution import ExecutionContext, default_field_resolver, default_type_resolver
+from ...execution.collect_fields import collect_fields
 from ...language import (
     FieldNode,
     FragmentDefinitionNode,
@@ -35,21 +35,14 @@ def enter_operation_definition(
                     for definition in document.definitions
                     if isinstance(definition, FragmentDefinitionNode)
                 }
-                fake_execution_context = ExecutionContext(
+                fields = collect_fields(
                     schema,
                     fragments,
-                    root_value=None,
-                    context_value=None,
-                    operation=node,
-                    variable_values=variable_values,
-                    field_resolver=default_field_resolver,
-                    type_resolver=default_type_resolver,
-                    errors=[],
-                    middleware_manager=None,
-                    is_awaitable=None,
-                )
-                fields = fake_execution_context.collect_fields(
-                    subscription_type, node.selection_set, {}, set()
+                    variable_values,
+                    subscription_type,
+                    node.selection_set,
+                    {},
+                    set(),
                 )
                 if len(fields) > 1:
                     field_selection_lists = list(fields.values())