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

Login with Twitter

Let’s work on logging users in with Twitter because it’s also something we know how to do.

There are four steps:

  1. Create the app
  2. Create the sign-in link
  3. User logs in on twitter
  4. Exchange code for access token

Create the app

Here are the instructions from Twitter.

You can name the app anything you want.

  • I named it Social Media App for Async JS.
  • We’re going to set callbackURL to https://localhost/auth/twitter/callback.

Before you move on, make sure you add your Twitter credentials to the .env file.

Terminal window
TWITTER_CLIENT_ID="Your Client ID"
TWITTER_CLIENT_SECRET="Your Client Secret"

When the user clicks the sign-in link, we will redirect the user to Twitter. We can do this in two steps:

  1. We direct the user to an endpoint in our server.
  2. In this endpoint, we redirect the user to Twitter.
<!-- Direct user to endpoint in our server -->
<a href="/auth/twitter" ...> Login with Twitter </a>

In this endpoint, we craft the sign-in link for Twitter. We’ve already done this in the OAuth chapter so we’re going to speed through some bits.

Here’s how you create the sign-in link.

import PKCE from '@zellwk/javascript/utils/pkce.js'
router.get('/auth/twitter', (req, res) => {
const pkce = await PKCE()
const baseURL = 'https://twitter.com/i/oauth2/authorize'
const params = {
response_type: 'code',
client_id: process.env.TWITTER_CLIENT_ID,
redirect_uri: 'https://localhost/auth/twitter/callback',
state: pkce.state,
code_challenge: pkce.code_challenge,
code_challenge_method: pkce.code_challenge_method,
scope: 'tweet.read users.read offline.access'
}
const query = new URLSearchParams(params)
const link = baseURL + '?' + query.toString()
})
Note

We set scope to tweet.read, users.read and offline.access — because we need these scopes to refresh the user’s access token later.

Twitter uses PKCE, so before we redirect the user to Twitter, we need to save code_verifier and state into cookies.

router.get('/auth/twitter', (req, res) => {
// ...
res.cookie('code_verifier', pkce.code_verifier, {
httpsOnly: true,
secure: true,
})
res.cookie('state', pkce.state, { httpsOnly: true, secure: true })
})

Then we redirect the user to Twitter

router.get('/auth/twitter', (req, res) => {
// ...
res.redirect(link)
})

User logs in to Twitter

The user should see a screen like the one below, and they should be able to login to Twitter.

Nothing for us to do here :)

Exchange code for access token

When the user authorise the Twitter login, Twitter will redirect them back to /auth/twitter/callback.

We need to take a couple of steps here:

  1. Check whether state is valid
  2. Grab code from the url and code_verifier from the cookies.
  3. Send a request to Twitter to get the access token

Checking whether state is valid

We need to grab both state from the callback url and state from the cookies. We’ll check whether they are the same value before we proceed with the rest of the steps.

router.get('/auth/twitter/callback', async (req, res) => {
const { state: returnedState } = req.query
const { state } = req.cookies
if (state !== returnedState) return
})

Grabbing code and code_verifier

We need to grab both code and code_verifier because we need to send them to Twitter.

We can grab code from the callback URL and code_verifier from the cookies.

router.get('/auth/twitter/callback', async (req, res) => {
const { state: returnedState, code } = req.query
const { state, code_verifier } = req.cookies
if (state !== returnedState) return
})

Send a request to Twitter

Then we send this code to twitter’s token endpoint to get the access token.

We have covered this in the previous lessons so we’ll go through this portion quickly. Refer back to this lesson if you’re unsure of the steps.

Here’s the request to get an access token from Twitter.

router.get('/auth/twitter/callback', async (req, res) => {
// ...
// Exchange code for access token
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: {
code,
code_verifier,
grant_type: 'authorization_code',
client_id: process.env.TWITTER_CLIENT_ID,
redirect_uri: 'https://localhost/auth/twitter/callback'
}
}
// Get the token
const token = response.body
console.log(token)
})

You should receive a token like this:

The user is now logged in.

Handling the access token

We’re going to store the access token in local storage again in the next lesson.