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

Client libraries vs REST

2m:25s

Many service providers create libraries to make it easier to use their services. These libraries are often called SDKs or client libraries.

“Client” in this context refer to you (the developer) because you’re a client to their business. It doesn’t refer to the browser in the Client-Server context.

How client libraries work

Most client libraries are made for backend languages. For example, Stripe has client libraries for Ruby, Python, and Node, amongst others.

You can download these client libraries with the language’s ecosystem. For example, you can install Stripe with npm.

Terminal window
npm install stripe -S

You can then require the client library in your servers.

const stripe = require('stripe')

Client libraries usually help you with two things:

  1. Authentication and Authorization
  2. Call specific endpoints in the API in a readable way

Authentication and Authorization

We don’t need the OAuth authentication flow here. Most of the time, you’ll use one or more of the following credentials:

  • An access token
  • An API Key
  • An API Secret
  • A Service Key

For example, you can authenticate Stripe with an API Key.

// Authentication in Stripe
const Stripe = require('stripe')
const stripe = Stripe('YOUR_API_KEY')

Once you do this, you can use the client library (stripe in this case) without further having to send in an Authorization header for all your requests.

// Use stripe normally
stripe.charges.create(/*...*/)

Calling APIs without using endpoints

Client libraries let you call API without remembering the endpoints.

For example, let’s say you want to charge a card with Stripe. If you use the client library, you can use the following code:

const charge = await stripe.charges.create({
amount: 2000,
currency: 'usd',
})

If you use REST API, you have to use the following code:

// Does the same thing as above
const response = await zlFetch('https://api.stripe.com/v1/charges', {
method: 'post',
auth: 'your-api-key',
body: {
amount: 2000,
currency: 'usd',
},
})

Code from the client library is easier to read because:

  1. stripe.charges.create is self-explanatory — you’re creating a stripe charge.
  2. The code is shorter and more concise

Should you use client libraries?

Yes — because most client libraries are easier to use compared to raw requests.

You may not want to use client libraries in the following cases:

  • When the REST API documentation is better than the client library’s documentation
  • When you only need 1-2 API requests and you can do it faster with raw REST APIs

3rd party libraries vs client libraries

Many developers create their own version of client libraries. They do this when the API doesn’t have a client library.

3rd-party libraries can go unmaintained after a while. Be aware of this risk if you use them. Use your best judgment and discretion. Personally, I don’t recommend using 3rd-party libraries unless they’re popular and highly used.