Removed plugins. Added middlewares

Author: syrusakbary

graphene/contrib/django/debug/tests/test_query.py

@@ -8,6 +8,7 @@
 from ..middleware import DjangoDebugMiddleware
 from ..types import DjangoDebug
 
+
 class context(object):
     pass
 
@@ -56,7 +57,7 @@ def resolve_reporter(self, *args, **kwargs):
             }]
         }
     }
-    schema = graphene.Schema(query=Query, plugins=[DjangoDebugMiddleware()])
+    schema = graphene.Schema(query=Query, middlewares=[DjangoDebugMiddleware()])
     result = schema.execute(query, context_value=context())
     assert not result.errors
     assert result.data == expected
@@ -104,7 +105,7 @@ def resolve_all_reporters(self, *args, **kwargs):
             }]
         }
     }
-    schema = graphene.Schema(query=Query, plugins=[DjangoDebugMiddleware()])
+    schema = graphene.Schema(query=Query, middlewares=[DjangoDebugMiddleware()])
     result = schema.execute(query, context_value=context())
     assert not result.errors
     assert result.data == expected
@@ -153,7 +154,7 @@ def resolve_all_reporters(self, *args, **kwargs):
             }]
         },
     }
-    schema = graphene.Schema(query=Query, plugins=[DjangoDebugMiddleware()])
+    schema = graphene.Schema(query=Query, middlewares=[DjangoDebugMiddleware()])
     result = schema.execute(query, context_value=context())
     assert not result.errors
     assert result.data['allReporters'] == expected['allReporters']
@@ -209,7 +210,7 @@ def resolve_all_reporters(self, *args, **kwargs):
             }]
         },
     }
-    schema = graphene.Schema(query=Query, plugins=[DjangoDebugMiddleware()])
+    schema = graphene.Schema(query=Query, middlewares=[DjangoDebugMiddleware()])
     result = schema.execute(query, context_value=context())
     assert not result.errors
     assert result.data['allReporters'] == expected['allReporters']

graphene/core/schema.py

@@ -7,8 +7,7 @@
 
 from graphene import signals
 
-from ..plugins import CamelCase, PluginManager
-from ..utils import promise_middleware
+from ..middlewares import MiddlewareManager, CamelCaseArgsMiddleware
 from .classtypes.base import ClassType
 from .types.base import InstanceType
 
@@ -24,19 +23,21 @@ class Schema(object):
     _executor = None
 
     def __init__(self, query=None, mutation=None, subscription=None,
-                 name='Schema', executor=None, plugins=None, auto_camelcase=True, **options):
+                 name='Schema', executor=None, middlewares=None, auto_camelcase=True, **options):
         self._types_names = {}
         self._types = {}
         self.mutation = mutation
         self.query = query
         self.subscription = subscription
         self.name = name
         self.executor = executor
-        plugins = plugins or []
+        if 'plugins' in options:
+            raise Exception('Plugins are deprecated, please use middlewares.')
+        middlewares = middlewares or []
         if auto_camelcase:
-            plugins.append(CamelCase())
+            middlewares.append(CamelCaseArgsMiddleware())
         self.auto_camelcase = auto_camelcase
-        self.plugins = PluginManager(self, plugins)
+        self.middleware_manager = MiddlewareManager(self, middlewares)
         self.options = options
         signals.init_schema.send(self)
 
@@ -109,8 +110,7 @@ def get_type(self, type_name):
         return self._types_names[type_name]
 
     def resolver_with_middleware(self, resolver):
-        plugins_resolve = self.plugins.get_plugin_functions('resolve')
-        return promise_middleware(resolver, plugins_resolve)
+        return self.middleware_manager.wrap(resolver)
 
     @property
     def types(self):

graphene/core/tests/test_schema.py

@@ -154,6 +154,12 @@ class MyType(ObjectType):
     assert schema.T(t) == schema.T(MyType)
 
 
+def test_deprecated_plugins_throws_exception():
+    with raises(Exception) as excinfo:
+        Schema(plugins=[])
+    assert 'Plugins are deprecated, please use middlewares' in str(excinfo.value)
+
+
 def test_schema_str():
     expected = """
 schema {

graphene/middlewares/__init__.py

@@ -0,0 +1,6 @@
+from .base import MiddlewareManager
+from .camel_case import CamelCaseArgsMiddleware
+
+__all__ = [
+    'MiddlewareManager', 'CamelCaseArgsMiddleware'
+]

graphene/middlewares/base.py

@@ -0,0 +1,23 @@
+from ..utils import promise_middleware
+
+MIDDLEWARE_RESOLVER_FUNCTION = 'resolve'
+
+
+class MiddlewareManager(object):
+
+    def __init__(self, schema, middlewares=None):
+        self.schema = schema
+        self.middlewares = middlewares or []
+
+    def add_middleware(self, middleware):
+        self.middlewares.append(middleware)
+
+    def get_middleware_resolvers(self):
+        for middleware in self.middlewares:
+            if not hasattr(middleware, MIDDLEWARE_RESOLVER_FUNCTION):
+                continue
+            yield getattr(middleware, MIDDLEWARE_RESOLVER_FUNCTION)
+
+    def wrap(self, resolver):
+        middleware_resolvers = self.get_middleware_resolvers()
+        return promise_middleware(resolver, middleware_resolvers)

graphene/middlewares/camel_case.py

@@ -0,0 +1,8 @@
+from ..utils import ProxySnakeDict
+
+
+class CamelCaseArgsMiddleware(object):
+
+    def resolve(self, next, root, args, context, info):
+        args = ProxySnakeDict(args)
+        return next(root, args, context, info)