Implemented async queries support

Author: grazor

README.md

@@ -26,7 +26,7 @@ This will add `/graphql` endpoint to your app.
 
 ### Sharing eventloop with Sanic
 
-In order to pass Sanic’s eventloop to GraphQL’s `AsyncioExecutor`, use `before_start` event:
+In order to pass Sanic’s eventloop to GraphQL’s `AsyncioExecutor`, use `before_start` listener:
 
 ```python
 def before_start(app, loop):
@@ -41,7 +41,7 @@ app.run(before_start=before_start)
 -   `context`: A value to pass as the `context` to the `graphql()` function.
 -   `root_value`: The `root_value` you want to provide to `executor.execute`.
 -   `pretty`: Whether or not you want the response to be pretty printed JSON.
--   `executor`: The `Executor` that you want to use to execute queries.
+-   `executor`: The `Executor` that you want to use to execute queries. If an `AsyncExecutor` instance is provided, performs queries asynchronously within executor’s loop.
 -   `graphiql`: If `True`, may present [GraphiQL] when loaded directly from a browser (a useful tool for debugging and exploration).
 -   `graphiql_template`: Inject a Jinja template string to customize GraphiQL.
 -   `jinja_env`: Sets jinja environment to be used to process GraphiQL template. If Jinja’s async mode is enabled (by `enable_async=True`), uses 

README.rst

@@ -24,9 +24,9 @@ Just use the ``GraphQLView`` view from ``sanic_graphql``
 This will add ``/graphql`` endpoint to your app.
 
 Sharing eventloop with Sanic
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-In order to pass Sanic's eventloop to GraphQL's ``AsyncioExecutor``, use ``before_start`` event:
+In order to pass Sanic's eventloop to GraphQL's ``AsyncioExecutor``, use ``before_start`` listener:
 
 .. code:: python
 
@@ -47,16 +47,16 @@ Supported options
    ``executor.execute``.
 -  ``pretty``: Whether or not you want the response to be pretty printed
    JSON.
--  ``executor``: The ``Executor`` that you want to use to execute
-   queries.
+-  ``executor``: The ``Executor`` that you want to use to execute queries. If an ``AsyncExecutor`` instance is provided,
+   performs queries asynchronously within executor's loop.
 -  ``graphiql``: If ``True``, may present
    `GraphiQL <https://github.com/graphql/graphiql>`__ when loaded
    directly from a browser (a useful tool for debugging and
    exploration).
 -  ``graphiql_template``: Inject a Jinja template string to customize
    GraphiQL.
--  ``jinja_env``: Sets jinja environment to be used to process GraphiQL template. If Jinja's async mode is enabled (by ``enable_async=True``), uses 
-``Template.render_async`` instead of ``Template.render``. If environment is not set, fallbacks to simple regex-based renderer.
+-  ``jinja_env``: Sets jinja environment to be used to process GraphiQL template. If Jinja's async mode is enabled (by ``enable_async=True``), uses
+   ``Template.render_async`` instead of ``Template.render``. If environment is not set, fallbacks to simple regex-based renderer.
 -  ``batch``: Set the GraphQL view as batch (for using in
    `Apollo-Client <http://dev.apollodata.com/core/network.html#query-batching>`__
    or

sanic_graphql/graphqlview.py

@@ -6,12 +6,14 @@
 from sanic.views import HTTPMethodView
 from sanic.exceptions import SanicException
 
+from promise import Promise
 from graphql import Source, execute, parse, validate
 from graphql.error import format_error as format_graphql_error
 from graphql.error import GraphQLError
 from graphql.execution import ExecutionResult
 from graphql.type.schema import GraphQLSchema
 from graphql.utils.get_operation_ast import get_operation_ast
+from graphql.execution.executors.asyncio import AsyncioExecutor
 
 from .render_graphiql import render_graphiql
 
@@ -36,14 +38,19 @@ class GraphQLView(HTTPMethodView):
     batch = False
     jinja_env = None
 
+    _enable_async = True
+
     methods = ['GET', 'POST', 'PUT', 'DELETE']
 
     def __init__(self, **kwargs):
         super(GraphQLView, self).__init__()
+
         for key, value in kwargs.items():
             if hasattr(self, key):
                 setattr(self, key, value)
 
+        self._enable_async = self._enable_async and isinstance(kwargs.get('executor'), AsyncioExecutor)
+
         assert not all((self.graphiql, self.batch)), 'Use either graphiql or batch processing'
         assert isinstance(self.schema, GraphQLSchema), 'A Schema is required to be provided to GraphQLView.'
 
@@ -71,11 +78,14 @@ async def dispatch_request(self, request, *args, **kwargs):
             show_graphiql = self.graphiql and self.can_display_graphiql(request, data)
 
             if self.batch:
-                responses = [self.get_response(request, entry) for entry in data]
+                responses = []
+                for entry in data:
+                    responses.append(await self.get_response(request, entry))
+
                 result = '[{}]'.format(','.join([response[0] for response in responses]))
                 status_code = max(responses, key=lambda response: response[1])[1]
             else:
-                result, status_code = self.get_response(request, data, show_graphiql)
+                result, status_code = await self.get_response(request, data, show_graphiql)
 
             if show_graphiql:
                 query, variables, operation_name, id = self.get_graphql_params(request, data)
@@ -105,10 +115,10 @@ async def dispatch_request(self, request, *args, **kwargs):
                 content_type='application/json'
             )
 
-    def get_response(self, request, data, show_graphiql=False):
+    async def get_response(self, request, data, show_graphiql=False):
         query, variables, operation_name, id = self.get_graphql_params(request, data)
 
-        execution_result = self.execute_graphql_request(
+        execution_result = await self.execute_graphql_request(
             request,
             data,
             query,
@@ -175,10 +185,14 @@ def parse_body(self, request):
 
         return {}
 
-    def execute(self, *args, **kwargs):
-        return execute(self.schema, *args, **kwargs)
+    async def execute(self, *args, **kwargs):
+        result = execute(self.schema, return_promise=self._enable_async, *args, **kwargs)
+        if isinstance(result, Promise):
+            return await result
+        else:
+            return result
 
-    def execute_graphql_request(self, request, data, query, variables, operation_name, show_graphiql=False):
+    async def execute_graphql_request(self, request, data, query, variables, operation_name, show_graphiql=False):
         if not query:
             if show_graphiql:
                 return None
@@ -207,7 +221,7 @@ def execute_graphql_request(self, request, data, query, variables, operation_nam
                 ))
 
         try:
-            return self.execute(
+            return await self.execute(
                 ast,
                 root_value=self.get_root_value(request),
                 variable_values=variables or {},

sanic_graphql/render_graphiql.py

@@ -152,7 +152,7 @@ def simple_renderer(template, **values):
     return template
 
 
-async def render_graphiql(*, graphiql_version=None, graphiql_template=None, jinja_env=None, **kwargs):
+async def render_graphiql(*, jinja_env=None, graphiql_version=None, graphiql_template=None, **kwargs):
     graphiql_version = graphiql_version or GRAPHIQL_VERSION
     template = graphiql_template or TEMPLATE
     kwargs['graphiql_version'] = graphiql_version

tests/app.py

@@ -15,12 +15,20 @@ def create_app(path='/graphql', **kwargs):
     async_executor = kwargs.pop('async_executor', False)
 
     if async_executor:
-        @app.listener('before_start')
         def init_async_executor(app, loop):
             executor = AsyncioExecutor(loop)
-            app.add_route(GraphQLView.as_view(schema=schema, **kwargs), path)
+            app.add_route(GraphQLView.as_view(schema=schema, executor=executor, **kwargs), path)
+
+        def remove_graphql_endpoint(app, loop):
+            app.remove_route(path)
+
+        app.server_kwargs = dict(
+            before_start=init_async_executor,
+            after_stop=remove_graphql_endpoint
+        )
     else:
         app.add_route(GraphQLView.as_view(schema=schema, **kwargs), path)
+        app.server_kwargs = dict()
 
     return app
 

tests/schema.py

@@ -1,3 +1,5 @@
+import asyncio
+
 from graphql.type.definition import GraphQLArgument, GraphQLField, GraphQLNonNull, GraphQLObjectType
 from graphql.type.scalars import GraphQLString
 from graphql.type.schema import GraphQLSchema
@@ -7,6 +9,7 @@ def resolve_raises(*_):
     raise Exception("Throws!")
 
 
+# Sync schema
 QueryRootType = GraphQLObjectType(
     name='QueryRoot',
     fields={
@@ -36,3 +39,24 @@ def resolve_raises(*_):
 )
 
 Schema = GraphQLSchema(QueryRootType, MutationRootType)
+
+
+# Schema with async methods
+async def resolver(context, *_):
+    await asyncio.sleep(0.001)
+    return 'hey'
+
+async def resolver_2(context, *_):
+    await asyncio.sleep(0.003)
+    return 'hey2'
+
+def resolver_3(context, *_):
+    return 'hey3'
+
+AsyncQueryType = GraphQLObjectType('AsyncQueryType', {
+    'a': GraphQLField(GraphQLString, resolver=resolver),
+    'b': GraphQLField(GraphQLString, resolver=resolver_2),
+    'c': GraphQLField(GraphQLString, resolver=resolver_3)
+})
+
+AsyncSchema = GraphQLSchema(AsyncQueryType)

tests/test_graphiqlview.py

@@ -2,61 +2,64 @@
 
 from jinja2 import Environment
 
-from .util import app, client, url_string, create_app
+from .app import create_app
+from .util import app, client, url_string
 
 
-@pytest.mark.parametrize('app', [create_app(graphiql=True)])
-def test_graphiql_is_enabled(app, client):
-    response = client.get(app,  uri=url_string(), headers={'Accept': 'text/html'})
-    assert response.status == 200
-
-
-@pytest.mark.parametrize('app', [create_app(graphiql=True)])
-def test_graphiql_simple_renderer(app, client):
-    response = client.get(app, uri=url_string(query='{test}'), headers={'Accept': 'text/html'})
-    assert response.status == 200
-    pretty_response = (
+@pytest.fixture
+def pretty_response():
+    return (
         '{\n'
         '  "data": {\n'
         '    "test": "Hello World"\n'
         '  }\n'
         '}'
     ).replace('\"','\\\"').replace('\n', '\\n')
 
-    assert pretty_response in response.body.decode('utf-8')
+
+@pytest.mark.parametrize('app', [
+    (create_app(async_executor=False, graphiql=True)),
+    (create_app(async_executor=True, graphiql=True)),
+])
+def test_graphiql_is_enabled(app, client):
+    response = client.get(app,  uri=url_string(), headers={'Accept': 'text/html'})
+    assert response.status == 200
 
 
-@pytest.mark.parametrize('app', [create_app(graphiql=True, jinja_env=Environment())])
-def test_graphiql_jinja_renderer(app, client):
+@pytest.mark.parametrize('app', [
+    (create_app(async_executor=False, graphiql=True)),
+    (create_app(async_executor=True, graphiql=True)),
+])
+def test_graphiql_simple_renderer(app, client, pretty_response):
     response = client.get(app, uri=url_string(query='{test}'), headers={'Accept': 'text/html'})
     assert response.status == 200
-    pretty_response = (
-        '{\n'
-        '  "data": {\n'
-        '    "test": "Hello World"\n'
-        '  }\n'
-        '}'
-    ).replace('\"','\\\"').replace('\n', '\\n')
-
     assert pretty_response in response.body.decode('utf-8')
 
 
-@pytest.mark.parametrize('app', [create_app(graphiql=True, jinja_env=Environment(enable_async=True))])
-def test_graphiql_jinja_async_renderer(app, client):
+@pytest.mark.parametrize('app', [
+    (create_app(async_executor=False, graphiql=True, jinja_env=Environment())),
+    (create_app(async_executor=True, graphiql=True, jinja_env=Environment())),
+])
+def test_graphiql_jinja_renderer(app, client, pretty_response):
     response = client.get(app, uri=url_string(query='{test}'), headers={'Accept': 'text/html'})
     assert response.status == 200
-    pretty_response = (
-        '{\n'
-        '  "data": {\n'
-        '    "test": "Hello World"\n'
-        '  }\n'
-        '}'
-    ).replace('\"','\\\"').replace('\n', '\\n')
+    assert pretty_response in response.body.decode('utf-8')
 
+
+@pytest.mark.parametrize('app', [
+    (create_app(async_executor=False, graphiql=True, jinja_env=Environment(enable_async=True))),
+    (create_app(async_executor=True, graphiql=True, jinja_env=Environment(enable_async=True))),
+])
+def test_graphiql_jinja_async_renderer(app, client, pretty_response):
+    response = client.get(app, uri=url_string(query='{test}'), headers={'Accept': 'text/html'})
+    assert response.status == 200
     assert pretty_response in response.body.decode('utf-8')
 
 
-@pytest.mark.parametrize('app', [create_app(graphiql=True)])
+@pytest.mark.parametrize('app', [
+    (create_app(async_executor=False, graphiql=True, jinja_env=Environment())),
+    (create_app(async_executor=True, graphiql=True, jinja_env=Environment())),
+])
 def test_graphiql_html_is_not_accepted(app, client):
     response = client.get(app, uri=url_string(), headers={'Accept': 'application/json'})
     assert response.status == 400