mongoose: Way to handle mongoose.connect() error in promise catch handler

How to handle mongoose.connect() error in catch handler? I want to use application initialization chain but can’t do that because mongoose.connect() does not return rejected promise. It returns rejected promise only if I specify callback, but it’s not a perfect solution.

Example:

mongoose.connect('mongodb://127.0.0.2/test') // if error it will throw async error
    .then(() => { // if all is ok we will be here
        return server.start();
    })
    .catch(err => { // we will not be here...
        console.error('App starting error:', err.stack);
        process.exit(1);
    });

Workaround:

mongoose.connect('mongodb://127.0.0.2/test', function() { /* dummy function */ })
    .then(() => {
        return server.start();
    })
    .catch(err => { // mongoose connection error will be handled here
        console.error('App starting error:', err.stack);
        process.exit(1);
    });

I think mongoose.connect() throws async error instead of return rejected promise in order to not break backward compatibility. Users expect that application will be finished with error code if something went wrong with mongoose connection establishment. If mongoose.connect() returns rejected promise application will be finished with 0 code and nothing will be output to console. So it will be good to have some way to say mongoose.connect() to return promise. Maybe something like exec():

mongoose.connect('mongodb://127.0.0.2/test').exec()
    .then(() => { // if all is ok we will be here
        return server.start();
    })
    .catch(err => { // if error we will be here
        console.error('App starting error:', err.stack);
        process.exit(1);
    });

About this issue

Original URL
State: closed
Created 8 years ago
Reactions: 10
Comments: 31 (6 by maintainers)

Commits related to this issue

Handle errors during initial connect, avoid "unhandled promise reject" When creating the initial connection towards mongodb, it could be down, and to avoid having unhandled promise rejections (which ... — committed to asilluron/hapi-mongoose by nover 6 years ago

Most upvoted comments

Use the callback of mongoose.connect to catch any error during the connection. You can start you server in the event open.

        mongoose.connection.once('open', function() {
            logger.info('MongoDB event open');
            logger.debug('MongoDB connected [%s]', url);

            mongoose.connection.on('connected', function() {
                logger.info('MongoDB event connected');
            });

            mongoose.connection.on('disconnected', function() {
                logger.warn('MongoDB event disconnected');
            });

            mongoose.connection.on('reconnected', function() {
                logger.info('MongoDB event reconnected');
            });

            mongoose.connection.on('error', function(err) {
                logger.error('MongoDB event error: ' + err);
            });

            // return resolve();
            return server.start();
        });

        return mongoose.connect(url, options, function(err) {
            if (err) {
                logger.error('MongoDB connection error: ' + err);
                // return reject(err);
                process.exit(1);
            }
        });

+24

mathieug on May 10, 2016

mongoose.connect('mongodb://localhost/dbCollection', function(err, db) {
    if (err) {
        console.log('Unable to connect to the server. Please start the server. Error:', err);
    } else {
        console.log('Connected to Server successfully!');
    }
});

+21

nasr18 on May 10, 2016

Just to confirm for anyone coming later, this works as expected:

mongoose.connect('http://127.0.0.1:27017/test')
  .then(() => {
    server.start();
  })
  .catch((err) => {
    console.log('Error on start: ' + err.stack);
    process.exit(1);
  });

+12

chidiwilliams on Jun 20, 2018

I have the same issue as @matheo. Just opened this ticket:

https://github.com/christkv/mongodb-core/issues/163

cbratschi on Feb 13, 2017

That’s why I created this issue 😃

Jokero on May 10, 2016

Why? No difference at all. When connection is opened, mongoose.connect callback will be called as well as returned promise will be fulfilled and open event will be emitted. So you can use what you want

Jokero on May 10, 2016

I have the same issue.

I’d like to be able to use mongoose.connect(...).catch(failCallback) but when an error occurs upon initial connection attempt failCallback does not execute. There’s something wrong with the MongooseThenable pseudo-promise that mongoose.connect returns. Moreover I have configured mongoose.Promise = require('bluebird') and I really expect such async calls to return a real promise, a Bluebird one in my case.

The problem with my failCallback not executing, however, happens only initially, i.e.:

// First kill mongod instance so that Mongoose cannot connect and start the app
mongoose.connect(uri, options).catch(failCallback); // failCallback does _not_ get called
// Then stop the app, start mongod instance so that Mongoose can connect, start the app
mongoose.connect(uri, options).then(successCallback); // successCallback gets called
// Then kill mongod instance so that Mongoose disconnects (while the app is running)
mongoose.connection.on('disconnected', function () {
  setTimeout(function () {
    mongoose.connect(uri, options).catch(reconnectFailCallback); // now reconnectFailCallback _does_ get called
  }, randomDelayOfAboutASecond);
});

But indeed it works like that (which is nonsensical):

// First kill mongod instance so that Mongoose cannot connect and start the app
var dummyNoopCallback = function () {};
mongoose.connect(uri, options, dummyNoopCallback).catch(failCallback); // failCallback _does_ get called

Why is that?

radkodinev on Jun 8, 2016

@Jokero sorry dude… misunderstood your question. 😃

nasr18 on May 10, 2016

@nasr18 What did you mean? 😃 I don’t want to use callback)

Jokero on May 10, 2016