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

Sending requests via Node

2m:11s

You can use the Fetch API to send a request directly in Node.

fetch('https://link-to-resource')
.then(response => response.json())
.then(data => console.log(data))
Note

Node supports Fetch natively since v17.0.0. If you’re using an earlier version of Node, you’ll need to install libraries like node-fetch to use Fetch in Node.

You can also use a library like zlFetch too. (More on this below).

CORS restrictions don’t apply on servers

Earlier in the course, I demonstrated the fact that you can’t use XHR or Fetch on some servers because of CORS.

Error when trying to fetch google.com from a browser

Well, these CORS restrictions don’t apply when you send the same request through a server. For example, you can fetch google.com and get the HTML as a response back from the server.

fetch('https://google.com')
.then(response => response.text())
.then(data => console.log(data))
Response from https://google.com

Installing zlFetch

You can install zlFetch with npm.

To do this, go to your command line, navigate to the project folder, and type the following command:

Terminal window
npm install zl-fetch -S
Note

The -S flag saves zl-fetch as a dependency. We do this because we will use zlFetch in the production code.

When the command is done, you will see a node_modules folder in your project. Inside this node_modules folder, you will be able to find zl-fetch.

This is how you know the library has been installed.

Using the zlFetch library

You must import a library into your file before you can use it.

import zlFetch from 'zl-fetch'

Once you do this, you can use zlFetch.

zlFetch('https://api.github.com/users/zellwk/repos')
.then(response => {
const repos = response.body
console.log(repos)
})

If you run the server now, you should see a huge list of content in your Terminal.

This happens because the Terminal does not have interactive functions, unlike browser consoles — you can’t click on the dropdown to view the object, so it simply displays everything when it can.

If you want to get a log that seems less insane, you need to be intentional about what you’re trying to log. For example, you can log the length of the array if you want to know how many items there are.

zlFetch('https://api.github.com/users/zellwk/repos').then(response => {
const repos = response.body
console.log(repos.length)
})

That’s all you need to know about sending requests with Node.

There’s one final thing for you to know in this chapter — how to protect your API Keys and API Secrets so they’re safe from prying eyes.