strawberry-graphql/strawberry

Features

• GraphQL Frameworks - Provides a comprehensive type-safe framework for implementing GraphQL schemas and resolvers in Python.
• Schema-Driving Annotations - Uses Python type annotations to declaratively define the GraphQL schema structure.
• Type-Hint-Based Schema Definitions - Derives the GraphQL schema structure by inspecting Python type annotations and dataclasses at runtime.
• GraphQL APIs - Provides a type-safe framework for building GraphQL servers in Python using type annotations and dataclasses.
• GraphQL Servers - Functions as a type-safe asynchronous GraphQL server and execution engine for Python applications.
• Query Validators - Validates incoming GraphQL queries against the schema for syntax and type correctness before execution.
• GraphQL Type Mappings - Maps Python classes and type annotations directly to GraphQL schema object types.
• Mutation Definitions - Defines the root mutation type to specify signatures and return types for data modification operations.
• Root Query Definitions - Provides the ability to define the root query type and its return types for data requests.
• API Resolver Mappings - Maps GraphQL schema fields to specific resolver functions that fetch or compute the requested data.
• Cursor-Based Pagination - Implements cursor-based and offset-based pagination to retrieve sliced subsets of large datasets.
• Stream Subscriptions - Streams real-time data from the server to clients using asynchronous generators across various transport layers.
• Resolver Context Injection - Injects authenticated user information and request metadata into field resolver functions via a type-safe context object.
• GraphQL Resolver Contexts - Injects request-specific metadata into resolvers, providing access to the current runtime state and execution context.
• Unified Request Protocols - Implements a unified connection protocol that handles queries, mutations, and subscriptions via shared transport specifications.
• Concurrent Resolver Execution - Runs data fetching tasks concurrently using non-blocking asynchronous resolvers to prevent execution bottlenecks.
• Django Integrations - Exposes a GraphQL schema endpoint within a Django application through a dedicated request view.
• FastAPI Application Integration - Integrates GraphQL schemas into the FastAPI server framework via a custom router for HTTP requests.
• Flask Integrations - Exposes a GraphQL schema as a web view for integration into Flask applications.
• Field Resolvers - Implements field resolvers that map GraphQL schema fields to Python functions for data retrieval.
• Field Argument Handling - Implements logic to handle input parameters within field resolvers for filtering and specifying returned data.
• GraphQL HTTP Endpoints - Exposes GraphQL schemas via HTTP endpoints to handle queries and mutations within web applications.
• GraphQL Parent-Object Data Access - Allows field resolvers to access data from their parent object to compute derived values or perform related lookups.
• GraphQL Query Type Mapping - Maps Python functions and classes to the root Query type to define API entry points.
• Schema Definitions - Provides the tools to define the structural components of the API, including query, mutation, and subscription types.
• Federated Schema Architecture - Splits the API into multiple subgraphs that merge into a unified gateway using unique entity keys.
• Quart Integrations - Exposes GraphQL schemas through a web view to handle requests within the Quart asynchronous framework.
• Real-Time Data Streaming - Provides utilities for pushing live server-side data updates to connected clients via WebSockets and Server-Sent Events.
• ASGI-Based - Implements request processing based on the ASGI standard for asynchronous communication over HTTP and WebSockets.
• Web Framework Integration Adapters - Connects the GraphQL execution engine to various web servers through request and response translation layers.
• Web Framework Integrations - Connects GraphQL schemas to ASGI-compliant servers like FastAPI, Django, and Flask to expose API endpoints.
• ASGI Frameworks - Exposes GraphQL schemas over HTTP and WebSockets using the ASGI specification for asynchronous server interoperability.
• Resolver Execution Tracing - Records timing and performance metrics for API resolver functions to integrate with external monitoring platforms.
• GraphQL Directive Execution Control - Uses GraphQL directives to conditionally include, skip, or modify the evaluation of fields during request execution.
• Asynchronous ORM Mappings - Handles compatibility between GraphQL fields and database models for both synchronous and asynchronous fetching.
• Schema Field Visibility - Controls field visibility in the schema by overriding retrieval logic to support different access levels.
• Custom Scalars - Allows the creation of custom scalar types with specialized serialization and parsing logic.
• Federated Field Extensions - Adds new fields to existing interfaces defined in other services to enrich federated resources.
• Enum Definitions - Enables the definition of Enum types to restrict field values to a specific set of constants.
• Federated Entity Definitions - Enables the definition of unique keys for object types to allow cross-service referencing in a federated graph.
• Federated Interfaces - Creates interfaces that act as entities within a federated graph to share type definitions across subgraphs.
• Entity Reference Resolvers - Defines resolvers that fetch specific object instances by their unique keys within a federated GraphQL architecture.
• GraphQL Mutation Implementations - Executes create, update, or delete records in the underlying data store via specialized mutation operations.
• Event Stream Broadcasters - Integrates with broadcast groups to push asynchronous events from background tasks to subscribed clients.
• Incremental List Streaming - Delivers large lists incrementally by sending an initial set of items followed by subsequent payloads.
• Interactive Schema Playgrounds - Provides a web interface to write queries, execute them, and browse generated documentation.
• Request Processing - Allows customization of the request lifecycle, including overrides for request context and JSON encoding.
• GraphQL Subscriptions over SSE - Enables real-time GraphQL subscription data delivery using the Server-Sent Events protocol over HTTP.
• WebSocket Transports - Implements persistent bidirectional communication channels using asynchronous consumers for real-time GraphQL data exchange.
• Field-Level Access Controls - Provides mechanisms to restrict access to specific GraphQL fields based on custom permission logic.
• Query Complexity Protections - Protects server resources by limiting the depth and structural complexity of incoming GraphQL queries.
• Role-Based Access Controls - Enforces security policies by mapping authenticated user identities to specific permission classes and actions.
• GraphQL Query Validation Rules - Enforces custom constraints during the query validation phase to ensure requests adhere to specific rules.
• GraphQL Type Conversions - Transforms data between Pydantic validation models and GraphQL schema types to enable manual validation.
• Pydantic-to-GraphQL Mappings - Generates schema objects, inputs, and interfaces directly from Pydantic models to eliminate data duplication.
• GraphQL Deferred Fields - Implements the @defer directive to stream partial GraphQL results as they become available.
• Computed Fields - Supports the definition of fields that are computed dynamically at runtime during query execution.
• Validation Error Reporters - Converts internal validation errors into structured error extensions to provide clear, machine-readable feedback to clients.
• GraphQL Type Generics - Enables the definition of flexible, reusable GraphQL types using Python generics.
• Relay Global Object Identification - Implements the Relay global object identification specification for unique entity refetching.
• Request Batching - Groups multiple individual data lookups into single requests to reduce the number of database round-trips.
• Schema Extension Systems - Provides a system for integrating custom extensions into the schema to modify the execution pipeline and add global behaviors.
• Static Type Checking - Validates schema definitions during development using a static analysis plugin to catch type errors.
• Request Tracing - Integrates with observability tools to monitor the lifecycle and health of network requests.
• Cursor Pagination - Supports Relay-style connection pagination using both limit/offset and cursor-based strategies.
• Error Handling - Transforms Pydantic validation failures into structured, typed error representations for consistent client-side reporting.
• Directive-Based Execution - Alters field resolution and schema metadata using specialized directives to control execution behavior.
• GraphQL Directive Definitions - Enables the definition of custom directives to decorate and modify GraphQL operations and schema metadata.
• GraphQL Input Type Definitions - Supports the definition of complex GraphQL Input types to pass structured arguments to operations.
• Execution Interception - Provides hooks into the execution process to run custom logic and inject data into responses.
• SDL Schema Generation - Converts schema definition language (SDL) files into Python source code to automate type creation.
• Type-Safe Query Generation - Creates typed Python code based on specific GraphQL queries to ensure type safety for operation results.
• Federated Composers - Combines multiple subgraph APIs into a single unified federated graph using specific fields and directives.
• GraphQL SDL Exports - Generates schema definition language files from type definitions to support external tooling.
• Incremental GraphQL Delivery - Implements techniques for streaming partial GraphQL results to clients to reduce perceived latency.
• Relay Specification Implementations - Implements the Relay GraphQL specification for standardized connection-based pagination and global object identification.
• General Utilities - GraphQL library based on dataclasses.
• Python GraphQL Tools - Modern GraphQL library using Python type hints.
• Web APIs - A GraphQL library that leverages Python type annotations.
• Web Frameworks - GraphQL library using type annotations.

Star history