A sandbox is an environment you can play around and learn in.

And it's a great way to get acquainted with new technologies.

Let's create a sandbox to get a feel of how Mongoose works.

To get started using Mongoose, we'll need to install it.

I'm in the terminal, in my project folder.

And I'm going to install Mongoose with NPM using the save flag

When that's done hop over to your text editor and

let's create a temporary file for some experiments.

What we call it isn't important.

I'm going to call mine mongoose_sandbox.js

At the top of the file let's use strict.

And require the mongoose module.

Then we want to connect to the Mongo DB server.

We do that by calling the mongoose.connect method.

This takes one parameter, a connection string,

in our case it's mongodb:// which is the protocol we're using.

This is because we're talking to a mongodb database.

Then its local host, Which

is our local machine, :27017,

which is the default port for mongodb.

Then, /sandbox, which is the database name to sandbox.

We could name this anything we want, but sandbox is a sensible name.

Once this call is made,

we can monitor the status of the request through Mongoose's connection object.

Let's reference the connection object and store it in a variable called db.

The db object will now emit various events related

to the database connection that we can listen for.

When events occur, we can handle them.

One event that could occur is an error.

We hope an error doesn't happen, but

if it does we want to have some code to handle it.

We can listen for the error event with the on method.

For our error handler, we can log a message to the console so

we know if there were problems.

Now let's listen for the open event.

This event is emitted when the connection is ready to go.

It means that the connection to the mongodb server is open and

it's ready to talk.

We'll use the once method to listen for it.

This method is like the on method,

except while on fires its handler every time an event occurs,

once will only fire its handler the first time the event occurs.

This can relieve the app from listening when it no longer needs to.

Let's create a handler.

And blog out that the database connection was successful.

This handler is where we'll write all of the codes to communicate with

the database.

When we're done communicating, we can close the database connection.

First, we'll create a schema.

To do that, we'll reference the schema constructor from the mongoose object.

Let's make a schema to track animals called AnimalSchema.

We'll do this by calling new on the schema construct a function and

pass in an object.

The object we're passing into the schema constructor will describe our data.

Let's say, we wanted to track the type of the animal as a string.

The color of the animal as a string.

The size of the animal as a string.

The average mass of the animal in kilograms.

Which is a number.

And then the name of the animal as a string.

We'll use the animal schema to create a mongoose object called a model,

which will create and save our document objects.

Let's create a model called Animal.

We do this by using the mongoose method model.

Passing in the name of the model, Animal, and the schema that defines animals.

Mongoose will pluralize the string we supply as the first parameter here.

This will map to a collection in the mongodb database

whenever we save the document.

In this case the model will create or map to a collection named animals.

Let's create an animal document now.

Let's create an elephant calling the animal constructor function.

In the constructor function, it takes an object with all the properties and

values your model needs.

In this case, we're filling in all the attributes for

an elephant called Lawrence.

When we run this code an elephant in memory of our application is created.

However, Mongo will not know about it until we save it.

In fact, if we run this right now and

went into Mongo to look for an animal's collection we won't see it.

it's not been created by Mongoose yet.

When we save this elephant, Mongoose will create the animals collection and

save the elephant object in the new animals collection, all in one action.

Let's save it by calling the save method on the elephant object.

Now we have a problem.

This code won't work.

That's because save is an asynchronous method.

Our application will call the safe method first and

then call close right away before safe can finish, causing it to fail.

What we'll need to do is pass in a callback function into the save method,

and then close the database connection from inside the callback.

The save callback passes in an error as its parameter.

Let's handle that by logging out save failed.

If it does save, let's logout saved.

When the save is done the callback is fired and then the database will close.

We can pass in a call back to the close method to be notified

when the connection is closed.

Now

we're

going to test this out.

Make sure you've got your Mongo DB7 running.

Switch over to your terminal and then run the sandbox file.

Let's peek inside Mongo to see what we did.

First, use the database name from the connection string we used earlier.

In this case for me, it's sandbox.

Next we can get the collection names in our database.

There's our animals collection.

Let's find what animals are in our collection.

As you can see we have a collection named animals that contains one document and

then with a name to Lawrence.