Promise chaining in Node.js - Mini Project: Build & Apply

Promise chaining

📖 Scenario: You are building a simple Node.js program that simulates fetching user data and then fetching that user's posts from a server. Each fetch returns a Promise that resolves after a short delay.

🎯 Goal: Build a chain of Promises where you first fetch a user, then fetch the posts of that user, and finally log the posts.

📋 What You'll Learn

Create a function fetchUser that returns a Promise resolving to the user object { id: 1, name: 'Alice' } after 100ms.

Create a function fetchPosts that takes a user ID and returns a Promise resolving to an array of posts [{ id: 1, title: 'Hello World' }, { id: 2, title: 'Learning Promises' }] after 100ms.

Create a variable userId to store the fetched user's ID.

Chain the Promises so that fetchUser is called first, then fetchPosts is called with the userId, and finally the posts are logged.

💡 Why This Matters

🌍 Real World

Promise chaining is used in Node.js to handle sequences of asynchronous tasks, such as fetching data from APIs or databases in order.

💼 Career

Understanding Promise chaining is essential for backend developers working with asynchronous JavaScript, enabling them to write clean, readable, and maintainable code.

1

Create the fetchUser function

Create a function called fetchUser that returns a Promise. This Promise should resolve after 100 milliseconds with the object { id: 1, name: 'Alice' }.

Node.js

// Your code here

Hint

Use new Promise and setTimeout to simulate a delayed response.

2

Create the fetchPosts function

Create a function called fetchPosts that takes a parameter userId and returns a Promise. This Promise should resolve after 100 milliseconds with the array [{ id: 1, title: 'Hello World' }, { id: 2, title: 'Learning Promises' }].

Node.js

function fetchUser() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve({ id: 1, name: 'Alice' });
        }, 100);
    });
}

// Your code here

Hint

Use userId as a parameter but you don't need to use it inside the function body for this example.

3

Create the userId variable

Create a variable called userId and set it to null. This will hold the ID of the fetched user.

Node.js

function fetchUser() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve({ id: 1, name: 'Alice' });
        }, 100);
    });
}

function fetchPosts(userId) {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve([
                { id: 1, title: 'Hello World' },
                { id: 2, title: 'Learning Promises' }
            ]);
        }, 100);
    });
}

// Your code here

Hint

Use let to declare userId and set it to null.

4

Chain the Promises to fetch user and posts

Use fetchUser() and chain a .then() to get the user object. Inside this .then(), set userId to the user's id and return fetchPosts(userId). Chain another .then() to receive the posts and log them using console.log(posts).

Node.js

function fetchUser() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve({ id: 1, name: 'Alice' });
        }, 100);
    });
}

function fetchPosts(userId) {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve([
                { id: 1, title: 'Hello World' },
                { id: 2, title: 'Learning Promises' }
            ]);
        }, 100);
    });
}

let userId = null;

// Your code here

Hint

Remember to return fetchPosts(userId) inside the first .then() to chain the Promises.

Practice

1. What is the main purpose of promise chaining in Node.js?

easy

A. To convert synchronous code into asynchronous code

B. To run all asynchronous tasks at the same time

C. To run asynchronous tasks one after another in order

D. To stop all asynchronous tasks immediately

Solution

1. Step 1: Understand asynchronous task execution

   Promise chaining allows tasks to run one after another, waiting for each to finish.

2. Step 2: Identify the purpose of chaining

   Chaining with .then() ensures order, not parallel or immediate stop.

3. Final Answer:

   To run asynchronous tasks one after another in order -> Option C

4. Quick Check:

   Promise chaining = ordered async tasks [OK]

Hint: Promise chaining runs tasks step-by-step, not all at once [OK]

Common Mistakes:

• Thinking promises run in parallel by default
• Confusing chaining with synchronous loops
• Believing chaining stops tasks immediately

2. Which of the following is the correct syntax to chain two promises promise1 and promise2?

easy

A. promise1.then(promise2)

B. promise1.then(promise2())

C. promise1.then.then(promise2)

D. promise1.then(() => promise2())

Solution

1. Step 1: Understand how to pass functions to .then()

   The .then() method expects a function to call when the promise resolves.

2. Step 2: Check each option's syntax

   promise1.then(() => promise2()) correctly passes a function that calls promise2(). Options A and B call promise2() immediately or pass wrong types. promise1.then.then(promise2) has invalid chaining syntax.

3. Final Answer:

   promise1.then(() => promise2()) -> Option D

4. Quick Check:

   Pass a function to then() = promise1.then(() => promise2()) [OK]

Hint: Use a function inside then() to delay calling next promise [OK]

Common Mistakes:

• Calling the next promise immediately inside then()
• Using double then without parentheses
• Passing promise instead of function to then()

3. What will be logged to the console when running this code?

Promise.resolve(5)
  .then(x => x + 1)
  .then(x => { throw new Error('Fail'); })
  .catch(err => 'Caught: ' + err.message)
  .then(x => console.log(x));

medium

A. Caught: Fail

B. Fail

C. 6

D. undefined

Solution

1. Step 1: Follow the promise chain step-by-step

   The first then adds 1 to 5, resulting in 6. The second then throws an error.

2. Step 2: Understand error handling and final output

   The catch catches the error and returns the string 'Caught: Fail'. The last then logs this string.

3. Final Answer:

   Caught: Fail -> Option A

4. Quick Check:

   Error caught and message logged = Caught: Fail [OK]

Hint: Errors jump to catch, then continue chain with catch result [OK]

Common Mistakes:

• Expecting error to stop all logging
• Thinking catch returns undefined
• Ignoring that catch returns a value to next then

4. Identify the error in this promise chain:

fetchData()
  .then(data => processData(data))
  .then(result => console.log(result))
  .catch(console.error())

medium

A. Missing return in first then

B. Incorrect use of catch with immediate function call

C. processData is not a function

D. console.log should be inside catch

Solution

1. Step 1: Check the catch usage

   The catch method expects a function reference, but console.error() calls the function immediately, passing its result (undefined) instead.

2. Step 2: Correct catch usage

   It should be .catch(console.error) without parentheses to pass the function itself.

3. Final Answer:

   Incorrect use of catch with immediate function call -> Option B

4. Quick Check:

   Pass function to catch, not call it immediately [OK]

Hint: Pass function to catch, don't call it with () [OK]

Common Mistakes:

• Calling catch handler immediately instead of passing function
• Forgetting to return promises inside then
• Misplacing console.log inside catch

5. Given these functions:

function step1() { return Promise.resolve(2); }
function step2(x) { return Promise.resolve(x * 3); }
function step3(x) { return x + 4; }

What will this code log?

step1()
  .then(x => step2(x))
  .then(x => step3(x))
  .then(console.log);

hard

A. 10

B. Promise { 10 }

C. undefined

D. Error: step3 must return a Promise

Solution

1. Step 1: Calculate step1 and step2 results

   step1() resolves to 2. Then step2(2) resolves to 6 (2*3).

2. Step 2: Understand step3 return and final log

   step3(6) returns 10 (6+4) synchronously. Since then accepts a value or promise, it passes 10 to next then which logs 10.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Sync return in then passes value = 10 [OK]

Hint: then can handle sync values; they become resolved promises [OK]

Common Mistakes:

• Expecting step3 to return a Promise always
• Thinking console.log logs a Promise object
• Confusing synchronous return with Promise return