graphene-django

To use Relay features like global IDs and connections, define your DjangoObjectType classes with relay.Node in the interfaces option of the Meta class. You can also use filter_fields to enable advanced filtering via django-filter.

from graphene import relay, ObjectType
from graphene_django import DjangoObjectType
from graphene_django.filter import DjangoFilterConnectionField
from ingredients.models import Category, Ingredient

class CategoryNode(DjangoObjectType):
    class Meta:
        model = Category
        fields = '__all__'
        filter_fields = ['name', 'ingredients']
        interfaces = (relay.Node, )

class IngredientNode(DjangoObjectType):
    class Meta:
        model = Ingredient
        fields = '__all__'
        filter_fields = {
            'name': ['exact', 'icontains', 'istartswith'],
            'notes': ['exact', 'icontains'],
            'category': ['exact'],
            'category__name': ['exact'],
        }
        interfaces = (relay.Node, )

class Query(ObjectType):
    category = relay.Node.Field(CategoryNode)
    all_categories = DjangoFilterConnectionField(CategoryNode)

    ingredient = relay.Node.Field(IngredientNode)
    all_ingredients = DjangoFilterConnectionField(IngredientNode)

You can filter the results of a DjangoListField in two ways:

1. Via get_queryset on the DjangoObjectType: Define a @classmethod get_queryset(cls, queryset, info) on your DjangoObjectType. This is useful for logic tied to the type itself.
2. Via a field resolver on the Query type: Define a resolve_<field_name>(parent, info) method on your Query class. This allows for field-specific filtering logic.

When resolving a DjangoListField, the get_queryset method will be called with either the return of the field resolver (if one is defined) or the default queryset from the Django model.

from graphene import ObjectType, Schema
from graphene_django import DjangoListField

class RecipeType(DjangoObjectType):
   class Meta:
      model = Recipe
      fields = ("title", "instructions")

   @classmethod
   def get_queryset(cls, queryset, info):
      # Filter out recipes that have no title
      return queryset.exclude(title__exact="")

class Query(ObjectType):
   recipes = DjangoListField(RecipeType)

   def resolve_recipes(parent, info):
      # Only get recipes that have been published
      return Recipe.objects.filter(published=True)

schema = Schema(query=Query)

To enable Relay features like pagination, slicing, and abstract id values in Graphene-Django, you must implement relay.Node in your DjangoObjectType and define a relay.Connection.

Key steps:

1. Import relay from graphene.
2. Add relay.Node to the interfaces tuple in the DjangoObjectType.Meta class.
3. Define a Connection class inheriting from relay.Connection with the node set to your DjangoObjectType in its Meta class.
4. Use relay.ConnectionField in your Query class to expose the connection.

from graphene import relay
from graphene_django import DjangoObjectType
from .models import Question

class QuestionType(DjangoObjectType):
    class Meta:
        model = Question
        interfaces = (relay.Node,)
        fields = "__all__"

class QuestionConnection(relay.Connection):
    class Meta:
        node = QuestionType

class Query:
    questions = relay.ConnectionField(QuestionConnection)

    def resolve_questions(root, info, **kwargs):
        return Question.objects.all()

You can create custom mutations by inheriting from graphene.Mutation. Define input arguments in a class Arguments and specify the response fields as class attributes. The logic resides in the @classmethod mutate. Ensure you return an instance of the mutation class containing the response data.

import graphene
from graphene_django import DjangoObjectType
from .models import Question

class QuestionType(DjangoObjectType):
    class Meta:
        model = Question
        fields = '__all__'

class QuestionMutation(graphene.Mutation):
    class Arguments:
        # The input arguments for this mutation
        text = graphene.String(required=True)
        id = graphene.ID()

    # The class attributes define the response of the mutation
    question = graphene.Field(QuestionType)

    @classmethod
    def mutate(cls, root, info, text, id):
        question = Question.objects.get(pk=id)
        question.text = text
        question.save()
        # Notice we return an instance of this mutation
        return QuestionMutation(question=question)

class Mutation(graphene.ObjectType):
    update_question = QuestionMutation.Field()