如何确保在从 Mongoose 中的函数返回之前执行异步调用？

Question

I am new to mongoose and in order to prevent ASYNC OF HELL I came Across an npm package called async . I have used the async.series of the async npm package and my code looks in the given format given below

var userId=1234
function findUser(callback){
  user.findOne({userId:userId}).exec(function(err,userData){
         //Some Logic
   var schoolId=123;
   var schoolName=findSchool(123);     
   findStudents(schoolName);

   var schoolId=1234;
   var schoolName=findSchool(123);     
   findStudents(schoolName);

   callback(null);
  });
}

function findSchool(schoolId){
 school.findOne({schoolId:schoolId}).exec(function(err),schoolDetails){
    //Some Logic  
  });
    var schoolName="XYZ High School"
    return(schoolName);
}

 function findStudents(schoolName){
  student.findOne({schoolName:schoolName}).exec(function(err),studentDetails{
    //Some Logic  
  });
 }

 async.series([findUser],function(err){
     // for Error Handling
    }

Here I am using an async series function to prevent the ASYNC of HELL. I am calling findUser function in the async series call which is find the user details from my User model using the userId and then I am calling the findSchool function inside the findUser function which finds school details for the given SchoolId in School model. Once the function returns the call I am trying to find the students based on a particular schoolName using the findStudents function on the Student model.

The process is repeated for a different schoolId . My Issue comes when I call the findSchool function. Since it has a asynchronous call ( findOne ) on the school model, I am able to return the value of the schoolName even before the findOne is completed for the model.

Is there a way to ensure that the given function findSchool doesn't return the value of the schoolName until the school.findOne() has completed successfully? Just to add more clarity I don't want to my return statement inside the findOne of the findSchool function.

Answer 1

Async.each or async.waterfall should do the trick, I think.

The main thing here is that you're using return statements in your async functions, which will return before the async function has actually completed, and thus they won't pass along what you need.

You have to use async functions and callbacks for this. You can still have your functions separated like you want in your code, but you'll have to add callback functions instead of returns.

Answer 2

You should still use async but you need async.waterfall for that. Here is what you need to consider:

A main method to call your async function:

var getInformation = function(){
  async.waterfall([
    //Array of your functions in order, we will be back here later
  ], function (err) {
       if(err){
         console.log(err);
       }else{
         console.log('Everything OK!');
     }
  );
}

Then you need your functions to be async friendly, that means you should use callbacks and give your data from one function to another. Something like this:

function findUser(callback){
  //Do something
  if('Everything OK'){
    callback(err, yourData); //err should be null if everything is OK and yourData should be the data that you wanna use in your next function. e.g. schoolId 
  }else{
    callback(err); //Something was wrong, "err" should have something different to null
  }
}

function findSchool(callback, schoolId){ //Note that we receive the parameter schoolId here but not in the first function
  //Do something
  if('Everything OK'){
    callback(err, yourData); //err should be null if everything is OK and yourData should be the data that you wanna use in your next function. e.g. schoolName 
  }else{
    callback(err); //Something was wrong, "err" should have something different to null
  }
}

function findStudents(callback, schoolName){
  //Do something
  if('Everything OK'){
    callback(err); //err should be null if everything is OK if this is the last function maybe we don't need to send back more data from here 
  }else{
    callback(err); //Something was wrong, "err" should have something different to null
  }
}

Then you should call your functions in your main method:

var getInformation = function(){
  async.waterfall([
    findUser,
    findSchool,
    findStudents
    //Note that there is no need to tell the functions the parameters they are sending or receiving here
  ], function (err) {
       if(err){
         console.log(err);
       }else{
         console.log('Everything OK!');
     }
  );
}

And that's it, you have 3 functions that should be executed one after the other and no callback hell is needed.