An Introduction to Mongoose for MongoDB and Node.js

Mongoose is a JavaScript framework that is commonly used in a Node.js application with a MongoDB database. In this article, I am going to introduce you to Mongoose and MongoDB, and more importantly where these technologies fit in to your application.

An Introduction to Mongoose for MongoDB and Node.js

What Is
MongoDB?

Let’s start with MongoDB. MongoDB is a database that stores your data as documents. Most commonly these documents resemble a JSON-like structure:

{
  firstName: "Jamie",
  lastName: "Munro"
}

A document then is placed within a collection. As an example, the above document example defines a user object. This user object then would typically be part of a collection called users.

One of the key factors with MongoDB is its flexibility when it comes to structure. Even though in the first example, the user object contained a firstName and lastName property, these properties are not required in every user document that is part of the users collection. This is what makes MongoDB very different from a SQL database like MySQL or Microsoft SQL Server that requires a strongly-defined database schema of each object it stores.

The ability to create dynamic objects that are stored as documents in the database is where Mongoose comes into play.

What Is
Mongoose?

Mongoose is an Object Document Mapper (ODM). This means that Mongoose allows you to define objects with a strongly-typed schema that is mapped to a MongoDB document.

Mongoose provides an incredible amount of functionality around creating and working with schemas. Mongoose currently contains eight SchemaTypes that a property is saved as when it is persisted to MongoDB. They are:

  1. String
  2. Number
  3. Date
  4. Buffer
  5. Boolean
  6. Mixed
  7. ObjectId
  8. Array

Each data type allows you to specify:

  • a default value
  • a custom validation function
  • indicate a field is required
  • a get function that allows
    you to manipulate the data before it is returned as an object
  • a set function that allows
    you to manipulate the data before it is saved to the database
  • create indexes to allow data to be fetched faster

Further to these common options, certain data types allow you to further customize how the data is stored and retrieved from the database. For example, a String data type also allows you to specify the following additional options:

  • convert it to lowercase
  • convert it to uppercase
  • trim data prior to saving
  • a regular expression that can
    limit data allowed to be saved during the validation process
  • an enum that can define a
    list of strings that are valid

The Number and Date properties both support specifying a minimum and maximum value that is allowed for that field.

Most of the eight allowed data types should be quite familiar to you. However, there are several exceptions that may jump out to you, such as Buffer, Mixed, ObjectId, and Array.

The Buffer data type allows you to save binary data. A common example of binary data would be an image or an encoded file, such as a PDF document.

The Mixed data type turns the property into an “anything goes” field. This field resembles how many developers may use MongoDB because there is no defined structure. Be wary of using this data type as it loses many of the great features that Mongoose provides, such as data validation and detecting entity changes to automatically know to update the property when saving.

The ObjectId data type commonly specifies a link to another document in your database. For example, if you had a collection of books and authors, the book document might contain an ObjectId property that refers to the specific author of the document.

The Array data type allows you to store JavaScript-like arrays. With an Array data type, you can perform common JavaScript array operations on them, such as push, pop, shift, slice, etc.

Quick
Recap

Before moving on and generating some code, I just wanted to recap what we just learned. MongoDB is a database that allows you to store documents with a dynamic structure. These documents are saved inside a collection.

Mongoose is a JavaScript library that allows you to define schemas with strongly typed data. Once a schema is defined, Mongoose lets you create a Model based on a specific schema. A Mongoose Model is then mapped to a MongoDB Document via the Model’s schema definition.

Once you have defined your schemas and models, Mongoose contains many different functions that allow you to validate, save, delete, and query your data using common MongoDB functions. I’ll talk about this more with the concrete code examples to follow.

Installing
MongoDB

Before we can begin creating our Mongoose schemas and models, MongoDB must be installed and configured. I would suggest visiting MongoDB’s Download page. There are several different options available to install. I have linked to the Community Server. This allows you to install a version specific to your operating system. MongoDB also offers an Enterprise Server and a cloud support installation. Since entire books could be written on installing, tuning, and monitoring MongoDB, I am going to stick with the Community Server.

Once you’ve downloaded and installed MongoDB for your operating system of choice, you will need to start the database. Rather than reinventing the wheel, I would suggest visiting MongoDB’s documentation on how to install the MongoDB Community Edition.

I’ll wait here while you configure MongoDB. When you’re ready, we can move on to setting up Mongoose to connect to your newly installed MongoDB database.

Setting
Up Mongoose

Mongoose is a JavaScript framework, and I am going to use it in a Node.js application. If you already have Node.js installed, you can move on to the next step. If you do not have Node.js installed, I suggest you begin by visiting the Node.js Download page and selecting the installer for your operating system.

With Node.js set up and ready to go, I am going to create a new application and then install the Mongoose NPM Package.

With a command prompt that is set to where you wish your application to be installed, you can run the following commands:

mkdir mongoose_basics
cd mongoose_basics
npm init

For the initialization of my application, I left everything as their default values. Now I’m going to install the mongoose package as follows:

npm install mongoose --save

With all the prerequisites configured, let’s connect to a MongoDB database. I’ve placed the following code inside an index.js file because I chose that as the starting point for my application:

var mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/mongoose_basics');

The first line of code includes the mongoose library. Next, I open a connection to a database that I’ve called mongoose_basics using the connect function.

The connect function accepts two other optional parameters. The second parameter is an object of options where you can define things like the username and password, if required. The third parameter, which can also be the second parameter if you have no options, is the callback function after attempting to connect. The callback function can be used in one of two ways:

mongoose.connect(uri, options, function(error) {

// Check error in initial connection. There is no 2nd param to the callback.

});

// Or using promises

mongoose.connect(uri, options).then(

() => { /** ready to use. The `mongoose.connect()` promise resolves to undefined. */ },

err => { /** handle initial connection error */ }

);

To avoid a potential introduction to JavaScript Promises, I will use the first way. Below is an updated index.js file:

var mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/mongoose_basics', function (err) {

   if (err) throw err;

   console.log('Successfully connected');

});

If an error occurs when connecting to the database, the exception is thrown and all further processing is stopped. When no error occurs, I have logged a success message to the console.

Mongoose is now set up and connected to a database called mongoose_basics. My MongoDB connection is using no username, password, or custom port. If you need to set these options or any other option during connection, I suggest reviewing the Mongoose Documentation on connecting. The documentation provides detailed explanations of the many options available as well as how to create multiple connections, connection pooling, replicas, etc.

With a successful connection, let’s move on to define a Mongoose Schema.

Defining
a Mongoose Schema

During the introduction, I showed a user object that contained two properties: firstName and lastName. In the following example, I’ve translated that document into a Mongoose Schema:

var userSchema = mongoose.Schema({
    firstName: String,
    lastName: String
});

This is a very basic Schema that just contains two properties with no attributes associated with it. Let’s expand upon this example by converting the first and last name properties to be child objects of a name property. The name property will comprise both the first and last name. I’ll also add a created property that is of type Date.

var userSchema = mongoose.Schema({
    name: {
    	firstName: String,
	lastName: String
    },
    created: Date
});

As you can see, Mongoose allows me to create very flexible schemas with many different possible combinations of how I am able to organize my data.

In this next example, I am going to create two new schemas that will demonstrate how to create a relationship to another schema: author and book. The book schema will contain a reference to the author schema.

var authorSchema = mongoose.Schema({
    _id: mongoose.Schema.Types.ObjectId,
    name: {
    	    firstName: String,
	    lastName: String
	},
    biography: String,
    twitter: String,
    facebook: String,
    linkedin: String,
    profilePicture: Buffer,
    created: { 
    	type: Date,
    	default: Date.now
    }
});

Above is the author schema that expands upon the concepts of the user schema that I created in the previous example. To link the Author and Book together, the first property of the author schema is an _id property that is an ObjectId schema type. _id is the common syntax for creating a primary key in Mongoose and MongoDB. Then, like the user schema, I’ve defined a name property containing the author’s first and last name.

Expanding upon the user schema, the author contains several other String schema types. I’ve also added a Buffer schema type that could hold the author’s profile picture. The final property holds the created date of the author; however, you may notice it is created slightly differently because it has defined a default value of “now”. When an author is persisted to the database, this property will be set to the current date/time.

To complete the schema examples, let’s create a book schema that contains a reference to the author by using the ObjectId schema type:

var bookSchema = mongoose.Schema({
    _id: mongoose.Schema.Types.ObjectId,
    title: String,
    summary: String,
    isbn: String,
    thumbnail: Buffer,
    author: { 
    	type: mongoose.Schema.Types.ObjectId, 
    	ref: 'Author' 
    },
    ratings: [
    	{
            summary: String,
            detail: String,
            numberOfStars: Number,
            created: { 
                type: Date,
                default: Date.now
            }
    	}
    ],
    created: { 
    	type: Date,
    	default: Date.now
    }
});

The book schema contains several properties of type String. As mentioned above, it contains a reference to the author schema. To further demonstrate the powerful schema definitions, the book schema also contains an Array of ratings. Each rating consists of a summary, detail, numberOfStars, and created date property.

Mongoose allows you the flexibility to create schemas with references to other schemas or, as in the above example with the ratings property, it allows you to create an Array of child properties that could be contained in a related schema (like book to author) or inline as in the above example (with book to a ratings Array).

Creating and Saving Mongoose Models

Since the author and book schemas demonstrate Mongoose’s schema flexibility, I am going to continue using those schemas and derive an Author and Book model from them.

var Author = mongoose.model('Author', authorSchema);

var Book = mongoose.model('Book', bookSchema);

A Mongoose Model, when saved, creates a Document in MongoDB with the properties as defined by the schema it is derived from.

To demonstrate creating and saving an object, in this next example, I am going to create several objects: an Author Model and several Book Models. Once created, these objects will be persisted to MongoDB using the save method of the Model.

var jamieAuthor = new Author {
    _id: new mongoose.Types.ObjectId(),
    name: {
    	firstName: 'Jamie',
    	lastName: 'Munro'
    },
    biography: 'Jamie is the author of ASP.NET MVC 5 with Bootstrap and Knockout.js.',
    twitter: 'https://twitter.com/endyourif',
    facebook: 'https://www.facebook.com/End-Your-If-194251957252562/'
};

jamieAuthor.save(function(err) {
	if (err) throw err;
	
	console.log('Author successfully saved.');
	
	var mvcBook = new Book {
            _id: new mongoose.Types.ObjectId(),
            title: 'ASP.NET MVC 5 with Bootstrap and Knockout.js',
            author: jamieAuthor._id,
            ratings:[{
            	summary: 'Great read'
            }]
	};
	
	mvcBook.save(function(err) {
		if (err) throw err;
	
		console.log('Book successfully saved.');
	});
	
	var knockoutBook = new Book {
            _id: new mongoose.Types.ObjectId(),
            title: 'Knockout.js: Building Dynamic Client-Side Web Applications',
            author: jamieAuthor._id
	};
	
	knockoutBook.save(function(err) {
		if (err) throw err;
	
		console.log('Book successfully saved.');
	});
});

In the above example, I’ve shamelessly plugged a reference to my two most recent books. The example starts by creating and saving a jamieObject that is created from anAuthor Model. Inside the save function of the jamieObject, if an error occurs, the application will output an exception. When the save is successful, inside the save function, the two book objects are created and saved. Similar to the jamieObject, if an error occurs when saving, an error is outputted; otherwise, a success message is outputted in the console.

To create the reference to the Author, the book objects both reference the author schema’s _id primary key in the author property of the book schema.

Validating Data Before Saving

It’s quite common for the data that will end up creating a model to be populated by a form on a webpage. Because of this, it’s a good idea to validate this data prior to saving the Model to MongoDB.

In this next example, I’ve updated the previous author schema to add validation on the following properties: firstName, twitter, facebook, and linkedin.

var authorSchema = mongoose.Schema({
    _id: mongoose.Schema.Types.ObjectId,
    name: {
		firstName: {
			type: String,
			required: true
		},
		lastName: String
	},
	biography: String,
	twitter: {
		type: String,
		validate: {
			validator: function(text) {
				return text.indexOf('https://twitter.com/') === 0;
			},
			message: 'Twitter handle must start with https://twitter.com/'
		}
	},
	facebook: {
		type: String,
		validate: {
			validator: function(text) {
				return text.indexOf('https://www.facebook.com/') === 0;
			},
			message: 'Facebook must start with https://www.facebook.com/'
		}
	},
	linkedin: {
		type: String,
		validate: {
			validator: function(text) {
				return text.indexOf('https://www.linkedin.com/') === 0;
			},
			message: 'LinkedIn must start with https://www.linkedin.com/'
		}
	},
	profilePicture: Buffer,
	created: { 
		type: Date,
		default: Date.now
	}
});

The firstName property has been attributed with the required property. Now when I call the save function, Mongoose will return an error with a message indicating the firstName property is required. I chose not to make the lastName property required in case Cher or Madonna were to be authors in my database.

The twitter, facebook, and linkedin properties all have very similar custom validators applied to them. They each ensure that the values begin with the social networks’ respective domain name. These fields are not required, so the validator will only be applied when data is supplied for that property.

Searching for and Updating Data

An introduction to Mongoose wouldn’t be complete without an example of searching for a record and updating one or more properties on that object.

Mongoose provides several different functions to find data for a specific Model. The functions are find, findOne, and findById.

The find and findOne functions both accept an object as input allowing for complex searches, whereas findById accepts just a single value with a callback function (an example will follow shortly). In this next example, I am going to demonstrate how to find all books that contain the string “mvc” in their title.

Book.find({
	title: /mvc/i
}).exec(function(err, books) {
	if (err) throw err;
	
	console.log(books);
});

Inside the find function, I am searching for the case insensitive string “mvc” on the title property. This is accomplished using the same syntax for searching a string with JavaScript.

The find function call also be chained to other query methods, such as where, and, or, limit, sort, any, etc.

Let’s expand upon the previous example to limit our results to the first five books and sort on the created date descending. This will return up to the five most recent books containing “mvc” in the title.

Book.find({
	title: /mvc/i
}).sort('-created')
.limit(5)
.exec(function(err, books) {
	if (err) throw err;
	
	console.log(books);
});

After applying the find function, the order of the other functions is not important because all of the chained functions are compiled together into a single query and not executed until the exec function is called.

As I mentioned earlier, the findById is executed a bit differently. It executes immediately and accepts a callback function, instead of allowing for a chain of functions. In this next example, I am querying a specific author by their _id.

Author.findById('59b31406beefa1082819e72f', function(err, author) {
    if (err) throw err;
    
    console.log(author);
});

The _id in your case might be slightly different. I copied this _id from a previous console.log when finding a list of books with “mvc” in their title.

Once an object has been returned, you can modify any of its properties to update it. Once you have made the necessary changes, you call the save method, just like when you were creating the object. In this next example, I will extend the findbyId example and update the linkedin property on the author.

Author.findById('59b31406beefa1082819e72f', function(err, author) {
	if (err) throw err;
	
	author.linkedin = 'https://www.linkedin.com/in/jamie-munro-8064ba1a/';
	
	author.save(function(err) {
		if (err) throw err;
		
		console.log('Author updated successfully');
	});
});

After the author is successfully retrieved, the linkedin property is set and the save function is called. Mongoose is able to detect that the linkedin property was changed, and it will send an update statement to MongoDB on only the properties that have been modified. If an error occurred when saving, an exception will be thrown and will halt the application. When successful, a success message is logged to the console.

Mongoose also offers two additional functions that make finding an object and saving it in a single step with the appropriately named functions: findByIdAndUpdate and findOneAndUpdate. Let’s update the previous example to use the findByIdAndUpdate.

Author.findByIdAndUpdate('59b31406beefa1082819e72f', 
    { linkedin: 'https://www.linkedin.com/in/jamie-munro-8064ba1a/' }, 
    function(err, author) {
	    if (err) throw err;
	
	    console.log(author);
});

In the previous example, the properties to update are supplied as an object to the second parameter of the findByIdAndUpdate function. The callback function is now the third parameter. When the update is successful, the author object returned contains the updated information. This is logged to the console to see the updated author’s properties.

Final Sample Code

Throughout this article, I provided small snippets of code identifying a very specific action, such as creating a schema, creating a model, etc. Let’s put it all together in a full example.

Firstly, I’ve created two additional files: author.js and book.js. These files contain their respective schema definitions and the model creation. The final line of code makes the model available for use in the index.js file.

Let’s start with the author.js file:

var mongoose = require('mongoose');

var authorSchema = mongoose.Schema({
    _id: mongoose.Schema.Types.ObjectId,
    name: {
		firstName: {
			type: String,
			required: true
		},
		lastName: String
	},
	biography: String,
	twitter: {
		type: String,
		validate: {
			validator: function(text) {
				return text.indexOf('https://twitter.com/') === 0;
			},
			message: 'Twitter handle must start with https://twitter.com/'
		}
	},
	facebook: {
		type: String,
		validate: {
			validator: function(text) {
				return text.indexOf('https://www.facebook.com/') === 0;
			},
			message: 'Facebook must start with https://www.facebook.com/'
		}
	},
	linkedin: {
		type: String,
		validate: {
			validator: function(text) {
				return text.indexOf('https://www.linkedin.com/') === 0;
			},
			message: 'LinkedIn must start with https://www.linkedin.com/'
		}
	},
	profilePicture: Buffer,
	created: { 
		type: Date,
		default: Date.now
	}
});

var Author = mongoose.model('Author', authorSchema);

module.exports = Author;

Next comes the book.js file:

var mongoose = require('mongoose');

var bookSchema = mongoose.Schema({
    _id: mongoose.Schema.Types.ObjectId,
    title: String,
	summary: String,
	isbn: String,
	thumbnail: Buffer,
	author: { 
		type: mongoose.Schema.Types.ObjectId, 
		ref: 'Author' 
	},
	ratings: [
		{
			summary: String,
			detail: String,
			numberOfStars: Number,
			created: { 
				type: Date,
				default: Date.now
			}
		}
	],
	created: { 
		type: Date,
		default: Date.now
	}
});

var Book = mongoose.model('Book', bookSchema);

module.exports = Book;

And finally, the updated index.js file:

var mongoose = require('mongoose');

var Author = require('./author');
var Book = require('./book');

mongoose.connect('mongodb://localhost/mongoose_basics', function (err) {
    if (err) throw err;
	
	console.log('Successfully connected');
	
	var jamieAuthor = new Author({
		_id: new mongoose.Types.ObjectId(),
		name: {
			firstName: 'Jamie',
			lastName: 'Munro'
		},
		biography: 'Jamie is the author of ASP.NET MVC 5 with Bootstrap and Knockout.js.',
		twitter: 'https://twitter.com/endyourif',
		facebook: 'https://www.facebook.com/End-Your-If-194251957252562/'
	});

	jamieAuthor.save(function(err) {
		if (err) throw err;
		
		console.log('Author successfully saved.');
		
		var mvcBook = new Book({
			_id: new mongoose.Types.ObjectId(),
			title: 'ASP.NET MVC 5 with Bootstrap and Knockout.js',
			author: jamieAuthor._id,
			ratings:[{
				summary: 'Great read'
			}]
		});
		
		mvcBook.save(function(err) {
			if (err) throw err;
		
			console.log('Book successfully saved.');
		});
		
		var knockoutBook = new Book({
			_id: new mongoose.Types.ObjectId(),
			title: 'Knockout.js: Building Dynamic Client-Side Web Applications',
			author: jamieAuthor._id
		});
		
		knockoutBook.save(function(err) {
			if (err) throw err;
		
			console.log('Book successfully saved.');
		});
	});
});

In the above example, all of the Mongoose actions are contained within the connect function. The author and book files are included with the require function after including the mongoose library.

With MongoDB running, you can now run the complete Node.js application with the following command:

node index.js

After I saved some data to my database, I updated the index.js file with the find functions as follows:

var mongoose = require('mongoose');

var Author = require('./author');
var Book = require('./book');

mongoose.connect('mongodb://localhost/mongoose_basics', function (err) {
    if (err) throw err;
	
	console.log('Successfully connected');
	
	Book.find({
		title: /mvc/i
	}).sort('-created')
	.limit(5)
	.exec(function(err, books) {
		if (err) throw err;
		
		console.log(books);
	});
	
	Author.findById('59b31406beefa1082819e72f', function(err, author) {
		if (err) throw err;
		
		author.linkedin = 'https://www.linkedin.com/in/jamie-munro-8064ba1a/';
		
		author.save(function(err) {
			if (err) throw err;
			
			console.log('Author updated successfully');
		});
	});
	
	Author.findByIdAndUpdate('59b31406beefa1082819e72f', { linkedin: 'https://www.linkedin.com/in/jamie-munro-8064ba1a/' }, function(err, author) {
		if (err) throw err;
		
		console.log(author);
	});
});

Once again, you can run the application with the command: node index.js.

Summary

After reading this article, you should be able to create extremely flexible Mongoose Schemas and Models, apply simple or complex validation, create and update documents, and finally search for the documents that were created.

Hopefully you now feel comfortable using Mongoose. If you are looking to learn more, I would suggest reviewing the Mongoose Guides which delve into more advanced topics such as population, middleware, promises, etc.

Happy hunting (poor Mongoose animal reference)!