Let's say we wanted to create the default animal to be saved if we don't supply

any data to the model.

Mongooses schema lets us as defined default values very easily.

Let's change the schema to give us a goldfish animal as default.

Instead of just specifying a type,

we can give each property a type and a default value.

Goldfish are small,

golden and really light in

comparison to elephants,

and named Angela?

Anyway, now we can create a generic animal with our model by

passing an empty object into it.

And when I say a generic animal, I mean a goldfish.

If we were just to call save on the animal,

under elephant.save, we could run into problems.

The save method runs asynchronously.

It's impossible to know which save will finish first.

If the elephant saves finish first, it will close the database connection.

The generic animal won't be saved.

Instead, we'll place the goldfish.save inside the other's callback and

put the db.close inside the goldfish's callback

to ensure the correct sequence of events.

Remember we already have an elephant in the database.

Running this file again will create another one.

Let's empty the animals collection before we save it.

The model can do this for us.

Let's ask the model to empty our animals collection before we save anything.

We can do this by calling the remove method on the animal model and

passing in an empty object.

We could specify which documents we want to remove by passing in a query

object here.

But if we leave all of the properties blank, it will remove all documents.

A query object would match properties from itself

against properties of documents in the database.

Any matching documents would be removed.

We want all the save actions to take place after the removal, so

we'll route this code in removes callback.

Now when we run this script We'll start with an empty collection every time.

Let's run this file in the terminal and then check the database.

There's the default animal, a goldfish, and an elephant.

Let's save one more animal, a whale,

to show that these defaults can be overwritten.

Let's create a variable called whale and call the animal constructor.

The type is whale.

The size is big.

The mass is 195,500 kilograms.

Wow.

And its name is Fig.

Notice we're not supplying the color here.

The whale should pick up the color from the defaults.

Let's save it after we save our other two animals.

Before we run this, let's also see how we can read animals out of the database.

Let's ask the model for all big animals, and

then write out their names to the console.

The models find method takes in an object as its first parameter.

This object should contain keys and values you want to match to your results.

The second parameter is a callback function that passes in an error object

and the results from your query.

Let's print out each one of the results in the console now.

console.log(animal.name +) "

the " animal.color,

+" " + animal type.

Just a note here.

You see this pattern we're building up with all these callbacks?

This is a common pattern in Node, which you may have seen or experienced before.

Manage an asynchronous calls by nesting them inside a callback

after another callback.

This is known as the pyramid of doom.

But we're just playing around with Mongoose to just get a feel

of how it works.

Our code in the rest API we're going to build won't suffer from this as much.

Special objects called promises can help us manage asynchronous code and

make it easier for us to read and work with.

Treehouse content that covers promises is in the teachers notes.

However, we're not using promises in this course.

Also, we'll clean up a lot of this code in the next video.

In the terminal, run this file again.

The data was successfully submitted and

that the models were found that are big animals that we asked for.

There we have the golden whale, Fig.

Fig is golden because the default values were specified in the schema.

So far, we've performed three of the four basic database operations with Mongoose,

namely reading, writing, and deleting.

Updating is a similar process.

We'll cover that later.

Now let's look at some more advanced things you can do with Mongoose.