MongoDB is a no-SQL database. Mongoose is a library or "wrapper" that gives us a bunch of convenience methods for working with MongoDB records (kind of like jQuery's convenience methods for manipulating the DOM). Generally we will not be interacting directly with MongoDB, instead we'll be working with mongoose.

Let's do a quick activity and get Mongoose and Mongo setup on our machines.

1. Assuming you already have MongoDB installed _{(you did this at installfest)}, to get started using mongoose in a project, we have to install it in our package.json:

  npm install --save mongoose

2. Next we need to require Mongoose in our project and connect to the MongoDB service (it could be local or hosted). We can do this in server.js for now. Later we'll do it in models/index.js.

  var mongoose = require('mongoose');
  mongoose.connect('mongodb://localhost/todo-app-demo');

<details>
  <summary>What's a connection string?</summary>
  `mongodb://localhost/todo-app-demo` is a string formatted by specifications provided by the Mongoose package in order to connect to a MongoDB database on your local system named `todo-app-demo`. You can name it whatever you like and it will be created as soon as you save some data to it.
</details>

3. Finally, we need to run the MongodDB service. Generally you will want it open in a separate tab, running in the background.

  mongod

**Note:** If you already have an instance of MongoDB running, you'll get an error at this step. If that's the case, you can move on to the next step, since MongoDB is already running!

Running your MongoDB service is no different from running your Express Server!

Once you've finished the above steps, here's how you would set up an Express application with a "Todo" model (so we can start CRUDing todos!).

1. In your Express application, create a folder called models with a file for your first model. In the example, we have a Todo model, so the filename is todo.js. Your folder structure should look similar to this:

your-app-name
├── models
│   └── todo.js
├── public
│   ├── scripts
│   │   └── main.js
│   └── styles
│       └── main.css
├── views
│   └── index.html
├── .gitignore
├── package.json
├── README.md
└── server.js

var TodoSchema = new Schema({ task: String, description: String });

var Todo = mongoose.model('Todo', TodoSchema);

module.exports = Todo;

</details>

3. <details>
<summary>In `server.js`, require your model.</summary>
```js
// server.js
// Note without requiring your models you can't use them in server.js!
var Todo = require('./models/todo');

Schema: Similar to an object constructor, a Schema is a diagram or blueprint for what every object in the noSQL database will contain. Here's an example of a simple Address Book noSQL database schema:

    var ContactSchema = new Schema({
        firstName: String,
        lastName: String,
        address: String,
        phoneNumber: Number,
        email: String,
        professionalContact: Boolean
    });

With the above Schema, we can expect that all of our Address Book entries would have a first name, last name, address, and email address in the form of Strings. We can count on the phoneNumber to always be accepted, stored, and returned as a number. Lastly, the boolean value of Professional Contact will always be a true or false

Model: A model is a Schema that has been 'activated' with real data and is performing actions such as reading, saving, updating, etc.

var Contact = mongoose.model('Contact', ContactSchema);

Every model instance that we store in the database is assigned an ID. In mongo that actually means an _id. We can use this ID later to look up a particular record. Later on we'll look at how we can use those IDs can help us form relationships in the database.

Most databases also require that we specify the data-type for each attribute. In mongoose we can use data-types from javascript such as String, Number, and even Array.

Let's look at this example:

// models/person.js
var mongoose = require('mongoose'),
  Schema = mongoose.Schema;

var personSchema = new mongoose.Schema({
    firstName: String,
    lastName: String,
    age: Number,
    superPower: String,
    weakness: String,
    isExcited: Boolean
});

var Person = mongoose.model('Person', personSchema);

module.exports = Person;

In the above note how we've assigned String, Number and even a Boolean as the data-types for this Schema.

Let's create an instance of this model.

  // server.js
  var Person = require('./models/person');

  var justin = new Person({
      firstName: "Justin",
      lastName: "Castilla",
      age: 33,
      superPower: "Beard",
      weakness: "Razors",
      isExcited: true
  });

  justin.save(function(err, newPerson){
    if(err) {return console.log(err);}
    console.log("saved new person: ", newPerson);
  });

The above logs to the terminal the newPerson success object:

saved new person:  { 
  __v: 0,
  firstName: 'Justin',
  lastName: 'Castilla',
  age: 33,
  superPower: 'Beard',
  weakness: 'Razors',
  isExcited: true,
  _id: 57866b9f9d89c840336a135e }

Notice that mongo has added an _id and __v attributes.

// save new todo in db
newTodo.save(function handleDBTodoSaved(err, savedTodo) {
  res.json(savedTodo);
});

</details>

#### Get one todo: `.findOne()`

<details>
<summary>We can use <a href="http://mongoosejs.com/docs/api.html#query_Query-findOne">.findOne()</a> to return the first document in the collection that matches certain criteria. In this case, we're looking for a todo that has a certain `_id`.</summary>
```js
// get one todo
app.get('/api/todos/:id', function (req, res) {
  // get todo id from url params (`req.params`)
  var todoId = req.params.id;

  // find todo in db by id
  Todo.findOne({ _id: todoId }, function (err, foundTodo) {
    res.json(foundTodo);
  });
});

// find todo in db by id
Todo.findOne({ _id: todoId }, function (err, foundTodo) {
  // update the todos's attributes
  foundTodo.task = req.body.task;
  foundTodo.description = req.body.description;

  // save updated todo in db
  foundTodo.save(function (err, savedTodo) {
    res.json(savedTodo);
  });
});

</details>

#### Delete todo: `.findOneAndRemove()`

<details>
<summary>The <a href="http://mongoosejs.com/docs/api.html#model_Model.findOneAndRemove" target="_blank">.findOneAndRemove()</a> method takes care of finding the document with a certain `_id` and removing it from the database.</summary>
```js
// delete todo
app.delete('/api/todos/:id', function (req, res) {
  // get todo id from url params (`req.params`)
  var todoId = req.params.id;

  // find todo in db by id and remove
  Todo.findOneAndRemove({ _id: todoId }, function (err, deletedTodo) {
    res.json(deletedTodo);
  });
});

Exploring your databases with the MongoDB shell can be a chore. Robomongo is a free application that can make it a little easier on you: Setting up Robomongo.

Fork and clone this Book App tutorial and get started on your first CRUD application! For today, only attempt Sprint 1. Sprint 2 will be covered at a later date.

• Scotch Tutorial: Intro to MongoDB
• MongoDB Shell Commands
• MongoDB CRUD Tutorials
• .find()
• .findOne()
• .findById()
• .findOneAndRemove()
• .remove()