Mongoose Connections

A Mongoose connection is a Node.js module that establishes and manages connections between a Node.js application and a MongoDB database. It optimizes resource utilization, handles connection pooling, and manages errors, facilitating efficient data operations.

Why do we need Mongoose Connections?

• Critical Link: Database connections in Mongoose establish a crucial link between Node.js applications and MongoDB.
• Performance Boost: Efficient connection management reduces overhead and latency, improving application performance.
• Scalability: Properly configured connections enable applications to handle increased workloads and growing data volumes.
• Error Resilience: Connection events and error handling mechanisms ensure applications respond to changes in database connectivity.

Steps to Establishing Mongoose Connections

• Install Mongoose: First, make sure you have Node.js installed. You can install Mongoose using npm, the Node.js package manager, by running the following command in your terminal:

npm install mongoose

• Create a Node.js Application: Now, create a Node.js application file, let’s name it app.js, and import the Mongoose library:

const mongoose = require('mongoose');

• Establish a Connection: To establish a connection to your MongoDB database, use the mongoose.connect() method. You typically provide a MongoDB connection URL as an argument. Replace ‘mongodb://localhost/mydatabase’ with your MongoDB URL.

mongoose.connect('mongodb://localhost/mydatabase', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
})
.then(() => {
    console.log('Connected to MongoDB');
})
.catch((error) => {
    console.error('Error connecting to MongoDB:', error);
});

• Handling Connection Events: It’s a good practice to handle connection events to know when the connection is open, closed, or if there’s an error. You can add event listeners for this purpose:

const db = mongoose.connection;

db.on('error', (error) => {
    console.error('MongoDB connection error:', error);
});

db.once('open', () => {
    console.log('Connected to MongoDB');
});

db.on('disconnected', () => {
    console.log('Disconnected from MongoDB');
});

• Close the ConnectionWhen your application exits or no longer needs the database connection, remember to close it:

process.on('SIGINT', () => {
    mongoose.connection.close(() => {
        console.log('Mongoose connection is disconnected due to application termination');
        process.exit(0);
    });
});

Connection Events and Error Handling

Connection Events in mongoose: In Mongoose, connection events play an important role in monitoring and controlling the interaction between your Node.js application and MongoDB databases. Key connection events include:

• ‘connected’: This is fired when a connection is successfully established with the MongoDB database.
• ‘error’: This is fired when there is an issue with the connection, such as an invalid URL or authentication error.
• ‘disconnected’: This indicates that the connection to the database has been lost.
• ‘reconnected’: This is Fired after a disconnected connection successfully reconnects to the database.
• ‘close’: This is fired to signal that the connection has been closed explicitly.

Example:

Javascript

const mongoose = require('mongoose');

// MongoDB connection URL
const mongoURI = 'mongodb://localhost/mydatabase';

// Connection options
const options = {
    useNewUrlParser: true,
    useUnifiedTopology: true,
};

// Establish the connection
mongoose.connect(mongoURI, options)
    .then(() => {
        console.log('Connected to MongoDB');
    })
    .catch((error) => {
        console.error('Error connecting to MongoDB:', error.message);

        // Handle specific error conditions
        if (error.name === 'MongoNetworkError') {
            console.error('Network error occurred. Check your MongoDB server.');
        } else if (error.name === 'MongooseServerSelectionError') {
            console.error('Server selection error. Ensure'
                + ' MongoDB is running and accessible.');
        } else {
            // Handle other types of errors
            console.error('An unexpected error occurred:', error);
        }
    });

// Handling connection events
const db = mongoose.connection;

db.on('error', (error) => {
    console.error('MongoDB connection error:', error);
});

db.once('open', () => {
    console.log('Connected to MongoDB');
});

db.on('disconnected', () => {
    console.log('Disconnected from MongoDB');
});

// Gracefully close the connection when the application exits
process.on('SIGINT', () => {
    mongoose.connection.close(() => {
        console.log('Mongoose connection is disconnected'
         + ' due to application termination');
        process.exit(0);
    });
});

Specific functions used in Mongoose

• mongoose.connect(url, options): Establishes a connection to the MongoDB database specified by the url and optional options.
• mongoose.Schema(definition, options):Defines a schema for your MongoDB documents using the specified definition and optional options.
• mongoose.model(name, schema): Creates a model based on a defined schema, allowing you to interact with MongoDB data using this model.
• Model.create(doc(s), [options], [callback]): Inserts one or more documents into the database.
• Model.find(conditions, [projection], [callback]): Retrieves documents from the database that match the specified conditions.
• Model.findOneAndUpdate(): Updates documents that match the conditions with the specified update.
• Model.deleteOne(conditions, [callback]): Deletes a single document that matches the conditions.

Creating a Connection

To open a connection to your MongoDB database using Mongoose, you typically do this at the beginning of your Node.js application. You need to specify the MongoDB URI, which includes information about the database server and authentication details.

const mongoose = require('mongoose');

// MongoDB URI
const dbURI = 'mongodb://localhost/mydatabase';

// Connect to MongoDB
mongoose.connect(dbURI, { useNewUrlParser: true, useUnifiedTopology: true });

// Event handling for successful connection
mongoose.connection.on('connected', () => {
    console.log('Mongoose connected to ' + dbURI);
});

// Event handling for connection error
mongoose.connection.on('error', (err) => {
    console.error('Mongoose connection error: ' + err);
});

// Event handling when the connection is disconnected
mongoose.connection.on('disconnected', () => {
    console.log('Mongoose disconnected');
});

Closing a Connection

Closing the connection is important when your Node.js application is shutting down or when the database connection is no longer needed. You can use mongoose.connection.close() to close the connection.

// Close the Mongoose connection when the Node.js process exits
process.on('SIGINT', () => {
    mongoose.connection.close(() => {
        console.log('Mongoose connection closed through app termination');
        process.exit(0);
    });
});

// Or you can close the connection
//explicitly when you're done with it
// mongoose.connection.close();