async.waterfall is not working with mongoose asynchronous functions

Question

import Student from './api/user/student.model';
import Class from './api/user/class.model';
import User from './api/user/user.model';
import request from 'request';
import async from 'async';

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter;


function seedDb() {
    Student.remove({}, (err, data) => {
        Class.remove({}, (err, data1) => {
            User.remove({}, (err, data2) => {
                User.create({
                    email: 'admin@example.com',
                    password: 'admin'
                }, (err, data3) => {
                    User.findOne({
                        email: 'admin@example.com'
                    }, (err, foundUser) => {
                        foundUser.save((err, done) => {
                            let url = 'https://gist.githubusercontent.com/relentless-coder/b7d74a9726bff8b281ace936757953e5/raw/6af59b527e07ad3a589625143fb314bad21d4f8e/dummydata.json';
                            let options = {
                                url: url,
                                json: true
                            }
                            request(options, (err, res, body) => {
                                if (!err && body) {
                                    let classId;
                                    async.forEachOf(body, (el, i) => {
                                        console.log(i);
                                        if (i % 4 === 0) {
                                            async.waterfall([(fn) => {
                                                Student.create(el, (err, success) => {
                                                    fn(null, success._id);
                                                })
                                            }, (id, fn) => {
                                                console.log('The class creation function is called');
                                                Class.create({name: `Class ${i}`}, (err, newClass)=>{
                                                    classId = newClass._id;
                                                    newClass.students.push(id);
                                                    newClass.save()
                                                    fn(null, 'done');
                                                })
                                            }])
                                        } else {
                                            async.waterfall([(fn) => {
                                                Student.create(el, (err, success) => {
                                                    fn(null, success._id)
                                                })
                                            }, (id, fn) => {
                                                console.log('Class find function is called and classId', id, classId)
                                                Class.findById(classId, (err, foundClass) => {
                                                    console.log(foundClass)
                                                    foundClass.students.push(id);
                                                    foundClass.save();
                                                    fn(null, 'done');
                                                })

                                            }])
                                        }
                                    })

                                }
                            });
                        })

                    });
                })
            })

        })


    })

}

What I am trying to do is that, I have a sample data of 20 students. I have to seed my database with those 20 students distributed among 5 classes with each class containing 4 students.

What's preventing me from achieving this is for some of the iterations, the value of classId is undefined.

Can anyone help me with this?

Sridhar · Accepted Answer

What I am trying to do is that, I have a sample data of 20 students. I have to seed my database with those 20 students distributed among 5 classes with each class containing 4 students.

As Neil suggested, we can eliminate few callbacks and loops. The idea is to separate code based on the functionalities. Following is the approach I took to solve the problem with the available information.

'use strict';
let _ = require('lodash');
const BATCH_COUNT = 4;

function seedDb() {
  clearAll().then(() => {
    return Promisea.all([
      createSuperAdmin(),
      fetchStudentDetails()
    ]);
  }).then((result) => {
    let user = result[0];
    let body = result[1];
    return createStudents(body);
  }).then((users) => {
    let studentsBatch = groupByIds(_.map(users, '_id'), BATCH_COUNT);
    return addStudentsToClass(studentsBatch);
  }).then(() => {
    console.log('Success');
  }).catch((err) => {
    console.log('err', err.stack);
  });
}

function addStudentsToClass(batches) {
  let bulk = Class.collection.initializeOrderedBulkOp();
  for (let i = 0; i < _.size(batches); i++) {
    bulk.insert({
      name: `Class ${i}`,
      students: batches[i]
    });
  }
  return bulk.execute();
}

function createStudents(users) {
  let bulk = Student.collection.initializeOrderedBulkOp();
  _.each(users, (user) => {
    bulk.insert(user);
  });
  return bulk.execute();
}

function createSuperAdmin() {
  return User.findOneAndUpdate({
    email: 'admin@example.com',
    password: 'admin'
  }, {}, {
    new: true,
    upsert: true
  });
}

function groupByIds(ids, count) {
  let batch = [];
  let index = 0;
  while (index < ids.length) {
    let endIndex = index + count;
    batch.push(ids.slice(index, endIndex));
    index = endIndex;
  }
  return batch;
}

function fetchStudentDetails() {
  let options = {
    url: 'https://data.json', // Your URL
    json: true
  };
  return new Promise((resolve, reject) => {
    request(options, (err, res, body) => {
      if (err) {
        return reject(err);
      }
      return resolve(body);
    });
  });
}

function clearAll() {
  return Promise.all([
    Student.remove({}).exec(),
    Class.remove({}).exec(),
    User.remove({}).exec()
  ]);
}

async.waterfall is not working with mongoose asynchronous functions

Answers (2)

Modern async/await Version

Actual async.js version

Related Questions