Support for Async Django

examples/cookbook/cookbook/recipes/schema.py

@@ -1,17 +1,41 @@
-from graphene import Node
+import asyncio
+
+from asgiref.sync import sync_to_async
+
+from graphene import Field, Node, String
 from graphene_django.filter import DjangoFilterConnectionField
 from graphene_django.types import DjangoObjectType
 
 from cookbook.recipes.models import Recipe, RecipeIngredient
 
 
 class RecipeNode(DjangoObjectType):
+    async_field = String()
+
     class Meta:
         model = Recipe
         interfaces = (Node,)
         fields = "__all__"
         filter_fields = ["title", "amounts"]
 
+    async def resolve_async_field(self, info):
+        await asyncio.sleep(2)
+        return "success"
+
+
+class RecipeType(DjangoObjectType):
+    async_field = String()
+
+    class Meta:
+        model = Recipe
+        fields = "__all__"
+        filter_fields = ["title", "amounts"]
+        skip_registry = True
+
+    async def resolve_async_field(self, info):
+        await asyncio.sleep(2)
+        return "success"
+
 
 class RecipeIngredientNode(DjangoObjectType):
     class Meta:
@@ -28,7 +52,13 @@ class Meta:
 
 class Query:
     recipe = Node.Field(RecipeNode)
+    raw_recipe = Field(RecipeType)
     all_recipes = DjangoFilterConnectionField(RecipeNode)
 
     recipeingredient = Node.Field(RecipeIngredientNode)
     all_recipeingredients = DjangoFilterConnectionField(RecipeIngredientNode)
+
+    @staticmethod
+    @sync_to_async
+    def resolve_raw_recipe(self, info):
+        return Recipe.objects.first()

examples/cookbook/cookbook/urls.py

@@ -1,9 +1,10 @@
-from django.conf.urls import url
 from django.contrib import admin
+from django.urls import re_path
+from django.views.decorators.csrf import csrf_exempt
 
-from graphene_django.views import GraphQLView
+from graphene_django.views import AsyncGraphQLView
 
 urlpatterns = [
-    url(r"^admin/", admin.site.urls),
-    url(r"^graphql$", GraphQLView.as_view(graphiql=True)),
+    re_path(r"^admin/", admin.site.urls),
+    re_path(r"^graphql$", csrf_exempt(AsyncGraphQLView.as_view(graphiql=True))),
 ]

graphene_django/debug/middleware.py

@@ -1,5 +1,8 @@
+from asgiref.sync import sync_to_async
 from django.db import connections
+from graphql.type.definition import GraphQLNonNull
 
+from ..utils import is_running_async, is_sync_function
 from .exception.formating import wrap_exception
 from .sql.tracking import unwrap_cursor, wrap_cursor
 from .types import DjangoDebug
@@ -67,3 +70,28 @@ def resolve(self, next, root, info, **args):
             return context.django_debug.on_resolve_error(e)
         context.django_debug.add_result(result)
         return result
+
+
+class DjangoSyncRequiredMiddleware:
+    def resolve(self, next, root, info, **args):
+        parent_type = info.parent_type
+        return_type = info.return_type
+
+        if isinstance(parent_type, GraphQLNonNull):
+            parent_type = parent_type.of_type
+        if isinstance(return_type, GraphQLNonNull):
+            return_type = return_type.of_type
+
+        if any(
+            [
+                hasattr(parent_type, "graphene_type")
+                and hasattr(parent_type.graphene_type._meta, "model"),
+                hasattr(return_type, "graphene_type")
+                and hasattr(return_type.graphene_type._meta, "model"),
+                info.parent_type.name == "Mutation",
+            ]
+        ):
+            if is_sync_function(next) and is_running_async():
+                return sync_to_async(next)(root, info, **args)
+
+        return next(root, info, **args)

graphene_django/fields.py

@@ -1,21 +1,21 @@
 from functools import partial
 
+from asgiref.sync import sync_to_async
 from django.db.models.query import QuerySet
 from graphql_relay import (
     connection_from_array_slice,
     cursor_to_offset,
     get_offset_with_default,
     offset_to_cursor,
 )
-from promise import Promise
 
 from graphene import Int, NonNull
 from graphene.relay import ConnectionField
 from graphene.relay.connection import connection_adapter, page_info_adapter
 from graphene.types import Field, List
 
 from .settings import graphene_settings
-from .utils import maybe_queryset
+from .utils import is_running_async, is_sync_function, maybe_queryset
 
 
 class DjangoListField(Field):
@@ -49,19 +49,44 @@ def model(self):
     def get_manager(self):
         return self.model._default_manager
 
-    @staticmethod
+    @classmethod
     def list_resolver(
-        django_object_type, resolver, default_manager, root, info, **args
+        cls, django_object_type, resolver, default_manager, root, info, **args
     ):
-        queryset = maybe_queryset(resolver(root, info, **args))
+        if is_running_async():
+            if is_sync_function(resolver):
+                resolver = sync_to_async(resolver)
+
+        iterable = resolver(root, info, **args)
+
+        if info.is_awaitable(iterable):
+
+            async def resolve_list_async(iterable):
+                queryset = maybe_queryset(await iterable)
+                if queryset is None:
+                    queryset = maybe_queryset(default_manager)
+
+                if isinstance(queryset, QuerySet):
+                    # Pass queryset to the DjangoObjectType get_queryset method
+                    queryset = maybe_queryset(
+                        await sync_to_async(django_object_type.get_queryset)(
+                            queryset, info
+                        )
+                    )
+
+                return await sync_to_async(list)(queryset)
+
+            return resolve_list_async(iterable)
+
+        queryset = maybe_queryset(iterable)
         if queryset is None:
             queryset = maybe_queryset(default_manager)
 
         if isinstance(queryset, QuerySet):
             # Pass queryset to the DjangoObjectType get_queryset method
             queryset = maybe_queryset(django_object_type.get_queryset(queryset, info))
 
-        return queryset
+        return list(queryset)
 
     def wrap_resolve(self, parent_resolver):
         resolver = super().wrap_resolve(parent_resolver)
@@ -235,20 +260,36 @@ def connection_resolver(
 
         # eventually leads to DjangoObjectType's get_queryset (accepts queryset)
         # or a resolve_foo (does not accept queryset)
+
+        if is_running_async():
+            if is_sync_function(resolver):
+                resolver = sync_to_async(resolver)
+
         iterable = resolver(root, info, **args)
+
+        if info.is_awaitable(iterable):
+
+            async def resolve_connection_async(iterable):
+                iterable = await iterable
+                if iterable is None:
+                    iterable = default_manager
+
+                iterable = await sync_to_async(queryset_resolver)(
+                    connection, iterable, info, args
+                )
+
+                return await sync_to_async(cls.resolve_connection)(
+                    connection, args, iterable, max_limit=max_limit
+                )
+
+            return resolve_connection_async(iterable)
+
         if iterable is None:
             iterable = default_manager
         # thus the iterable gets refiltered by resolve_queryset
         # but iterable might be promise
         iterable = queryset_resolver(connection, iterable, info, args)
-        on_resolve = partial(
-            cls.resolve_connection, connection, args, max_limit=max_limit
-        )
-
-        if Promise.is_thenable(iterable):
-            return Promise.resolve(iterable).then(on_resolve)
-
-        return on_resolve(iterable)
+        return cls.resolve_connection(connection, args, iterable, max_limit=max_limit)
 
     def wrap_resolve(self, parent_resolver):
         return partial(

graphene_django/filter/fields.py

@@ -1,6 +1,7 @@
 from collections import OrderedDict
 from functools import partial
 
+from asgiref.sync import sync_to_async
 from django.core.exceptions import ValidationError
 
 from graphene.types.argument import to_arguments
@@ -92,6 +93,18 @@ def filter_kwargs():
 
         qs = super().resolve_queryset(connection, iterable, info, args)
 
+        if info.is_awaitable(qs):
+
+            async def filter_async(qs):
+                filterset = filterset_class(
+                    data=filter_kwargs(), queryset=await qs, request=info.context
+                )
+                if await sync_to_async(filterset.is_valid)():
+                    return filterset.qs
+                raise ValidationError(filterset.form.errors.as_json())
+
+            return filter_async(qs)
+
         filterset = filterset_class(
             data=filter_kwargs(), queryset=qs, request=info.context
         )

graphene_django/rest_framework/mutation.py

@@ -1,6 +1,7 @@
 from collections import OrderedDict
 from enum import Enum
 
+from asgiref.sync import sync_to_async
 from django.shortcuts import get_object_or_404
 from rest_framework import serializers
 
@@ -11,6 +12,7 @@
 from graphene.types.objecttype import yank_fields_from_attrs
 
 from ..types import ErrorType
+from ..utils import is_running_async
 from .serializer_converter import convert_serializer_field
 
 
@@ -166,6 +168,17 @@ def mutate_and_get_payload(cls, root, info, **input):
         kwargs = cls.get_serializer_kwargs(root, info, **input)
         serializer = cls._meta.serializer_class(**kwargs)
 
+        if is_running_async():
+
+            async def perform_mutate_async():
+                if await sync_to_async(serializer.is_valid)():
+                    return await sync_to_async(cls.perform_mutate)(serializer, info)
+                else:
+                    errors = ErrorType.from_errors(serializer.errors)
+                    return cls(errors=errors)
+
+            return perform_mutate_async()
+
         if serializer.is_valid():
             return cls.perform_mutate(serializer, info)
         else:

graphene_django/tests/async_test_helper.py

@@ -0,0 +1,6 @@
+from asgiref.sync import async_to_sync
+
+
+def assert_async_result_equal(schema, query, result, **kwargs):
+    async_result = async_to_sync(schema.execute_async)(query, **kwargs)
+    assert async_result == result