graphql-python/graphene-django

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.

Star history