title: NodeJS/Express/Mongoose get error Can't set headers after they are sent
body: <p>I'm using MEAN stack with Mongoose to query data on MongoDB. First call into /api/Validations is fine but on second time, it always gets this error:
  <img src="https://i.stack.imgur.com/Sf0R4.png" alt="enter image description here"></p>
  
  <p>Here my code, server.js:</p>
  
  <pre><code>var express = require('express')
      , app = express()
      , bodyParser = require('body-parser')
      , breezeRoutes = require('./breeze-routes')
      , controller = require('./controller')
      , compress = require('compression')
      , cors = require('cors')
      , errorHandler = require('./errorHandler')
      , favicon = require('static-favicon')
      , fileServer = require('serve-static')
      , http = require('http')
      , isDev = app.get('env') === 'development'
      , logger = require('morgan')
      , port = process.env["PORT"] || 4000;
  
  app.use(favicon());
  app.use(logger('dev'));
  app.use(compress());
  app.use(bodyParser()); // both json &amp; urlencoded  
  app.use(cors());          // enable ALL CORS requests
  controller.init(app); // Configure  routes for REST API      
  app.use(errorHandler);
  
  // create server (in case interested in socket.io)
  var server = http.createServer(app);
  
  // Start listening for HTTP requests
  server.listen(port); // app.listen( port ); // if we weren't using 'server'
  
  console.log('\nListening on port ' + port);
  </code></pre>
  
  <p>controller.js:</p>
  
  <pre><code>(function (controller) {
      var mongooseDB = require("./mongooseDB");
  
      controller.init = configureRoutes;
      function configureRoutes(app) {  
          app.get('/api/Validations', getValidations);     
      }  
  
      function getValidations(req, res, next) {
          mongooseDB.getValidations(makeResponseHandler(res, next));
      }
  
      function makeResponseHandler(res, next) {
          // returns a function that handles response from a Breeze Mongo query or save
          return function (err, results) {
              if (err) {
                  next(err);
              } else {
                  // Prevent browser from caching results of API data requests
                  //res.setHeader('Cache-Control', 'no-cache, private, no-store, must-revalidate, max-stale=0, post-check=0, pre-check=0');
                  //res.setHeader("Content-Type:", "application/json");
                  res.send(JSON.stringify(results));
                  res.end();
              }
  
          }
      } 
  })(module.exports)
  </code></pre>
  
  <p>mongooseDB.js</p>
  
  <pre><code>(function (mongooseDB) {
      var schema = require("./schema");
      var validator = require("./validator");
      var mongoUrl = 'mongodb://localhost:27017/dpt';
      var mongoose = require('mongoose');
      var Validations = mongoose.model('Validations', schema.ValidationSchema);
  
      mongooseDB.getValidations = function (next) {
          mongoose.connect(mongoUrl);
          mongoose.connection.on('open', function () {
              var query = Validations.find();
              query.exec(function (err, docs) {
                  mongoose.disconnect();
                  if (err) {
                      next(err, null);
                  } else {
                      next(null, docs);
                  }
              });
          });
      };
  })(module.exports)
  </code></pre>
  
  <p>validationSchema.js</p>
  
  <pre><code>var mongoose = require('mongoose');
  var Schema = mongoose.Schema;
  var validationSchema = new Schema({
      ValidationID: { type: String, index: 1, required: true, unique: true },
      Integer: { type: Number, required: true },
      String: String,
      Date: Date,
      BeforeDate: Date,
      AfterDate: Date,
      Age: Number,
      CreditCard : Number,
      Email: String,
      Phone: String,
      URL: String,
      Zip: String,
      StartsWithDPT: String,
      ContainsDPT: String
  }, { collection: 'Validations' });
  exports.ValidationSchema = validationSchema;
  </code></pre>
  
  <p>I read all "can't set headers after they are sent" on stack overflow and try to apply some approach but no luck. 
  Please help me.</p>
  
  <p><strong>UPDATE 1:</strong></p>
  
  <p>I think this is Mongoose issue because after I changed it to use MongoDB, it works fine: 
        (function (database) {
           var MongoClient = require('mongodb').MongoClient;</p>
  
  <pre><code>        database.getDb = getDb;
          database.getValidations = getValidations;
  
          var db = null;
          // todo: get from configuration
          var mongoUrl = 'mongodb://localhost:27017/dpt';
          var mongoOptions = {
              server: { auto_reconnect: true }
          };
  
          function getDb(next) {
              if (db) {
                  next(null, db);
              } else {
                  MongoClient.connect(mongoUrl, mongoOptions, function (err, theDb) {
                      if (err) {
                          err.message = (err.message || '') + '. Is the MongoDb server running?';
                          next(err, null);
                      } else {
                          db = theDb;
                          next(null, db);
                      }
                  });
              }
          }
  
          function getValidations(next) {
              getDb(function (err, data) {
                  if (err) {
                      err.message = (err.message || '') + '. Is the MongoDb server running?';
                      next(err, null);
                  } else {
                      data.collection("Validations").find().toArray(function (err1, results) {
                          next(null, results);
                      });;
  
                  }
              });
          }    
  })(module.exports)
  </code></pre>
  
  <p>Now I can call /api/Validations many times as I want by this issue is still there because this project requires Mongoose. </p>