graphene-django

Build powerful, efficient, and flexible GraphQL APIs with seamless Django integration.

4,284

766

4,284

157

View on GitHub

Top Related Projects

strawberry

3,926

A GraphQL library for Python that leverages type annotations 🍓

ariadne

2,187

Python library for implementing GraphQL servers using schema-first approach.

starlette

10,027

The little ASGI framework that shines. 🌟

Quick Overview

Graphene-Django is a library that integrates the Graphene GraphQL framework with Django, allowing developers to easily create GraphQL APIs in Django applications. It provides tools and utilities to define GraphQL schemas, types, and queries based on Django models and views.

Pros

Seamless integration with Django ORM and models
Automatic generation of GraphQL types from Django models
Support for custom fields, filtering, and pagination
Easy to extend and customize for complex use cases

Cons

Learning curve for developers new to GraphQL
Performance can be an issue with complex queries or large datasets
Limited built-in support for real-time subscriptions
Documentation could be more comprehensive for advanced use cases

Code Examples

Defining a GraphQL type from a Django model:

import graphene
from graphene_django import DjangoObjectType
from .models import Book

class BookType(DjangoObjectType):
    class Meta:
        model = Book
        fields = ("id", "title", "author", "published_date")

Creating a query to fetch books:

import graphene
from .types import BookType
from .models import Book

class Query(graphene.ObjectType):
    all_books = graphene.List(BookType)
    book = graphene.Field(BookType, id=graphene.Int(required=True))

    def resolve_all_books(self, info):
        return Book.objects.all()

    def resolve_book(self, info, id):
        return Book.objects.get(pk=id)

Defining a mutation to create a new book:

import graphene
from .types import BookType
from .models import Book

class CreateBook(graphene.Mutation):
    class Arguments:
        title = graphene.String(required=True)
        author = graphene.String(required=True)

    book = graphene.Field(BookType)

    def mutate(self, info, title, author):
        book = Book.objects.create(title=title, author=author)
        return CreateBook(book=book)

class Mutation(graphene.ObjectType):
    create_book = CreateBook.Field()

Getting Started

Install the library:

pip install graphene-django

Add 'graphene_django' to INSTALLED_APPS in settings.py:

INSTALLED_APPS = [
    ...
    'graphene_django',
]

Create a schema.py file in your Django app:

import graphene
from graphene_django import DjangoObjectType
from .models import YourModel

class YourModelType(DjangoObjectType):
    class Meta:
        model = YourModel

class Query(graphene.ObjectType):
    all_items = graphene.List(YourModelType)

    def resolve_all_items(self, info):
        return YourModel.objects.all()

schema = graphene.Schema(query=Query)

Add the GraphQL URL to your urls.py:

from django.urls import path
from graphene_django.views import GraphQLView
from .schema import schema

urlpatterns = [
    path("graphql", GraphQLView.as_view(graphiql=True, schema=schema)),
]

Competitor Comparisons

graphene

8,058

GraphQL framework for Python

Pros of Graphene

More flexible and can be used with various Python frameworks, not just Django
Lighter weight and potentially faster for non-Django projects
Provides a more "Pythonic" way of defining GraphQL schemas

Cons of Graphene

Requires more manual setup and configuration for Django projects
Less integrated with Django's ORM and model system
May require additional libraries for features that come built-in with Graphene-Django

Code Comparison

Graphene:

import graphene

class Query(graphene.ObjectType):
    hello = graphene.String(name=graphene.String(default_value="World"))

    def resolve_hello(self, info, name):
        return f"Hello {name}"

schema = graphene.Schema(query=Query)

Graphene-Django:

from graphene_django import DjangoObjectType
import graphene
from .models import MyModel

class MyModelType(DjangoObjectType):
    class Meta:
        model = MyModel

class Query(graphene.ObjectType):
    my_model = graphene.Field(MyModelType)

schema = graphene.Schema(query=Query)

The main difference is that Graphene-Django provides tighter integration with Django models and simplifies the process of exposing them through GraphQL. Graphene, on the other hand, offers more flexibility but requires more manual setup for Django projects.

strawberry

3,926

A GraphQL library for Python that leverages type annotations 🍓

Pros of Strawberry

Type-first approach with Python 3.7+ type hints, leading to cleaner and more intuitive code
Built-in support for asynchronous resolvers, making it easier to work with async code
Better integration with mypy for improved type checking and IDE support

Cons of Strawberry

Newer project with a smaller community and ecosystem compared to Graphene-Django
Less documentation and fewer examples available for complex use cases
May require more manual setup for Django integration compared to Graphene-Django

Code Comparison

Strawberry:

@strawberry.type
class Book:
    title: str
    author: str

@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> List[Book]:
        return [Book(title="1984", author="George Orwell")]

Graphene-Django:

class Book(DjangoObjectType):
    class Meta:
        model = BookModel

class Query(graphene.ObjectType):
    books = graphene.List(Book)

    def resolve_books(self, info):
        return BookModel.objects.all()

Both Strawberry and Graphene-Django are powerful GraphQL libraries for Python, with Strawberry offering a more modern, type-focused approach, while Graphene-Django provides tighter integration with Django and a larger ecosystem. The choice between them depends on project requirements and developer preferences.

gql

1,528

A GraphQL client in Python

Pros of gql

More lightweight and focused on client-side GraphQL operations
Supports asyncio for asynchronous GraphQL requests
Easier to use for simple GraphQL client applications

Cons of gql

Less integrated with Django and ORM
Fewer built-in tools for schema definition and validation
Limited server-side functionality compared to Graphene-Django

Code Comparison

gql:

from gql import gql, Client

client = Client(transport=transport)
query = gql('''
    query getContinents {
        continents {
            code
            name
        }
    }
''')
result = client.execute(query)

Graphene-Django:

import graphene
from graphene_django import DjangoObjectType

class ContinentType(DjangoObjectType):
    class Meta:
        model = Continent

class Query(graphene.ObjectType):
    continents = graphene.List(ContinentType)

    def resolve_continents(self, info):
        return Continent.objects.all()

schema = graphene.Schema(query=Query)

The code comparison shows that gql is more focused on executing GraphQL queries as a client, while Graphene-Django is designed for defining GraphQL schemas and resolvers on the server-side, with tight integration to Django models.

ariadne

2,187

Python library for implementing GraphQL servers using schema-first approach.

Pros of Ariadne

Schema-first approach, allowing for better separation of concerns
More flexible and customizable, with support for custom scalars and directives
Easier integration with existing Django views and URLs

Cons of Ariadne

Less mature ecosystem compared to Graphene-Django
Requires more manual setup and configuration
Smaller community and fewer resources available

Code Comparison

Ariadne:

from ariadne import QueryType, make_executable_schema

type_defs = """
    type Query {
        hello: String!
    }
"""

query = QueryType()

@query.field("hello")
def resolve_hello(_, info):
    return "Hello, World!"

schema = make_executable_schema(type_defs, query)

Graphene-Django:

import graphene

class Query(graphene.ObjectType):
    hello = graphene.String()

    def resolve_hello(self, info):
        return "Hello, World!"

schema = graphene.Schema(query=Query)

Both Ariadne and Graphene-Django are popular GraphQL libraries for Django, each with its own strengths. Ariadne offers a schema-first approach and more flexibility, while Graphene-Django provides a more mature ecosystem and easier setup. The choice between them depends on project requirements and developer preferences.

starlette

10,027

The little ASGI framework that shines. 🌟

Pros of Starlette

Lightweight and high-performance ASGI framework
Built-in WebSocket support
Flexible routing system with support for path parameters

Cons of Starlette

No built-in GraphQL support (requires additional libraries)
Steeper learning curve for developers new to ASGI
Less opinionated, requiring more setup for complex applications

Code Comparison

Starlette (basic route):

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route

async def homepage(request):
    return JSONResponse({"message": "Hello, World!"})

app = Starlette(routes=[Route("/", homepage)])

Graphene-Django (basic GraphQL query):

import graphene
from graphene_django import DjangoObjectType
from .models import User

class UserType(DjangoObjectType):
    class Meta:
        model = User

class Query(graphene.ObjectType):
    users = graphene.List(UserType)

    def resolve_users(self, info):
        return User.objects.all()

schema = graphene.Schema(query=Query)

While Graphene-Django provides a seamless integration of GraphQL with Django, Starlette offers a more flexible and lightweight approach for building ASGI applications. Starlette excels in performance and WebSocket support, but requires additional setup for GraphQL functionality. Graphene-Django, on the other hand, simplifies GraphQL integration within the Django ecosystem but may be less suitable for high-performance, asynchronous applications.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Graphene-Django

Graphene-Django is an open-source library that provides seamless integration between Django, a high-level Python web framework, and Graphene, a library for building GraphQL APIs. The library allows developers to create GraphQL APIs in Django quickly and efficiently while maintaining a high level of performance.

Features

Seamless integration with Django models
Automatic generation of GraphQL schema
Integration with Django's authentication and permission system
Easy querying and filtering of data
Support for Django's pagination system
Compatible with Django's form and validation system
Extensive documentation and community support

Installation

To install Graphene-Django, run the following command:

pip install graphene-django

Configuration

After installation, add 'graphene_django' to your Django project's INSTALLED_APPS list and define the GraphQL schema in your project's settings:

INSTALLED_APPS = [
    # ...
    'graphene_django',
]

GRAPHENE = {
    'SCHEMA': 'myapp.schema.schema'
}

Usage

To use Graphene-Django, create a schema.py file in your Django app directory and define your GraphQL types and queries:

import graphene
from graphene_django import DjangoObjectType
from .models import MyModel

class MyModelType(DjangoObjectType):
    class Meta:
        model = MyModel

class Query(graphene.ObjectType):
    mymodels = graphene.List(MyModelType)

    def resolve_mymodels(self, info, **kwargs):
        return MyModel.objects.all()

schema = graphene.Schema(query=Query)

Then, expose the GraphQL API in your Django project's urls.py file:

from django.urls import path
from graphene_django.views import GraphQLView
from . import schema

urlpatterns = [
    # ...
    path('graphql/', GraphQLView.as_view(graphiql=True)), # Given that schema path is defined in GRAPHENE['SCHEMA'] in your settings.py
]

Testing

Graphene-Django provides support for testing GraphQL APIs using Django's test client. To create tests, create a tests.py file in your Django app directory and write your test cases:

from django.test import TestCase
from graphene_django.utils.testing import GraphQLTestCase
from . import schema

class MyModelAPITestCase(GraphQLTestCase):
    GRAPHENE_SCHEMA = schema.schema

    def test_query_all_mymodels(self):
        response = self.query(
            '''
            query {
                mymodels {
                    id
                    name
                }
            }
            '''
        )

        self.assertResponseNoErrors(response)
        self.assertEqual(len(response.data['mymodels']), MyModel.objects.count())

Contributing

Contributions to Graphene-Django are always welcome! To get started, check the repository's issue tracker and contribution guidelines.

License

Graphene-Django is released under the MIT License.

Resources

Official GitHub Repository
Graphene Documentation
Django Documentation
GraphQL Specification
GraphiQL - An in-browser IDE for exploring GraphQL APIs
Graphene-Django Community - Join the community to discuss questions and share ideas related to Graphene-Django

Tutorials and Examples

Related Projects

Graphene - A library for building GraphQL APIs in Python
Graphene-SQLAlchemy - Integration between Graphene and SQLAlchemy, an Object Relational Mapper (ORM) for Python
Graphene-File-Upload - A package providing an Upload scalar for handling file uploads in Graphene
Graphene-Subscriptions - A package for adding real-time subscriptions to Graphene-based GraphQL APIs

Support

If you encounter any issues or have questions regarding Graphene-Django, feel free to submit an issue on the official GitHub repository. You can also ask for help and share your experiences with the Graphene-Django community on ð¬ Discord

Release Notes

See Releases page on github

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot