NodeJS Promise Chaining

Node.js is great at handling tasks that don't need to happen instantly, like fetching data from a website. Promise chaining helps you manage these tasks in a specific order, one after the other.

What is Promise Chaining?

Promise chaining in Node.js allows you to execute multiple asynchronous operations in a sequence, where each operation starts after the previous one completes.

• Sequential Execution: Makes sure asynchronous tasks run in a specific order, each task waiting for the previous one's result.
• Error Handling: Provides a clean way to handle errors in asynchronous operations, making sure any problems are caught and dealt with.

Syntax

promise
    .then(value => {
        return newValue;
    })
    .then(newValue => {
        return anotherValue;
    })
    .catch(error => {

    });

• .then() handles the result of a promise and can return a new value or promise.
• .catch() handles errors that occur in the promise chain.

How Promise Chaining Works

Promises are like placeholders for something that will happen later (like data coming from a server). Chaining lets you decide what to do after something happens.

• Each .then() receives the result from the previous step. You can use that result and then pass something new along to the next step.
• Returning a value from .then() automatically creates a new promise that carries that value. This keeps the chain going. If you return a promise from .then(), the chain waits for that promise to finish before moving on.
• The .catch() at the end is like a safety net. It catches any errors that might have occurred in any of the steps in the chain.
  

Let's now understand promise changing with the help of an example

const myPromise = new Promise((resolve, reject) => {
    setTimeout(() => { resolve(10); }, 500);
});

myPromise
    .then(value => {
        console.log("First then:", value);
        return value * 2;
    })
    .then(newValue => {
        console.log("Second then:", newValue);
        return newValue + 5;
    })
    .then(finalValue => {
        console.log("Final value:", finalValue);
    })
    .catch(error => { console.error("Error:", error); });

First then: 10
Second then: 20
Final value: 25

• A new Promise myPromise is created, resolving with the value 10 after a 500ms delay.
• The first .then receives the resolved value (10), logs it, and returns the value multiplied by 2.
• The second .then receives the result from the previous .then (20), logs it, and returns the value plus 5.
• The final .then receives the result (25) and logs it. This is the end of the chain.
• The .catch block would handle any errors that might have occurred in the promise chain.

Handling Errors in Promise Chaining

Error handling is essential in asynchronous code. Promise chaining provides a clean way to manage errors.

const myPromise = new Promise((resolve, reject) => {
    setTimeout(() => { reject("Something went wrong!"); },
               500);
});

myPromise
    .then(
        value => { console.log("This won't be executed"); })
    .then(newValue => {
        console.log("This also won't be executed");
    })
    .catch(error => { console.error("Error:", error); });

Output

Error: Something went wrong!

• The Promise is rejected after 500ms.
• The .then blocks are skipped because the promise was rejected.
• The .catch block is executed, logging the error message.

Promise Chaining vs. Async/Await

While Promise chaining improves readability compared to callbacks, async/await offers an even more synchronous-like approach.

Using Async/Await (Equivalent Code)

async function fetchDetail() {
    try {
        const user = await fetchData(1);
        console.log("User fetched:", user.name);

        const orders = await fetchOrders(user);
        console.log("Orders fetched:", orders);

        const processedOrder = await processOrder(orders[0]);
        console.log("Final Result:", processedOrder);
    } catch (error) {
        console.error("Error:", error);
    }
}

fetchDetail();

Key Differences