graphql-python/graphene-django
Graphene Django
Graphene-Django is a GraphQL integration framework and schema mapper used to build typed APIs for Django applications. It functions as a database API layer that transforms Django model fields and relationships into a graph schema, allowing clients to request specific data in a single call.
The project implements the Relay specification, providing tools for global object identification and standardized connection-based pagination to manage large datasets. It distinguishes itself by mapping database models, forms, and serializers directly into GraphQL object types and mutations.
The framework covers a broad range of capabilities, including field-level access control, middleware-based request interception, and the handling of real-time operations via WebSocket routing. It also includes utilities for SQL performance inspection and mutation transaction wrapping to ensure data integrity during updates.
A specialized test client is provided to verify API responses and execute queries against the endpoint.
Features
- GraphQL API Implementations - Implements a full server-side GraphQL interface to expose Django data models and logic via a typed schema.
- GraphQL APIs - Provides a framework for exposing Django data models through automatically generated GraphQL interfaces.
- GraphQL Schema Definitions - Implements the core process of mapping internal Django data models to a typed GraphQL schema.
- API Result Filters - Provides capabilities to restrict API response sets using model field filters and custom lookup logic.
- Foreign Key Constraints - Maps foreign keys between database entities to enable nested data retrieval through a graph schema.
- GraphQL Data Mappers - Maps relational database tables and ORM models to GraphQL types with optimized query resolution.
- GraphQL Integrations - Bridges Django database schemas with GraphQL APIs by mapping models to a typed graph schema.
- GraphQL Mutation Implementations - Implements server-side logic for creating and updating database records via GraphQL mutations.
- Object Relational Mappings - Provides frameworks for defining and managing relationships between Django models and GraphQL object types.
- Queryset Filtering Backends - Controls database record visibility and ownership at the GraphQL type level using custom queryset filtering logic.
- Related Object Retrievers - Traverses foreign key and many-to-many relationships to retrieve nested linked data in a single GraphQL request.
- Result Ordering and Limiting - Allows clients to specify model fields for sorting the sequence of returned database records.
- Custom Object Types - Defines plain object types to decouple the external data structure from the internal database schema.
- Data Set Pagination - Implements standardized patterns for page-based navigation and result set limits in GraphQL queries.
- Authentication-Based Visibility Controls - Limits returned objects based on user authentication, visibility rules, and custom business logic.
- Resolver-to-Method Mapping - Maps GraphQL query and mutation objects to specific data fetching methods to define the API structure.
- Django Model Mappings - Automatically transforms database models and relationships into a graph schema to expose backend data via an API.
- GraphQL HTTP Endpoints - Exposes the GraphQL schema via a single HTTP endpoint and provides an interactive browser interface for testing.
- Model List Exposure - Returns collections of database objects as GraphQL lists based on the model's default data set.
- Model-to-Type Mapping - Transforms Django database model fields into GraphQL object types to expose data structures via a graph schema.
- Model-to-Type Mappings - Automatically transforms Django database model fields into GraphQL object types to expose data structures.
- Relay Specification Implementations - Ensures compliance with Relay standards for connections, edges, and global object identification.
- Relay Specifications - Implements standardized cursor-based pagination and global unique identifiers following the Relay specification.
- Database APIs - Acts as a programmatic interface that exposes database records and relationships as a queryable graph.
- Pagination Connection Limits - Enforces maximum limits on the number of objects requested in a Relay connection to ensure efficient pagination.
- Application-to-Database Enum Mapping - Transforms database field options into typed GraphQL enums to ensure valid input selection.
- Choice Field Enums - Automatically generates typed GraphQL enums from Django model choice fields using standard naming patterns.
- GraphQL Schema Exports - Enables printing the GraphQL schema as SDL or JSON for use with external tools and plugins.
- Transactional Data Mutations - Ensures that a set of mutation fields within a single request are executed within a transaction for atomic success or rollback.
- GraphQL Middleware Interceptors - Runs a sequence of middleware classes for every incoming query to handle authentication and other cross-cutting concerns.
- API Access Restrictions - Controls which users can query or mutate specific data fields using integrated authorization logic.
- Field-Level Access Controls - Hides or exposes specific model fields in the API using inclusion or exclusion lists based on permissions.
- Permission-Based Access Control - Restricts access to GraphQL queries and mutations based on user roles and specific permissions.
- Form-to-Mutation Generation - Derives mutation input arguments and validation logic directly from existing Django model forms.
- GraphQL Testing - Verifies response data and error states by executing queries against the API using a specialized test client.
- API Response Verifications - Simulates network requests using mock data to verify that GraphQL queries and mutations return expected results.
- Form-to-Mutation Mappings - Generates GraphQL mutation input arguments and validation logic directly from existing Django forms.
- Relay Mutation Generation - Generates mutation fields and payload objects that comply with the Relay specification for client-side tracking.
- Request Interception Middlewares - Provides a middleware pipeline to intercept incoming GraphQL queries for authentication and cross-cutting concerns.
- Serializer-to-Mutation Mappings - Utilizes existing Django REST framework serializers to handle input validation and verification for GraphQL mutations.
- API Development - GraphQL integration for Django models.
- Python GraphQL Tools - Django integration for the Graphene library.
