Educational

CRUD Operations with MongoDB

—

by

Saim Khalid
in

Introduction

When building full-stack applications or APIs, MongoDB is often the database of choice due to its flexibility, scalability, and ease of use. MongoDB is a NoSQL database that stores data in JSON-like documents, allowing you to store and query unstructured data efficiently. Combined with Node.js, which is well-suited for handling asynchronous operations, you can create robust web applications and APIs that interact with MongoDB.

In this post, we will focus on how to perform CRUD operations (Create, Read, Update, Delete) with MongoDB in a Node.js application. These operations are essential for interacting with a database, and understanding how to implement them is key to building powerful and dynamic applications.

We will use Mongoose, an Object Data Modeling (ODM) library for MongoDB and Node.js, to simplify working with MongoDB. Mongoose provides an elegant way to define models, validate data, and interact with the database.

1. Setting Up MongoDB and Node.js

Before we dive into the CRUD operations, let’s set up MongoDB and the Node.js environment.

1.1. Install MongoDB

First, ensure that MongoDB is installed on your local machine or that you have access to a MongoDB database hosted remotely. If you’re working locally, you can download and install MongoDB from the official website: MongoDB Download Center.

For remote MongoDB databases, you can use services like MongoDB Atlas (cloud-hosted MongoDB). Sign up for an account at MongoDB Atlas and create a database cluster to obtain your connection string.

1.2. Install Required Packages

Create a new directory for your project and initialize a Node.js project:

mkdir mongo-node-crud
cd mongo-node-crud
npm init -y

Now, install Mongoose to interact with MongoDB:

npm install mongoose

1.3. Connecting to MongoDB

Once Mongoose is installed, we can set up a connection to MongoDB. In your project directory, create a file called app.js:

const mongoose = require('mongoose');

// Connect to MongoDB
mongoose.connect('mongodb://localhost:27017/mydb', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('Connected to MongoDB'))
  .catch((err) => console.log('Failed to connect to MongoDB', err));

Replace 'mongodb://localhost:27017/mydb' with your MongoDB connection string if you’re using a remote database (e.g., from MongoDB Atlas).

2. Defining a Schema and Model in Mongoose

Before performing CRUD operations, we need to define a Schema and a Model in Mongoose. A Schema defines the structure of the documents within a collection, and the Model provides methods to interact with the database.

2.1. Define a User Schema

In this example, we’ll create a simple User model with a name, email, and age.

const mongoose = require('mongoose');

// Define a schema for the User
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);

module.exports = User;

This schema defines a User with the following fields:

  • name: A required string representing the user’s name.
  • email: A required string representing the user’s email, which must be unique.
  • age: A required number representing the user’s age.

We then create a Mongoose model called User, which will allow us to interact with the users collection in MongoDB.

3. Create Operation: Adding a New Document

The Create operation involves adding new documents to the MongoDB collection. In Mongoose, we use the save() method to create new documents.

3.1. Creating a New User

To create a new user, first, import the User model into your app.js file and use the save() method:

const User = require('./User');

// Create a new user
const createUser = async () => {
  const user = new User({

name: 'John Doe',
email: '[email protected]',
age: 30
  });

  try {

const result = await user.save();
console.log('User Created:', result);
  } catch (err) {

console.log('Error creating user:', err);
  }
};

createUser();

Here’s what’s happening:

  • We create a new instance of the User model with the necessary fields.
  • We then call the save() method on the user instance to save the document to the database.
  • If the save operation is successful, the user document is added to the users collection, and the result is logged.

4. Read Operation: Retrieving Documents

The Read operation allows us to retrieve documents from the MongoDB collection. There are several ways to query documents in Mongoose, including finding all documents, finding one by ID, and applying filters.

4.1. Finding All Users

To retrieve all users from the users collection, we use the find() method:

const getAllUsers = async () => {
  try {

const users = await User.find();
console.log('All Users:', users);
  } catch (err) {

console.log('Error retrieving users:', err);
  }
};

getAllUsers();
  • The find() method returns an array of all documents in the collection.
  • The result is logged to the console.

4.2. Finding a Single User by ID

To find a user by their unique _id, we use the findById() method:

const getUserById = async (id) => {
  try {

const user = await User.findById(id);
if (!user) {
  console.log('User not found');
} else {
  console.log('User found:', user);
}
  } catch (err) {

console.log('Error retrieving user by ID:', err);
  }
};

getUserById('60b8d6b0f7ae5c2d080b2e8d');
  • The findById() method takes a document’s _id and returns the corresponding document.
  • If no document is found, it returns null.

4.3. Querying with Filters

You can also use query filters to retrieve users based on specific criteria. For example, let’s retrieve users who are over 25 years old:

const getUsersByAge = async () => {
  try {

const users = await User.find({ age: { $gt: 25 } }); // $gt is MongoDB's "greater than" operator
console.log('Users over 25:', users);
  } catch (err) {

console.log('Error retrieving users by age:', err);
  }
};

getUsersByAge();
  • The find() method can accept an object with filters, such as { age: { $gt: 25 } }, which finds all users whose age is greater than 25.

5. Update Operation: Modifying Documents

The Update operation involves modifying existing documents. In Mongoose, we use methods like updateOne(), updateMany(), or findByIdAndUpdate() to update documents.

5.1. Updating a Single User by ID

To update a user’s data, we can use the findByIdAndUpdate() method, which finds a user by their _id and updates their fields:

const updateUser = async (id, updatedData) => {
  try {

const user = await User.findByIdAndUpdate(id, updatedData, { new: true });
console.log('Updated User:', user);
  } catch (err) {

console.log('Error updating user:', err);
  }
};

updateUser('60b8d6b0f7ae5c2d080b2e8d', { age: 31 });
  • The findByIdAndUpdate() method takes the _id of the user, the updated data, and an options object.
  • The { new: true } option ensures that the updated document is returned after the update.

5.2. Updating Multiple Users

You can also update multiple users at once using the updateMany() method. For example, let’s update all users over 30 years old and set their age to 35:

const updateUsersOver30 = async () => {
  try {

const result = await User.updateMany({ age: { $gt: 30 } }, { age: 35 });
console.log('Updated Users:', result);
  } catch (err) {

console.log('Error updating multiple users:', err);
  }
};

updateUsersOver30();
  • The updateMany() method accepts a filter and the update operation.
  • This will update all documents that match the filter.

6. Delete Operation: Removing Documents

The Delete operation allows

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *