How do you return value from an async method using promise which itself is calling another async Method in Nodejs?

Question

I have implemented an operation which is verifying if data is available in db and then storying the data. For this i have created two methods as follows :

function IfUserExists(userId) {
    logger.info(`Checking If ${userId} exists`);
    return new Promise(resolve => {
        var query = { _id: userId }
        MongoClient.connect(url, function (err, db) {
            if (err) {
                logger.error(err.message);
                db.close();
                resolve({ response: false, Message: err.message });
            }
            var dbo = db.db(database);
            dbo.collection("users").find(query).count(function (err, result) {
                if (err) {
                    logger.error(err.message);
                    db.close();
                    resolve({ response: false, Message: err.message });
                }
                if (result == 1)
                    resolve({ response: true, Message23: `${userId} does exists` });
                else
                    resolve({ response: false, Message: `${userId} does not exists` });
                db.close();
            });
        });
    });
}

async function createForm(userId) {
    return new Promise(async resolve => {
        var IfUserExists_flag = await User.IfUserExists(userId);
        console.log("IfUserExists_flag", IfUserExists_flag);
        if (IfUserExists_flag.response) {
            MongoClient.connect(url, (err, db) => {
                if (err) {
                    logger.error(err.message);
                    db.close();
                    resolve({ response: false, Message1: err.message });
                } else {
                    var dbo = db.db(database);
                    console.log("database", database);
                    var data = { userId: userId, questionAnsId: [] }
                    dbo.collection("Forms").insertOne(data, (err, result) => {
                        if (err) {
                            logger.error(err.message);
                            db.close();
                            resolve({ response: false, Message2: err.message });
                        } else {
                            logger.info(result);
                            resolve({ response: true, Message3: result });
                            db.close();
                        }
                    });
                }
            });
            resolve(IfUserExists_flag);
        } else {
            log.error("Cannot Create Form :" + IfUserExists_flag)
            resolve(IfUserExists_flag);
        }
    });
}

However, even if everything is done properly, its still giving me response from IfUserExists rather then from the createForm. Any idea how to resolve it?

Answer 1

Your problem is that resolve(IfUserExists_flag); is called before MongoClient.connect(url, (err, db) => { callback is called - and since a Promise can only be resolved once, the first one executed "wins" - just remove resolve(IfUserExists_flag); in the if block

However, having an async executor in the new Promise is also an anti pattern

Promisify only what you need to, the mongodb stuff - and return that Promise

async function createForm(userId) {
    var IfUserExists_flag = await User.IfUserExists(userId);
    console.log("IfUserExists_flag", IfUserExists_flag);
    if (IfUserExists_flag.response) {
        // make the Promise here to promisify the Mongo stuff
        return new Promise((resolve, reject) => {
            MongoClient.connect(url, (err, db) => {
                if (err) {
                    logger.error(err.message);
                    db.close();
                    resolve({ response: false, Message1: err.message });
                } else {
                    var dbo = db.db(database);
                    console.log("database", database);
                    var data = { userId: userId, questionAnsId: [] }
                    dbo.collection("Forms").insertOne(data, (err, result) => {
                        if (err) {
                            logger.error(err.message);
                            db.close();
                            resolve({ response: false, Message2: err.message });
                        } else {
                            logger.info(result);
                            resolve({ response: true, Message3: result });
                            db.close();
                        }
                    });
                }
            });
        });
    } else {
        log.error("Cannot Create Form :" + IfUserExists_flag)
        return IfUserExists_flag;
    }
}

This isn't the cleanest either ... but it's OK