recursive directive

Author: MardanovTimur

graphql/execution/executor.py

@@ -107,6 +107,8 @@ def execute(
     if executor is None:
         executor = SyncExecutor()
 
+    # operation_name, document_ast
+
     exe_context = ExecutionContext(
         schema,
         document_ast,

graphql/execution/utils.py

@@ -1,12 +1,17 @@
 # -*- coding: utf-8 -*-
 import logging
 from traceback import format_exception
+from copy import deepcopy
 
 from ..error import GraphQLError
 from ..language import ast
 from ..pyutils.default_ordered_dict import DefaultOrderedDict
 from ..type.definition import GraphQLInterfaceType, GraphQLUnionType
-from ..type.directives import GraphQLIncludeDirective, GraphQLSkipDirective
+from ..type.directives import (
+    GraphQLIncludeDirective,
+    GraphQLSkipDirective,
+    GraphQLRecursionDirective,
+)
 from ..type.introspection import (
     SchemaMetaFieldDef,
     TypeMetaFieldDef,
@@ -237,7 +242,8 @@ def collect_fields(
         directives = selection.directives
 
         if isinstance(selection, ast.Field):
-            if not should_include_node(ctx, directives):
+            validate = validate_directives(ctx, directives, selection)
+            if isinstance(validate, bool) and not validate:
                 continue
 
             name = get_field_entry_key(selection)
@@ -316,6 +322,65 @@ def should_include_node(ctx, directives):
     return True
 
 
+def validate_directives(ctx, directives, selection):
+    for directive in directives:
+        if directive.name.value in (GraphQLSkipDirective.name, GraphQLIncludeDirective.name):
+            # @skip, @include checking directive
+            return should_include_node(ctx, directive)
+        elif directive.name.value == GraphQLRecursionDirective.name:
+            build_recursive_selection_set(ctx, directive, selection)
+
+
+def relay_node_check(selection, frame=['edges', 'node']):
+    """ Check it if relay structure is presented
+    modules {
+            edges {
+                node {
+                    uid # place new recursive query here
+                    }
+                }
+            }
+    """
+    if frame:
+        relay_frame = frame.pop(0)
+    else:
+        return True
+    for selection in selection.selection_set.selections:
+        if selection.name.value == relay_frame:
+            return relay_node_check(selection, frame)
+    return False
+
+def insert_recursive_selection(selection, depth, frame=[]):
+    def insert_in_frame(selection, paste_selection, frame=frame):
+        if frame:
+            relay_frame = frame.pop(0)
+        else:
+            # remove directive
+            selection.directives = []
+            paste_selection.directives = []
+            # return inner selection
+            returnable_selection_set = selection.selection_set
+            # insert in depth
+            returnable_selection_set.selections.append(paste_selection)
+            return returnable_selection_set
+        for selection in selection.selection_set.selections:
+            if selection.name.value == relay_frame:
+                return insert_in_frame(selection, paste_selection, frame)
+    #  remove_directive(selection)
+    for counter in range(int(depth)):
+        copy_selection = deepcopy(selection)
+        copy_frame = deepcopy(frame)
+        selection = insert_in_frame(selection, copy_selection, frame)
+
+
+def build_recursive_selection_set(ctx, directive, selection):
+    depth_size = directive.arguments[0].value.value
+    is_relay = relay_node_check(selection)
+    if is_relay:
+        insert_recursive_selection(selection, depth_size, ['edges', 'node'])
+    else:
+        insert_recursive_selection(selection, depth_size)
+
 def does_fragment_condition_match(
     ctx,  # type: ExecutionContext
     fragment,  # type: Union[FragmentDefinition, InlineFragment]

graphql/language/parser.py

@@ -252,19 +252,15 @@ def parse_document(parser):
 
         if skip(parser, TokenKind.EOF):
             break
-    print('Final definiations and location', definitions, loc(parser, start))
     return ast.Document(definitions=definitions, loc=loc(parser, start))
 
 
 def parse_definition(parser):
     # type: (Parser) -> Any
-    print('parse_definition', )
     if peek(parser, TokenKind.BRACE_L):
-        print('parse_definition: BRACE_L', parser.lexer, parser.token )
         return parse_operation_definition(parser)
 
     if peek(parser, TokenKind.NAME):
-        print('parse_definition: NAME', parser.lexer, parser.token)
 
         name = parser.token.value
 

graphql/type/schema.py

@@ -1,7 +1,7 @@
 from collections import Iterable
 
 from .definition import GraphQLObjectType
-from .directives import GraphQLDirective, specified_directives
+from .directives import GraphQLDirective, specified_directives, GraphQLRecursionDirective
 from .introspection import IntrospectionSchema
 from .typemap import GraphQLTypeMap
 
@@ -122,7 +122,7 @@ def get_type(self, name):
 
     def get_directives(self):
         # type: () -> List[GraphQLDirective]
-        return self._directives
+        return self._directives + [GraphQLRecursionDirective, ]
 
     def get_directive(self, name):
         # type: (str) -> Optional[GraphQLDirective]