graphql-dotnet/graphql-dotnet

Features

• GraphQL API Implementations - Provides a comprehensive toolkit for implementing server-side GraphQL interfaces using both code-first and schema-first approaches.
• Server Frameworks - Provides a comprehensive server-side toolkit for building and executing GraphQL APIs within .NET applications.
• DataLoader Batching Engines - Implements the DataLoader pattern to batch requests and cache results, eliminating N+1 query problems.
• Data Fetching Optimizations - Optimizes data retrieval by batching multiple requests into single calls to minimize database round-trips.
• GraphQL Type Definitions - Defines the schema by creating .NET classes that inherit from GraphType to declare fields and types.
• Code-First Mappings - Builds schemas using strongly-typed C# classes that inherit from base graph types to configure fields programmatically.
• Code-First Schema Builders - Offers a system for defining API structures using either programmatic code-first definitions or the GraphQL Schema Definition Language.
• Field-Level Middleware - Provides a middleware pipeline to intercept and wrap field resolution with custom logic via a provider.
• Field-Level Access Controls - Restricts access to specific types or fields based on defined security policies or user roles.
• GraphQL Authorization Frameworks - Includes a framework for enforcing field-level and scope-based access control within the GraphQL schema.
• Role-Based Access Control - Restricts access to schema types and fields based on assigned user roles.
• Tree Traversal - Implements a visitor pattern to traverse the abstract syntax tree and execute logic at specific nodes.
• Strongly-Typed Query Validation - Verifies request structure and semantics against the schema to ensure type safety and structural validity.
• GraphQL AST Parsing - Converts GraphQL query strings into abstract syntax trees using a lexer for subsequent execution.
• Dependency Injection - Utilizes dependency injection to decouple the framework's internal logic from specific container implementations.
• GraphQL Service Registrations - Integrates with .NET dependency injection for automatic schema resolution and scoped service management.
• Middleware Stack Resolution - Implements a middleware stack that wraps resolver execution to add cross-cutting behaviors.
• Observable Subscription Streams - Uses an asynchronous observer pattern to stream real-time data updates to clients with automated resource cleanup.
• Data Loader Batchers - Implements the DataLoader pattern to batch and cache multiple data requests, solving the N+1 query problem.
• Federation Engines - Includes a federation engine to compose multiple independent subgraphs into a single unified API gateway.
• Field Resolvers - Implements resolver methods that utilize source data and context to resolve nested fields in the data graph.
• GraphQL Request Processing - Executes queries and mutations by parsing documents and mapping them to the appropriate underlying data sources.
• GraphQL Schema Definitions - Enables the creation of data graphs using either a schema language or class-based inheritance.
• Schema-First Mapping - Implements the ability to parse schema definition language strings and map them to C# classes and resolvers.
• Code-First Schema Generators - Provides a programmatic way to generate GraphQL schemas directly from C# class definitions and annotations.
• GraphQL Subscriptions - Implements real-time data streaming by maintaining persistent connections that push updates to clients via subscriptions.
• Real-Time Data Streaming - Pushes live data updates from the server to connected clients using persistent observable streams.
• Cross-Request Data Caches - Enables data loaders to use persistent memory caches so fetched data persists across multiple requests.
• CLR Type Mappings - Automatically maps .NET system types like Guid and BigInt to corresponding GraphQL scalar types.
• Custom Scalars - Allows the definition of non-standard primitive data types with custom parsing and serialization.
• Scalar Serializers - Converts raw input values and AST literal nodes into typed values and vice versa.
• CLR Type Inference - Derives GraphQL field and argument configurations directly from the provided CLR system types.
• Type System Mappings - Maps codebase structures and system types to a formal GraphQL type system for input and output.
• Assembly Scanning Registrations - Automatically discovers and registers graph types by scanning assemblies for type mappings.
• Entity Reference Resolvers - Implements resolvers that fetch entities by their key fields to enable subgraph resolution in a federated architecture.
• Lambda-Based Mappings - Maps CLR properties and methods to GraphQL fields using lambda expressions for compile-time type safety.
• GraphQL Schema Behavior Plugins - Intercepts and transforms field and type execution logic based on schema directives.
• Request-Scoped Caching - Implements request-scoped caching to ensure repeated lookups within a single request return instantly.
• GraphQL Query Performance Optimizations - Optimizes API performance using document caching, field complexity analysis, and execution tracing.
• CLR Attribute Type Generation - Maps .NET classes to GraphQL types by interpreting attributes such as Name and OutputType on properties.
• Method-to-Field Resolvers - Creates GraphQL fields by invoking source methods and using their return values as field resolvers.
• Execution Lifecycle Listeners - Intercepts the execution lifecycle by hooking into specific events to log validation results.
• Native AOT Compilation - Supports execution in environments that forbid dynamic code generation through ahead-of-time compilation.
• Resolver Context Injection - Provides mechanisms to inject shared dependencies and metadata directly into field resolver functions.
• Dependency Resolver Interfaces - Provides abstractions that decouple schema and field resolution from specific dependency injection container implementations.
• GraphQL Resolver Contexts - Injects a security principal and execution context into resolvers to enable identity-based logic.
• Query Execution Timeouts - Provides mechanisms to limit the duration of specific GraphQL queries to prevent system resource exhaustion.
• Subgraph Architectures - Configures federation directives and entity resolvers to split a large data graph into smaller subgraph architectures.
• Execution Pipeline Interceptions - Provides delegates to intercept and modify execution options and results for custom timing or error logging.
• Schema-Auto-Resolved Executions - Executes GraphQL requests against a schema resolved automatically from dependency injection at runtime.
• Real-Time Message Push - Pushes real-time data updates from the server to clients to provide instant event notifications.
• Schema Ahead-Of-Time Compilations - Supports generating compiled schema code at build time for execution in JIT-less environments.
• GraphQL Type Resolvers - Defers GraphQL type resolution to runtime by allowing resolvers to return type references.
• Persisted Query Whitelists - Implements security whitelisting by storing query strings on the server and executing them via hash identifiers.
• Array Materialization Pooling - Utilizes shared array pooling to store query results, minimizing frequent memory allocations.
• Asynchronous Validators - Runs validation rules asynchronously to support remote authentication checks and external data lookups.
• Field Complexity Values - Allows assigning custom complexity impact values to individual fields for precise request cost measurement.
• External DI Container Integrations - Provides integration with third-party dependency injection containers to resolve types and services during execution.
• Graph Type Metadata - Provides interfaces to read and write custom metadata to GraphQL types, fields, and directives.
• GraphQL Subscription Cleanups - Automatically disposes of subscription resources and observers when a client terminates their connection.
• Query Complexity Calculators - Calculates total request complexity by aggregating custom weight values assigned to individual API fields.
• Composable Middleware Pipelines - Ships a configurable chain of middleware to handle cross-cutting concerns like logging and authorization during field resolution.
• Resolved Value Caching - Caches resolved objects during the request lifecycle to prevent redundant data fetching.
• Schema Directives - Attaches directives to schema elements to expose meta-information via introspection.
• External Schema Linkers - Links shared types and directives from other schemas using identifiers to reuse common definitions across federated services.
• Introspection Control - Controls the information returned during schema introspection to hide specific elements from clients.
• Automatic Dependency Registrations - Provides automated discovery and registration of service implementations within the DI container via assembly scanning.
• Service Lifetime Scopes - Allows the schema to be registered as a singleton, scoped, or transient for optimized performance.
• Validated Document Caches - Caches parsed ASTs and validation results in memory to skip processing for repeated identical requests.
• Validation Context Dependency Injection - Injects request-scoped service providers into the validation context to allow validation rules access to external services.
• Apollo Tracing Integrations - Instruments field execution and appends metrics compatible with the Apollo tracing specification to responses.
• Field - Tracks execution timing and performance metrics for individual GraphQL fields.
• Compile-Time Generators - Generates compiled code for schemas at build time to eliminate runtime reflection and support JIT-less environments.
• Concurrency Limits - Caps the maximum number of asynchronous field resolvers that can execute simultaneously to maintain system stability.
• Auto-Generated Graph Fields - Automatically generates GraphQL fields from the properties of a CLR type with support for field exclusion.
• Federation Schema Initializers - Configures schemas with the necessary types and directives to support specific versions of GraphQL Federation.
• Scoped Service Resolvers - Passes a request-specific service provider into execution options so resolvers can access scoped dependencies.
• Cross-Argument Constraint Validations - Enforces complex constraints across multiple arguments during the query validation stage.
• GraphQL Directive Definitions - Provides capabilities for defining custom directives that modify GraphQL execution or add schema metadata.
• Custom Logic Validators - Provides custom server-side logic to validate GraphQL input values against specific business rules.
• Auto-Generated Interface Types - Automatically generates GraphQL interface types from system interfaces while preserving inheritance hierarchies.
• Interface Inheritance - Supports hierarchical relationships where one GraphQL interface inherits fields from another.
• CLR Type Schema Construction - Constructs a complete GraphQL schema automatically from plain .NET classes using attributes for configuration.
• Execution Interception - Uses schema visitors to intercept and modify the behavior of field resolvers during execution.
• Execution Interceptors - Uses schema visitors to intercept and wrap field resolvers based on directives.
• GraphQL Schema Introspection - Exposes available types and fields to clients via a standard specification for tool discovery.
• Federated Composers - Composes multiple independent GraphQL schemas into a single unified gateway for distributed data sources.
• Persisted Queries - Supports storing query strings on the server to be executed via unique identifiers, reducing bandwidth and parsing overhead.
• ValueTask Execution Pipelines - Optimizes the execution pipeline using ValueTask to reduce memory allocations and increase high-throughput performance.
• GraphQL Tools - Implementation of the GraphQL specification.
• API Development - Core GraphQL implementation for the .NET ecosystem.
• NET GraphQL Tools - GraphQL implementation for .NET.

Historique des stars