CODEWITHSUNDEEP
javascriptnode.jsasynchronouspromise
Patrick Connors
Patrick Connors

Reputation: 6065

Using mongoose promises with async/await

I'm trying to get the hang of using Mongoose promises with the async/await functionality of Node.js. When my function printEmployees is called I want to save the list of employees which are queried by the orderEmployees function. While, the console.log statement inside orderEmployees returns the expected query, the console.log inside of printEmployees returns undefined, suggesting that I'm not returning the promise correctly.

I'm new to promises so entirely possible that I'm not correctly understanding the paradigm... any help is much appreciated.

  printEmployees: async(company) => {
    var employees = await self.orderEmployees(company);
    // SECOND CONSOLE.LOG
    console.log(employees);
  },

  orderEmployees: (companyID) => {
    User.find({company:companyID})
    .exec()
    .then((employees) => {
      // FIRST CONSOLE.LOG
      console.log(employees);
      return employees;
    })
    .catch((err) => {
      return 'error occured';
    });
  },

Upvotes: 38

Views: 99917

Answers (5)

nicholaswmin
nicholaswmin

Reputation: 22949

You need to return your Promise.

  • Currently, you are awaiting on a function that returns undefined.
  • await only actually "waits" for the value if it's used with a Promise.
  • Always keep in mind that you can only await Promises or async functions, which implicitly return a Promise1.
orderEmployees: (companyID) => {
  return User.find({ company:companyID }).exec()
}

Also really important, you should throw instead of return in your .catch handler. Returning from within a .catch handler will cause the promise chain to trigger it's .then instead of it's .catch thus breaking the error handling chain.

Better yet, don't include .catch at all and let the the actual error bubble up the promise chain, instead of overriding it with your own non-descriptive 'error occured' message.

Error conditions should throw the error, not return it.

1 You can also await non-Promises, but only for values that are evaluated synchronously.

Upvotes: 30

Mohammed Ramadan
Mohammed Ramadan

Reputation: 723

if you're going to use async/await then it works like this.

  • await in front of the function that returns a promise.
  • async in front of the wrapping function.
  • wrap the function body inside try/catch block.

Please have a look on this function, it is a middleware before i execute a specific route in express.

const validateUserInDB = async (req, res, next) => {
    try {
        const user = await UserModel.findById(req.user._id);
        if (!user) return res.status(401).json({ message: "Unauthorized." });
        req.user = user;
        return next();
    } catch (error) {
        return res.status(500).json({ message: "Internal server error." })
    }
}
  • The code after await is waiting the promise to be resolved.
  • Catch block catches any error happened inside the try block even if the error that is triggered by catch method comes from awaiting promise.

Upvotes: 3

James
James

Reputation: 82096

You need to return a Promise from orderEmployees

orderEmployees: companyId => User.find({ companyId }).exec()

If you want to do some error handling or pre-processing before you return then you can keep your code as is but just remember to return the result (promises are chainable).

Upvotes: 3

Tamas Hegedus
Tamas Hegedus

Reputation: 29916

In order to make orderEmployees behave like async functions, you have to return the resulting promise. There are two rules to follow when using promises without async/await keywords:

  1. A function is asynchronous if it returns a Promise
  2. If you have a promise (for example returned by an async function) you must either call .then on it or return it.

When you are using async/await then you must await on promises you obtain.

This said you will notice that you do not return the promise generated inside orderEmployees. Easy to fix, but its also easy to rewrite that function to async too.

orderEmployees: (companyID) => {
  return User.find({company:companyID}) // Notice the return here
  .exec()
  .then((employees) => {
    // FIRST CONSOLE.LOG
    console.log(employees);
    return employees;
  })
  .catch((err) => {
    return 'error occured';
  });
},

or 

orderEmployees: async(companyID) => {
  try {
    const employees = await User.find({company:companyID}).exec();
    console.log(employees);
    return employees;
  } catch (err) {
    return 'error occured';
  }
},

PS: the error handling is somewhat flawed here. We usually do not handle errors by returning an error string from a function. It is better to have the error propagate in this case, and handle it from some top-level, UI code.

Upvotes: 49

barnski
barnski

Reputation: 1732

You are not returning a Promise from orderEmployees.

printEmployees: async(company) => {
  var employees = await self.orderEmployees(company);
  // SECOND CONSOLE.LOG
  console.log(employees);
},

orderEmployees: (companyID) => {
  return User.find({company:companyID})
 .exec()
 .then((employees) => {
   // FIRST CONSOLE.LOG
   console.log(employees);
   return employees;
 })
 .catch((err) => {
   return 'error occured';
 });
},

Upvotes: 4

Related Questions