Fixed order of middlewares.

Author: sergey-komissarov

README.md

@@ -503,8 +503,17 @@ processing. For that define `middleware` setting of your
 `GraphqlWsConsumer` subclass, like this:
 
 ```python
-async def threadpool_for_synch_resolvers(next_middleware, root, info, *args, **kwds):
-    """Offload synchronous resolvers to the threadpool."""
+async def threadpool_for_sync_resolvers(next_middleware, root, info, *args, **kwds):
+    """Offload synchronous resolvers to the threadpool.
+    
+    This middleware should always be the last in the middlewares calls
+    stack and the closest to the real resolver. If this middleware is
+    not the last it will check the next middleware to call instead of
+    real resolver.
+
+    The first middleware in the middlewares list will be the closest to
+    the resolver.
+    """
     # Invoke next middleware.
     if asyncio.iscoroutinefunction(next_middleware):
         result = await next_middleware(root, info, *args, **kwds)
@@ -514,7 +523,7 @@ async def threadpool_for_synch_resolvers(next_middleware, root, info, *args, **k
 
 class MyGraphqlWsConsumer(channels_graphql_ws.GraphqlWsConsumer):
     ...
-    middleware = [threadpool_for_synch_resolvers]
+    middleware = [threadpool_for_sync_resolvers]
 ```
 
 It is recommended to write asynchronous middlewares. But synchronous

channels_graphql_ws/graphql_ws_consumer.py

@@ -138,6 +138,8 @@ class GraphqlWsConsumer(ch_websocket.AsyncJsonWebsocketConsumer):
     #        result = await result
     #     return result
     # ```
+    # The first middleware in the middlewares list will be the closest
+    # to the resolver in the middlewares call stack.
     # For more information read docs:
     # - https://docs.graphene-python.org/en/latest/execution/middleware/#middleware
     # - https://graphql-core-3.readthedocs.io/en/latest/diffs.html#custom-middleware
@@ -604,12 +606,12 @@ async def unbound_root_middleware(*args, **kwds):
                 )
 
             # NOTE: Middlewares order is important, root middleware
-            # should always be the closest to the real resolver (first
-            # in the middleware list).
-            middlewares = []
+            # should always be the farest from the real resolver (last
+            # in the middleware list). Because we want to calculate
+            # resolver execution time with middlewares included.
+            middlewares = list(self.middleware)
             if self.warn_resolver_timeout is not None:
                 middlewares.append(unbound_root_middleware)
-            middlewares.extend(self.middleware)
             middleware_manager: Optional[graphql.MiddlewareManager] = None
             if middlewares:
                 middleware_manager = graphql.MiddlewareManager(*middlewares)