📄️ Overview: GraphQL Error Handling
A 12-class course that collects everything about GraphQL error handling in one place: the spec's error model, transport rules, design patterns, real company implementations, and the true-nullability work that is changing the defaults.
📄️ Class 1: The GraphQL Error Model
What the GraphQL specification actually defines about errors: request errors vs execution errors, the anatomy of an error, partial results as a guaranteed feature, and the gaps the spec leaves open on purpose.
📄️ Class 2: Error Propagation and the Ambiguous Null
How Non-Null types make errors destroy data they never touched, why every null in a GraphQL response means two possible things, and what the nullable-by-default guidance actually costs.
📄️ Class 3: GraphQL over HTTP: Status Codes and Media Types
What the GraphQL-over-HTTP specification says about status codes: the 2xx rules, the new 294 Partial Success code, when 4xx and 5xx are correct, why the media type your server sends changes everything, and where errors land when @defer and @stream split the response.
📄️ Class 4: An Error Taxonomy and extensions.code
Why error messages are not an API, how to classify GraphQL errors along fault and retriability axes, and how to design a stable extensions.code vocabulary, with the Apollo Server and Netflix DGS conventions as examples.
📄️ Class 5: Errors as Data
Expected business outcomes belong in the schema, not the errors list: union result types, error interfaces, the userErrors list, the trade-offs of each design stage, and the line this course draws between outcomes and failures.
📄️ Class 6: Server Implementation in Spring GraphQL
Wiring error codes and the errors-as-data pattern into a Spring for GraphQL server: exception resolvers, masking by default, batch loader and subscription errors, correlation IDs, testing, federation, and how DGS, Apollo Server and Hot Chocolate compare.
📄️ Class 7: Client-Side Error Handling
What Apollo Client, urql, and Relay each do with a response carrying data and errors: error policies, the error link, CombinedError, Relay's @catch and @throwOnFieldError, the JVM pair of Spring's GraphQlClient and Apollo Kotlin, honest partial-data UI, and what error nulls do to normalized caches.
📄️ Class 8: Where Error Handling Is Going: True Nullability
Semantic nullability, the @semanticNonNull migration bridge, and the proposed onError request property with its PROPAGATE, HALT, and NULL error behaviors: the specification work that finally separates 'can this be absent' from 'how far do errors spread'.
📄️ Class 9: Case Study: Shopify
The userErrors pattern at its source: how Shopify's Admin API splits system failures from business outcomes, how the pattern grew typed codes and the DisplayableError interface, and which parts generalize beyond Shopify's scale.
📄️ Class 10: Case Study: GitHub and GitLab
Two public GraphQL APIs at comparable scale, two opposite error philosophies: GitHub's top-level errors with a nonstandard type key, and GitLab's contributor-enforced errors-as-data rules, compared on machine-readability, discoverability, and documentation.
📄️ Class 11: Case Study: Meta/Relay and Netflix DGS
Where semantic nullability actually came from: the Relay team's decade with the ambiguous null, told from public talks and docs, plus Netflix DGS as a framework that ships error classification as a default.
📄️ Class 12: Guidelines: A Decision Framework
The whole course folded into one decision path, twenty consolidated guidelines with their sources, a migration sequence for existing schemas, and the master reading list.