Learn Apollo, Jspm and Nightmare

GraphQL is a fan favorite for good reason. It lets a client make specific, complex, and/or aggregate queries for data, and it’s user-friendly to boot.

If you’ve been meaning to learn GraphQL and start harnessing its powers, this is a great place to start.

This course is for GraphQL newbies with a basic understanding of React. It focuses on the client-side implementation of GraphQL usage using the Apollo client.

We’ll start with a guide on how to add the Apollo client to an existing project, then move on using the Query and Mutation components to fetch and manipulate data using a GraphQL API.

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

GraphQL Data in React with Apollo Client

Nightmare is a high-level browser automation library.

The goal is to expose just a few simple methods, and have an API that feels synchronous for each block of scripting, rather than deeply nested callbacks. It's designed for automating tasks across sites that don't have APIs.

nightmare

Many pages you'll want to grab data from will require you to log in first. This video demonstrates how to log in and grab whatever data off the page you will need.

Scraping Data from Sites with Login Forms with Nightmare

Many websites have more than just simple static content. Dynamic content which is rendered by JavaScript requires browser to be able to scrape data. This video demonstrates how to use Nightmare (which is a wrapper around Electron) to launch a url and scrape dynamic data.

Scraping Dynamic JavaScript Websites with Nightmare

jspm is a package manager for the SystemJS universal module loader, built on top of the dynamic ES6 module loader.

jspm

JSPM can handle installed packages, transpiling ES6, and bundling all from the command-line. This video gives a quick overview of install JSPM, installing packages with JSPM, writing a very simple app in ES6 that uses those packages, then bundling up for production.

An Introduction to JSPM (JavaScript Package Manager)

In this lesson I refactor a simple application built with Apollo, GraphQL, and React to utilize Apollo Boost. Apollo Boost combines many of the Apollo libraries we had to import and configure separately into one awesome API. 

Resources:

[What's in Apollo Boost](https://github.com/apollographql/apollo-client/tree/master/packages/apollo-boost#whats-in-apollo-boost)

[Zero config GraphQL State Management](https://dev-blog.apollodata.com/zero-config-graphql-state-management-27b1f1b3c2c3)


Zero-config Apollo + GraphQL with Apollo Boost

In this lesson we look at how the Apollo @client directive can be used to fetch client-side state along with server data with one query. I also show how to update the client-side state using a mutation connected to a button.

Additional Resources [Apollo Client 2.0](https://dev-blog.apollodata.com/apollo-client-2-0-beyond-graphql-apis-888807b53afe)


Fetch Server Data and Client-side State in One Query using React Apollo + GraphQL

In this lesson I refactor a React component that utilizes a higher-order component for mutations to the new Mutation render prop component baked into react-apollo 2.1.

Additional Resources:
https://dev-blog.apollodata.com/introducing-react-apollo-2-1-c837cc23d926

Update Application State with React Apollo Mutation Component

In this lesson I refactor some code that utilizes the Mutation component to update client-side cache to use the new ApolloConsumer component baked into react-apollo 2.1.

Additional Resources: 
https://dev-blog.apollodata.com/introducing-react-apollo-2-1-c837cc23d926

Update Application State with React Apollo ApolloConsumer Component

In this lesson we’ll execute GraphQL queries using our AWS AppSync API and show how to display the returned data inside of our React application using the AWS AppSync GraphQL client.

We'll create a query string using `gql` (`graphql-tag`) and pass that query into a `graphql` Higher-order component where we will pass the resulting data in our exisiting app.


Execute Queries to an AWS AppSync GraphQL API from a React Application

In this lesson, we’ll execute GraphQL mutations using our AWS AppSync API and show how to add data to the database from a React web application using the AWS AppSync GraphQL client.

We'll create a `mutation` query string that will call `createTodo` that is defined in our WAS AppSync GraphQL client. This query will be passed in as props from a Higher-order component and we'll wire up input in React to feed values into this query.

Execute Mutations to an AWS AppSync GraphQL API from a React Application

Apollo provides a universal GraphQL API on top of your existing services, so you can build new application features fast without waiting on backend changes.

apollo

In this lesson, we’ll show how you can have your mutations work when the user is offline. We’ll handle the offline mutation with an optimistic response, then when the user comes back online the data will be sent to the dashboard for a seamless user experience.



Implement an Optimistic Response to a React UI & Showcasing Offline Functionality

In this lesson we’ll show how to use GraphQL subscriptions coming from our AWS AppSync API to listen to real time data changes in a React application and render the new data as it comes in.

Subscribe to New Data in a React Application with AWS AppSync GraphQL Subscriptions

Building a real world, scalable & production-ready GraphQL API is hard. In this course, we’ll learn how to create a production-ready GraphQL API that can handle everything from queries to mutations & subscriptions. We’ll also connect to our API from a React application and execute queries, mutations & subscriptions using the new API.



Course Overview: Scalable Offline-Ready GraphQL Applications with AWS AppSync & React

You already know that Apollo Client can manage your remote data and state from a GraphQL server, but did you know that you can also use it to manage local state in your React apps? You can! 

`apollo-link-state` lets you query and mutate local state the same as you would a GraphQL server. This means that you don't need to add _another_ dependency like Redux or MobX to your app. 

Managing your remote and local state using the same interface results in a codebase that's easier to maintain and reason about.

Manage local state in React using GraphQL and Apollo Client.

The Apollo Client gives you a simple way to query data from an external API in any application. With `apollo-link-state`, you can take those same concepts you've already learned and interact with local state.

In this lesson, you will learn how to query and update state in your `ApolloClient` with React using the `ApolloProvider` and `Query` components. First, we'll set up the application to read from state, then write a function that will increment that state.

Read and Update Local State with Apollo Link State in React

In this lesson, you will learn how to update the Apollo Link State cache using a mutation.

Create Apollo Link State Mutation

In this lesson, you will learn how to use variables to update local state in React with your Apollo Link State Mutations.

Dynamically Update Local State using Apollo Link State with Mutation Variables

In this lesson, you will learn how to query local and remote data in Apollo Link State in the same component.

We'll set the `@client` decorator on the local client State variable and set an empty `Query` object to get this done.

Query Local and Remote Data in Apollo Link State

We will learn how to set up the Apollo Client using Apollo Boost, connect it to a GraphQL endpoint and use the Apollo Provider to connect it to our React Application. In addition we demonstrate how to use an Apollo Consumer

Setup and Connect an Apollo Client to a React Application with Apollo Provider

In order to display data we first need to fetch it. The Query component allows us to describe which data we are interested and automatically handle the fetching of our data. Once we received the data we can render it using React. Since the Query component handles the data fetching we need to make sure we properly deal with the cases of a loading state as well as when the receive Errors from the GraphQL API. In this lesson we will cover both.

Fetch Data using the Apollo Query Component

In addition to using the AWS AppSync console, we can also use the AWS Amplify CLI to create GraphQL APIs & the AWS Amplify to interact with the API. In this video, we'll look at an alternate way to create & manage your AppSync GraphQL API.

Topics

Instructors

Content Type

Free or Pro