Graphene Documentation

An Interface is an abstract type that defines a set of fields that implementing types must include. To create an interface, inherit from graphene.Interface. To implement an interface in an ObjectType, include the interface in the interfaces tuple within the Meta inner class.

Implementing an interface allows you to return different object types from a single field, provided they all satisfy the interface's field requirements. You can query interface fields directly or use inline fragments (... on TypeName) to access type-specific fields.

import graphene

# 1. Define the Interface
class Character(graphene.Interface):
    id = graphene.ID(required=True)
    name = graphene.String(required=True)
    friends = graphene.List(lambda: Character)

# 2. Implement the Interface in ObjectTypes
class Human(graphene.ObjectType):
    class Meta:
        interfaces = (Character,)

    starships = graphene.List(Starship)
    home_planet = graphene.String()

class Droid(graphene.ObjectType):
    class Meta:
        interfaces = (Character,)

    primary_function = graphene.String()

# 3. Use the Interface in a Query
class Query(graphene.ObjectType):
    hero = graphene.Field(Character, required=True, episode=graphene.Int(required=True))

    def resolve_hero(root, info, episode):
        if episode == 5:
            return get_human(name='Luke Skywalker')
        return get_droid(name='R2-D2')

schema = graphene.Schema(query=Query, types=[Human, Droid])

To satisfy Relay's requirements for mutations, subclass relay.ClientIDMutation. This automatically manages the input/output structure required by Relay. Define an inner Input class for the mutation arguments and implement the mutate_and_get_payload class method to handle the business logic. The method should return an instance of the mutation class containing the desired return fields.

class IntroduceShip(relay.ClientIDMutation):

    class Input:
        ship_name = graphene.String(required=True)
        faction_id = graphene.String(required=True)

    ship = graphene.Field(Ship)
    faction = graphene.Field(Faction)

    @classmethod
    def mutate_and_get_payload(cls, root, info, **input):
        ship_name = input.ship_name
        faction_id = input.faction_id
        ship = create_ship(ship_name, faction_id)
        faction = get_faction(faction_id)
        return IntroduceShip(ship=ship, faction=faction)

If you need to customize how global IDs are encoded or decoded, you can subclass Node.

• Override to_global_id(type_, id) to define how the type name and ID are combined.
• Override get_node_from_global_id(info, global_id, only_type=None) to define how to resolve an object from an encoded ID.

When implementing get_node_from_global_id, you can use the only_type argument to validate that the decoded type matches the expected GraphQL type.

class CustomNode(Node):

    class Meta:
        name = 'Node'

    @staticmethod
    def to_global_id(type_, id):
        return f"{type_}:{id}"

    @staticmethod
    def get_node_from_global_id(info, global_id, only_type=None):
        type_, id = global_id.split(':')
        if only_type:
            # We assure that the node type that we want to retrieve
            # is the same that was indicated in the field type
            assert type_ == only_type._meta.name, 'Received not compatible node.'

        if type_ == 'User':
            return get_user(id)
        elif type_ == 'Photo':
            return get_photo(id)