Mongoose In-Depth

Mongoose is a MongoDB Object Data Modeling (ODM) library for Node.js. It provides a powerful
framework to model your data, define schemas, perform CRUD operations, manage relationships
between different models, and add validation, middleware, and more. In this in-depth explanation, we
will dive into key concepts, features, and advanced topics in Mongoose.

1. Mongoose Basics

1.1 Installation and Setup

Mongoose is an npm package that can be installed in your Node.js project.

npm install mongoose

You need to establish a connection to MongoDB using mongoose.connect():

const mongoose = require('mongoose');

// Connect to MongoDB

mongoose.connect('mongodb://localhost/mydatabase', { useNewUrlParser: true, useUnifiedTopology:

.then(() => console.log('MongoDB connected'))

.catch(err => console.log('MongoDB connection error: ', err));

2. Schema and Model in Mongoose

2.1 Schema Definition

A schema defines the structure of the documents within a MongoDB collection. It outlines the fields and
their types, validation, default values, and more.

const mongoose = require('mongoose');

// Define a schema

const userSchema = new mongoose.Schema({

name: {

type: String,

required: true,
 },

email: {

type: String,

required: true,

unique: true,

},

age: {

type: Number,

min: 18, // Validation: age should be 18 or older

},

createdAt: {

type: Date,

default: Date.now,

},

});

// Create a model based on the schema

const User = mongoose.model('User', userSchema);

module.exports = User;

2.2 Model Creation

A model is a constructor function that allows us to create and interact with documents that follow the
schema.

const User = mongoose.model('User', userSchema);

After defining the model, you can perform operations like creating, reading, updating, and deleting
(CRUD) documents in the associated MongoDB collection.

3. CRUD Operations with Mongoose

3.1 Create Operation

const newUser = new User({

name: 'Alice',

email: '[email protected]',

age: 30,

});

newUser.save()

.then(user => console.log('User created:', user))

.catch(err => console.log('Error creating user:', err));

You can also use create() to simplify the creation process:

User.create({

name: 'Bob',

email: '[email protected]',

age: 25,

})

.then(user => console.log('User created:', user))

.catch(err => console.log('Error creating user:', err));

3.2 Read Operation

To find documents, use the find(), findOne(), or findById() methods.

// Find all users

User.find()

.then(users => console.log('All Users:', users))

.catch(err => console.log('Error finding users:', err));

// Find a user by email

User.findOne({ email: '[email protected]' })

.then(user => console.log('Found User:', user))

.catch(err => console.log('Error finding user:', err));

User.findById('60c7f8f5b5f0d44b88abec30')

.then(user => console.log('User by ID:', user))

.catch(err => console.log('Error finding user:', err));

3.3 Update Operation

You can update documents using methods like update(), updateOne(), findByIdAndUpdate(), etc.

// Update a user by email

User.updateOne({ email: '[email protected]' }, { age: 31 })

.then(result => console.log('Update result:', result))

.catch(err => console.log('Error updating user:', err));

// Update a user and return the updated document

User.findByIdAndUpdate('60c7f8f5b5f0d44b88abec30', { age: 32 }, { new: true })

.then(user => console.log('Updated User:', user))

.catch(err => console.log('Error updating user:', err));

3.4 Delete Operation

To delete a document, you can use deleteOne(), deleteMany(), or findByIdAndDelete():

// Delete a user by ID

User.findByIdAndDelete('60c7f8f5b5f0d44b88abec30')

.then(result => console.log('Deleted User:', result))

.catch(err => console.log('Error deleting user:', err));

4. Mongoose Query Helpers

Mongoose provides built-in methods to handle complex queries such as pagination, sorting, and
filtering.

4.1 Sorting and Pagination

User.find()

.sort({ createdAt: -1 }) // Sort by createdAt in descending order

.skip(10) // Skip first 10 users for pagination

.exec((err, users) => {

if (err) {

console.log(err);

} else {

console.log('Paginated Users:', users);

});

4.2 Filtering

You can use query operators such as $gt, $lt, $in, $ne, etc., to filter results.

User.find({ age: { $gte: 18 } })

.then(users => console.log('Adult Users:', users))

.catch(err => console.log('Error finding users:', err));

5. Mongoose Middleware

Middleware in Mongoose can run before or after certain actions, such as saving, updating, or removing
documents. This can be useful for data validation, logging, or modifying data before it is saved.

5.1 Pre and Post Middleware

• Pre Middleware: Runs before the action is performed (e.g., before saving a document).

• Post Middleware: Runs after the action is performed (e.g., after a document is saved).

// Pre-save middleware for hashing passwords

userSchema.pre('save', async function (next) {

if (this.isModified('password')) {

this.password = await bcrypt.hash(this.password, 8);

next();

});
// Post-save middleware

userSchema.post('save', function (doc, next) {

console.log('New user saved:', doc);

next();

});

5.2 Validation Middleware

You can use middleware to validate the data before saving.

userSchema.pre('save', function (next) {

if (!this.email.includes('@')) {

return next(new Error('Email is not valid'));

next();

});

6. Mongoose Virtuals

A virtual is a field that is not stored in the database but is derived from other fields. It's often used for
computed properties.

6.1 Defining a Virtual

userSchema.virtual('fullName').get(function () {

return this.firstName + ' ' + this.lastName;

});

This will add a fullName property to the document without saving it to the database.

7. Mongoose Population

Population is the process of replacing fields that store ObjectIds with the actual documents that are
referenced.

7.1 Example of Population

Imagine you have a Post model that has a reference to the User model for the author.

const postSchema = new mongoose.Schema({

content: String,

author: {

type: mongoose.Schema.Types.ObjectId,

ref: 'User', // Reference to the User model

},

});

const Post = mongoose.model('Post', postSchema);

// Populate the author field with user data

Post.find()

.populate('author') // Populate the author field with the actual user data

.exec((err, posts) => {

if (err) console.log(err);

else console.log(posts);

});

8. Mongoose Indexing

Indexing can improve the performance of queries that are frequently used, especially for large datasets.

8.1 Defining an Index

userSchema.index({ email: 1 }); // Index on the 'email' field

You can also define compound indexes and set options like uniqueness.

9. Advanced Mongoose Features

9.1 Aggregation Framework

Mongoose supports the MongoDB aggregation framework, which allows you to perform complex
queries, including grouping, sorting, and transforming data.

User.aggregate([
 { $match: { age: { $gte: 18 } } },

{ $group: { _id: null, averageAge: { $avg: '$age' } } }

])

.then(result => console.log('Average Age:', result))

.catch(err => console.log('Error in aggregation:', err));

9.2 Transactions

Mongoose supports transactions in MongoDB to handle multi-step operations that need to be

const session = await mongoose.startSession();

session.startTransaction();

try {

await User.create([{ name: 'Alice', email: '[email protected]' }], { session });

await session.commitTransaction();

} catch (error) {

await session.abortTransaction();

console.error('Transaction aborted:', error);

} finally {

session.endSession();

10. Conclusion

Mongoose is a powerful tool that simplifies interacting with MongoDB from a Node.js environment. It
provides a rich set of features such as schema-based modeling, middleware, population, validation, and
aggregation, making it easier to manage and manipulate data. Understanding how to use Mongoose
effectively will help you build robust applications with MongoDB.