spec change: allow empty selection sets

Replicates graphql/graphql-js@7d3fe64

Author: Cito

src/graphql/language/parser.py

@@ -97,6 +97,7 @@ def parse(
     no_location: bool = False,
     max_tokens: int | None = None,
     experimental_fragment_arguments: bool = False,
+    allow_empty_selection_sets: bool = True,
 ) -> DocumentNode:
     """Given a GraphQL source, parse it into a Document.
 
@@ -132,6 +133,17 @@ def parse(
           ...B(x: $var)
         }
 
+    If ``allow_empty_selection_sets`` is set to ``True`` (the default), the parser
+    accepts selection sets that contain no selections, changing the grammar from
+    ``SelectionSet : { Selection+ }`` to ``SelectionSet : { Selection* }``.
+    See https://github.com/graphql/graphql-spec/pull/1227
+
+    For example::
+
+        {
+          viewer { }
+        }
+
     :param source: A GraphQL source string or source object.
     :param no_location: By default, the parser creates AST nodes that know the
         location in the source that they correspond to. Setting this parameter to
@@ -143,6 +155,9 @@ def parse(
         number of tokens allowed within a document.
     :param experimental_fragment_arguments: Allows fragment variable definitions
         and arguments on fragment spreads to be parsed (experimental).
+    :param allow_empty_selection_sets: Allows selection sets without selections
+        (the default). Deprecated, since empty selection sets are now always allowed;
+        this option will be removed in a future version.
     :returns: The parsed GraphQL document AST.
 
     Parse a GraphQL document with the default parser options:
@@ -176,6 +191,7 @@ def parse(
         no_location=no_location,
         max_tokens=max_tokens,
         experimental_fragment_arguments=experimental_fragment_arguments,
+        allow_empty_selection_sets=allow_empty_selection_sets,
     )
     return parser.parse_document()
 
@@ -375,6 +391,7 @@ class Parser:
     _no_location: bool
     _max_tokens: int | None
     _experimental_fragment_arguments: bool
+    _allow_empty_selection_sets: bool
     _lexer: Lexer
     _token_counter: int
 
@@ -385,13 +402,15 @@ def __init__(
         max_tokens: int | None = None,
         experimental_fragment_arguments: bool = False,
         lexer: Lexer | None = None,
+        allow_empty_selection_sets: bool = True,
     ) -> None:
         if not is_source(source):
             source = Source(cast("str", source))
 
         self._no_location = no_location
         self._max_tokens = max_tokens
         self._experimental_fragment_arguments = experimental_fragment_arguments
+        self._allow_empty_selection_sets = allow_empty_selection_sets
         # You may override the lexer used to lex the source; this is used by schema
         # coordinates to introduce a lexer with a restricted syntax.
         self._lexer = lexer if lexer is not None else Lexer(source)
@@ -562,11 +581,23 @@ def parse_variable(self) -> VariableNode:
         return VariableNode(name=self.parse_name(), loc=self.loc(start))
 
     def parse_selection_set(self) -> SelectionSetNode:
-        """SelectionSet: {Selection+}"""
+        """SelectionSet: {Selection+}
+
+        With ``allow_empty_selection_sets`` enabled (the default):
+
+        SelectionSet: {Selection*}
+
+        The ``allow_empty_selection_sets`` option is deprecated and will be removed in
+        a future version, at which point this will be the only grammar.
+        """
         start = self._lexer.token
         return SelectionSetNode(
-            selections=self.many(
-                TokenKind.BRACE_L, self.parse_selection, TokenKind.BRACE_R
+            selections=(
+                self.any(TokenKind.BRACE_L, self.parse_selection, TokenKind.BRACE_R)
+                if self._allow_empty_selection_sets
+                else self.many(
+                    TokenKind.BRACE_L, self.parse_selection, TokenKind.BRACE_R
+                )
             ),
             loc=self.loc(start),
         )

src/graphql/language/printer.py

@@ -113,7 +113,7 @@ def leave_variable_definition(node: PrintedNode, *_args: Any) -> str:
 
     @staticmethod
     def leave_selection_set(node: PrintedNode, *_args: Any) -> str:
-        return block(node.selections)
+        return block(node.selections) if node.selections else "{}"
 
     @staticmethod
     def leave_field(node: PrintedNode, *_args: Any) -> str:

src/graphql/validation/rules/scalar_leafs.py

@@ -62,7 +62,10 @@ def enter_field(self, node: FieldNode, *_args: Any) -> None:
                         node,
                     )
                 )
-            elif not selection_set.selections:
+            elif (
+                not selection_set.selections
+                and not self.context.allow_empty_selection_sets
+            ):
                 field_name = node.name.value
                 self.report_error(
                     GraphQLError(

src/graphql/validation/rules/single_field_subscriptions.py

@@ -94,7 +94,19 @@ def enter_operation_definition(
                     )
                 )
                 return
-            if len(grouped_field_set) > 1:
+            if not grouped_field_set:
+                self.report_error(
+                    GraphQLError(
+                        (
+                            "Anonymous Subscription"
+                            if operation_name is None
+                            else f"Subscription '{operation_name}'"
+                        )
+                        + " must select one top level field.",
+                        node.selection_set,
+                    )
+                )
+            elif len(grouped_field_set) > 1:
                 field_details_lists = list(grouped_field_set.values())
                 extra_field_details_lists = field_details_lists[1:]
                 extra_field_selection = [

src/graphql/validation/validate.py

@@ -44,6 +44,7 @@ def validate(
     rules: Collection[type[ASTValidationRule]] | None = None,
     max_errors: int | None = None,
     hide_suggestions: bool = False,
+    allow_empty_selection_sets: bool = True,
 ) -> list[GraphQLError]:
     """Implements the "Validation" section of the spec.
 
@@ -69,6 +70,11 @@ def validate(
         Defaults to 100.
     :param hide_suggestions: Whether suggestion text should be omitted from
         validation errors.
+    :param allow_empty_selection_sets: If enabled (the default), a selection set on
+        an object, interface or union type is only required to be present, rather
+        than to be non-empty. Pair this with the ``allow_empty_selection_sets``
+        parse option. See https://github.com/graphql/graphql-spec/pull/1227.
+        Deprecated, since empty selection sets are now always allowed.
     :returns: Validation errors, or an empty list when the document is valid.
 
     Validate with the default specified rules:
@@ -115,7 +121,12 @@ def on_error(error: GraphQLError) -> None:
         errors.append(error)
 
     context = ValidationContext(
-        schema, document_ast, type_info, on_error, hide_suggestions
+        schema,
+        document_ast,
+        type_info,
+        on_error,
+        hide_suggestions,
+        allow_empty_selection_sets,
     )
 
     # This uses a specialized visitor which runs multiple visitors in parallel,

src/graphql/validation/validation_context.py

@@ -346,6 +346,9 @@ class ValidationContext(ASTValidationContext):
     :param type_info: TypeInfo instance used to track traversal state.
     :param on_error: Callback invoked for each validation error.
     :param hide_suggestions: Whether suggestion text should be omitted from errors.
+    :param allow_empty_selection_sets: Whether selection sets on composite types may
+        be empty (the default). Deprecated, since empty selection sets are now always
+        allowed.
 
     >>> from graphql import GraphQLError, TypeInfo, build_schema, parse
     >>> from graphql.validation import ValidationContext
@@ -367,6 +370,7 @@ class ValidationContext(ASTValidationContext):
     _variable_usages: dict[NodeWithSelectionSet, list[VariableUsage]]
     _recursive_variable_usages: dict[OperationDefinitionNode, list[VariableUsage]]
     _hide_suggestions: bool
+    _allow_empty_selection_sets: bool
 
     def __init__(
         self,
@@ -375,19 +379,29 @@ def __init__(
         type_info: TypeInfo,
         on_error: Callable[[GraphQLError], None],
         hide_suggestions: bool = False,
+        allow_empty_selection_sets: bool = True,
     ) -> None:
         super().__init__(ast, on_error)
         self.schema = schema
         self._type_info = type_info
         self._variable_usages = {}
         self._recursive_variable_usages = {}
         self._hide_suggestions = hide_suggestions
+        self._allow_empty_selection_sets = allow_empty_selection_sets
 
     @property
     def hide_suggestions(self) -> bool:
         """Whether validation error suggestions are hidden."""
         return self._hide_suggestions
 
+    @property
+    def allow_empty_selection_sets(self) -> bool:
+        """Whether empty selection sets on composite types are allowed.
+
+        Deprecated, since empty selection sets are now always allowed.
+        """
+        return self._allow_empty_selection_sets
+
     def get_variable_usages(self, node: NodeWithSelectionSet) -> list[VariableUsage]:
         """Get variable usages found directly within the given node.
 

tests/execution/test_executor.py

@@ -256,6 +256,27 @@ def merges_parallel_fragments():
             None,
         )
 
+    def executes_empty_selection_sets():
+        Type = GraphQLObjectType(
+            "Type",
+            lambda: {
+                "a": GraphQLField(GraphQLString, resolve=lambda *_args: "Apple"),
+                "deep": GraphQLField(Type, resolve=lambda *_args: {}),
+            },
+        )
+        schema = GraphQLSchema(Type)
+
+        document = parse(
+            "{ a deep { } ...Frag } fragment Frag on Type { }",
+            allow_empty_selection_sets=True,
+        )
+
+        result = execute_sync(schema, document)
+        assert result == ({"a": "Apple", "deep": {}}, None)
+
+        empty_document = parse("{ }", allow_empty_selection_sets=True)
+        assert execute_sync(schema, empty_document) == ({}, None)
+
     def provides_info_about_current_execution_state():
         resolved_infos = []
 

tests/language/test_parser.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TypeAlias, cast
+from typing import Any, TypeAlias, cast
 
 import pytest
 
@@ -49,9 +49,11 @@
 Location: TypeAlias = tuple[int, int] | None
 
 
-def assert_syntax_error(text: str, message: str, location: Location) -> None:
+def assert_syntax_error(
+    text: str, message: str, location: Location, **options: Any
+) -> None:
     with pytest.raises(GraphQLSyntaxError) as exc_info:
-        parse(text)
+        parse(text, **options)
     error = exc_info.value
     assert error.message == f"Syntax Error: {message}"
     assert error.description == message
@@ -503,6 +505,52 @@ def disallows_parsing_fragment_spread_arguments_without_experimental_flag():
         with pytest.raises(GraphQLSyntaxError):
             parse(document)
 
+    def allows_parsing_empty_selection_sets():
+        document = parse("{ node { } }", no_location=True)
+
+        assert document == DocumentNode(
+            definitions=(
+                OperationDefinitionNode(
+                    description=None,
+                    operation=OperationType.QUERY,
+                    name=None,
+                    variable_definitions=None,
+                    directives=None,
+                    selection_set=SelectionSetNode(
+                        selections=(
+                            FieldNode(
+                                alias=None,
+                                name=NameNode(value="node"),
+                                arguments=None,
+                                directives=None,
+                                selection_set=SelectionSetNode(selections=()),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        )
+
+    def allows_parsing_an_empty_operation_selection_set():
+        document = parse("{ }", no_location=True)
+        operation = cast("OperationDefinitionNode", document.definitions[0])
+
+        assert operation.selection_set.selections == ()
+
+    def allows_parsing_an_empty_fragment_selection_set():
+        document = parse("fragment a on t { }", no_location=True)
+        fragment = cast("FragmentDefinitionNode", document.definitions[0])
+
+        assert fragment.selection_set.selections == ()
+
+    def disallows_parsing_empty_selection_sets_when_disabled():
+        assert_syntax_error(
+            "{ node { } }",
+            "Expected Name, found '}'.",
+            (1, 10),
+            allow_empty_selection_sets=False,
+        )
+
     def contains_location_information_that_only_stringifies_start_end():
         result = parse("{ id }")
         assert str(result.loc) == "0:6"

tests/language/test_printer.py

@@ -20,6 +20,24 @@ def prints_minimal_ast():
         ast = FieldNode(name=NameNode(value="foo"))
         assert print_ast(ast) == "foo"
 
+    def prints_empty_selection_sets():
+        ast = parse(
+            "{ foo { } bar { ... on Baz { } } }", allow_empty_selection_sets=True
+        )
+        assert print_ast(ast) == dedent(
+            """
+            {
+              foo {}
+              bar {
+                ... on Baz {}
+              }
+            }
+            """
+        )
+
+        empty_operation_ast = parse("{ }", allow_empty_selection_sets=True)
+        assert print_ast(empty_operation_ast) == "{}"
+
     def produces_helpful_error_messages():
         bad_ast = {"random": "Data"}
         with pytest.raises(TypeError) as exc_info: