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

Twitter: Refreshing the access token

If the access token is not valid, we need to use the refresh token to generate a new access token.

Here’s where we left off in the previous lesson:

providers.forEach(async provider => {
// ...
if (isValid) {
setLoginStatus({ provider, loggedIn: true })
}
// Code to generate another access token goes here...
})

If we want to write the refresh token flow, we need to make sure the access token is invalid.

There are two ways to invalidate the access token:

  1. We can wait 2 hours for the access token to become invalid…
  2. Or we can change the access token’s value so it becomes invalid.

We don’t want to wait 2 hours when we code… so naturally we will choose the second option.

Invalidating the access token

We can invalidate the access token by changing two things:

  1. The expiresAt value
  2. The accessToken value

The easiest way is to change the accessToken value in the browser.

To do this, you can open up Local Storage in your developer tools and edit the stored value.

Using the refresh token

We can refresh the access token since the access token is invalid now.

Here, we need to send the refreshToken to the backend. We’ll use the /auth/:provider/refresh endpoint.

providers.forEach(async provider => {
// ...
const { response } = await zlFetch.post(`/auth/${provider}/refresh`, {
body: { refreshToken },
returnError: true,
})
})

We cannot send a refresh request for Github because Github doesn’t have a refresh token. So we need to prevent Github from reaching this point.

providers.forEach(async provider => {
// ...
// Prevents Github from sending refresh token request
if (provider === 'github') return
// Send a request to get a new access token
const { response } = await zlFetch.post(`/auth/${provider}/refresh`, {
body: { refreshToken },
returnError: true,
})
})

From the backend, we will send a request to Twitter to get the new access token.

You can view the instructions from Twitter here.

Refresh token grant instructions from Twitter

Here’s the code you need to send to Twitter.

router.post('/auth/twitter/refresh', async (req, res) => {
const { refreshToken } = req.body
const { response } = await zlFetch.post(
'https://api.twitter.com/2/oauth2/token',
{
auth: {
username: process.env.TWITTER_CLIENT_ID,
password: process.env.TWITTER_CLIENT_SECRET,
},
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
},
body: {
refresh_token: refreshToken,
grant_type: 'refresh_token',
client_id: process.env.TWITTER_CLIENT_ID,
},
returnError: true,
},
)
const token = response.body
console.log(token)
})

Twitter will send you a new access token and a new refresh token.

Since Twitter sent us a new refresh token… it simply means we need to update the refresh token value stored in the local storage.

So we send the access token, expiresAt, and refresh token to the frontend.

router.post('/auth/twitter/refresh', async (req, res) => {
// ...
if (response) {
const token = response.body
const expiresAt = token.expires_in * 1000 + Date.now()
const params = {
expiresAt,
accessToken: token.access_token,
refreshToken: token.refresh_token,
}
res.json(params)
}
})
Note

We don’t need to send provider to the frontend because the frontend already knows the provider.

We also don’t need to send authStatus to the frontend since we’re passing the information through a request and not through the query string.

We can now grab the new token information and save them to local storage once again.

providers.forEach(async provider => {
// ...
// Save token with response
const newToken = response.body
localStore.set(provider, {
accessToken: newToken.accessToken,
refreshToken: newToken.refreshToken,
expiresAt: newToken.expiresAt,
})
// Then we log the user in
setLoginStatus({ provider, loggedIn: true })
})

And we have now completely implemented Login with Twitter.

Let’s refactor our code a bit in the next lesson before we move onto the next identity provider.