Strawberry GraphQL Django

The integration provides several automated features for building GraphQL APIs:

• Automatic Type Generation: Generate GraphQL types from Django models with full type safety.
• Advanced Filtering: Powerful filtering system with lookups (contains, exact, in, etc.).
• Pagination: Built-in offset and cursor-based (Relay) pagination.
• Ordering: Sort results by any field with automatic ordering support.
• Authentication & Permissions: Django auth integration with a flexible permission system.
• CRUD Mutations: Auto-generated create, update, and delete mutations with validation.
• Query Optimizer: Automatic select_related and prefetch_related to prevent N+1 queries via DjangoOptimizerExtension.
• Django Integration: Works with Django views (sync and async), forms, and validation.
• Debug Toolbar: GraphiQL integration with Django Debug Toolbar for query inspection.

When the DjangoOptimizerExtension is insufficient—such as when fetching data from external APIs, performing complex custom aggregations, or handling non-standard relationship patterns—use Strawberry's DataLoader. DataLoaders batch and cache requests to prevent redundant work.

from strawberry.dataloader import DataLoader
from typing import List

# 1. Define the batch loading function
async def load_authors(keys: List[int]) -> List[Author]:
    """Batch load authors by ID"""
    authors = Author.objects.filter(id__in=keys)
    author_map = {author.id: author for author in authors}
    return [author_map.get(key) for key in keys]

# 2. Add the loader to your context
def get_context():
    return {"author_loader": DataLoader(load_fn=load_authors)}

# 3. Use the loader in a resolver
@strawberry.field
async def author(self, info) -> Author:
    loader = info.context["author_loader"]
    return await loader.load(self.author_id)

When using @strawberry_django.partial for updates, all auto fields become optional. To distinguish between a field being omitted (no change) and a field being explicitly set to null, use the Maybe type pattern:

1. Maybe[T]: The field is either absent (None) or has a value (Some(value)). Use this for required fields that you want to allow omitting during an update.
2. Maybe[T | None]: The field is absent (None), has a value (Some(value)), or is explicitly null (Some(None)). Use this for nullable fields where you need to support setting them to null.

Implementation Pattern: When resolving the mutation, check if the Maybe wrapper is not None before applying the value.

from strawberry import Maybe

@strawberry_django.input(models.Fruit)
class FruitUpdateInput:
    id: strawberry.relay.GlobalID
    # name is required, null not allowed
    name: Maybe[str]
    # color is optional, can be explicitly set to null
    color: Maybe[str | None]

@strawberry.type
class Mutation:
    @strawberry_django.mutation
    def update_fruit(self, info, input: FruitUpdateInput) -> Fruit:
        fruit = input.id.resolve_node_sync(info)

        if input.name is not None:
            fruit.name = input.name.value

        if input.color is not None:
            # input.color.value is either a string or None
            fruit.color = input.color.value

        fruit.save()
        return cast(Fruit, fruit)

For large datasets, use DjangoCursorConnection instead of the default ListConnection.

Key Differences:

• Performance: ListConnection uses SQL OFFSET (slicing), which slows down as page numbers increase. DjangoCursorConnection uses range queries (e.g., Q(field__gte=...)), which is more efficient when used with database indexes.
• Use Case: Best for infinitely scrollable lists. It does not support jumping to specific pages.
• Ordering Requirement: Requires a strictly ordered QuerySet. If the ordering is not unique (e.g., order_by('date')), DjangoCursorConnection will automatically append the primary key to the order to ensure stability.
• Compatibility Note: If the order is configurable by the user (e.g., via @strawberry_django.order), cursors will not be compatible between different sort orders.

@strawberry.type
class Query:
    # Uses range-based pagination via Django QuerySets
    fruit: DjangoCursorConnection[FruitType] = strawberry_django.connection()

    @strawberry_django.connection(DjangoCursorConnection[FruitType])
    def fruit_with_custom_resolver(self) -> list[Fruit]:
        return Fruit.objects.all()

The Query Optimizer supports fields that return an interface (polymorphic queries). It automatically handles optimizing subtypes of the interface for both top-level queries and model relations.

Supported Polymorphic Approaches

1. Django Polymorphic: Works out of the box if you use the django-polymorphic library.
2. django-model-utils InheritanceManager: Supported automatically. The optimizer calls select_subclasses, passing in subtypes present in your schema.
3. Custom Polymorphic Solution: If your models are not polymorphic, you can implement a custom solution by defining resolve_type in your GraphQL interface type to map instances to their correct GraphQL types.

Important Constraints

• Filtering: The optimizer does not filter your QuerySet. Django will return all instances of the model. You must ensure every model subclass has a corresponding GraphQL type, or implement a get_queryset method on your interface type to filter out unwanted subtypes. Failure to do this may result in the error: Abstract type 'ProjectType' must resolve to an Object type at runtime for field 'Query.projects'.
• Custom Solutions & Relations: When using a custom resolve_type approach, you must add get_queryset to your interface type to force the optimizer to use prefetch_related; otherwise, optimization will not work for relation fields.
• InheritanceManager & Base Managers: If you have polymorphic relations, the manager used to look up the related model must be an InheritanceManager. Since Strawberry Django uses the model's base manager by default (not objects), you should either change your base manager to an InheritanceManager or configure the extension with prefetch_custom_queryset=True.

@strawberry_django.interface(models.Project)
class ProjectType:
    topic: strawberry.auto

    @classmethod
    def resolve_type(cls, value, info, parent_type) -> str:
        if value.artist:
            return "ArtProjectType"
        if value.supervisor:
            return "ResearchProjectType"
        raise TypeError()

    @classmethod
    def get_queryset(cls, qs, info):
        return qs

@strawberry_django.type(models.ResearchProject)
class ResearchProjectType(ProjectType):
    supervisor: strawberry.auto

@strawberry_django.type(models.ArtProject)
class ArtProjectType(ProjectType):
    artist: strawberry.auto