CSCI 421 - Lecture 4

Instructor's Class Notes

Part 2:5 - Building a Data Model with MongoDB and Mongoose

Overview - This lecture will cover:

Use of the Model View Controller (MVC) aka "Routes and Controllers" architecture in order to add a database backend to an application.

In an MVC pattern, data is held in the model, processed by a controller, and then rendered in a view.
Mongoose - Installing and using the package that helps bridge that gap between the application front-end and the MongoDB backend
Connecting an application to a database
Defining schemas for a data model using Mongoose
Managing databases (remote, local, live production data)

Adding Mongoose to your Application - Following are the steps involved:

Installing Mongoose - While in your application directory, execute the following:


> npm install --save mongoose

The above command should update the dependencies of the package.json file, as shown in the excerpt below:


"dependencies": { 
    "express": "~4.9.0",
    "body-parser": "~1.8.1",
    "cookie-parser": "~1.3.3", 
    "morgan": "~1.3.0", 
    "serve-favicon": "~2.1.3", 
    "debug": "~2.0.0",
    "jade": "~1.6.0",
    "mongoose": "~3.8.20"
}

Adding a Mongoose Connection to your Application - Following are the steps involved:

Setting Up the Connection File - Create a file, db.js, and place it in the app_server/models directory. For now, this file will only have the following command:
```
var mongoose = require('mongoose');                    
                    
```

Adding database to app.js - Near the top of the app.js file add a requires statement to load db.js as so (see new statement in bold):


var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
require('./app_server/models/db');

Creating the Mongoose Connection - Update db.js with a URI and a connect method call:

URI Syntax - The Uniform Resource Locator (URI) syntax for a MongoDB is as follows:
db.js Updates - Add the following (or similar depending on DB name) to your db.js file:
```
var dbURI = 'mongodb://localhost/blogger';
mongoose.connect(dbURI);                        
                        
```
Note: - The first time your application successfully connects to the database the database will be created, if needed.

Monitoring the Mongoose Connection - You can add additional code to the bottom of db.js in order for your app to write to the console when connection events happen:


// Monitor and report when database is connected                      
mongoose.connection.on('connected', function () {
  console.log('Mongoose connected to ' + dbURI);
});

// Monitor and report error connecting to database
mongoose.connection.on('error',function (err) {
  console.log('Mongoose connection error: ' + err);
});

// Monitor and report when database is disconnected
mongoose.connection.on('disconnected', function () {
  console.log('Mongoose disconnected');
});

Graceful Shutdown and DB Disconnect - You will need extra code in db.js in order for your application to gracefully shutdown and disconnect from the database when its process terminates. Add the following to the bottom:


// Closes (disconnects) from Mongoose DB upon shutdown                       
gracefulShutdown = function (msg, callback) {
  mongoose.connection.close(function () {
    console.log('Mongoose disconnected through ' + msg);
    callback();
  });
};

// For nodemon restarts
process.once('SIGUSR2', function () {
  gracefulShutdown('nodemon restart', function () {
    process.kill(process.pid, 'SIGUSR2');
}); });

// For app termination
process.on('SIGINT', function() {
  gracefulShutdown('app termination', function () {
    process.exit(0);
}); });

// For Heroku app termination
process.on('SIGTERM', function() {
  gracefulShutdown('Heroku app shutdown', function () {
    process.exit(0);
}); });

A Complete db.js File - Here is the complete file:


var mongoose = require( 'mongoose' );
var gracefulShutdown;
var dbURI = 'mongodb://localhost/myapp';
mongoose.connect(dbURI);

// Monitor and report when database is connected                      
mongoose.connection.on('connected', function () {
  console.log('Mongoose connected to ' + dbURI);
});

// Monitor and report error connecting to database
mongoose.connection.on('error',function (err) {
  console.log('Mongoose connection error: ' + err);
});

// Monitor and report when database is disconnected
mongoose.connection.on('disconnected', function () {
  console.log('Mongoose disconnected');
}); 
// Closes (disconnects) from Mongoose DB upon shutdown    
gracefulShutdown = function (msg, callback) {
  mongoose.connection.close(function () {
    console.log('Mongoose disconnected through ' + msg);
    callback();
  });
};

// For nodemon restarts
process.once('SIGUSR2', function () {
  gracefulShutdown('nodemon restart', function () {
    process.kill(process.pid, 'SIGUSR2');
}); });

// For app termination
process.on('SIGINT', function() {
  gracefulShutdown('app termination', function () {
    process.exit(0);
}); });

// For Heroku app termination
process.on('SIGTERM', function() {
  gracefulShutdown('Heroku app shutdown', function () {
    process.exit(0);
}); });

What's Inside a MonogoDB Database?

MongoDB is a document database that can hold any type of document within.
The documents can be stored in groups called collections.
Documents can adhere to a common format called a schema.
A schema is made up of a number of paths that define the fields within.
A path describes a given field, its data type and other defining properties.
The Manning book has a good figure that describes the relationships between collections, documents, schemas and paths:

Defining Schema for Data Model using Mongoose

For each schema create a file in the models subdirectory. A single mode .js file in the models directory can hold multiple schemas.
The schema is required as it is used along with the model and placed within the model Javascript file within your models directory.

Example schema for the Loc8r review is:


var reviewSchema = new mongoose.Schema({
    author: String,
    rating: {
        type: Number,
        required: true,
        min: 0,
        max: 5
    },
    reviewText: String,
    createdOn: {
        type: Date,
        "default": Date.now
    }
});

For a full example consider locations.js from Chapter 5. The locations.js file is called a model file and it is stored in the models directory.

Adding Models to your Database

Adding models to your database is done by creating a different model .js file for each model. As stated prior, locations.js from Chapter 5 is just such a model, and it contains schemas.
To add a model to your application's database, simply add a statement like the following to the bottom of your db.js file:
```
require('./locations');                
                
```

Static Data via Controllers

Before taking the plunge to a full-blown REST API written using db.js and your models, lets consider a simple controller that returns static (unchanging) data according to a schema.
For a full example consider locations.js from Chapter 5.
Once you have updated your corresponding view(s) to work with static data from your controllers you are then one step closer to hooking up your application to the database backend.
For an example of a database-driven application that does not use controllers or a REST API, but instead delivers data via routes that directly access the database, consider the todo application that is here.