Make experimental executor fully compatible with the spec

Author: syrusakbary

graphql/execution/experimental/executor.py

@@ -3,7 +3,8 @@
 from promise import Promise
 
 from ...type import GraphQLSchema
-from ..base import ExecutionContext, ExecutionResult, get_operation_root_type
+from ...pyutils.default_ordered_dict import DefaultOrderedDict
+from ..base import ExecutionContext, ExecutionResult, get_operation_root_type, collect_fields
 from ..executors.sync import SyncExecutor
 from ..middleware import MiddlewareManager
 from .fragment import Fragment
@@ -60,7 +61,15 @@ def execute_operation(exe_context, operation, root_value):
     type = get_operation_root_type(exe_context.schema, operation)
     execute_serially = operation.operation == 'mutation'
 
-    fragment = Fragment(type=type, selection_set=operation.selection_set, context=exe_context)
+    fields = collect_fields(
+        exe_context,
+        type,
+        operation.selection_set,
+        DefaultOrderedDict(list),
+        set()
+    )
+
+    fragment = Fragment(type=type, field_asts=fields, context=exe_context)
     if execute_serially:
         return fragment.resolve_serially(root_value)
     return fragment.resolve(root_value)

graphql/execution/experimental/fragment.py

@@ -22,18 +22,24 @@ def get_base_type(type):
     return type
 
 
-def get_resolvers(context, type, selection_set):
-    from .resolver import field_resolver
+def get_subfield_asts(context, return_type, field_asts):
     subfield_asts = DefaultOrderedDict(list)
     visited_fragment_names = set()
-    if selection_set:
-        subfield_asts = collect_fields(
-            context, type, selection_set,
-            subfield_asts, visited_fragment_names
-        )
+    for field_ast in field_asts:
+        selection_set = field_ast.selection_set
+        if selection_set:
+            subfield_asts = collect_fields(
+                context, return_type, selection_set,
+                subfield_asts, visited_fragment_names
+            )
+    return subfield_asts
+
+
+def get_resolvers(context, type, field_asts):
+    from .resolver import field_resolver
 
     resolvers = []
-    for response_name, field_asts in subfield_asts.items():
+    for response_name, field_asts in field_asts.items():
         field_ast = field_asts[0]
         field_name = field_ast.name.value
         field_def = get_field_def(context and context.schema, type, field_name)
@@ -55,14 +61,14 @@ def get_resolvers(context, type, selection_set):
         if isinstance(field_base_type, GraphQLObjectType):
             field_fragment = Fragment(
                 type=field_base_type,
-                selection_set=field_ast.selection_set,
+                field_asts=get_subfield_asts(context, field_base_type, field_asts),
                 info=info,
                 context=context
             )
         elif isinstance(field_base_type, (GraphQLInterfaceType, GraphQLUnionType)):
             field_fragment = AbstractFragment(
                 abstract_type=field_base_type,
-                selection_set=field_ast.selection_set,
+                field_asts=field_asts,
                 info=info,
                 context=context
             )
@@ -78,9 +84,9 @@ def get_resolvers(context, type, selection_set):
 
 class Fragment(object):
 
-    def __init__(self, type, selection_set, context=None, info=None):
+    def __init__(self, type, field_asts, context=None, info=None):
         self.type = type
-        self.selection_set = selection_set
+        self.field_asts = field_asts
         self.context = context
         self.info = info
 
@@ -89,7 +95,7 @@ def partial_resolvers(self):
         return get_resolvers(
             self.context,
             self.type,
-            self.selection_set
+            self.field_asts
         )
 
     def have_type(self, root):
@@ -156,17 +162,17 @@ def execute_field(prev_promise, resolver):
     def __eq__(self, other):
         return isinstance(other, Fragment) and (
             other.type == self.type and
-            other.selection_set == self.selection_set and
+            other.field_asts == self.field_asts and
             other.context == self.context and
             other.info == self.info
         )
 
 
 class AbstractFragment(object):
 
-    def __init__(self, abstract_type, selection_set, context=None, info=None):
+    def __init__(self, abstract_type, field_asts, context=None, info=None):
         self.abstract_type = abstract_type
-        self.selection_set = selection_set
+        self.field_asts = field_asts
         self.context = context
         self.info = info
         self._fragments = {}
@@ -183,7 +189,12 @@ def get_fragment(self, type):
             assert type in self.possible_types, (
                 'Runtime Object type "{}" is not a possible type for "{}".'
             ).format(type, self.abstract_type)
-            self._fragments[type] = Fragment(type, self.selection_set, self.context, self.info)
+            self._fragments[type] = Fragment(
+                type,
+                get_subfield_asts(self.context, type, self.field_asts),
+                self.context,
+                self.info
+            )
         return self._fragments[type]
 
     def resolve_type(self, result):

graphql/execution/experimental/resolver.py

@@ -1,7 +1,7 @@
 import collections
 from functools import partial
 
-from promise import Promise
+from promise import Promise, is_thenable
 
 from ...error import GraphQLError, GraphQLLocatedError
 from ...type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
@@ -25,8 +25,18 @@ def is_promise(value):
 def on_complete_resolver(on_error, __func, exe_context, info, __resolver, *args, **kwargs):
     try:
         result = __resolver(*args, **kwargs)
+        if isinstance(result, Exception):
+            return on_error(result)
+        # return Promise.resolve(result).then(__func).catch(on_error)
         if is_promise(result):
-            return result.then(__func).catch(on_error)
+            # TODO: Remove this, if a promise is resolved with an Exception,
+            # it should raise by default. This is fixing an old behavior
+            # in the Promise package
+            def on_resolve(value):
+                if isinstance(value, Exception):
+                    return on_error(value)
+                return value
+            return result.then(on_resolve).then(__func).catch(on_error)
         return __func(result)
     except Exception as e:
         return on_error(e)
@@ -76,6 +86,9 @@ def complete_object_value(fragment_resolve, exe_context, on_error, result):
 def field_resolver(field, fragment=None, exe_context=None, info=None):
     # resolver = exe_context.get_field_resolver(field.resolver or default_resolve_fn)
     resolver = field.resolver or default_resolve_fn
+    if exe_context:
+        # We decorate the resolver with the middleware
+        resolver = exe_context.get_field_resolver(resolver)
     return type_resolver(field.type, resolver,
                          fragment, exe_context, info, catch_error=True)