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

Basic Authentication

2m:12s

When you let a user log in with their username and password, we say you are using Basic Authentication.

Using Basic Authentication

In Basic Authentication, you need to:

  • Write the username and password in this format: username:password.
  • Encode the username:password string into a base64 string.
  • Send the encoded string via an Authorization header

Here’s a deeper explanation for steps 2 and 3.

Encoding the username and password

Encoding here means to convert the username:password string into the base64 format.

You can do this with a function called btoa (pronounced as B to A).

btoa stands for binary data to base64-encoded ascii. This function is available natively in both browsers and Node.

Creating the Authorization Header

For Basic authentication, the Authorization header must begin with Basic (with a space), followed by the encoded base64 string.

If you use Fetch, you need to write the entire header yourself.

// Using Fetch
fetch('link-to-resource', {
method: 'post,
headers: {
Authorization: `Basic ${encodedString}`
}
})

The process is easier in zlFetch because it encodes the username:password string and writes the Authorization header for you.

All you have to do is pass in an auth option that contains the username and password properties.

zlFetch('link-to-resource', {
auth: {
username: 'username',
password: '12345678',
},
})

Basic authentication in the real world

Very few API services let you authenticate with Basic Authentication today.

Most services require other authentication methods (using tokens, API keys, or API secrets) for security purposes.

When I was writing this course, one of the remaining examples I could find was GitHub. Unfortunately, it has ceased its Basic Authentication service in November 2020.

Github’s message on ceasing their Basic Authentication service

As far as I know, (thankfully), we can use GitHub’s Basic Authentication service if you replace the password with a Personal Access Token.

Github lets us authenticate with Personal Access Tokens instead of passwords

Two things to note here:

  1. You can create a Personal access token by following the steps in this guide.
  2. You should try using Basic authentication with GitHub (if you can) — doing so will help prove to yourself that you got this lesson down flat.

You can use the following code to perform a Basic Authentication with GitHub. (Just make sure you switch out username and password with the appropriate values!).

zlFetch.post('https://api.github.com/user/repos', {
auth: {
username: 'username',
password: 'personal-access-token',
},
})

That’s all you need to know about Basic Authentication.

Next up, you’ll learn about Bearer Authentication — which is probably one of the most important ways to authenticate nowadays.