Merge branch 'features/middleware' into features/next

Author: syrusakbary

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

@@ -18,9 +18,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'
 
-    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 +63,12 @@ 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
+
+    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

graphql/execution/executor.py

@@ -14,18 +14,24 @@
                    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 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 +43,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):
@@ -132,6 +139,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 +166,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,

graphql/execution/middleware.py

@@ -0,0 +1,49 @@
+import inspect
+from functools import partial
+from itertools import chain
+
+from promise import Promise
+
+MIDDLEWARE_RESOLVER_FUNCTION = 'resolve'
+
+
+class MiddlewareManager(object):
+
+    def __init__(self, *middlewares):
+        self.middlewares = middlewares
+        self._middleware_resolvers = get_middleware_resolvers(middlewares)
+        self._cached_resolvers = {}
+
+    def get_field_resolver(self, field_resolver):
+        if field_resolver not in self._cached_resolvers:
+            self._cached_resolvers[field_resolver] = middleware_chain(field_resolver, self._middleware_resolvers)
+
+        return self._cached_resolvers[field_resolver]
+
+
+middlewares = MiddlewareManager
+
+
+def get_middleware_resolvers(middlewares):
+    for middleware in middlewares:
+        # If the middleware is a function instead of a class
+        if inspect.isfunction(middleware):
+            yield middleware
+        if not hasattr(middleware, MIDDLEWARE_RESOLVER_FUNCTION):
+            continue
+        yield getattr(middleware, MIDDLEWARE_RESOLVER_FUNCTION)
+
+
+def middleware_chain(func, middlewares):
+    if not middlewares:
+        return func
+    middlewares = chain((func, make_it_promise), middlewares)
+    last_func = None
+    for middleware in middlewares:
+        last_func = partial(middleware, last_func) if last_func else middleware
+
+    return last_func
+
+
+def make_it_promise(next, *a, **b):
+    return Promise.resolve(next(*a, **b))

graphql/execution/tests/test_executor.py

@@ -3,7 +3,7 @@
 from pytest import raises
 
 from graphql.error import GraphQLError
-from graphql.execution import execute
+from graphql.execution import execute, MiddlewareManager
 from graphql.language.parser import parse
 from graphql.type import (GraphQLArgument, GraphQLBoolean, GraphQLField,
                           GraphQLInt, GraphQLList, GraphQLObjectType,
@@ -561,3 +561,45 @@ def resolver(*_):
 
     execute(schema, query)
     logger.exception.assert_called_with("An error occurred while resolving field Query.foo")
+
+
+def test_middleware():
+    doc = '''{
+        ok
+    }'''
+
+    class Data(object):
+
+        def ok(self):
+            return 'ok'
+
+    doc_ast = parse(doc)
+
+    Type = GraphQLObjectType('Type', {
+        'ok': GraphQLField(GraphQLString),
+    })
+    middlewares = MiddlewareManager(lambda *_: None)
+    result = execute(GraphQLSchema(Type), doc_ast, Data(), middlewares=middlewares)
+    assert result.data == {'ok': None}
+
+
+def test_middleware_wrong():
+    doc = '''{
+        ok
+    }'''
+
+    class Data(object):
+
+        def ok(self):
+            return 'ok'
+
+    doc_ast = parse(doc)
+
+    Type = GraphQLObjectType('Type', {
+        'ok': GraphQLField(GraphQLString),
+    })
+    middlewares = [None]
+    with raises(AssertionError) as excinfo:
+        execute(GraphQLSchema(Type), doc_ast, Data(), middlewares=middlewares)
+
+    assert 'middlewares have to be an instance of MiddlewareManager. Received "[None]".' == str(excinfo.value)