Essential CSS
JavaScript Roadmap
Learn JavaScript
Mastering Web Typography
Practical Astro
Understanding Async JS
Unorthodox Tailwind
API Masterclass
Build and Deploy
The Beginner Freelancer
Real World Node
Profile Billing Logout
Understanding Async JS
Lesson Plan
  1. Introduction
    1. What is Asynchronous JS?
    2. Callbacks are not automatically asynchronous
    3. What is an API?
    4. Evolution of HTTP APIs
    5. Ajax vs Asynchronous JavaScript
  2. Fundamental Concepts
    1. How to fetch resources
    2. Using XHR
    3. Using the Fetch API
    4. Using libraries
    5. Core JavaScript concepts
    6. Understanding Promises
    7. Understanding Async Functions
    8. Understanding the Event Loop
    9. Understanding JSON
    10. Async JS Best Practices
    11. Using Optimistic UI
  3. Understanding Rest API
    1. Diving into Rest APIs
    2. The Rest Architecture
    3. The Rest Structure
    4. Anatomy of a Request
    5. What's an endpoint
    6. Request methods
    7. Understanding request headers
    8. Understanding the request body
    9. Authentication
    10. Basic Authentication
    11. Bearer Authentication
    12. Authenticating with API keys and API Secrets
    13. Cross Origin Resource Sharing
    14. Anatomy of a response
    15. HTTP Statuses
    16. Response headers
    17. The response body
    18. Handling Errors
    19. Reading API documentations
    20. Understanding Curl
  4. Node Basics
    1. Why we are using Node
    2. Command Line Basics
    3. Installing Node
    4. Managing dependencies
    5. Using ES Modules in Node
    6. Using Node
    7. Restarting the server automatically
    8. Sending requests via Node
    9. Protecting API keys and secrets
  5. Building a server
    1. What's a server
    2. Building a simple server with Express
    3. Two kinds of servers
    4. API Server architecture
    5. Handling routes
    6. Understanding Middlewares
    7. Enabling CORS
    8. Receiving data
    9. Sending responses
    10. Handling errors in Express
    11. Using the server as a proxy
    12. Minimum viable server
  6. Open Authorization
    1. Open Authorisation (OAuth)
    2. Authenticating with Access Tokens
    3. Obtaining Access Tokens
    4. Public and Confidential Clients
    5. Authorisation Code Grant
    6. Understanding scope
    7. Proof Key for Code Exchange (PKCE)
    8. PKCE with Twitter
    9. Dynamic state and `code_verifier`
    10. Saving the access token in cookies
    11. Passing access tokens to the browser
    12. Saving the access token in local storage
    13. Refresh Token Grant
    14. Device Code Grant
    15. Client libraries vs REST
  7. Building Social Media Logins
    1. Introduction
    2. Starter Files
    3. Creating SSL certificates
    4. Login in with Github
    5. Github: Saving the token to local storage
    6. Github: Persisting the login status
    7. Login with Twitter
    8. Twitter: Saving the token to local storage
    9. Twitter: Persisting the login status
    10. Twitter: Refreshing the access token
    11. Login with Facebook
    12. Facebook: Saving the token to localStorage
    13. Facebook: Persisting the login status
    14. Facebook: Refreshing the access token
    15. Login with google
    16. Google: Saving the token to localStorage
    17. Google: Refreshing the access token

Github: Saving the token to local storage

As we mentioned in the last lesson, we’re going to store the access token in local storage. Before we can save the token into local storage, we need to send the token to the browser.

We covered how to do this in an earlier lesson. For this app, we’re going to use the simplest method — query strings.

Sending token to frontend via the query string

You can redirect the user back to the homepage with a query string. This query string should include at least three parameters:

  1. An authStatus parameter — so we know whether the authentication is successful
  2. A provider parameter — so we know it’s from Github and not other identity providers.
  3. A token parameter — so we know can save the token in Local Storage.

Here’s how you can do this.

router.get('/auth/github/callback', async (req, res) => {
// ...
const token = response.body
// Create the query string
const params = {
authStatus: 'success',
provider: 'github',
access_token: token.access_token,
}
const query = new URLSearchParams(params).toString()
// Redirect user to the index page with the query string
res.redirect('/' + '?' + query)
})

Getting the token from the query string

On the frontend, we need to get the token from the query string before we can save it to local storage.

We can do this with URLSearchParams.

// Inside main.js
const searchParams = new URLSearchParams(location.search)
const authStatus = searchParams.get('authStatus')
const provider = searchParams.get('provider')
const accessToken = searchParams.get('access_token')

The accessToken will only be available when authStatus is success. We can use this as a condition to check whether we should get the rest of the parameters.

const searchParams = new URLSearchParams(location.search)
if (searchParams.get('authStatus') === 'success') {
const provider = searchParams.get('provider')
const accessToken = searchParams.get('access_token')
console.log(provider)
console.log(accessToken)
}
The token

Saving the token

We can save the token to Local Storage with the localStore library I created. You can import the library with the following code in this starter project:

import { localStore } from './lib.js'

We’ll save the token like this:

if (searchParams.get('authStatus') === 'success') {
const provider = searchParams.get('provider')
const accessToken = searchParams.get('access_token')
localStore.set(provider, { accessToken })
}

Two things to note:

First: We set key to provider because it allows us to grab access token from a specific identity provider later.

Second: We store the access token as an object (instead of a string) because other identity providers give you more information. You’ll see this in later lessons.

If you check the applications tab in your console, you should see the token now:

The token in local storage.

Updating the status

Once we save the access token, we want to update the status to “Logged in”. We can do this by searching for the provider’s status and replacing its text content

if (searchParams.get('authStatus') === 'success') {
// ...
const element = document.querySelector(`.status[data-provider="${provider}"]`)
element.textContent = 'Logged In'
}

Wipe the query string with history

We need to wipe the query string to ensure the the access token doesn’t get copied accidentally (if the user decides to copy the page url).

This step is important because for security purposes.

We can do this with history.replace.

if (searchParams.get('authStatus') === 'success') {
// ...
history.replaceState('', '', location.pathname)
}