Italy's daily coronavirus death toll and new cases fall

on
0

Mongoose – Node.js + MongoDB with Mongoose Tutorial

on

Develope Node.js + MongoDB Application with Mongoose

In my previous post, I demonstrated how to perform CRUD (Create, Read, Update, Delete) operations using Node.js and MongoDB API. This tutorial explains how to easily develop Node.js and MongoDB application with Mongoose application by using the Mongoose API. This tutorial assumes that reader has the knowledge on Node.js and MongoDB and knows how to set up the environment for this tutorial. Those who want to read the basic tutorials on Node.js and MongoDB please refer Introduction to Node.js and How to Install MongoDB on Windows.
If you are interested in receiving more updates on Node.js and MongoDB tutorials, please subscribe here.
Here is the overview of the sections covered in this tutorial.
  1. Introduction to Mongoose API
  2. Connecting to MongoDB using Mongoose
  3. Create Schema and Model in Mongoose
  4. Inserting Data using Mongoose
  5. Querying the DB using Mongoose
  6. Updating existing documents
  7. Deleting existing documents
  8. Example Application

Mongoose API

Mongoose is an mongodb object modelling API for node.js. Mongoose provides a straight-forward, schema-based solution to modeling your application data and includes built-in type casting, validation, query building, business logic hooks and more, out of the box. (Introduction taken from the Mongoose API Home page)
To use mongoose API in node.js application one would have to download the Node package for mongoose API using the following command: npm install mongoose and then import the mongoose API package in your node.js application by using the following command: var mongoose = require('mongoose');

Connecting to MongoDB using Mongoose

The below code connects to the MongoDB database named test running on localhost, port 27017.
1var dbHost = 'mongodb://localhost:27017/test';
2mongoose.connect(dbHost);
After you have connected to the DB, you need to get a connection object. The connection object initially is in pending state and once it goes into open state we can proceed to interact with MongoDB. For this to happen we register a callback to listen to the open event, the below code registers to listen to error and open events fired by the connection.
1db.on('error', console.error.bind(console, 'connection error:'));
2db.once('open', function(){
3  console.log("Connected to DB");
4  //do operations which involve interacting with DB.
5});

Create Schema and Model in Mongoose

We need to create the schema of the document we are going to persist in the DB. While creating the schema we can mention the attributes of the document, the type of the attribute, additional information like whether an index needs to be created for the attribute and so on. In our example our book document would have the following attributes: name, isbn, author, pages. The below is the sample Schema I created for this example:
1//Create a schema for Book
2var bookSchema = mongoose.Schema({
3  name: String,
4  //Also creating index on field isbn
5  isbn: {type: String, index: true},
6  author: String,
7  pages: Number
8});
Using the above schema we create a Model. The API to create model accepts the following: name of the model, name of the schema it has to use to create model class, name of the collection and whether to skip initialization. The below is the code to create Book Model from the schema:
1//Create a Model by using the schema defined above
2//Optionally one can provide the name of collection where the instances
3//of this model get stored. In this case it is "mongoose_demo". Skipping
4//this value defaults the name of the collection to plural of model name i.e books.
5var Book = mongoose.model('Book', bookSchema, "mongoose_demo");
Lets now see how to insert, read, update and delete records using the Model created above. Unlike previous post, in this post I will show you few examples of inserting records, querying for records, editing records and deleting records.

Inserting data using Mongoose

We create an instance of the Model class and then invoke save method on the instance to save the data to the DB. While invoking the save method we also provide a callback which gets executed after the save method returns either with an error or after successfully inserting the data. The below code creates two instances of Book model class and saves it to the DB.
1//Instantiating the Model - An instance of Model represents a mongodb document
2var book1 = new Book({
3  name:"Mongoose Demo 1",
4  isbn: "MNG123",
5  author: "Author1,  Author2",
6  pages: 123
7});
8 
9//Saving the model instance to the DB
10book1.save(function(err){
11  if ( err ) throw err;
12  console.log("Book Saved Successfully");
13});
14 
15var book2 = new Book({
16  name:"Mongoose Demo 2",
17  isbn: "MNG124",
18  author: "Author2,  Author3",
19  pages: 90
20});
21 
22book2.save(function(err){
23  if ( err ) throw err;
24  console.log("Book Saved Successfully");
25});

Querying the DB using Mongoose

There are multiple APIs which one can use to query the collection in mongoDB, one can find all those APIs here. In this example I use find API to query the collection. The below code defines a function which queries for documents having less than 100 pages:
1var queryBooks = function(){
2  //Now querying those books which have less than 100 pages
3  //Find API takes in a query condition, attributes in the document to be projected,
4  //callback to be executed when the data is available.
5  Book.find({pages : {$lt:100}}, "name isbn author pages", function(err, result){
6    if ( err ) throw err;
7    console.log("Find Operations: " + result);
8  });
9}

Updating existing documents

Document can be updated by using the update API as shown below:
1var updateBook = function(){
2  /*
3  Find the book to be updated using the condition and then execute the update
4  passed to the API as the second argument
5  */
6  Book.update({isbn : {$eq: 'MNG125'}}, {$set: {name: "Mongoose Demo 3.1"}}, function(err, result){
7    console.log("Updated successfully");
8    console.log(result);
9  });
10}

Deleting existing documents

Documents can be deleted from the collection by using the remove API and by specifying the condition for selecting the documents to be deleted.
1var deleteBook = function(){
2  /*
3    When callback is not passed, the action is not invoked on the collection
4    until the exec() method is called.
5    In this case I am not passing the callback and instead executing the action
6    by invoking the exec() method.
7  */
8  Book.remove({isbn:{$eq: 'MNG124'}}).exec();
9}

Node.js + MongoDB + Mongoose Example Application

With this I have shown how the CRUD operations can be performed individually. Putting this all together into a working example given below:
1var mongoose = require('mongoose');
2var dbHost = 'mongodb://localhost:27017/test';
3mongoose.connect(dbHost);
4//Create a schema for Book
5var bookSchema = mongoose.Schema({
6  name: String,
7  //Also creating index on field isbn
8  isbn: {type: String, index: true},
9  author: String,
10  pages: Number
11});
12 
13//Create a Model by using the schema defined above
14//Optionally one can provide the name of collection where the instances
15//of this model get stored. In this case it is "mongoose_demo". Skipping
16//this value defaults the name of the collection to plural of model name i.e books.
17var Book = mongoose.model('Book', bookSchema, "mongoose_demo");
18 
19var db = mongoose.connection;
20 
21db.on('error', console.error.bind(console, 'connection error:'));
22db.once('open', function(){
23  console.log("Connected to DB");
24 
25  //Instantiating the Model - An instance of Model represents a mongodb document
26  var book1 = new Book({
27    name:"Mongoose Demo 1",
28    isbn: "MNG123",
29    author: "Author1,  Author2",
30    pages: 123
31  });
32 
33  //Saving the model instance to the DB
34  book1.save(function(err){
35    if ( err ) throw err;
36    console.log("Book Saved Successfully");
37  });
38 
39  var book2 = new Book({
40    name:"Mongoose Demo 2",
41    isbn: "MNG124",
42    author: "Author2,  Author3",
43    pages: 90
44  });
45 
46  book2.save(function(err){
47    if ( err ) throw err;
48    console.log("Book Saved Successfully");
49    deleteBook();
50  });
51 
52  var book3 = new Book({
53    name:"Mongoose Demo 3",
54    isbn: "MNG125",
55    author: "Author2,  Author4",
56    pages: 80
57  });
58 
59  book3.save(function(err){
60    if ( err ) throw err;
61    console.log("Book Saved Successfully");
62    queryBooks();
63    updateBook();
64 
65  });
66 
67});
68 
69var queryBooks = function(){
70  //Now querying those books which have less than 100 pages
71  //Find API takes in a query condition, attributes in the document to be projected,
72  //callback to be executed when the data is available.
73  Book.find({pages : {$lt:100}}, "name isbn author pages", function(err, result){
74    if ( err ) throw err;
75    console.log("Find Operations: " + result);
76  });
77}
78 
79var updateBook = function(){
80  /*
81  Find the book to be updated using the condition and then execute the update
82  passed to the API as the second argument
83  */
84  Book.update({isbn : {$eq: 'MNG125'}}, {$set: {name: "Mongoose Demo 3.1"}}, function(err, result){
85    console.log("Updated successfully");
86    console.log(result);
87  });
88}
89 
90var deleteBook = function(){
91  /*
92    When callback is not passed, the action is not invoked on the collection
93    until the exec() method is called.
94    In this case I am not passing the callback and instead executing the action
95    by invoking the exec() method.
96  */
97  Book.remove({isbn:{$eq: 'MNG124'}}).exec();
98}
And querying for data from the mongo console we get the following:
1> db.mongoose_demo.find()
2{ "_id" : ObjectId("55490d87e34c8acc20b5363d"), "name" : "Mongoose Demo 1", "isbn" : "MNG123", "author" : "Author1,  Author2", "pages" : 123, "__v" : 0 }
3{ "_id" : ObjectId("55490d87e34c8acc20b5363f"), "name" : "Mongoose Demo 3.1", "isbn" : "MNG125", "author" : "Author2,  Author4", "pages" : 80, "__v" : 0 }

Summary

I hope that this tutorial would be very much helpful to understand how Mongoose API can be used for connecting to the MongoDB. It is obvious that with the help of Mongoose Object Data Mapping (ODM) once can write more complex CRUD operations with minimal effort. Please try the above examples write your feedback in the comments section.

Comments

Post a Comment