Building Apps with Mongo(ose)

Today's DB Objectives:

• Learn the basics of Mongoose
• Build a generic API
• Practice Schema-based with Reddit Clone
• 1-to-Many and Many-to-Many relationships
• Using Mongoose to "JOIN"

Some duplication

Last time we ran out of time without making it all the way through the notes. Today I'm going to duplicate some of the notes from last time and add some fresh material to round it out. My goal is that you leave able to create a Node-based API backed by Mongo.

A completely generic API

For this mini-project we'll build a backend that will just work for almost any front-end you want to build. It won't do much, but if you are a front-end developer that wants to work fast this will do your job. Visit the repo on GitHub and follow the intstructions in the README.md.

• Task z: get the API running on a cloud9 server
• Task y: use POSTMAN to create a "character" with health and experience and a level
• Task x: use POSTMAN to increase that character's level by 2
• Task w: inspect the character in the running database

The Schema API

In the above examples we didn't really lean on any structure, just loosey-goosey CRUD. Now I want to introduce a little bit more software engineering into your Mongo work. By using Mongoose we get the ability to use Schemas (still flexible but structured). The ethos is that Schemas are converted to Models which instantiate to Documents. When we work with models it becomes Object-Oriented coding.

Let's play with some Schema features:

• In a schema you give the field names and the types that you want in your documents. For instance mongoose.Schema({aField: String, anotherField: Number})
• The basic types are: String, Number, Date, Buffer (binary data), Boolean, Mixed, ObjectId, Array
• You can elaborate on any field by replacing the type with a JSON object that has a type key along with some other optional keys. For instance mongoose.Schema({aField: {type: String, required: true}})
• There are many extra arguments but some of the best are: default, get, index, required, unique, validate, match
• You can make Class-level functions called statics, or Object-level methods before you declare the Model

MiniTask 1: Create a Dog Schema, with some pertinent characteristics

MiniTask 2: Give each dog the ability to bark their name.

MiniTask 3: Make a Class-level method for listing the names of all dogs.

I'll talk about arrays in Schema a little further down.

Check out the mongoose guide.

A Reddit Clone

Next I want to show you a pretty functional MEAN stack built on this tech. The github code is here and it should run on your cloud9 environment with a quick npm insall. Again we will talk this out in class and make some alterations.

Sample reddit

Task 1: get this running.

Task 2: create some posts in the database directly then refresh your page.

Task 3: create some comments in the database directly.

Task 4: Talk out how you would keep someone from upvoting more than once.

The JOIN problem

The biggest complaint about noSQL is living without JOINs. That is because we want to think in terms of relationships. In particular many to 1, 1 to many, 1 to 1, and many to many. In Mongo we can solve this problem in several ways.

Each document has an _id and documents can store other documents or arrays. So you can choose:

• Embed one document inside of another.
• Keep an array of documents in the referencing document.
• Keep an array of "_id"s in the referencing document.
• Keep a reference (or array of references) in the referenced doc pointing to their parent.
• Keep an array of references on both sides.
• Keep an array of documents on both sides.

Mongoose has a great feature called populate which will "re-hydrate" these references when you need them.

Here is a sample stolen from them:

Last Task: Create a blog engine which has comments and authors. Reference between them in two different ways from the above list.