VariableDefinition Directives: hide behind experimental flag

Replicates graphql/graphql-js@3fdf240

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 
 The current version 1.0.0rc2 of GraphQL-core-next is up-to-date with GraphQL.js
 version 14.0.0rc2. All parts of the API are covered by an extensive test
-suite of currently 1549 unit tests.
+suite of currently 1551 unit tests.
 
 
 ## Documentation

graphql/language/lexer.py

@@ -123,13 +123,16 @@ class Lexer:
 
     def __init__(self, source: Source,
                  no_location=False,
-                 experimental_fragment_variables=False) -> None:
+                 experimental_fragment_variables=False,
+                 experimental_variable_definition_directives=False) -> None:
         """Given a Source object, this returns a Lexer for that source."""
         self.source = source
         self.token = self.last_token = Token(TokenKind.SOF, 0, 0, 0, 0)
         self.line, self.line_start = 1, 0
         self.no_location = no_location
         self.experimental_fragment_variables = experimental_fragment_variables
+        self.experimental_variable_definition_directives = \
+            experimental_variable_definition_directives
 
     def advance(self):
         self.last_token = self.token

graphql/language/parser.py

@@ -28,24 +28,46 @@
 SourceType = Union[Source, str]
 
 
-def parse(source: SourceType,
-          no_location=False,
-          experimental_fragment_variables=False) -> DocumentNode:
+def parse(source: SourceType, no_location=False,
+          experimental_fragment_variables=False,
+          experimental_variable_definition_directives=False) -> DocumentNode:
     """Given a GraphQL source, parse it into a Document.
 
     Throws GraphQLError if a syntax error is encountered.
 
     By default, the parser creates AST nodes that know the location
     in the source that they correspond to. The `no_location` option
     disables that behavior for performance or testing.
+
+    Experimental features:
+
+    If `experimental_fragment_variables` is set to True, the parser will
+    understand and parse variable definitions contained in a fragment
+    definition. They'll be represented in the `variable_definitions` field
+    of the `FragmentDefinitionNode`.
+
+    The syntax is identical to normal, query-defined variables. For example:
+
+        fragment A($var: Boolean = false) on T  {
+          ...
+        }
+
+    If `experimental_variable_definition_directives` is set to True, the parser
+    understands directives on variable definitions:
+
+        query Foo($var: String = "abc" @variable_definition_directive) {
+          ...
+        }
     """
     if isinstance(source, str):
         source = Source(source)
     elif not isinstance(source, Source):
         raise TypeError(f'Must provide Source. Received: {source!r}')
     lexer = Lexer(
         source, no_location=no_location,
-        experimental_fragment_variables=experimental_fragment_variables)
+        experimental_fragment_variables=experimental_fragment_variables,
+        experimental_variable_definition_directives  # noqa
+        =experimental_variable_definition_directives)
     return parse_document(lexer)
 
 
@@ -171,12 +193,21 @@ def parse_variable_definitions(lexer: Lexer) -> List[VariableDefinitionNode]:
 def parse_variable_definition(lexer: Lexer) -> VariableDefinitionNode:
     """VariableDefinition: Variable: Type DefaultValue? Directives[Const]?"""
     start = lexer.token
+    if lexer.experimental_variable_definition_directives:
+        return VariableDefinitionNode(
+            variable=parse_variable(lexer),
+            type=expect(lexer, TokenKind.COLON)
+            and parse_type_reference(lexer),
+            default_value=parse_value_literal(lexer, True)
+            if skip(lexer, TokenKind.EQUALS) else None,
+            directives=parse_directives(lexer, True),
+            loc=loc(lexer, start))
     return VariableDefinitionNode(
         variable=parse_variable(lexer),
-        type=expect(lexer, TokenKind.COLON) and parse_type_reference(lexer),
+        type=expect(lexer, TokenKind.COLON) and parse_type_reference(
+            lexer),
         default_value=parse_value_literal(lexer, True)
         if skip(lexer, TokenKind.EQUALS) else None,
-        directives=parse_directives(lexer, True),
         loc=loc(lexer, start))
 
 

graphql/language/printer.py

@@ -52,7 +52,7 @@ def leave_operation_definition(self, node, *_args):
     def leave_variable_definition(self, node, *_args):
         return (f"{node.variable}: {node.type}"
                 f"{wrap(' = ', node.default_value)}"
-                f"{wrap(' ', ' '.join(node.directives))}")
+                f"{wrap(' ', join(node.directives, ' '))}")
 
     def leave_selection_set(self, node, *_args):
         return block(node.selections)

tests/language/test_parser.py

@@ -83,7 +83,8 @@ def parses_constant_default_values():
           'Unexpected $', (1, 37))
 
     def parses_variable_definition_directives():
-        parse('query Foo($x: Boolean = false @bar) { field }')
+        parse('query Foo($x: Boolean = false @bar) { field }',
+              experimental_variable_definition_directives=True)
 
     def does_not_accept_fragments_named_on():
         assert_syntax_error(

tests/language/test_printer.py

@@ -40,7 +40,8 @@ def correctly_prints_mutation_operation_without_name():
 
     def correctly_prints_query_operation_with_artifacts():
         query_ast_with_artifacts = parse(
-            'query ($foo: TestType) @testDirective { id, name }')
+            'query ($foo: TestType) @testDirective { id, name }',
+            experimental_variable_definition_directives=True)
         assert print_ast(query_ast_with_artifacts) == dedent("""
             query ($foo: TestType) @testDirective {
               id
@@ -51,7 +52,8 @@ def correctly_prints_query_operation_with_artifacts():
     def correcty_prints_query_operation_with_variable_directive():
         query_ast_with_variable_directive = parse(
             'query ($foo: TestType = {a: 123}'
-            ' @testDirective(if: true) @test) { id }')
+            ' @testDirective(if: true) @test) { id }',
+            experimental_variable_definition_directives=True)
         assert print_ast(query_ast_with_variable_directive) == dedent("""
             query ($foo: TestType = {a: 123} @testDirective(if: true) @test) {
               id

tests/validation/test_known_directives.py

@@ -1,12 +1,14 @@
 from functools import partial
 
+from graphql.language import parse
 from graphql.utilities import build_schema
-from graphql.validation import KnownDirectivesRule
+from graphql.validation import validate, KnownDirectivesRule
 from graphql.validation.rules.known_directives import (
     unknown_directive_message, misplaced_directive_message)
 
 from .harness import (
-    expect_fails_rule, expect_passes_rule, expect_sdl_errors_from_rule)
+    expect_fails_rule, expect_passes_rule, expect_sdl_errors_from_rule,
+    test_schema)
 
 
 expect_sdl_errors = partial(
@@ -98,7 +100,7 @@ def with_many_unknown_directives():
 
     def with_well_placed_directives():
         expect_passes_rule(KnownDirectivesRule, """
-            query Foo($var: Boolean @onVariableDefinition) @onQuery {
+            query Foo($var: Boolean) @onQuery {
               name @include(if: $var)
               ...Frag @include(if: true)
               skippedField @skip(if: true)
@@ -110,9 +112,21 @@ def with_well_placed_directives():
             }
             """)
 
+    def with_well_placed_variable_definition_directives():
+        # Need to parse with experimental flag
+        query_string = """
+            query Foo($var: Boolean @onVariableDefinition) {
+              name
+            }
+            """
+        errors = validate(test_schema, parse(
+            query_string, experimental_variable_definition_directives=True),
+            [KnownDirectivesRule])
+        assert errors == [], 'Should validate'
+
     def with_misplaced_directives():
         expect_fails_rule(KnownDirectivesRule, """
-            query Foo($var: Boolean @onField) @include(if: true) {
+            query Foo($var: Boolean) @include(if: true) {
               name @onQuery @include(if: $var)
               ...Frag @onQuery
             }
@@ -121,13 +135,27 @@ def with_misplaced_directives():
               someField
             }
             """, [
-            misplaced_directive('onField', 'variable definition', 2, 37),
-            misplaced_directive('include', 'query', 2, 47),
+            misplaced_directive('include', 'query', 2, 38),
             misplaced_directive('onQuery', 'field', 3, 20),
             misplaced_directive('onQuery', 'fragment spread', 4, 23),
             misplaced_directive('onQuery', 'mutation', 7, 26),
         ])
 
+    def with_misplaced_variable_definition_directives():
+        # Need to parse with experimental flag
+        query_string = """
+            query Foo($var: Boolean @onField) {
+              name
+            }
+            """
+        errors = validate(test_schema, parse(
+            query_string, experimental_variable_definition_directives=True),
+            [KnownDirectivesRule])
+        expected_errors = [
+            misplaced_directive('onField', 'variable definition', 2, 37)]
+        assert len(errors) >= 1, 'Should not validate'
+        assert errors == expected_errors
+
     def describe_within_sdl():
 
         def with_directive_defined_inside_sdl():