Performing Database Operations using Mongoose

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It simplifies interacting with MongoDB by providing a higher-level abstraction, enabling you to define schemas, models, and perform CRUD operations more easily. This article explores how to perform essential database operations—Create, Read, Update, and Delete (CRUD)—using Mongoose in a Node.js application.

Prerequisites

Before we dive into the code, ensure that:

1. You have Node.js and MongoDB installed on your system.
2. You’ve installed Mongoose in your Node.js project by running the following command:

   npm install mongoose
   

3. You have a MongoDB database running either locally or on MongoDB Atlas.

Step 1: Set Up a Mongoose Connection

Before performing any database operations, you need to connect your Node.js application to a MongoDB database using Mongoose.

Here’s how you can set up a basic Mongoose connection in your server.js or app.js file:

const mongoose = require('mongoose');

// Connection URI for MongoDB
const uri = 'mongodb://localhost:27017/mydatabase'; // Change as per your setup

// Connect to MongoDB using Mongoose
mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('Connected to MongoDB'))
  .catch((err) => console.error('MongoDB connection error:', err));

Explanation:

• mongoose.connect(): Establishes a connection to the MongoDB database.
• useNewUrlParser and useUnifiedTopology: These options are used to avoid warnings related to MongoDB’s deprecation.

Step 2: Define a Mongoose Schema

Schemas define the structure of the documents in your MongoDB collection. In this step, we’ll create a User schema to store basic user data (e.g., name, email, and age).

const mongoose = require('mongoose');

// Define a User schema
const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  age: { type: Number, required: true }
});

// Create a model based on the schema
const User = mongoose.model('User', userSchema);

Explanation:

• new mongoose.Schema({...}): Defines the structure and validation rules for the data.
• required: Ensures that certain fields must be provided when creating a document.
• unique: Guarantees that the email field is unique across all documents in the collection.

Step 3: Create (Insert) Data into MongoDB

Now that we’ve defined our schema, let’s create a new user and insert it into the MongoDB database.

const newUser = new User({
  name: 'Jane Doe',
  email: 'janedoe@example.com',
  age: 28
});

// Save the user to the database
newUser.save()
  .then((user) => {
    console.log('User saved:', user);
  })
  .catch((err) => {
    console.error('Error saving user:', err);
  });

Explanation:

• new User({...}): Creates an instance of the User model with the data you want to store.
• save(): Saves the created document into the MongoDB collection.

Step 4: Read (Query) Data from MongoDB

Once you have data in the database, you can query it using Mongoose methods like find(), findOne(), and findById().

Find All Users:

User.find()
  .then((users) => {
    console.log('All users:', users);
  })
  .catch((err) => {
    console.error('Error fetching users:', err);
  });

Find a Single User by Email:

User.findOne({ email: 'janedoe@example.com' })
  .then((user) => {
    console.log('User found:', user);
  })
  .catch((err) => {
    console.error('Error finding user:', err);
  });

Find a User by ID:

const userId = 'some_user_id_here'; // Use an actual ObjectId here
User.findById(userId)
  .then((user) => {
    console.log('User found by ID:', user);
  })
  .catch((err) => {
    console.error('Error finding user by ID:', err);
  });

Explanation:

• User.find(): Retrieves all documents in the users collection.
• User.findOne(): Fetches the first document that matches the provided query (in this case, by email).
• User.findById(): Retrieves a document by its unique MongoDB ObjectId.

Step 5: Update Data in MongoDB

Updating data is simple with Mongoose. You can use methods like updateOne(), updateMany(), or findByIdAndUpdate() to modify documents.

Update a User’s Age:

User.updateOne({ email: 'janedoe@example.com' }, { $set: { age: 29 } })
  .then((result) => {
    console.log('User updated:', result);
  })
  .catch((err) => {
    console.error('Error updating user:', err);
  });

Update a User by ID:

User.findByIdAndUpdate(userId, { $set: { age: 30 } }, { new: true })
  .then((user) => {
    console.log('User updated by ID:', user);
  })
  .catch((err) => {
    console.error('Error updating user by ID:', err);
  });

Explanation:

• updateOne(): Updates the first document that matches the query.
• findByIdAndUpdate(): Finds a document by its ObjectId and updates it.
• $set: The $set operator is used to update specified fields in the document.
• new: true: Ensures the updated document is returned after the modification.

Step 6: Delete Data from MongoDB

Mongoose makes it easy to remove data using methods like deleteOne(), deleteMany(), or findByIdAndDelete().

Delete a User by Email:

User.deleteOne({ email: 'janedoe@example.com' })
  .then((result) => {
    console.log('User deleted:', result);
  })
  .catch((err) => {
    console.error('Error deleting user:', err);
  });

Delete a User by ID:

User.findByIdAndDelete(userId)
  .then((user) => {
    console.log('User deleted by ID:', user);
  })
  .catch((err) => {
    console.error('Error deleting user by ID:', err);
  });

Explanation:

• deleteOne(): Deletes the first document that matches the query.
• findByIdAndDelete(): Finds and deletes a document by its unique ObjectId.

Step 7: Using Mongoose Validation

Mongoose also supports built-in data validation and custom validation for your schemas. Here’s an example of adding validation rules to the User schema:

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true, match: /.+\@.+\..+/ },
  age: { type: Number, required: true, min: 18, max: 100 }
});

In this schema:

• match ensures that the email field follows a valid email format.
• min and max enforce age restrictions.

Conclusion

Mongoose simplifies working with MongoDB by providing a structured way to define data models and perform database operations. With Mongoose, you can easily:

• Create new documents and insert them into MongoDB.
• Query the database to read and retrieve data.
• Update existing documents based on certain criteria.
• Delete documents from the database.

With its robust support for validation and schema definitions, Mongoose allows you to build efficient and scalable applications that interact seamlessly with MongoDB.