Understanding Async Programming and Promises in NestJS

Asynchronous programming is a critical concept in JavaScript, and it plays a significant role in server-side applications built with NestJS. As NestJS is based on TypeScript and JavaScript, it leverages asynchronous programming techniques to handle I/O-bound tasks, such as database operations, API calls, and file processing, efficiently.

In this module, we will explore asynchronous programming in NestJS, how Promises work, and how you can leverage async/await and Promises to handle asynchronous tasks more effectively.

Table of Contents

1. Introduction
2. What is Asynchronous Programming?
3. Promises in JavaScript
4. Using Async/Await in NestJS
5. Working with Promises in NestJS Services
6. Error Handling in Async Operations
7. Parallel and Sequential Async Calls
8. Best Practices for Async Programming in NestJS
9. Conclusion

Introduction

In a modern web application, you frequently need to perform time-consuming tasks, such as querying a database, making HTTP requests to external services, or processing files. If these tasks are performed synchronously, they would block the event loop, making the application unresponsive. This is where asynchronous programming comes into play, enabling non-blocking operations and improving the overall performance of the application.

In NestJS, asynchronous programming is essential, and it makes use of Promises, async/await, and asynchronous methods to ensure smooth, non-blocking operations. This module will help you understand how async programming and Promises are used in NestJS.

What is Asynchronous Programming?

Asynchronous programming allows tasks to be executed without blocking the main execution thread. In a typical synchronous execution model, each operation is performed sequentially, and the program waits for each task to complete before moving to the next one.

With asynchronous programming, tasks are executed concurrently. While one task is waiting for a result (e.g., a database query), other tasks can be executed. This ensures that your application remains responsive and can handle multiple requests efficiently.

In NestJS, this is particularly important for handling I/O-bound tasks like database queries or external API calls.

Example of Synchronous vs Asynchronous Code

Synchronous:

const data1 = fetchDataFromDatabase(); // Blocking, waits for the database call to finish
const data2 = processData(data1);
console.log(data2);

Asynchronous:

async function processAsyncData() {
  const data1 = await fetchDataFromDatabase(); // Non-blocking, moves on to the next task while waiting
  const data2 = processData(data1);
  console.log(data2);
}

In asynchronous code, await allows you to pause the execution of the current function until the Promise resolves, without blocking other operations.

Promises in JavaScript

A Promise is an object that represents the eventual completion or failure of an asynchronous operation. Promises allow you to chain operations and handle results asynchronously. Promises can be in one of the following states:

• Pending: The operation is still being performed.
• Fulfilled: The operation completed successfully.
• Rejected: The operation failed.

Creating and Using Promises

A Promise is created using the new Promise() constructor. It accepts a function that takes two parameters: resolve and reject.

const fetchData = new Promise((resolve, reject) => {
  // Simulate a database operation
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve('Data fetched successfully');
    } else {
      reject('Failed to fetch data');
    }
  }, 1000);
});

fetchData
  .then((data) => console.log(data))  // Success
  .catch((error) => console.error(error));  // Error

In the example above:

• If the operation is successful, resolve() is called, and the Promise is fulfilled.
• If the operation fails, reject() is called, and the Promise is rejected.

Chaining Promises

Promises can be chained using .then() for handling success and .catch() for handling errors.

fetchData
  .then((data) => {
    return processData(data); // Returning another promise
  })
  .then((processedData) => {
    console.log(processedData);
  })
  .catch((error) => {
    console.error(error);
  });

Using Async/Await in NestJS

Async/Await is a more readable and straightforward way to handle Promises in modern JavaScript. Instead of chaining .then() and .catch(), you can use the async keyword to define a function that returns a Promise and the await keyword to pause execution until the Promise resolves.

Example: Using Async/Await in NestJS Services

In a NestJS service, you might need to handle asynchronous operations such as database queries or HTTP requests. Here’s how you can use async/await to simplify this:

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Cat } from './cat.schema';

@Injectable()
export class CatsService {
  constructor(@InjectModel(Cat.name) private catModel: Model<Cat>) {}

  // Asynchronous method to fetch cats from the database
  async findAll(): Promise<Cat[]> {
    return await this.catModel.find().exec();
  }

  // Asynchronous method to create a new cat
  async create(createCatDto: CreateCatDto): Promise<Cat> {
    const createdCat = new this.catModel(createCatDto);
    return await createdCat.save();
  }
}

In this example:

• The findAll() method returns a Promise that resolves to a list of cats.
• The create() method is asynchronous, and we use await to wait for the database operation to complete before returning the result.

Handling Errors with Async/Await

When using async/await, you can handle errors using try/catch blocks.

async create(createCatDto: CreateCatDto): Promise<Cat> {
  try {
    const createdCat = new this.catModel(createCatDto);
    return await createdCat.save();
  } catch (error) {
    throw new Error('Failed to create cat');
  }
}

This way, if the Promise rejects, the error will be caught and handled gracefully.

Working with Promises in NestJS Services

In NestJS services, Promises can be returned from methods, and you can use them to handle asynchronous tasks. NestJS works seamlessly with Promises, whether you use async/await or the .then() and .catch() methods.

Example: Fetching Data with Promises in a Service

@Injectable()
export class CatsService {
  constructor(@InjectModel(Cat.name) private catModel: Model<Cat>) {}

  findAll(): Promise<Cat[]> {
    return this.catModel.find().exec(); // Returning a Promise directly
  }

  async findOne(id: string): Promise<Cat> {
    try {
      return await this.catModel.findById(id).exec();
    } catch (error) {
      throw new Error('Failed to fetch cat');
    }
  }
}

In the above code, findAll() returns a Promise directly, while findOne() uses async/await to handle the asynchronous operation.

Error Handling in Async Operations

In asynchronous programming, handling errors properly is crucial to ensure that your application behaves predictably. You can use try/catch blocks around asynchronous code to catch any errors that may occur.

Example: Handling Errors in Async Code

async function fetchData() {
  try {
    const data = await someAsyncOperation();
    console.log(data);
  } catch (error) {
    console.error('Error occurred:', error.message);
  }
}

This pattern is commonly used in NestJS to catch errors from asynchronous operations and to throw appropriate exceptions if necessary.

Parallel and Sequential Async Calls

When working with multiple asynchronous operations, you might want to run some operations sequentially or in parallel.

Running Async Calls Sequentially

async function fetchDataSequentially() {
  const result1 = await asyncOperation1();
  const result2 = await asyncOperation2();
  return [result1, result2];
}

Running Async Calls in Parallel

If the operations don’t depend on each other, you can run them in parallel using Promise.all().

async function fetchDataInParallel() {
  const [result1, result2] = await Promise.all([asyncOperation1(), asyncOperation2()]);
  return [result1, result2];
}

Promise.all() runs the asynchronous operations concurrently and waits for all of them to complete before proceeding.

Best Practices for Async Programming in NestJS

1. Use Async/Await: Prefer async/await over .then() and .catch() for better readability and cleaner error handling.
2. Handle Errors Gracefully: Always handle errors from asynchronous operations using try/catch blocks to avoid unhandled exceptions.
3. Run Independent Async Tasks in Parallel: Use Promise.all() to run independent asynchronous tasks concurrently for better performance.
4. Use await for I/O Operations: Always use await for asynchronous I/O-bound operations like database queries and HTTP requests to prevent blocking.
5. Keep Code Readable: Keep your asynchronous code clean and organized, avoiding deeply nested callbacks or chains of Promises.

Conclusion

In this module, we have learned how asynchronous programming works in NestJS and how to handle async tasks using Promises and async/await. Async programming is crucial for building efficient and non-blocking applications, and NestJS provides all the tools you need to handle async operations in a clean and effective way.