Definition Defining your schema
Root Types Root types are the entry points for queries, mutations and subscriptions.
Generators Use Rails generators to install GraphQL and scaffold new types.
Introspection GraphQL has an introspection system that tells about the schema.
Lazy Execution Resolvers can return "unfinished" results that are deferred for batch resolution.
Parsing GraphQL Schema Definition Language into a Ruby Schema Defining a schema from a string or .graphql file
Dynamic types and fields Using different schema members for each request
Object Identification Working with unique global IDs
Executing Queries Evaluate GraphQL queries with your schema
Ahead-of-Time AST Analysis Check incoming query strings and reject them if they don't pass your checks
Phases of Execution The steps GraphQL takes to run your query
Complexity & Depth Limiting query depth and field selections
Timeout Cutting off GraphQL execution
Multiplex Run multiple queries concurrently
Lookahead Detecting child selections during field resolution
Tracing Observation hooks for execution
Backtrace Annotations Use the GraphQL backtrace for debugging
Response Extensions Adding "extensions" to the response hash
Instrumentation Wrap query execution with custom logic
Objects Objects expose data and link to other objects
Scalars Scalars are "simple" data types like integers and strings
Enums Enums are sets of discrete values
Input Objects Input objects are sets of key-value pairs which can be used as field arguments.
Interfaces Interfaces are lists of fields which objects may implement
Unions Unions are sets of types which may appear in the same place (but don't share fields).
Lists Ordered lists containing other types
Non-Null Types Values which must be present
Extending the GraphQL-Ruby Type Definition System Adding metadata and custom helpers to the DSL
Directives Special instructions for the GraphQL runtime
Field Extensions Programmatically modify field configuration and resolution
Overview Overview of GraphQL authorization in general and an intro to the built-in framework.
Visibility Programatically hide parts of the GraphQL schema from some users.
Authorization During execution, check if the current user has permission to access retrieved objects.
CanCan Integration Hook up GraphQL to CanCan abilities
Pundit Integration Hook up GraphQL to Pundit policies
Scoping Filter lists to match the current viewer and context
Introduction Implement fields and resolvers with the Ruby DSL
Arguments Fields may take arguments as inputs
Resolvers Reusable, extendable resolution logic for complex fields
Validation Rails-like validations for arguments and fields
Limits Always limit lists of items
Mutation Root The Mutation object is the entry point for mutation operations.
Mutation Classes Use mutation classes to implement behavior, then hook them up to your schema.
Mutation errors Tips for handling and returning errors from mutations
Mutation authorization Checking permissions for mutations
Errors in GraphQL A conceptual introduction to errors in GraphQL
Top-level "errors" The top-level "errors" array and how to use it.
Error Handling Rescuing application errors from field resolvers
Type Errors Handling type errors
Overview Introduction to pagination in GraphQL
Connection Concepts Introduction to Connections
Using Connections Pagination with GraphQL-Ruby's built-in connections
Custom Connections Building & using cursor-based connections in GraphQL-Ruby
Cursors Advancing through lists with opaque cursors
Stable Relation Connections Advanced pagination for ActiveRecord
RangeAdd helper for mutations A helper for Relay's RANGE_ADD operations
Overview Getting started with the Fiber-based Dataloader
Sources Batch-loading objects for GraphQL::Dataloader
Dataloader The Dataloader orchestrates Fibers and Sources
Dataloader vs. GraphQL-Batch Comparing and Contrasting Batch Loading Options
Testing Tips for testing Dataloader implementation
Non-Blocking Data Loading for GraphQL Using Dataloader to fetch external data in parallel
Overview Introduction to Subscriptions in GraphQL-Ruby
Subscription Classes Subscription resolvers for pushing updates to clients
Subscription Type The root type for subscriptions
Triggers Sending updates from your application to GraphQL
Broadcasts Delivering the same GraphQL result to multiple subscribers
Implementation Subscription execution and delivery
Action Cable Implementation GraphQL subscriptions over ActionCable
Pusher Implementation GraphQL subscriptions over Pusher
Ably Implementation GraphQL subscriptions over Ably
Multi-Tenant Switching tenants in GraphQL Subscription execution
GraphQL::Pro Home Overview of GraphQL::Pro features
Installation Get started with GraphQL::Pro
Dashboard Installing GraphQL-Pro's Dashboard
Encrypted, Versioned Cursors and IDs Increased opacity and configurability for Relay identifiers
Overview Learn how persisted queries work and how OperationStore implements them.
Getting Started Add GraphQL::Pro::OperationStore to your app
ActiveRecord Backend Storing persisted queries with ActiveRecord
Redis Backend Storing persisted queries with Redis
Client Workflow Add clients to the system, then sync their operations with the database.
Server Management Tips for administering persisted queries with OperationStore
Access Control Manage authentication & visibility for your OperationStore server.
Overview What is @defer, and why use it?
Server Setup Configuring the schema and server to use @defer
Usage Using @defer on the client side
Stream Using @stream to receive list items one at a time
Rate Limiters for GraphQL Manage access to your GraphQL API
Configuring Redis Preparing the rate limiter backend
Active Operation Limiter Limit the number of concurrent GraphQL operations
Runtime Limiter Limit the total runtime of a client's GraphQL Operations
GraphQL ObjectCache A server-side cache for GraphQL-Ruby
Schema Setup Prepare your schema to serve cached responses
Caching Results Configuration options for caching objects and fields
Redis Configuration Setting up the Redis backend
Runtime Considerations Settings and observability per-query
API Versioning for GraphQL-Ruby Evolve your schema over time, feature-by-feature
Installing Changesets Adding Changesets to your schema
Defining Changesets Creating a set of modifications to release in an API version
Releasing Changesets Associating changes to version numbers
Apollo Subscriptions GraphQL subscriptions with GraphQL-Ruby and Apollo Client
Relay Subscriptions GraphQL subscriptions with GraphQL-Ruby and Relay Modern
urql Subscriptions GraphQL subscriptions with GraphQL-Ruby and urql
AST Visitor Analyze and modify parsed GraphQL code
Overview Testing a GraphQL system
Schema Structure Make sure that your schema changes are backwards-compatible
Integration Tests Run the whole GraphQL stack in tests
Development Hacking on GraphQL Ruby
Getting Started Start here!
Related Projects Code, blog posts and presentations about GraphQL Ruby