feed_item

Video

What Is GraphQL? Video

Course

GraphQL Odyssey Course

post

What is GraphQL? GraphQL introduction

Why use GraphQL?

Docs

Full Stack GraphQL Tutorial

Glossary

GraphQL Glossary

GraphQL FAQ

GraphQL is becoming more and more prevalent in the tech world. You might be wondering what exactly GraphQL is. This collection provides a variety of resources that will help you learn and build with GraphQL.

What Is GraphQL?

Code

Apollo GraphQL Android Client

Intro to the Android Apollo SDK

Panel

Apollo-Android: a Journey to Kotlin Multiplatform

Talk

Take Control Of Your APIs With GraphQL

Podcast

GraphQL and Apollo with GDE Mike Nakhimovich

Blog Post

Exploring GraphQL with Coroutines on Android

Add GraphQL to Your Jetpack Compose Apps

Consume your GraphQL API on Android Devices with Apollo Android. Apollo Android is a GraphQL client that generates type-safe Kotlin models from your GraphQL queries. It also handles parsing and caching so you can focus on what matters most to your users and build beautiful mobile apps.

GraphQL for Android

The Apollo CLI

Apollo Client Devtools

Apollo Extension for VS Code

Apollo Config API

Stream

Apollo Configuration Deep Dive

Building a Portable Apollo Server Config

GraphQL Code Generator

CI/CD for GraphQL

How to Build and Run Queries in Apollo Explorer

Build and Run GraphQL Operations with the Apollo Explorer

One of the many benefits of adopting GraphQL is the ever growing eco-system of tools and services available to help you build your apps even faster. From code-gen to configuring Apollo Server, this collection has a range of tools, tips, and configuration best practices designed to boost your productivity.

GraphQL Tooling and  Code-gen

Intro to Apollo Client 3.0

Demystifying Cache Normalization

Guide

A Quick Overview of Cache Normalization in Apollo Client

Previewing the Apollo Client 3 Cache

Dispatch This: Using Apollo Client 3 as a State Management Solution

Local State Management with Reactive Variables

What are Reactive Variables in Apollo Client 3

What are Type Polices in Apollo Client 3

Apollo Client & Client-side Architecture Basics

A Treatise on State

State management is about caching the data you need to provide experiences for your users. Apollo Client is both a GraphQL client and a state management library. In this collection, you’ll learn how to use the latest version of Apollo Client as your single source of truth for state in client-side UI libraries like React.

Caching & State Management with Apollo Client

Principled GraphQL – An Opinionated Guide to Data Graphs

Announcing the GraphQL at Enterprise Scale Guide [Free Ebook]

Tutorial

Designing GraphQL Schemas

Refactoring Your GraphQL Schema

GraphQL Schema Design: Building Evolvable Schemas

A Battle Tested Guide for Backend Developers

GraphQL In Production Panel – GraphQL Summit 2020

Get Started with Apollo Studio

Manage Your Schema with Apollo Studio

Analyzing Your Graph’s Performance with Tracing

Who’s Using My Graph?

Register Schema Changes Automatically with Schema Reporting

View Your Graph History and Schema Changes with Apollo Studio

Introducing Schema Change Notifications with Apollo Graph Manager

Schema Checks: Introducing the New GraphQL CI Tool In Apollo Studio

User roles are now available in Apollo Studio

Book

Production Ready GraphQL

Advanced GraphQL Course

Putting your data graph into production doesn&#8217;t have to be a guessing game or scary experience. This collection is composed of written and video resources focused on stability, monitoring, schema management, schema design, and best practices.

Production Ready Graphs

Apollo Federation

Announcing managed federation

Getting Started with Apollo Federation

Your First Federated Schema with Apollo Server

Setting Up Federation in Apollo Studio

Apollo Federation Docs

Setting Up Authentication and Authorization with Apollo Federation

Using Apollo Federation with Local Schemas

Federation Panel – GraphQL Summit 2020

Apollo Federation With Jesse Rosenberger, Engineering Manager @ Apollo

GraphQL and Federation at StockX

Project Constellation; The Future of Federation

It can be challenging to serve an enterprise-scale data graph with a single, monolithic GraphQL server. To keep teams productive, you can use Apollo Federation to divide your graph’s implementation across multiple composable services. Learn about federation principles, tooling, and how to implement federation.

Federation 101

A guide to authentication in GraphQL

Authorization in GraphQL

Authentication in Apollo Client

Authentication in Apollo Server

How to Auth: Secure a GraphQL API with Confidence

The Ultimate Guide to handling JWTs on frontend clients (GraphQL)

When building a GraphQL endpoint, you’ll probably have to face the question of how to control who can see and interact with the data in your API. This typically involves authentication (determining who you are) and authorization (determining if you have access). In this collection, we’ll cover strategies and best practices for both.

Auth

Full Stack Error Handling with GraphQL and Apollo 🚀

200 OK! Error Handling in GraphQL

Error Handling in Apollo Server

Handle and Inspect Errors with the Error Link

Video Walkthrough of Error Handling with Apollo Link

Handling GraphQL Errors in React

Using the Error Link to Manage Authentication Errors in React

At Apollo, we’ve heard a lot of desire from GraphQL developers for more guidance on how to do error handling. Learn how to communicate errors to your client in an organized way, and open up new possibilities for tooling.

Error Handling with Apollo

that issue has been fixed now I can fetch response headers below is the solution
let client: ApolloClient = { 
// The cache is necessary to set up the store, which we’re going 
// to hand to the provider 
let cache = InMemoryNormalizedCache() 
let store = ApolloStore(cache: cache)
let client = URLSessionClient() 
let provider = CustomInterceptorProvider(store: store, client: client) 
let url = URL(string: “graphql link”)!
let requestChainTransport = RequestChainNetworkTransport( 
interceptorProvider: provider, 
endpointURL: url 
)
// Remember to give the store you already created to the client so it 
// doesn’t create one on its own 
return ApolloClient(networkTransport: requestChainTransport, store: store) 
}()
struct CustomInterceptorProvider: InterceptorProvider { 
private let store: ApolloStore 
private let client: URLSessionClient
<pre><code>init(store: ApolloStore, client: URLSessionClient) {
 self.store = store
 self.client = client
}

func interceptors&lt;Operation: GraphQLOperation&gt;(for operation: Operation) -&gt; [ApolloInterceptor] {
 return [
 MaxRetryInterceptor(),
 CacheReadInterceptor(store: self.store),
 NetworkLoggerInterceptor(),
 RequestLoggingInterceptor(),
 NetworkFetchInterceptor(client: self.client),
 ResponseLoggingInterceptor(),
 ResponseCodeInterceptor(),
 JSONResponseParsingInterceptor(),
 AutomaticPersistedQueryInterceptor(),
 CacheWriteInterceptor(store: self.store)
 ]
}
</code></pre>
}
final class NetworkLoggerInterceptor: ApolloInterceptor { 
public var id: String = UUID().uuidString
<pre><code>func interceptAsync&lt;Operation&gt;(
 chain: RequestChain,
 request: HTTPRequest&lt;Operation&gt;,
 response: HTTPResponse&lt;Operation&gt;?,
 completion: @escaping (Result&lt;GraphQLResult&lt;Operation.Data&gt;, Error&gt;) -&gt; Void
) where Operation : GraphQLOperation {
 if let token = AccountService.shared.getAccessToken() {
 request.addHeader(name: "Authorization", value: "Bearer \(token)")
 }
 
 print("Outgoing request: \(request)")
 
 chain.proceedAsync(
 request: request,
 response: response,
 interceptor: self
 ) { result in
 print("Incomming respone :\(result)")
 
 // Handle the Result
 switch result {
 case .success(let graphQLResult):
 completion(.success(graphQLResult))
 case .failure(let error):
 if let responseCodeError = error as? ResponseCodeInterceptor.ResponseCodeError {
 switch responseCodeError {
 case .invalidResponseCode(_, let rawData):
 self.handleAuthenticationFailure(data: rawData)
 }
 }else {
 self.showrGlobalAlert(errorMessage: error.localizedDescription)
 }
 }
 completion(result)
 }
}

private func handleAuthenticationFailure(data: Data?) {
 if let finalData = data {
 do {
 let apiError = try JSONDecoder().decode(APIError.self, from: finalData)
 print("Error Message: \(apiError.message)")
 print("Error Code: \(apiError.code)")
 print("Error Details: \(apiError.details)")
 self.showAPIErrorGlobalAlert(apiError)
 } catch {
 print("Failed to decode error JSON: \(error.localizedDescription)")
 }
 }
}

private func showAPIErrorGlobalAlert(_ apiError: APIError) {
 DispatchQueue.main.async {
 if let topController = UIApplication.shared.windows.first?.rootViewController {
 if let presentedVC = topController.presentedViewController {
 presentedVC.dismiss(animated: true) {
 self.showAPIErrorGlobalAlert(apiError)
 }
 }else {
 topController.errorAlert(title: "Error", message: apiError.details)
 if apiError.code == "SESSION_EXPIRED" || apiError.code == "UNAUTHENTICATED" || apiError.code == "INVALID_TOKEN" {
 if let appDelegate = UIApplication.shared.delegate as? AppDelegate {
 appDelegate.navigateToLoginAfterLogout()
 }
 }
 }
 }
 }
}

private func showrGlobalAlert(errorMessage: String) {
 DispatchQueue.main.async {
 if let topController = UIApplication.shared.windows.first?.rootViewController {
 if let presentedVC = topController.presentedViewController {
 presentedVC.dismiss(animated: true) {
 self.showrGlobalAlert(errorMessage: errorMessage)
 }
 }else {
 topController.errorAlert(title: "Error", message: errorMessage)
 }
 }
 }
}
</code></pre>
}
class RequestLoggingInterceptor: ApolloInterceptor {
<pre><code>public var id: String = UUID().uuidString

func interceptAsync&lt;Operation: GraphQLOperation&gt;(
 chain: RequestChain,
 request: HTTPRequest&lt;Operation&gt;,
 response: HTTPResponse&lt;Operation&gt;?,
 completion: @escaping (Result&lt;GraphQLResult&lt;Operation.Data&gt;, Error&gt;) -&gt; Void
) {
 print("Outgoing request: \(request)")
 chain.proceedAsync(
 request: request,
 response: response,
 interceptor: self,
 completion: completion
 )
}
</code></pre>
}
class ResponseLoggingInterceptor: ApolloInterceptor { 
enum ResponseLoggingError: Error { 
case notYetReceived 
}
<pre><code>public var id: String = UUID().uuidString

func interceptAsync&lt;Operation: GraphQLOperation&gt;(
chain: RequestChain,
request: HTTPRequest&lt;Operation&gt;,
response: HTTPResponse&lt;Operation&gt;?,
completion: @escaping (Result&lt;GraphQLResult&lt;Operation.Data&gt;, Error&gt;) -&gt; Void
) {
 defer {
 // Even if we can't log, we still want to keep going.
 chain.proceedAsync(
 request: request,
 response: response,
 interceptor: self,
 completion: completion
 )
 }

 guard let receivedResponse = response else {
 chain.handleErrorAsync(
 ResponseLoggingError.notYetReceived,
 request: request,
 response: response,
 completion: completion
 )
 return
 }

 if let httpResponse = response?.httpResponse {
 self.logResponseDetails(httpResponse: httpResponse)
 }
}

private func logResponseDetails(httpResponse: HTTPURLResponse) {
 let statusCode = httpResponse.statusCode
 let headers = httpResponse.allHeaderFields
 
 if let accessToken = headers["x-access-token"] as? String {
 AccountService.shared.setAccessToken(token: accessToken)
 }
}
</code></pre>
} but In this I am getting response twice in controller can some one help?

ankit shelar

Getting response nil

Champ Meetup - Introducing Rhai: Elevating Router Scripts with Unit Testing

Liz Hennessy

Learn the basics of GraphQL with Java and Netflix's Domain Graph Service (DGS) framework

Intro to GraphQL with Java & DGS

Apollo Connectors: Blazing-Fast Integration with REST APIs

Enhance customer experiences with Apollo GraphOS

Apollo Developer Hub

Explore our resources

Not sure where to start? We've got multiple ways to learn.

Docs

Odyssey

Blog

Community

Events

Apollo Collections

Looking for resources on federation, caching, or other special topics? We've grouped our favorite posts, videos, tutorials, and docs into collections to help you solve common GraphQL challenges.