How to Convert an Existing Callback to a Promise in Node.js ?

Node.js, by nature, uses an asynchronous, non-blocking I/O model, which often involves the use of callbacks. While callbacks are effective, they can lead to complex and hard-to-read code, especially in cases of nested callbacks, commonly known as "callback hell." Promises provide a cleaner, more readable way to handle asynchronous operations. This article will guide you through the process of converting existing callbacks to promises in Node.js.

Why Convert Callbacks to Promises?

• Readability: Promises make code easier to read and maintain by avoiding deep nesting.
• Error Handling: Promises provide a unified approach for error handling using .catch() blocks.
• Chaining: Promises support chaining, allowing sequential asynchronous operations to be handled more gracefully.
• Compatibility: Modern JavaScript features like async/await work seamlessly with promises, making asynchronous code even more readable and manageable.

Structure of a Callback

Here, fs.readFile is an asynchronous function that takes a file path, an encoding, and a callback function that is executed once the file has been read.

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Error reading file:', err);
        return;
    }
    console.log('File content:', data);
});

Approach

Installation Steps

Step 1: Make a folder structure for the project.

mkdir myapp

Step 2: Navigate to the project directory

cd myapp

Step 3: Initialize the NodeJs project inside the myapp folder.

npm init -y

Project Structure:

Steps to Convert Callbacks to Promises

To convert a callback-based function to a promise-based one, we typically use the Promise constructor. The basic idea is to wrap the callback inside a promise and resolve or reject the promise based on the outcome of the asynchronous operation.

Promises have four states:

• Pending: The promise has not yet completed. It did not succeed and fail.
• Fulfilled: The promise ended with success.
• Rejected: The promise ended with an error.
• Settled: The promise either gave an error or succeeded.

Wrap the Function in a Promise:

The first step is to create a new promise and call the original callback-based function inside the promise's executor function.

const fs = require('fs');

function readFilePromise(filePath, encoding) {
    return new Promise((resolve, reject) => {
        fs.readFile(filePath, encoding, (err, data) => {
            if (err) {
                reject(err); // Reject the promise if there's an error
            } else {
                resolve(data); // Resolve the promise with the file content
            }
        });
    });
}

// Usage
readFilePromise('example.txt', 'utf8')
    .then(data => console.log('File content:', data))
    .catch(err => console.error('Error reading file:', err));

Error Handling:

Ensure that the reject function is called when there’s an error. This allows you to handle errors using .catch().

Chaining Promises:

You can chain multiple promises for sequential asynchronous operations. Each then block can return a value or another promise.

readFilePromise('example.txt', 'utf8')
    .then(data => {
        console.log('File content:', data);
        return readFilePromise('anotherFile.txt', 'utf8');
    })
    .then(anotherData => {
        console.log('Another file content:', anotherData);
    })
    .catch(err => console.error('Error:', err));

Example 1: This example Converts an existing callback to a Promise

// app.js

// Existing Callback
const callback = function (err, success) {
    if (err) {
        console.log("Geek is very sad!");
    }
    else {
        console.log("Geek is optimistic, "
            + "thus becomes successful");
    }
}

const caller = function (status, callback) {
    if (status === 'Happy')
        callback(null, true);
    else {
        callback(new Error(), false);
    }
}

// Calling the caller method

// Executes the success part
caller('Happy', callback);

// Executes the error part
caller('Sad', callback);

Output:

Geek is optimistic, thus becomes successful
Geek is very sad!

Approach:

• First define a function named error and insert the error codeblock of callback function into it.
• After that also define a function named success and insert the success codeblock into it.
• Then modify the caller code by returning promise object.
• Use the success and error methods in any of the following ways.
• See the code snippet below for better understanding.

Example: Implementation to convert an existing callback to a promise in Node.js.

// app.js

// This snippet briefly shows
// the implementation
const error = function () {

    // The error codeblock from
    // the existing callback.
    console.log("Geek is very sad!");
}

const success = function () {

    // The success codeblock from
    // the existing callback
    console.log("Geek is optimistic, "
        + "thus becomes successful");
}

const caller = function (status) {
    return new Promise(function (resolve, reject) {
        if (status === 'Happy') {

            // Calling the resolve function 
            // when function returns success
            resolve();
        }
        else {

            // Calling the reject function
            // when function returns failure
            reject();
        }
    });
};

// Throw success
caller('Happy').then(success).catch(error);

// Throw error
caller('Sad').then(success).catch(error);

Output:

Geek is optimistic, thus becomes successful
Geek is very sad!

Let us change the following code snippet into a promise implementation. To make the implementation run, we need to set up a web app running on a node server. To understand using an example we need to set up a node server on the system. You can follow the following steps to set up a node server. Install node and set up a simple node application by following the steps as shown.

Example 2: Here, the scenario is that we have a student array having id and name as values. We need to get the name of the student having the given id. We are given an existing callback that needs to be converted to a promise.

// app.js

/* Here we have a student array that stores JSON objects
of student id and name. We are going to create a GET
Request using expressjs in node first. Then we will
write a route to get name of student based on id. */

const express = require('express');
const app = express();

// Students array
let students = [
    {
        id: 101,
        name: "Geek A"
    },
    {
        id: 102,
        name: "Geek B"
    },
    {
        id: 103,
        name: "Geek C"
    },
    {
        id: 104,
        name: "Geek D"
    }
];

// Definition of the callback function
const callback = (err, student) => {
    if (err) {
        return `Student with given id ${err} not found`;
    }
    else {
        return "Here is the student: " + student.name;
    }
}

// Passing studentid and callback function as parameter
const findName = (studentId, callbackFunction) => {
    let student = students.find(function (studentValue) {
        return studentValue.id == studentId;
    });

    // Student not found
    if (typeof student === 'undefined') {
        return callbackFunction(studentId, false);
    }
    else {  // Student found
        return callbackFunction(null, student);
    }
}

const getName = (req, res) => {

    // Sending back the response to the server
    res.send(findName(req.params.studentId, callback));
}

app.get('/getName/:studentId', getName);

app.listen(8000, 'localhost', function () {
    console.log('Server Listening');
});

Step to Run Application: Run the application using the following command from the root directory of the project

node app.js

Output:

Now, we can convert the callback function into promises. Here, we can follow the earlier steps again i.e. Error logic in the failure function and Success logic in the success function. Please see the below code for more clarity.

// app.js

const express = require('express');
const app = express();

let students = [
    {
        id: 101,
        name: "Geek A"
    },
    {
        id: 102,
        name: "Geek B"
    },
    {
        id: 103,
        name: "Geek C"
    },
    {
        id: 104,
        name: "Geek D"
    }
];

// Writing the success logic here
const success = (student) => {
    return "Here is the student: " + student.name;
}

// Writing the failure logic here.
const failure = (fail) => {
    return `Student with the given id ${fail} was not found`;
}

const findName = (studentId) => {
    return new Promise(function (resolve, reject) {
        let student = students.find(function (studentValue) {
            return studentValue.id == studentId;
        });
        if (student) {
            resolve(student);
        }
        else {
            reject(id);
        }
    });
}

const getName = async (req, res) => {
    let answer = await findName(
        req.params.studentId).then(success).catch(failure);

    res.send(answer);
}

app.get('/getName/:studentId', getName);

app.listen(8000, 'localhost', function () {
    console.log('Server Listening');
});

Step to Run Application: Run the application using the following command from the root directory of the project

node app.js

Output:

Example: The example to demonstrate this is to use a setTimeout() function which accepts a callback and delays the execution of JavaScript code. As soon as the time set to function gets over, the callback function executes.

// app.js

// Defining a callback function 
const callback = () => {
    console.log("Hello! GeeksforGeeks");
}

// Passing the callback function
// as a parameter
setTimeout(callback, 2000);

// The callback gets executed as
// soon as 2 seconds are over.
// This behavior shows the
// execution of a callback.

Output:

Hello! GeeksforGeeks