Docs improvement Subscriptions

docs/faq.md

@@ -11,11 +11,13 @@ def resolver(root, info: Info):
 
 ## How to access the current user object in resolvers?
 
-The current user object is accessible via the `info.context.request.user` object.
+The current user object is accessible via the `get_current_user` method.
 
 ```python
+from strawberry_django.auth.queries import get_current_user
+
 def resolver(root, info: Info):
-    current_user = info.context.request.user
+    current_user = get_current_user(info)
 ```
 
 ## Autocompletion with editors

docs/guide/subscriptions.md

@@ -1,6 +1,139 @@
-### Subscriptions
+# Subscriptions
 
 Subscriptions are supported using the
 [Strawberry Django Channels](https://strawberry.rocks/docs/integrations/channels) integration.
 
-Check its docs to know how to use it.
+This guide will give you a minimal working example to get you going.
+There are 3 parts to this guide:
+
+1. Making Django compatible
+2. Setup local testing
+3. Creating your first subscription
+
+## Making Django compatible
+
+It's important to realise that Django doesn't support websockets out of the box.
+To resolve this, we can help the platform along a little.
+
+This implementation is based on Django Channels - this means that should you wish - there is a lot more websockets fun to be had. If you're interested, head over to [Django Channels](https://channels.readthedocs.io).
+
+To add the base compatibility, go to your `MyProject.asgi.py` file and replace it with the following content.
+Ensure that you replace the relevant code with your setup.
+
+```python
+# MyProject.asgi.py
+import os
+
+from django.core.asgi import get_asgi_application
+from strawberry_django.routers import AuthGraphQLProtocolTypeRouter
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "MyProject.settings")  # CHANGE the project name
+django_asgi_app = get_asgi_application()
+
+# Import your Strawberry schema after creating the django ASGI application
+# This ensures django.setup() has been called before any ORM models are imported
+# for the schema.
+
+from .schema import schema  # CHANGE path to where you housed your schema file.
+application = AuthGraphQLProtocolTypeRouter(
+    schema,
+    django_application=django_asgi_app,
+)
+```
+
+Also, ensure that you enable subscriptions on your AsgiGraphQLView in `MyProject.urls.py`:
+
+```python
+...
+
+urlpatterns = [
+	...
+    path(
+        'graphql/',
+        AsyncGraphQLView.as_view(
+            schema=schema,
+            graphiql=settings.DEBUG,
+            subscriptions_enabled=True,
+        ),
+    ),
+    ...
+]
+
+```
+
+Note, django-channels allows for a lot more complexity. Here we merely cover the basic framework to get subscriptions to run on Django with minimal effort. Should you be interested in discovering the far more advanced capabilities of Dango channels, head over to [channels docs](https://channels.readthedocs.io)
+
+## Setup local testing
+
+The classic `./manage.py runserver` will not support subscriptions as it runs on WSGI mode. However, Django has ASGI server support out of the box through Daphne, which will override the runserver command to support our desired ASGI support.
+
+There are other asgi servers available, such as Uvicorn and Hypercorn. For the sake of simplicity we'll use Daphne as it comes with the runserver override. [Django Docs](https://docs.djangoproject.com/en/4.2/howto/deployment/asgi/daphne/) This shouldn't stop you from using any of the other ASGI flavours in production or local testing like Uvicorn or Hypercorn
+
+To get started: Firstly, we need install Daphne to handle the workload, so let's install it:
+
+```bash
+pip install daphne
+```
+
+Secondly, we need to add `daphne` to your settings.py file before 'django.contrib.staticfiles'
+
+```python
+INSTALLED_APPS = [
+	...
+    'daphne',
+    'django.contrib.staticfiles',
+    ...
+]
+```
+
+and add your `ASGI_APPLICATION` setting in your settings.py
+
+```python
+# settings.py
+...
+ASGI_APPLICATION = 'MyProject.asgi.application'
+...
+```
+
+Now you can run your test-server like as usual, but with ASGI support:
+
+```bash
+./manage.py runserver
+```
+
+## Creating your first subscription
+
+Once you've taken care of those 2 setup steps, your first subscription is a breeze.
+Go and edit your schema-file and add:
+
+```python
+import asyncio
+import strawberry
+
+@strawberry.type
+class Subscription:
+    @strawberry.subscription
+    async def count(self, target: int = 100) -> int:
+        for i in range(target):
+            yield i
+            await asyncio.sleep(0.5)
+```
+
+That's pretty much it for this basic start.
+See for yourself by running your test server `./manange.py runserver` and opening `http://127.0.0.1:8000/graphql/` in your browser. Now run:
+
+```graphql
+subscription {
+  count(target: 10)
+}
+```
+
+You should see something like (where the count changes every .5s to a max of 9)
+
+```json
+{
+  "data": {
+    "count": 9
+  }
+}
+```

docs/guide/types.md

@@ -103,12 +103,15 @@ You can use that `info` parameter to, for example,
 limit access to results based on the current user in the request:
 
 ```{.python title=types.py}
+from stawberry_django.auth.utils import get_current_user
+
 @strawberry.django.type(models.Fruit)
 class Berry:
 
     @classmethod
     def get_queryset(cls, queryset, info, **kwargs):
-        if not info.context.request.user.is_staff:
+        user = get_current_user(info)
+        if not user.is_staff:
             # Restrict access to top secret berries if the user is not a staff member
             queryset = queryset.filter(is_top_secret=False)
         return queryset.filter(name__contains="berry")

docs/guide/unit-testing.md

@@ -15,7 +15,7 @@ from strawberry_django.test.client import TestClient
 
 def test_me_unauthenticated(db):
     client = TestClient("/graphql")
-    res = gql_client.query("""
+    res = client.query("""
       query TestQuery {
         me {
           pk
@@ -31,18 +31,20 @@ def test_me_unauthenticated(db):
 
 def test_me_authenticated(db):
     user = User.objects.create(...)
-
     client = TestClient("/graphql")
-    res = client.query("""
-      query TestQuery {
-        me {
-          pk
-          email
-          firstName
-          lastName
-        }
-      }
-    """)
+
+    with client.login(user):
+        res = client.query("""
+          query TestQuery {
+            me {
+              pk
+              email
+              firstName
+              lastName
+            }
+          }
+        """)
+
     assert res.errors is None
     assert res.data == {
         "me": {
@@ -53,3 +55,5 @@ def test_me_authenticated(db):
         },
     }
 ```
+
+For more information how to apply these tests, take a look at the (source)[https://github.com/strawberry-graphql/strawberry-graphql-django/blob/main/strawberry_django/test/client.py] and (this example)[https://github.com/strawberry-graphql/strawberry-graphql-django/blob/main/tests/test_permissions.py#L49]

pyproject.toml

@@ -63,6 +63,7 @@ Markdown = "^3.3.7"
 Pygments = "^2.15.1"
 factory-boy = "^3.2.1"
 django-guardian = "^2.4.0"
+channels = { version = ">=3.0.5" }
 
 [tool.poetry.extras]
 debug-toolbar = ["django-debug-toolbar"]

strawberry_django/auth/queries.py

@@ -1,10 +1,17 @@
+from strawberry.types import Info
+
 import strawberry_django
 
+from .utils import get_current_user
+
 
-def resolve_current_user(info):
-    if not info.context.request.user.is_authenticated:
+def resolve_current_user(info: Info):
+    user = get_current_user(info)
+
+    if not getattr(user, "is_authenticated", False):
         return None
-    return info.context.request.user
+
+    return user
 
 
 def current_user():

strawberry_django/auth/utils.py

@@ -0,0 +1,56 @@
+from typing import Literal, Optional, overload
+
+from asgiref.sync import sync_to_async
+from strawberry.types import Info
+
+from strawberry_django.utils.typing import UserType
+
+
+@overload
+def get_current_user(info: Info, *, strict: Literal[True]) -> UserType: ...
+
+
+@overload
+def get_current_user(info: Info, *, strict: bool = False) -> Optional[UserType]: ...
+
+
+def get_current_user(info: Info, *, strict: bool = False) -> Optional[UserType]:
+    """Get and return the current user based on various scenarios."""
+    try:
+        user = info.context.request.user
+    except AttributeError:
+        try:
+            # queries/mutations in ASGI move the user into consumer scope
+            user = info.context.get("request").consumer.scope["user"]
+        except AttributeError:
+            # websockets / subscriptions move scope inside of the request
+            user = info.context.get("request").scope.get("user")
+
+    if user is None:
+        raise ValueError("No user found in the current request")
+
+    # Access an attribute inside the user object to force loading it in async contexts.
+    if user is not None:
+        _ = user.is_authenticated
+
+    return user
+
+
+@overload
+async def aget_current_user(
+    info: Info,
+    *,
+    strict: Literal[True],
+) -> UserType: ...
+
+
+@overload
+async def aget_current_user(
+    info: Info,
+    *,
+    strict: bool = False,
+) -> Optional[UserType]: ...
+
+
+async def aget_current_user(info: Info, *, strict: bool = False) -> Optional[UserType]:
+    return await sync_to_async(get_current_user)(info, strict=strict)