graphql javascript react redux Technology typescript

State management with React Context, TypeScript, and GraphQL

Go to the profile of Lily Barrett

Uninterested in debugging sort errors in your state? Need up-to-date documentation in your React apps? Learn on!

Unwanted side effects of sort errors: Misplaced dev time and elevated irritability

Once I first encountered TypeScript, I felt an honest quantity of despair: Why did I’ve to put in writing what felt like extra boilerplate code? When utilizing it with React, why did I’ve to find out the kind of each single React prop, and the request and response objects for async calls? And what the hell have been intersection and union varieties?

After spending time working with TypeScript, nevertheless, I shortly fell in love with it. It saves me from losing time on dumb sort errors, supplies dynamic self-documentation, and makes it far simpler for my colleagues to know the expectations set for the code at first look.

My curiosity in TypeScript grew as I explored totally different approaches to state management in React purposes. I’m particularly enthusiastic about React’s new Context API, which I consider might be very highly effective, particularly when mixed with GraphQL and TypeScript.

In October, my pleasure composed itself into a chat for the Boston TypeScript meetup (for which I’m now additionally co-organizer), the place I coated my strategy to state management in React purposes with TypeScript.

However what about Redux?

However earlier than we get into all that: We have to speak briefly about Redux. It’s well-established, arguably the default state management sample for React by now. So why don’t we simply use it?

  • Relying in your software’s wants, Redux could be overly complicated/heavy-handed
  • You could not need to use all the Redux ecosystem, together with motion creators, reducers, and so forth.
  • You wind up with tons of boilerplate code

What’s the Context API and why do I care?

I began utilizing the Context API in some purposes over Redux this yr, and I discovered it elegant and quick to implement. The Context API is “an upgraded version of old concept of context in React which allow[s] components to share data outside the parent-child relationship,” Rakshit Soral aptly writes in “Everything You Need to Know About React’s Context API.”

My very own brief definition?

The Context API is a solution to share state and keep away from prop drilling (as of React 16.three). What all of it boils right down to is a clear, fairly solution to share info throughout your software with out sending it down by means of elements that don’t care about it.

My diagram of the Context API could also be over-simplified, although you’ll see there’s actually not an excessive amount of extra to it than this. You use a Supplier, which is the basis supply of data to all elements within the tree, and you additionally use a Shopper, whose duty includes taking knowledge or performance from the Supplier and feeding it on to the elements that require that info.

First, you’ve received React.createContext, which initializes and passes the context an preliminary worth. On this instance from the Context API docs, React.createContext returns an object with a Supplier and Shopper.

const Supplier, Shopper = React.createContext(defaultValue);

The Supplier within the under code — additionally from the docs — accepts a worth prop that represents the knowledge, knowledge, features, and so on., that get shared by way of context.

<MyContext.Supplier worth=/* some worth */>

The Shopper within the following instance — once more, from the docs — wraps a perform that takes in a worth from the Supplier and returns JSX within the type of elements which might be aware about the Supplier‘s information.

value => /* render something based on the context value */

What’s GraphQL and why do I care?

GraphQL, like React, was created by Fb. In contrast to REST, GraphQL makes use of only one single endpoint that lets you fetch knowledge by way of a number of queries directly. It lets you request solely the info you need, precisely whenever you need it.

As you’ll be able to see above, GraphQL additionally has a built-in sort system that helps present dynamic API self-documentation because the API grows and evolves. Even higher, you possibly can generate static varieties in your queries as a part of the Apollo tooling system.

Including GraphQL to your app

$ npm set up –save apollo-boost react-apollo graphql

Apollo Increase provides you a bunch of packages proper out of the field.

Getting a lift with Apollo

  • apollo-client is a caching GraphQL shopper that you should use with React (in addition to with Angular and different frameworks)
  • apollo-cache-inmemory is an ordinary, in-memory cache really helpful to be used with apollo-client
  • apollo-link-http merely fetches GraphQL outcomes from a GraphQL endpoint over an HTTP connection
  • graphql-tag exports the gql perform, which lets you write simply parseable strings for our queries and mutations

react-apollo incorporates bindings for utilizing apollo-client with React, and graphql is simply Fb’s reference implementation of GraphQL.

Configuring the Apollo shopper

Right here’s an instance from the React Apollo docs:

import ApolloClient from ‘apollo-client’;
import HttpLink from ‘apollo-link-http’;
import InMemoryCache from ‘apollo-cache-inmemory’;const shopper = new ApolloClient(
// By default, this shopper will ship queries to the `/graphql` endpoint on the identical host
// Cross the configuration choice uri: YOUR_GRAPHQL_API_URL to the `HttpLink` to hook up with a special host
hyperlink: new HttpLink(),
cache: new InMemoryCache(),

Right here, you import ApolloClient, HttpLink, and the InMemoryCache. In the event you’d choose to make use of a GraphQL endpoint aside from the default endpoint, which resides on the identical host because the shopper, HttpLink accepts a configuration object.

What this implies is, for instance, for those who’re utilizing a microservice that lives on a special host, you’ll cross in a customized config object in your GraphQL endpoint.

Subsequent, you wrap your root element in ApolloProvider, imported from react-apollo. This provides every element in your software entry to GraphQL by way of Apollo. The instance under can also be from the React Apollo docs:

import ApolloProvider from ‘react-apollo’;ReactDOM.render(
<ApolloProvider shopper=shopper>
<MyRootComponent />

Producing varieties with Apollo

$ npm i –save apollo-codegen

The package deal.json scripts I choose to make use of are under:

“introspect”: “apollo-codegen introspect-schema GRAPHQL_ENDPOINT –output PATH_TO_SCHEMA_FILE”,
// this fetches the schema and saves it in our challenge
“generate”: “apollo-codegen generate GLOB_PATH_TO_QUERY_FILES –schema PATH_TO_SCHEMA_FILE –target typescript –output PATH_TO_GENERATED_TYPES_FILE –add-typename –tag-name gql”,
// this generates sort interfaces from our schema
“typegen”: “npm run introspect && npm run generate”

In my introspect script, I’m calling apollo codegen introspect-schema with my endpoint and requesting GraphQL to output my schema information to a specified file.

My generate script seems at my auto-generated schema file and my queries and mutations and generates varieties for my queries and mutations.

And, lastly, my typegen script combines these two aforementioned scripts.

I run npm run typegen, and I’m good to go with my GraphQL varieties!

Please notice, once more: That is my most popular strategy. Everybody ought to, in fact, be happy to configure their package deal.json scripts nevertheless they really feel is greatest!

Demo time

I drank approach an excessive amount of espresso the opposite day and determined I needed to rebuild and rebrand Amazon.

Fortunately, I made a decision to start out small.

My companion simply moved to Philadelphia, and people have their very own lingo for numerous issues down there. Like this one:

Jawn: noun, mainly in japanese Pennsylvania, used to seek advice from a factor, place, individual, or occasion that one needn’t or can’t give a selected identify to.

My Jawn Retailer MVP ought to ultimately show an inventory of merchandise with their costs and give me the power so as to add issues to my cart. I also needs to have the ability to take away gadgets from my cart and see the up to date complete immediately.

Whereas I clarify tips on how to arrange React Context with GraphQL and TypeScript in the remainder of this text, it’s also possible to discover the complete supply code right here.

For my prototype, I’m utilizing Faker.js, a terrific library for producing pretend knowledge. Faker.js hosts a FakerQL endpoint, permitting me to get my pretend knowledge from a GraphQL endpoint. It presents me the next varieties to question:

For my functions, since I’m operating a retailer, I’ll be fetching knowledge by way of FakerQL for merchandise to promote.

My app additionally makes use of the next applied sciences:

  • TypeScript with Parcel.js, a bundler which helps TS proper out of the field
  • React’s Context API

Establishing my GraphQL shopper

Getting my retailer prepared for the grand opening!

My app already has all the required Apollo dependencies put in, and these scripts are included in my package deal.json:

“test”: “npm run test”,
“dev”: “parcel ./index.html”,
“introspect”: “apollo-codegen introspect-schema –output ./data/models/index.json”,
“generate”: “apollo-codegen generate ./data/**/*.ts –schema ./data/models/index.json –target typescript –output ./data/models/index.ts –add-typename –tag-name gql”,
“typegen”: “npm run introspect && npm run generate”,
“build”: “tsc”

You’ll discover using the FakerQL endpoint and a path to a knowledge folder the place I’m each auto-generating schema fashions and establishing my question varieties.

And right here’s the precise construction for my knowledge folder:

– knowledge
– formatters
– fashions
– queries

My formatters are features for calculating costs in several nations (already carried out). Once I run my introspect script, Apollo will output the schema into an index.json file in my fashions folder. All information within the modelsfolder will wind up being auto-generated.

Once I run my generate script, Apollo will take a look at my queries, in conjunction with the endpoint schema, and output the kinds onto an index.ts file in my fashions folder.

Subsequent, I have to create an occasion of ApolloClient so I can use its capabilities.

// ./index.tsx
import React from “react”;
import ApolloProvider from “react-apollo”;
import ApolloClient from “apollo-client”;
import HttpLink from “apollo-link-http”;
import InMemoryCache from “apollo-cache-inmemory”;const shopper = new ApolloClient(
hyperlink: new HttpLink(
uri: “”,
// Keep in mind, we solely want ONE endpoint!
cache: new InMemoryCache(),
);class App extends React.Element
public render ()
// App contents

Identical to within the instance we noticed earlier than, we’re utilizing ApolloClient, HttpLink, and the InMemoryCache. I’m passing in a URI configuration object with the FakerQL endpoint.

I’m additionally making certain that the basis element is wrapped in ApolloProvider, and that each one elements within the tree can subsequently reap the benefits of GraphQL.

Let’s get right down to enterprise: I want a question to fetch all of the merchandise by way of FakerQL. I want to have a file for every question in my knowledge folder.

// knowledge/queries/JAWN_QUERY.tsimport gql from “graphql-tag”;export default gql`
question FindJawnProducts
// The FakerQL docs inform me I can question “allProducts” and get a
record of merchandise again
// I am additionally specifying the fields I would like returned for every
Product: id, identify, worth


Right here, I’m utilizing gql to drop my question into an simply readable string. Once I take a look at the FakerQL docs, they inform me I can question allProducts and specify the above fields — amongst others — to be returned for every product.

Once I run npm run typegen, listed here are the kinds that get generated:

export interface FindJawnProducts_allProducts
__typename: “Product”;
id: string;
identify: string;
worth: string;
export interface FindJawnProducts null)[]

FindJawnProducts_allProducts represents the sort for a person venture or merchandise, and FindJawnProducts is the sort for an array or listing of merchandise in our retailer. These varieties shall be helpful for establishing our context and typing elements that wind up profiting from this knowledge.

Earlier than I get our elements utilizing knowledge from GraphQL, I cease to ask myself: What different info do I would like apart from the product particulars fetched from FakerQL?

Because it seems, I need to help two totally different markets: the U.S. and the U.Okay.

So as to present the right calculations for product costs, I want my elements to concentrate on my market. On this case, I’ll cross the market down as a prop into the basis element.

class App extends React.Element
public render ()
const market = this.props;
return (
<ApolloProvider shopper=shopper>
<Container fluid>
<Col xs=12 sm=6>
<JawnList market=market/>
<Col xs=12 sm=6>
<Cart market=market/>

const HotApp = scorching(module)(App);
render(<HotApp market=”US” />, doc.getElementById(“root”));

However I don’t need to drill props down from the basis element simply to offer consciousness about my market.

I even have two elements — JawnList and Cart — that probably have to know concerning the merchandise I’m fetching from my API, however I don’t need to move that knowledge down as a prop, both.

My causes? Prop drilling can get extremely messy as your software will increase in measurement. My MVP might develop right into a a lot greater app, and I don’t need to wind up passing particulars down by means of elements that don’t care about them.

Enter the Context API!

Context API magic!

I create a file referred to as JawnContext.tsx, the place I outline and create my context for the appliance:

That is the place the Apollo-generated varieties will begin to come in useful. Cart shall be an array of FakerQL merchandise. addToCart will absorb a FakerQL product as an argument and add it to the Cart. removeFromCart will do precisely what it feels like. And, lastly, the market may be typed as both “US”or “UK”.

Then, React.createContext works its magic! (null, by the best way, is my default worth for the context).

Subsequent, let’s hook up my context to my root element.

You’ll discover that App is typed to JawnState — the context sort — since one of many element’s props is market, which I now need to derive from context.

You’ll additionally discover that I’m wrapping the element with JawnContext.Supplier and its worth object, which accommodates the values of every of the context properties — the implementations of addToCart and removeFromCart, the market handed into the basis, and the present state of the cart.

Shifting on to the shoppers: That is private choice right here — some people favor to create new features to wrap every consuming element — however I need to arrange a reusableWithJawnContext supplier right here so I can simply compose it with the GraphQL supplier and the consuming element each time vital.

Right here, my Props prolong JawnState, the sort for the context, and the perform accepts a React element as a toddler. It’s then returning a toddler, wrapped by JawnContext.Shopper, which spreads the given props and context state inside it.

To permit JawnList to efficiently eat my context in a type-safe style, I have to outline JawnListType as a toddler that mixes attributes from the JawnState context and GraphQL’s autogenerated knowledge sort, FindJawnProducts.

This provides me entry to the info from my GraphQL endpoint, in addition to the market and addToCart from my context.

On the backside of the above code, you’ll see I’ve created a perform to make the required GraphQL question for the product knowledge. I’m composing that with the withJawnContext supplier and my element. React Apollo provides meChildDataProps, the generic sort for a element wrapped by ApolloProvider.

Equally, I want to permit Cart to eat the context.

Right here, I’m composing the withJawnContext supplier with Cart — typed to JawnState— which provides me entry to market, cart, and removeFromCart from context.

And that’s about it! My software permits customers so as to add and take away gadgets from their carts and view up to date complete costs, and I get to keep away from prop-drilling throughout my software. I win!


  • Apollo helps us question a single endpoint and generate GraphQL varieties for our schema, queries, and mutations
  • The Context API, working collectively with TypeScript, offers a type-safe, light-weight strategy to share state and knowledge with out drilling down props

A model of this text was initially revealed on You will discover the complete supply code for the Jawn Retailer right here.

Further helpful assets: