Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js, designed to work in an asynchronous environment. Mongoose provides a straightforward API to interact with MongoDB. It allows you to model your application data and perform operations like create, read, update, and delete (CRUD) in MongoDB.
In this article, we will explain the important Mongoose Document API functions that allow us to interact with MongoDB documents, including creating, retrieving, updating, and deleting documents.
What is a Mongoose Document?
In Mongoose, a document corresponds to a MongoDB document. When you use a Mongoose model to create a new document, it behaves as an instance of the model. This instance allows you to interact with MongoDB in an easy-to-use manner, providing a range of methods to perform operations on the document.
Setting Up Mongoose in Your Node.js Application
Before we dive into the Mongoose Document API, let’s first set up a Node.js application and install the required dependencies.
Step 1: Install Mongoose
To get started, you need to install the Mongoose package. You can do this by running the following command in your terminal:
npm install mongoose
Step 2: Create a Node.js Application
After that, create a folder and also create a file in that folder, for example, index.js, To run the file using this command.
node index.js
Step 3: Start MongoDB Server
Also don't forget to start the MongoDB server on another terminal tab using this command.
mongod
Key Mongoose Document Operations
1. Creating a new document
To create a new document, you need to create a mongoose model, and then using that model, you can create a new document. And to save it to the database, we need to use the save() method to save one document or insertMany() method to insert multiple documents.
Example: Creating and Saving a Document
In the below example, we are going to create a new document. Open the index.js file and write the below code:
const mongoose = require("mongoose");
// Database connection
mongoose.connect("mongodb://127.0.0.1:27017/geeksforgeeks", {
useNewUrlParser: true,
useUnifiedTopology: true,
});
// User model
const User = mongoose.model("User", {
name: { type: String },
age: { type: Number },
});
// Creating a new dummy user document
const newUser = new User({
name: "Ayush",
age: 20,
});
// Save it to the database
newUser.save((err, res) => {
if (err) return handleError(err);
else return console.log("Result: ", res)
});
// For inserting multiple documents
User.insertMany(
[
{
name: "Rishu",
age: 21,
},
{
name: "Megha",
age: 24,
},
{
name: "Aman",
age: 16,
},
{
name: "Riya",
age: 18,
},
],
(err, res) => {
if (err) return handleError(err);
else return console.log("Result: ", res)
}
);
Steps to run the application: Write the below code in the terminal to run the server up:
node index.js
Output:
create User ExamplesAbove is the sample data in the database after the function is executed, You can use MongoDB compass or terminal to see the database:
Mongo Compass Output data2. Retrieving documents
To retrieve a document we need to use the findOne() method. These methods allow you to query MongoDB based on specific conditions. It takes conditions as a parameter, which is absolutely optional.
Example: In the below example, we are going to retrieve documents. Open the index.js file and write the below code:
const mongoose = require('mongoose');
// Database connection
mongoose.connect('mongodb://127.0.0.1:27017/geeksforgeeks', {
useNewUrlParser: true,
useUnifiedTopology: true
});
// User model
const User = mongoose.model('User', {
name: { type: String },
age: { type: Number }
});
// Find only one document matching
// the condition(age >= 21)
User.findOne({ age: { $gte: 21 } }, function (err, res) {
if (err) {
console.log(err)
}
else {
console.log("Result : ", res);
}
});
Steps to run the application: Write the below code in the terminal to run the server up:
node index.js
Output:
Finding only one Result using findOne().3. Updating Documents
To update a document you need to use the updateOne() method or findOneAndUpdate() method. The key difference b/w them is that updateOne() doesn't return the updated document while findOneAndUpdate() return the updated document.
Example: In the below example, we are going to update documents. Open the index.js file and write the below code:
const mongoose = require('mongoose');
// Database connection
mongoose.connect('mongodb://127.0.0.1:27017/geeksforgeeks', {
useNewUrlParser: true,
useUnifiedTopology: true
});
// User model
const User = mongoose.model('User', {
name: { type: String },
age: { type: Number }
});
// Update only one document matching
User.updateOne({ name: "Rishu" },
{ age: 22 }, function (err, res) {
if (err) {
console.log(err)
}
});
// Or you can use findOneAndUpdate()
const doc = User.findOneAndUpdate(
{ name: "Rishu" },
{ age: 22 },
// if 'new' isn't true then findOneAndUpdate()
// will return the document as it was
// before it was updated.
{ new: true },
function (err, res) {
if (err) {
console.log(err)
}
else {
console.log("Result : ", res);
}
});
Steps to run the application: Write the below code in the terminal to run the server up:
node index.js
Output:
Updating valuesAs you can see below, the document is updated:
Mongo Compass Output4. Overwriting a document
To overwrite a document we can use replaceOne() method. The 'replaceOne()' method takes 2 required parameters, some optional parameters, and a callback function. The first parameter is the document you want to overwrite and the second one is the new document object.
Example: In the below example, we are going to overwrite documents. Open the index.js file and write the below code:
const mongoose = require('mongoose');
// Database connection
mongoose.connect('mongodb://127.0.0.1:27017/geeksforgeeks', {
useNewUrlParser: true,
useUnifiedTopology: true
});
// User model
const User = mongoose.model('User', {
name: { type: String },
age: { type: Number }
});
// OverWrite a document using `replaceOne()` method
User.replaceOne(
{ name: "Rishu" },
{ name: "Raja", age: 19 }, (err) => {
if (err) return console.error(err);
else {
console.log('{ name: "Rishu" } is replaced
with {name: "Raja", age: 19}')
}
});
Steps to run the application: Write the below code in the terminal to run the server up:
node index.js
Output:
Overwriting values of names formerly strings OverwritingAs you can see below, the document is overwritten:
Mongo Compass overwrites outputWhy Choose Mongoose for MongoDB?
- Schema Validation: Mongoose helps you define strict schemas that validate data before saving it into MongoDB, ensuring data integrity.
- Querying Power: Mongoose provides a rich set of query methods, including
find()
, findOne()
, updateOne()
, and more, to retrieve and manipulate data efficiently. - Built-in Middleware: Mongoose offers middleware (hooks) that allow you to run custom logic before or after certain events, such as saving or deleting documents.
- Scalability: Mongoose provides robust options for building scalable applications that interact with MongoDB.
Conclusion
The Mongoose Document API provides powerful methods for working with MongoDB documents in a Node.js environment. By using methods like save()
, findOne()
, updateOne()
, and replaceOne()
, you can easily manage your data and ensure smooth CRUD operations. With these techniques, you’re well-equipped to manage MongoDB documents efficiently in your Node.js applications.
Similar Reads
Mongoose Tutorial
Mongoose is a popular ODM (Object Data Modeling) library for MongoDB and Node.js that simplifies database interactions by providing a schema-based solution to model application data. It is widely used to build scalable, structured, and efficient database-driven applications.Built on MongoDB for seam
6 min read
Mongoose Schemas
Mongoose Schemas Creating a Model
Mongoose is one of the most popular Object Data Modeling (ODM) libraries for MongoDB, providing schema-based solutions to model our application's data. This allows us to define the structure of documents within a MongoDB collection, including validation, typecasting, and other powerful features that
5 min read
Mongoose Schemas and Indexes
Mongoose is a powerful Object Data Modeling (ODM) library for MongoDB in a Node.js environment. It provides a straightforward way to interact with MongoDB, including features like schema definition, model creation, and database query handling. One key feature of Mongoose is its ability to create and
5 min read
Mongoose Schemas Instance methods
Mongoose is a powerful Object Data Modeling (ODM) library for MongoDB, designed to work in a Node.js environment. One of the key features of Mongoose is its ability to define instance methods on schema objects, which allow you to perform operations on individual documents. This guide will explore Mo
5 min read
Mongoose Schemas Ids
Mongoose is a MongoDB object modeling and handling for a node.js environment. Mongoose automatically adds an _id property of type ObjectId to a document when it gets created. This can be overwritten with a custom id as well, but note that without an id, mongoose doesn't allow us to save or create a
2 min read
Mongoose Schemas Virtuals
Virtuals are a powerful feature in Mongoose that allow us to add attributes to documents without actually storing them in the database. These properties can be dynamically calculated based on other fields, making it easier to manage and manipulate your data. In this comprehensive article, weâll dive
6 min read
Mongoose Schemas Aliases
Mongoose is a MongoDB object modeling and handling for a node.js environment. Mongoose Schemas Aliases help in converting a short property name in the database into a longer, more verbal, property name to enhance code readability. Creating node application And Installing Mongoose: Step 1: Create a
2 min read
Mongoose Schemas With ES6 Classes
Mongoose is a MongoDB object modeling and handling for a node.js environment. To load Mongoose schema from an ES6 Class, we can use a loadClass() method which is provided by Mongoose Schema itself. By using loadClass() method: ES6 class methods will become Mongoose methodsES6 class statics will bec
2 min read
Mongoose Schemas Query Helpers
Mongoose is a MongoDB object modeling and handling for a node.js environment. Mongoose Schema Query Helpers are like instance methods for Mongoose queries. These query helpers can be used to filter out mongoose query results or perform additional operations on the existing result. Creating node appl
3 min read
Mongoose Documents
Mongoose Documents
Mongoose is a powerful Object Data Modeling (ODM) library for MongoDB and Node.js, making it easier to interact with MongoDB databases. It provides a structured way to handle data, perform validation, and manage documents in MongoDB with ease. In this article, we will explain Mongoose Documents, how
5 min read
Mongoose Documents vs Models
Mongoose, a popular Node library, is widely used for interacting with MongoDB, a NoSQL database. Mongoose simplifies the process of working with MongoDB by providing an object data modeling (ODM) framework. In the Mongoose ecosystem, two key concepts are Documents and Models. In this article, we'll
4 min read
Mongoose Documents Updating Using save()
An important aspect of a mongoose model is to save the document explicitly when changes have been made to it. This is done using the save() method. In this article, we will see its uses and see the things we should keep in mind while saving our document.We will take the help of an example to underst
5 min read
Mongoose Queries
Mongoose Queries
Mongoose is a powerful object modeling tool for MongoDB and Node.js. It provides a schema-based solution to model your data, simplifying interactions with MongoDB databases. Mongoose queries are essential for performing CRUD (Create, Read, Update, Delete) operations, making them indispensable for an
7 min read
Mongoose deleteMany() Function
The deleteMany() function is employed to remove all documents meeting specified conditions from a collection. Unlike the remove() function, deleteMany() deletes all matching documents without considering the single option. This method is essential for Node.js developers working with Mongoose, as it
4 min read
Mongoose Queries Model.replaceOne() Function
The Queries Model.replaceOne() function of the Mongoose API is used to replace an existing document with the given document. It replaces only the first document that is returned in the filter. Syntax: Model.replaceOne( filter, doc, options, callback ) Parameters: It accepts the following 4 parameter
3 min read
Find() Method in Mongoose
The Mongoose find() method is one of the most widely used methods for querying MongoDB collections in Node.js. It provides a flexible and powerful way to fetch data from your MongoDB database. In this article, we will explore the find() method in detail, its syntax, parameters, and how to implement
5 min read
FindById Method in Mongoose
The findById() method in Mongoose is one of the most commonly used methods for retrieving a document by its unique identifier (_id) in a MongoDB collection. This article will cover everything we need to know about how to use the findById() method, including syntax, examples, installation, and troubl
4 min read
Mongoose QueriesModel.findByIdAndDelete() Method
The Mongoose Queries findByIdAndUpdate() method is used to search for a matching document, and delete it. It then returns the found document (if any) to the callback. This function uses this function with the id field. Installation of Mongoose Module: Step 1. You can visit the link to Install the mo
4 min read
Mongoose findByIdAndRemove() Function
MongoDB is the most used cross-platform, document-oriented database that provides, high availability, high performance, and easy scalability. MongoDB works on the concept of collecting and documenting the data. findByIdAndRemove() stands proud as a convenient way to discover a file by its specific i
2 min read
Mongoose QueriesModel.findByIdAndDelete() Method
The Mongoose Queries findByIdAndUpdate() method is used to search for a matching document, and delete it. It then returns the found document (if any) to the callback. This function uses this function with the id field. Installation of Mongoose Module: Step 1. You can visit the link to Install the mo
4 min read
FindOne() Method in Mongoose
The findOne() method in Mongoose is one of the most commonly used functions for querying data from a MongoDB database. It provides a simple and efficient way to retrieve a single document that matches a specified query condition. This article will explore how to use the findOne() method, explain its
5 min read
Mongoose findOneAndDelete() Function
The findOneAndDelete() function in Mongoose is an efficient and commonly used method to find a document based on a specified filter and delete it from a MongoDB collection. This method simplifies the process of removing documents and is a key tool for developers working with Node.js and MongoDB. In
5 min read
Mongoose | findOneAndRemove() Function
The findOneAndRemove() function is used to find the element according to the condition and then remove the first matched element. Installation of mongoose module:You can visit the link to Install mongoose module. You can install this package by using this command. npm install mongooseAfter installin
2 min read
Mongoose | findOneAndReplace() Function
When working with MongoDB in Node.js, Mongoose is an essential tool for schema-based modeling and database operations. One of the most powerful and frequently used functions in Mongoose is findOneAndReplace(). This function helps in finding a document and replacing it with a new one. But how exactly
5 min read
Mongoose Queries Model.findOneAndUpdate() Function
The Queries Model.findOneAndUpdate() function of the Mongoose API is used to find and update an existing document with the information mentioned in the "update" object. It finds and updates only the first document that is returned in the filter. Syntax: Model.findOneAndUpdate(conditions, update, opt
3 min read
Mongoose Document Model.replaceOne() API
The Model.replaceOne() method of the Mongoose API is used to replace any one document in a collection. This method works the same as the update method but it replaces MongoDB's existing document with the given document with any atomic operator i.e $set. Syntax: Model.replaceOne() Parameters: Â The Mo
3 min read
updateMany() Method in Mongoose
In Mongoose, the updateMany() method is a powerful tool for performing bulk updates in MongoDB. It updates multiple documents that match a specified condition, applying the changes to all the matched documents in a single operation. Unlike updateOne(), which updates only the first matching document,
4 min read
Mongoose Queries Model.updateOne() Function
The Queries Model.updateOne() function of the Mongoose API is used to update an existing document with the information mentioned in the "update" object. It updates only the first document that is returned in the filter. Syntax: Model.updateOne(filter, update, options, callback ) Parameters: It accep
3 min read