Switch out regular executor for parallel executor running w/ synchronous middleware.

Author: jhgg

graphql/core/defer.py

@@ -64,14 +64,7 @@
 from graphql.core.compat import PY3
 
 __all__ = ("Deferred", "AlreadyCalledDeferred", "DeferredException",
-           "defer", "inline_callbacks", "return_value")
-
-
-class _DefGen_Return(BaseException):
-    """Exception to return a result from an inline callback."""
-
-    def __init__(self, value):
-        self.value = value
+           "defer", "succeed", "fail", "DeferredDict", "DeferredList")
 
 
 class AlreadyCalledDeferred(Exception):

graphql/core/error.py

@@ -1,4 +1,5 @@
 from .language.location import get_location
+from .defer import DeferredException
 
 
 class Error(Exception):
@@ -38,6 +39,9 @@ def locations(self):
 
 
 def format_error(error):
+    if isinstance(error, DeferredException):
+        error = error.value
+
     return {
         'message': error.message,
         'locations': error.locations,

graphql/core/execution/__init__.py

@@ -1,14 +1,8 @@
 # -*- coding: utf-8 -*-
-import collections
-from ..error import GraphQLError, format_error
+from ..error import GraphQLError
 from ..language import ast
 from ..type.definition import (
-    GraphQLEnumType,
     GraphQLInterfaceType,
-    GraphQLList,
-    GraphQLNonNull,
-    GraphQLObjectType,
-    GraphQLScalarType,
     GraphQLUnionType,
 )
 from ..type.directives import (
@@ -20,12 +14,11 @@
     TypeMetaFieldDef,
     TypeNameMetaFieldDef,
 )
-from ..utils import is_nullish, type_from_ast
+from ..utils import type_from_ast
 from .values import get_argument_values, get_variable_values
 
 Undefined = object()
 
-
 """
 Terminology
 
@@ -52,6 +45,7 @@ class ExecutionContext(object):
 
     Namely, schema of the type system that is currently executing,
     and the fragments defined in the query document"""
+
     def __init__(self, schema, root, document_ast, operation_name, args):
         """Constructs a ExecutionContext object from the arguments passed
         to execute, which we will pass throughout the other execution
@@ -96,27 +90,13 @@ def __init__(self, data, errors=None):
 
 
 def execute(schema, root, ast, operation_name='', args=None):
-    """Implements the "Evaluating requests" section of the spec."""
-    assert schema, 'Must provide schema'
-    ctx = ExecutionContext(schema, root, ast, operation_name, args)
-    try:
-        data = execute_operation(ctx, root, ctx.operation)
-    except Exception as e:
-        ctx.errors.append(e)
-        data = None
-    if not ctx.errors:
-        return ExecutionResult(data)
-    formatted_errors = list(map(format_error, ctx.errors))
-    return ExecutionResult(data, formatted_errors)
-
-
-def execute_operation(ctx, root, operation):
-    """Implements the "Evaluating operations" section of the spec."""
-    type = get_operation_root_type(ctx.schema, operation)
-    fields = collect_fields(ctx, type, operation.selection_set, {}, set())
-    if operation.operation == 'mutation':
-        return execute_fields_serially(ctx, type, root, fields)
-    return execute_fields(ctx, type, root, fields)
+    """
+    Executes an AST synchronously. Assumes that the AST is already validated.
+    """
+    from .parallel_execution import Executor
+    from .middlewares import SynchronousExecutionMiddleware
+    e = Executor(schema, [SynchronousExecutionMiddleware.SynchronousExecutionMiddleware()])
+    return e.execute(ast, root, args, operation_name, validate_ast=False)
 
 
 def get_operation_root_type(schema, operation):
@@ -137,24 +117,6 @@ def get_operation_root_type(schema, operation):
     )
 
 
-def execute_fields_serially(ctx, parent_type, source, fields):
-    """Implements the "Evaluating selection sets" section of the spec
-    for "write" mode."""
-    results = {}
-    for response_name, field_asts in fields.items():
-        result = resolve_field(ctx, parent_type, source, field_asts)
-        if result is not Undefined:
-            results[response_name] = result
-    return results
-
-
-def execute_fields(ctx, parent_type, source, fields):
-    """Implements the "Evaluating selection sets" section of the spec
-    for "read" mode."""
-    # FIXME: just fallback to serial execution for now.
-    return execute_fields_serially(ctx, parent_type, source, fields)
-
-
 def collect_fields(ctx, type, selection_set, fields, prev_fragment_names):
     for selection in selection_set.selections:
         directives = selection.directives
@@ -268,136 +230,6 @@ def variable_values(self):
         return self.context.variables
 
 
-def resolve_field(ctx, parent_type, source, field_asts):
-    """A wrapper function for resolving the field, that catches the error
-    and adds it to the context's global if the error is not rethrowable."""
-    field_ast = field_asts[0]
-    field_name = field_ast.name.value
-
-    field_def = get_field_def(ctx.schema, parent_type, field_name)
-    if not field_def:
-        return Undefined
-
-    return_type = field_def.type
-    resolve_fn = field_def.resolver or default_resolve_fn
-
-    # Build a dict of arguments from the field.arguments AST, using the variables scope to fulfill any variable references.
-    # TODO: find a way to memoize, in case this field is within a list type.
-    args = get_argument_values(
-        field_def.args, field_ast.arguments, ctx.variables
-    )
-
-    # The resolve function's optional third argument is a collection of
-    # information about the current execution state.
-    info = ResolveInfo(
-        field_name,
-        field_asts,
-        return_type,
-        parent_type,
-        ctx
-    )
-
-    # If an error occurs while calling the field `resolve` function, ensure that it is wrapped as a GraphQLError with locations.
-    # Log this error and return null if allowed, otherwise throw the error so the parent field can handle it.
-    try:
-        result = resolve_fn(source, args, info)
-    except Exception as e:
-        reported_error = GraphQLError(str(e), [field_ast], e)
-        if isinstance(return_type, GraphQLNonNull):
-            raise reported_error
-        ctx.errors.append(reported_error)
-        return None
-
-    return complete_value_catching_error(
-        ctx, return_type, field_asts, info, result
-    )
-
-
-def complete_value_catching_error(ctx, return_type, field_asts, info, result):
-    # If the field type is non-nullable, then it is resolved without any
-    # protection from errors.
-    if isinstance(return_type, GraphQLNonNull):
-        return complete_value(ctx, return_type, field_asts, info, result)
-
-    # Otherwise, error protection is applied, logging the error and
-    # resolving a null value for this field if one is encountered.
-    try:
-        return complete_value(ctx, return_type, field_asts, info, result)
-    except Exception as e:
-        ctx.errors.append(e)
-        return None
-
-
-def complete_value(ctx, return_type, field_asts, info, result):
-    """Implements the instructions for completeValue as defined in the
-    "Field entries" section of the spec.
-
-    If the field type is Non-Null, then this recursively completes the value for the inner type. It throws a field error
-    if that completion returns null, as per the "Nullability" section of the spec.
-
-    If the field type is a List, then this recursively completes the value for the inner type on each item in the list.
-
-    If the field type is a Scalar or Enum, ensures the completed value is a legal value of the type by calling the `serialize`
-    method of GraphQL type definition.
-
-    Otherwise, the field type expects a sub-selection set, and will complete the value by evaluating all sub-selections."""
-    # If field type is NonNull, complete for inner type, and throw field error if result is null.
-    if isinstance(return_type, GraphQLNonNull):
-        completed = complete_value(
-            ctx, return_type.of_type, field_asts, info, result
-        )
-        if completed is None:
-            raise GraphQLError(
-                'Cannot return null for non-nullable type.',
-                field_asts
-            )
-        return completed
-
-    # If result is null-like, return null.
-    if is_nullish(result):
-        return None
-
-    # If field type is List, complete each item in the list with the inner type
-    if isinstance(return_type, GraphQLList):
-        assert isinstance(result, collections.Iterable), \
-            'User Error: expected iterable, but did not find one.'
-
-        item_type = return_type.of_type
-        return [complete_value_catching_error(
-            ctx, item_type, field_asts, info, item
-        ) for item in result]
-
-    # If field type is Scalar or Enum, serialize to a valid value, returning null if coercion is not possible.
-    if isinstance(return_type, (GraphQLScalarType, GraphQLEnumType)):
-        serialized_result = return_type.serialize(result)
-        if is_nullish(serialized_result):
-            return None
-        return serialized_result
-
-    # Field type must be Object, Interface or Union and expect sub-selections.
-    if isinstance(return_type, GraphQLObjectType):
-        object_type = return_type
-    elif isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
-        object_type = return_type.resolve_type(result)
-    else:
-        object_type = None
-
-    if not object_type:
-        return None
-
-    # Collect sub-fields to execute to complete this value.
-    subfield_asts = {}
-    visited_fragment_names = set()
-    for field_ast in field_asts:
-        selection_set = field_ast.selection_set
-        if selection_set:
-            subfield_asts = collect_fields(
-                ctx, object_type, selection_set,
-                subfield_asts, visited_fragment_names)
-
-    return execute_fields(ctx, object_type, result, subfield_asts)
-
-
 def default_resolve_fn(source, args, info):
     """If a resolve function is not given, then a default resolve behavior is used which takes the property of the source object
     of the same name as the field and returns it as the result, or if it's a function, returns the result of calling that function."""

graphql/core/execution/middlewares/AsyncioExecutionMiddleware.py

@@ -1,3 +1,4 @@
+# flake8: noqa
 from asyncio import Future, coroutine, iscoroutine, ensure_future
 from graphql.core.defer import Deferred
 

graphql/core/execution/parallel_execution.py

@@ -9,29 +9,33 @@
 from graphql.core.type import GraphQLEnumType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, \
     GraphQLScalarType, GraphQLUnionType
 from graphql.core.utils import is_nullish
+from graphql.core.language import ast
 
 
 class Executor(object):
     def __init__(self, schema, execution_middlewares=None):
         self.execution_middlewares = execution_middlewares or []
         self.schema = schema
 
-    def execute(self, request='', root=None, args=None, operation_name=None, execute_serially=False):
-        if not isinstance(request, Source):
-            request = Source(request, 'GraphQL request')
+    def execute(self, request='', root=None, args=None, operation_name=None, execute_serially=False, validate_ast=True):
+        if not isinstance(request, ast.Document):
+            if not isinstance(request, Source):
+                request = Source(request, 'GraphQL request')
 
-        ast = parse(request)
-        validation_errors = validate(self.schema, ast)
-        if validation_errors:
-            return ExecutionResult(
-                data=None,
-                errors=validation_errors,
-            )
+            request = parse(request)
+
+        if validate_ast:
+            validation_errors = validate(self.schema, request)
+            if validation_errors:
+                return ExecutionResult(
+                    data=None,
+                    errors=validation_errors,
+                )
 
         curried_execution_function = functools.partial(
             self._execute_graphql_query,
             root or object(),
-            ast,
+            request,
             operation_name,
             args or {},
             execute_serially)

tests/core_execution/test_lists.py

@@ -50,7 +50,7 @@ def test_non_nullable_list_of_nullables():
     # Returns null
     result = run(type, None)
     assert len(result.errors) == 1
-    assert result.errors[0]['message'] == 'Cannot return null for non-nullable type.'
+    assert result.errors[0]['message'] == 'Cannot return null for non-nullable field DataType.test.'
     # TODO: check error location
     assert result.data == {'nest': None}
 
@@ -62,7 +62,7 @@ def test_nullable_list_of_non_nullables():
     # Contains null
     result = run(type, [1, None, 2])
     assert len(result.errors) == 1
-    assert result.errors[0]['message'] == 'Cannot return null for non-nullable type.'
+    assert result.errors[0]['message'] == 'Cannot return null for non-nullable field DataType.test.'
     # TODO: check error location
     assert result.data == {'nest': {'test': None}}
     # Returns null
@@ -76,12 +76,12 @@ def test_non_nullable_list_of_non_nullables():
     # Contains null
     result = run(type, [1, None, 2])
     assert len(result.errors) == 1
-    assert result.errors[0]['message'] == 'Cannot return null for non-nullable type.'
+    assert result.errors[0]['message'] == 'Cannot return null for non-nullable field DataType.test.'
     # TODO: check error location
     assert result.data == {'nest': None}
     # Returns null
     result = run(type, None)
     assert len(result.errors) == 1
-    assert result.errors[0]['message'] == 'Cannot return null for non-nullable type.'
+    assert result.errors[0]['message'] == 'Cannot return null for non-nullable field DataType.test.'
     # TODO: check error location
     assert result.data == {'nest': None}

tests/core_execution/test_nonnull.py

@@ -149,7 +149,7 @@ def test_nulls_a_sync_returned_object_that_contains_a_non_nullable_field_that_re
     result = execute(schema, NullingData(), ast, 'Q', {})
     assert len(result.errors) == 1
     # TODO: check error location
-    assert result.errors[0]['message'] == 'Cannot return null for non-nullable type.'
+    assert result.errors[0]['message'] == 'Cannot return null for non-nullable field DataType.nonNullSync.'
     assert result.data == {
         'nest': None
     }
@@ -218,4 +218,4 @@ def test_nulls_the_top_level_if_sync_non_nullable_field_returns_null():
     assert result.data is None
     assert len(result.errors) == 1
     # TODO: check error location
-    assert result.errors[0]['message'] == 'Cannot return null for non-nullable type.'
+    assert result.errors[0]['message'] == 'Cannot return null for non-nullable field DataType.nonNullSync.'

tests_py35/core_execution/test_asyncio_executor.py

@@ -1,3 +1,5 @@
+# flake8: noqa
+
 from graphql.core.execution.parallel_execution import Executor
 from graphql.core.execution.middlewares.AsyncioExecutionMiddleware import AsyncioExecutionMiddleware
 from graphql.core.type import (