async-graphql/async-graphql

Features

• Schema Generation Macros - Uses Rust procedural macros to automatically derive GraphQL schema definitions from native language types.
• GraphQL API Development - Provides a type-safe framework for designing and implementing specification-compliant GraphQL servers in Rust.
• GraphQL Schema Definitions - Provides the core framework for describing the data graph using static type definitions or dynamic configurations.
• GraphQL Servers - Provides a specification-compliant server that handles GraphQL queries and mutations with type safety.
• Federated Entity Definitions - Creates types with unique keys and reference resolvers to enable entity resolution across multiple subgraphs.
• Apollo Federation Support - Implements entities, keys, and cross-subgraph field sharing to enable a distributed architecture.
• Entity Reference Resolvers - Implements reference resolvers that fetch entities by their unique keys to support a federated GraphQL architecture.
• GraphQL Schema Composition - Combines query, mutation, and subscription objects into a single specification-compliant API definition.
• GraphQL Query Performance Optimizations - Implements data request batching and complexity-based guarding to optimize query performance and stability.
• WebSocket Subscriptions - Handles WebSocket connections to stream real-time data updates to clients via subscriptions.
• Stream Subscriptions - Implements real-time message listening for multiple clients by returning asynchronous streams from resolvers.
• Shared State Stores - Uses a centralized mutable context object to synchronize shared data across all field resolvers during a request.
• Resolver Context Injection - Injects shared dependencies and request-scoped state into field resolver functions via a unified context.
• GraphQL Subscriptions over WebSocket - Delivers real-time GraphQL subscription data using WebSocket connections and asynchronous event streams.
• GraphQL Object Mappings - Maps native Rust structures directly to GraphQL objects with control over field flattening and exclusion.
• Schema-to-Struct Mappings - Automatically maps GraphQL schema definitions directly to native Rust struct types to eliminate manual data copying.
• Access Control Guards - Executes permission checks before resolvers run to block access based on roles or conditions.
• Access Restrictions - Validates requirements before calling a resolver and returns structured errors if access is denied.
• GraphQL Query Complexity Protection - Protects server resources by limiting the structural depth and complexity of GraphQL queries.
• Parsing Depth Limits - Rejects requests exceeding maximum nesting levels to prevent recursive resource exhaustion.
• Query Complexity Protections - Caps the total number of requested fields using weights to prevent resource-intensive operations.
• Query Depth Restrictions - Prevents denial-of-service attacks by restricting the maximum depth of recursive query nesting.
• Type-Safe API Schemas - Ensures consistency between the data model and API specification by mapping native Rust types to GraphQL objects and scalars.
• Request Batching - Groups multiple entity lookups into single requests to prevent redundant database queries.
• Concurrent Resolver Execution - Implements parallel execution of GraphQL resolver functions to minimize latency when fetching data from external sources.
• GraphQL APIs - Uses type-safe definitions to automatically generate a specification-compliant server for querying data.
• Federation v2 Specification - Uses the v2 specification to allow multiple subgraphs to contribute fields to the same type.
• Field Resolvers - Uses asynchronous functions to resolve specific fields in the GraphQL schema by fetching data from external sources.
• Query Execution Engines - Provides a runtime engine that evaluates GraphQL queries and mutations against a defined schema to produce data.
• GraphQL HTTP Endpoints - Exposes GraphQL schemas via HTTP endpoints to handle queries and mutations through integration with web servers.
• Selection Set Inspection - Analyzes the selection set at runtime to fetch only the fields required by the client.
• GraphQL Web Service Integration - Exposes a GraphQL schema as a web service by handling incoming requests and returning responses.
• Async Framework Adapters - Integrates the GraphQL engine with asynchronous HTTP frameworks to handle incoming requests and return responses.
• Real-Time Data Streaming - Implements real-time data streaming via WebSocket subscriptions and asynchronous event streams.
• GraphQL Object Mappings - Maps internal data structures to GraphQL objects via automatic field mapping or custom asynchronous resolvers.
• Query Complexity Analysis - Calculates query depth and complexity to protect server resources from expensive requests.
• Schema Computed Fields - Adds user-defined resolvers to a structure to calculate values not stored as simple members.
• Custom Scalars - Allows the creation of specialized scalar types through custom parsing and serialization logic.
• GraphQL Schema Behavior Plugins - Extends GraphQL schema behavior, such as authorization and filtering, through a dedicated plugin system.
• GraphQL Schema Exports - Prints the GraphQL schema as SDL to a string for use in external tools and documentation.
• Query Execution Tracing - Records execution time for each query step and includes it in the response for analysis.
• GraphQL Input Objects - Creates structures used as grouped arguments for mutations or queries.
• OneOf Input Objects - Implements OneOf input objects to enforce mutual exclusivity between distinct input fields.
• Asynchronous Event Streams - Delivers real-time data updates to clients via asynchronous event streams without requiring polling.
• GraphQL Type Generics - Supports generic parameters within GraphQL input type definitions to enable reusable data structures.
• GraphQL Interface Definitions - Creates common sets of fields that multiple object types implement to provide consistent APIs.
• Shared GraphQL Interfaces - Standardizes fields across multiple different object types using shared interfaces.
• API Performance Monitoring - Tracks latency, throughput, and health of GraphQL API endpoints using observability tools.
• Monitoring and Observability - Provides distributed tracing and telemetry exports to monitor API performance and debug requests.
• Trace Exporters - Transmits distributed trace data and metrics for API requests to external telemetry monitoring endpoints.
• Query Performance Monitoring - Captures distributed traces and metrics for each query step to analyze performance.
• Web Server Performance Monitoring - Tracks API execution through tracing and telemetry extensions to provide production observability.
• Federated External Fields - Marks fields as external to a subgraph and specifies required data during resolution.
• Cursor Pagination - Implements a standardized system of cursors and limits for paginating large datasets.
• Sequential Resolver Execution - Runs state-changing mutation operations sequentially to ensure a predictable order of execution.
• Federated Field Ownership - Controls which subgraph resolves a field using directives to share, override, or hide fields.
• Directive-Based Execution - Intercepts field resolution using directives to modify the behavior or the returned value of a field during execution.
• GraphQL Directive Definitions - Provides capabilities for defining custom directives that modify GraphQL execution or schema metadata.
• GraphQL Enum Mappings - Converts internal Rust enumeration types to GraphQL enums by mapping item names to constant case.
• GraphQL Input Type Definitions - Provides the ability to define complex object types used as arguments for queries and mutations.
• Custom Input Validators - Provides capabilities for executing user-defined business logic to validate GraphQL input values before processing requests.
• Execution Interception - Modifies the behavior of field resolvers during execution by intercepting the GraphQL lifecycle.
• Persisted Queries - Maps complex queries to short identifiers to reduce network bandwidth and parsing overhead.
• Request Lifecycle Hooks - Provides mechanisms to intercept and modify the GraphQL request processing pipeline at specific stages.
• Server Libraries - High-performance server-side library for Rust.

Historial de estrellas