graphql-hive/graphql-yoga

Features

• Operation Execution - Provides a specialized handler for executing GraphQL queries, mutations, and subscriptions with support for incremental delivery.
• GraphQL APIs - Provides a full-featured framework for hosting and executing GraphQL APIs by connecting schemas to request handlers.
• Server Implementations - Provides a comprehensive framework for building GraphQL server endpoints and managing request execution.
• Federated Data Gateways - Functions as a federation gateway that routes requests across multiple subgraphs using a supergraph schema.
• Cloud Deployment Platforms - Deploys across various hosting environments, including serverless functions and platform-as-a-service providers.
• Cross-Runtime Deployments - Enables API deployment across diverse JavaScript environments like Node.js, Deno, and Bun using a standardized fetch-based configuration.
• Deno Runtime Support - Runs a server on the Deno runtime utilizing a platform-agnostic HTTP handler based on the Fetch API.
• Multi-Transport Real-time Layers - Supports both WebSockets and Server-Sent Events to stream real-time data based on client capabilities.
• Universal Server Runtimes - Implements a platform-agnostic runtime layer that ensures consistent execution across serverless and edge environments.
• Request Validation - Ensures incoming requests adhere to HTTP specifications and enforces security rules on request body parameters.
• Runtime Agnostic Architectures - Uses web-standard Fetch APIs to decouple server logic from specific JavaScript runtimes.
• Federation Engines - Implements an Apollo Federation gateway and subgraph architecture to compose multiple services into a unified API.
• Server Frameworks - Provides a full-featured framework for constructing the server-side implementation of GraphQL APIs.
• GraphQL Execution Engines - Executes GraphQL operations against any valid schema object independently of the library used to construct it.
• Schema Definitions - Supports defining GraphQL types and relationships using both schema-first and code-first approaches.
• Schema-Agnostic Execution - Executes GraphQL operations against any schema object, regardless of the library used to construct it.
• GraphQL Subscriptions - Implements server-side GraphQL subscriptions for real-time data streaming via WebSockets and SSE.
• Real-Time Data Streaming - Implements application-level streaming to push live server-side data updates to clients via subscriptions.
• Environment Runtime Adapters - Integrates with any HTTP environment by using adapters to map requests and responses to standard Web API objects.
• Request Handling - Uses standard Web Fetch API request and response objects to ensure compatibility across diverse JS runtimes.
• Spec-Compliant GraphQL Servers - Provides a spec-compliant environment for hosting GraphQL APIs with support for subscriptions and directives.
• Web Framework Adapters - Provides adapters to map environment-specific requests to a unified handler for integration with various web frameworks.
• Query Complexity Analysis - Protects the API from resource exhaustion by capping the depth and cost of incoming GraphQL operations.
• Interactive Query Development - Provides an integrated in-browser environment for iteratively writing, validating, and testing GraphQL queries.
• Fastify Integrations - Connects to the Fastify framework to leverage its plugin ecosystem and request handling capabilities.
• Subscription Connection Managers - Supports the configuration of custom servers to manage persistent WebSocket connections for real-time updates.
• AST Caching - Caches Abstract Syntax Trees (ASTs) of GraphQL documents to avoid redundant parsing and validation.
• Query Result Caching - Caches query results to return identical responses for repeating requests and reduce server-side processing.
• Query Output Caches - Stores the final results of GraphQL query operations to reduce database load and improve response times.
• Distributed Event Synchronization - Integrates external datastores like Redis or Kafka to synchronize event streams across multiple server instances.
• Query Persistence Engines - Implements query persistence using hashes to minimize network traffic by avoiding the upload of full documents.
• Frontend API Mocking - Generates synthetic data based on the GraphQL schema to facilitate frontend development.
• GraphQL Integrated Development Environments - Ships an integrated development environment for writing, testing, and documenting GraphQL APIs in the browser.
• Serverless Function Runtimes - Integrates the server into managed environments by mapping cloud events to standard web requests.
• Serverless Deployment - Enables deployment to event-driven cloud environments using standard web request and response objects.
• Middleware-Based Request Pipelines - Processes requests through a modular pipeline of plugins that hook into the HTTP and execution lifecycles.
• Real-time Data Subscriptions - Delivers real-time GraphQL subscription updates using Server-Sent Events over standard HTTP.
• Real-time Event Streams - Streams real-time GraphQL subscription data to clients using the WebSocket protocol.
• Server-Sent Events - Streams real-time GraphQL subscription data to clients using Server-Sent Events over standard HTTP.
• Persisted Operation Enforcement - Prevents the execution of arbitrary GraphQL documents by requiring clients to send hashes of predefined operations.
• Operation Whitelisting - Limits the server to executing only a predefined set of hashed operations to prevent unauthorized queries.
• Error Handling Security - Hides unexpected server errors from clients to prevent the leakage of internal system details.
• GraphQL Security - Protects APIs using complexity and depth analysis, internal error masking, and persisted operation enforcement.
• Event Bus Management - Provides a built-in event bus with support for type-safe channels to publish and subscribe to event topics.
• Next.js Integrations - Integrates as a custom route handler to serve requests within a Next.js application environment.
• Custom Middleware Implementations - Allows the integration of custom logic into the request pipeline via global or endpoint-specific middleware.
• Plugin-Based Logic Extensions - Extends server capabilities such as federation and tracing by integrating external middleware into the execution pipeline.
• Introspection Control - Prevents reverse-engineering of the API schema by blocking introspection queries for unauthorized actors.
• Hook-Based Plugin Systems - Provides hooks into the HTTP and execution lifecycles to allow custom plugins to manipulate requests and responses.
• Pipeline Plugins - Integrates external plugins into a functional pipeline to provide capabilities like rate limiting, caching, and monitoring.
• Validation Caching - Stores parsed documents and validation outcomes in a shared cache to eliminate redundant processing.
• Distributed Tracing - Injects metrics into requests to enable distributed tracing across a federated architecture.
• Cache Invalidation Utilities - Implements mechanisms to clear cached query results automatically via mutations or manual entity targeting.
• Message Masking - Controls whether internal errors from downstream subgraphs are hidden or exposed to the client.
• Express Integrations - Integrates as middleware within an Express application to manage requests alongside other HTTP routes.
• Supergraph Registry Syncing - Automatically fetches and updates the supergraph from a registry via background polling to keep the schema current.
• Schema Explorers - Provides a mechanism for clients to query the server for its schema definition to aid API exploration.
• Incremental GraphQL Delivery - Allows sending critical results immediately and delivering slower fields in subsequent responses.
• NestJS Integrations - Runs a server within a NestJS application using a dedicated driver for standalone APIs.
• REST APIs - Exposes GraphQL queries, mutations, and subscriptions as a standard RESTful API.
• Server Bootstrapping - Provides a streamlined way to bootstrap a runnable GraphQL API environment by combining schemas and resolvers.
• Web Framework Integrations - Binds the GraphQL handler to existing web servers by mounting it as middleware on specific routes.

Star history