Merged in next branch.

Author: markusdap

.gitignore

@@ -62,6 +62,7 @@ target/
 
 # IntelliJ
 .idea
+*.iml
 
 # OS X
 .DS_Store

.travis.yml

@@ -6,7 +6,6 @@ python:
 - 3.4
 - 3.5
 - pypy
-cache: pip
 before_install:
   - |
       if [ "$TRAVIS_PYTHON_VERSION" = "pypy" ]; then
@@ -22,8 +21,8 @@ before_install:
         source "$HOME/virtualenvs/pypy-$PYPY_VERSION/bin/activate"
       fi
 install:
-- pip install --cache-dir $HOME/.cache/pip pytest-cov pytest-mock coveralls flake8 isort==3.9.6 gevent==1.1b5 six>=1.10.0 promise>=0.4.2
-- pip install --cache-dir $HOME/.cache/pip pytest>=2.7.3 --upgrade
+- pip install pytest-cov pytest-mock coveralls flake8 isort==3.9.6 gevent==1.1b5 six>=1.10.0 promise>=0.4.2 pytest-benchmark
+- pip install pytest==2.9.2
 - pip install -e .
 script:
 - flake8

graphql/__init__.py

@@ -33,7 +33,7 @@
     __GRAPHQL_SETUP__ = False
 
 
-VERSION = (0, 5, 3, 'final', 0)
+VERSION = (1, 0, 0, 'alpha', 0)
 
 __version__ = get_version(VERSION)
 
@@ -58,6 +58,7 @@
         GraphQLList,
         GraphQLNonNull,
         GraphQLField,
+        GraphQLInputObjectField,
         GraphQLArgument,
 
         # "Enum" of Type Kinds
@@ -135,6 +136,8 @@
     # Execute GraphQL queries.
     from .execution import (  # no import order
         execute,
+        MiddlewareManager,
+        middlewares
     )
 
     # Validate GraphQL queries.
@@ -213,6 +216,7 @@
         'GraphQLList',
         'GraphQLNonNull',
         'GraphQLField',
+        'GraphQLInputObjectField',
         'GraphQLArgument',
         'GraphQLObjectType',
         'GraphQLScalarType',
@@ -256,6 +260,8 @@
         'print_ast',
         'visit',
         'execute',
+        'MiddlewareManager',
+        'middlewares',
         'specified_rules',
         'validate',
         'GraphQLError',

graphql/execution/__init__.py

@@ -20,6 +20,7 @@
 """
 from .executor import execute
 from .base import ExecutionResult
+from .middleware import middlewares, MiddlewareManager
 
 
-__all__ = ['execute', 'ExecutionResult']
+__all__ = ['execute', 'ExecutionResult', 'MiddlewareManager', 'middlewares']

graphql/execution/base.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 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.introspection import (SchemaMetaFieldDef, TypeMetaFieldDef,
@@ -18,9 +19,9 @@ class ExecutionContext(object):
     and the fragments defined in the query document"""
 
     __slots__ = 'schema', 'fragments', 'root_value', 'operation', 'variable_values', 'errors', 'context_value', \
-                'argument_values_cache', 'executor'
+                'argument_values_cache', 'executor', 'middleware_manager', '_subfields_cache'
 
-    def __init__(self, schema, document_ast, root_value, context_value, variable_values, operation_name, executor):
+    def __init__(self, schema, document_ast, root_value, context_value, variable_values, operation_name, executor, middleware_manager):
         """Constructs a ExecutionContext object from the arguments passed
         to execute, which we will pass throughout the other execution
         methods."""
@@ -63,6 +64,13 @@ def __init__(self, schema, document_ast, root_value, context_value, variable_val
         self.context_value = context_value
         self.argument_values_cache = {}
         self.executor = executor
+        self.middleware_manager = middleware_manager
+        self._subfields_cache = {}
+
+    def get_field_resolver(self, field_resolver):
+        if not self.middleware_manager:
+            return field_resolver
+        return self.middleware_manager.get_field_resolver(field_resolver)
 
     def get_argument_values(self, field_def, field_ast):
         k = field_def, field_ast
@@ -74,6 +82,21 @@ def get_argument_values(self, field_def, field_ast):
 
         return result
 
+    def get_sub_fields(self, return_type, field_asts):
+        k = return_type, tuple(field_asts)
+        if k not in self._subfields_cache:
+            subfield_asts = DefaultOrderedDict(list)
+            visited_fragment_names = set()
+            for field_ast in field_asts:
+                selection_set = field_ast.selection_set
+                if selection_set:
+                    subfield_asts = collect_fields(
+                        self, return_type, selection_set,
+                        subfield_asts, visited_fragment_names
+                    )
+            self._subfields_cache[k] = subfield_asts
+        return self._subfields_cache[k]
+
 
 class ExecutionResult(object):
     """The result of execution. `data` is the result of executing the
@@ -228,7 +251,7 @@ def does_fragment_condition_match(ctx, fragment, type_):
         return True
 
     conditional_type = type_from_ast(ctx.schema, type_condition_ast)
-    if conditional_type == type_:
+    if conditional_type.is_same_type(type_):
         return True
 
     if isinstance(conditional_type, (GraphQLInterfaceType, GraphQLUnionType)):
@@ -245,6 +268,8 @@ def get_field_entry_key(node):
 
 
 class ResolveInfo(object):
+    __slots__ = ('field_name', 'field_asts', 'return_type', 'parent_type',
+                 'schema', 'fragments', 'root_value', 'operation', 'variable_values')
 
     def __init__(self, field_name, field_asts, return_type, parent_type,
                  schema, fragments, root_value, operation, variable_values):
@@ -277,10 +302,10 @@ def get_field_def(schema, parent_type, field_name):
     are allowed, like on a Union. __schema could get automatically
     added to the query type, but that would require mutating type
     definitions, which would cause issues."""
-    if field_name == SchemaMetaFieldDef.name and schema.get_query_type() == parent_type:
+    if field_name == '__schema' and schema.get_query_type() == parent_type:
         return SchemaMetaFieldDef
-    elif field_name == TypeMetaFieldDef.name and schema.get_query_type() == parent_type:
+    elif field_name == '__type' and schema.get_query_type() == parent_type:
         return TypeMetaFieldDef
-    elif field_name == TypeNameMetaFieldDef.name:
+    elif field_name == '__typename':
         return TypeNameMetaFieldDef
-    return parent_type.get_fields().get(field_name)
+    return parent_type.fields.get(field_name)

graphql/execution/executor.py

@@ -3,29 +3,40 @@
 import logging
 import sys
 
-from promise import Promise, is_thenable, promise_for_dict, promisify
+from promise import Promise, promise_for_dict, promisify
 
 from ..error import GraphQLError, GraphQLLocatedError
 from ..pyutils.default_ordered_dict import DefaultOrderedDict
+from ..pyutils.ordereddict import OrderedDict
 from ..type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
                     GraphQLSchema, GraphQLUnionType)
 from .base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
                    collect_fields, default_resolve_fn, get_field_def,
                    get_operation_root_type)
 from .executors.sync import SyncExecutor
+from .middleware import MiddlewareManager
 
 logger = logging.getLogger(__name__)
 
 
+def is_promise(obj):
+    return type(obj) == Promise
+
+
 def execute(schema, document_ast, root_value=None, context_value=None,
             variable_values=None, operation_name=None, executor=None,
-            return_promise=False):
+            return_promise=False, middlewares=None):
     assert schema, 'Must provide schema'
     assert isinstance(schema, GraphQLSchema), (
         'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
         'not multiple versions of GraphQL installed in your node_modules directory.'
     )
+    if middlewares:
+        assert isinstance(middlewares, MiddlewareManager), (
+            'middlewares have to be an instance'
+            ' of MiddlewareManager. Received "{}".'.format(middlewares)
+        )
 
     if executor is None:
         executor = SyncExecutor()
@@ -37,7 +48,8 @@ def execute(schema, document_ast, root_value=None, context_value=None,
         context_value,
         variable_values,
         operation_name,
-        executor
+        executor,
+        middlewares
     )
 
     def executor(resolve, reject):
@@ -85,7 +97,7 @@ def execute_field_callback(results, response_name):
         if result is Undefined:
             return results
 
-        if is_thenable(result):
+        if is_promise(result):
             def collect_result(resolved_result):
                 results[response_name] = resolved_result
                 return results
@@ -104,15 +116,15 @@ def execute_field(prev_promise, response_name):
 def execute_fields(exe_context, parent_type, source_value, fields):
     contains_promise = False
 
-    final_results = collections.OrderedDict()
+    final_results = OrderedDict()
 
     for response_name, field_asts in fields.items():
         result = resolve_field(exe_context, parent_type, source_value, field_asts)
         if result is Undefined:
             continue
 
         final_results[response_name] = result
-        if is_thenable(result):
+        if is_promise(result):
             contains_promise = True
 
     if not contains_promise:
@@ -132,6 +144,9 @@ def resolve_field(exe_context, parent_type, source, field_asts):
     return_type = field_def.type
     resolve_fn = field_def.resolver or default_resolve_fn
 
+    # We wrap the resolve_fn from the middleware
+    resolve_fn_middleware = exe_context.get_field_resolver(resolve_fn)
+
     # Build a dict of arguments from the field.arguments AST, using the variables scope to
     # fulfill any variable references.
     args = exe_context.get_argument_values(field_def, field_ast)
@@ -156,7 +171,7 @@ def resolve_field(exe_context, parent_type, source, field_asts):
     )
 
     executor = exe_context.executor
-    result = resolve_or_error(resolve_fn, source, args, context, info, executor)
+    result = resolve_or_error(resolve_fn_middleware, source, args, context, info, executor)
 
     return complete_value_catching_error(
         exe_context,
@@ -188,7 +203,7 @@ def complete_value_catching_error(exe_context, return_type, field_asts, info, re
     # resolving a null value for this field if one is encountered.
     try:
         completed = complete_value(exe_context, return_type, field_asts, info, result)
-        if is_thenable(completed):
+        if is_promise(completed):
             def handle_error(error):
                 exe_context.errors.append(error)
                 return Promise.fulfilled(None)
@@ -222,7 +237,7 @@ def complete_value(exe_context, return_type, field_asts, info, result):
     """
     # If field type is NonNull, complete for inner type, and throw field error if result is null.
 
-    if is_thenable(result):
+    if is_promise(result):
         return promisify(result).then(
             lambda resolved: complete_value(
                 exe_context,
@@ -238,16 +253,7 @@ def complete_value(exe_context, return_type, field_asts, info, result):
         raise GraphQLLocatedError(field_asts, original_error=result)
 
     if isinstance(return_type, GraphQLNonNull):
-        completed = complete_value(
-            exe_context, return_type.of_type, field_asts, info, result
-        )
-        if completed is None:
-            raise GraphQLError(
-                'Cannot return null for non-nullable field {}.{}.'.format(info.parent_type, info.field_name),
-                field_asts
-            )
-
-        return completed
+        return complete_nonnull_value(exe_context, return_type, field_asts, info, result)
 
     # If result is null-like, return null.
     if result is None:
@@ -283,7 +289,7 @@ def complete_list_value(exe_context, return_type, field_asts, info, result):
     contains_promise = False
     for item in result:
         completed_item = complete_value_catching_error(exe_context, item_type, field_asts, info, item)
-        if not contains_promise and is_thenable(completed_item):
+        if not contains_promise and is_promise(completed_item):
             contains_promise = True
 
         completed_results.append(completed_item)
@@ -295,15 +301,10 @@ def complete_leaf_value(return_type, result):
     """
     Complete a Scalar or Enum by serializing to a valid value, returning null if serialization is not possible.
     """
-    serialize = getattr(return_type, 'serialize', None)
-    assert serialize, 'Missing serialize method on type'
-
-    serialized_result = serialize(result)
-
-    if serialized_result is None:
-        return None
+    # serialize = getattr(return_type, 'serialize', None)
+    # assert serialize, 'Missing serialize method on type'
 
-    return serialized_result
+    return return_type.serialize(result)
 
 
 def complete_abstract_value(exe_context, return_type, field_asts, info, result):
@@ -360,14 +361,21 @@ def complete_object_value(exe_context, return_type, field_asts, info, result):
         )
 
     # Collect sub-fields to execute to complete this value.
-    subfield_asts = DefaultOrderedDict(list)
-    visited_fragment_names = set()
-    for field_ast in field_asts:
-        selection_set = field_ast.selection_set
-        if selection_set:
-            subfield_asts = collect_fields(
-                exe_context, return_type, selection_set,
-                subfield_asts, visited_fragment_names
-            )
-
+    subfield_asts = exe_context.get_sub_fields(return_type, field_asts)
     return execute_fields(exe_context, return_type, result, subfield_asts)
+
+
+def complete_nonnull_value(exe_context, return_type, field_asts, info, result):
+    """
+    Complete a NonNull value by completing the inner type
+    """
+    completed = complete_value(
+        exe_context, return_type.of_type, field_asts, info, result
+    )
+    if completed is None:
+        raise GraphQLError(
+            'Cannot return null for non-nullable field {}.{}.'.format(info.parent_type, info.field_name),
+            field_asts
+        )
+
+    return completed

graphql/execution/executors/asyncio.py

@@ -2,6 +2,8 @@
 
 from asyncio import Future, get_event_loop, iscoroutine, wait
 
+from promise import promisify
+
 try:
     from asyncio import ensure_future
 except ImportError:
@@ -45,5 +47,5 @@ def execute(self, fn, *args, **kwargs):
         if isinstance(result, Future) or iscoroutine(result):
             future = ensure_future(result, loop=self.loop)
             self.futures.append(future)
-            return future
+            return promisify(future)
         return result