In the last video, we saw how to connect MongoDB with Mongoose,

how to create schemas to represent the data we want to save, and

how to create models to save and retrieve documents from the database.

Let's take a look at some ways we can extend those tools to make

working with the data more convenient.

First let's clean up our sandbox a little.

There's a method we can call on the animal model that saves a batch of

documents in the database, create.

We can pass the create method an array of models or objects or a mix of the two.

We'll do exactly that,

create an array of a mix of JavaScript object literals and models.

Let's see this in action by creating an array of a few more animal

objects called animal data.

Let's create a mouse, Who's gray,

Who weighs 0.035

kilograms called Marvin.

A nutria,

Who's brown, Who weighs,

6.35, Whose name is Gretchen.

A wolf, Which is gray,

weighing 45 kilograms,

named Iris.

And finally, the three existing models,

elephant, animal and whale.

We can use this array to store them in the database.

Notice there are no size properties on these objects.

In fact, let's delete them from our other animals.

And we can remove the default value from our schema.

We'll see how to add this property back on dynamically in a moment.

For now, we can delete the three animal save calls,

and replace it with one create call on the animal model.

We can pass in our array of animal data.

And the callback has an error, and then the animals that were saved.

Let's remove these extra closing brackets that we don't need anymore and

clean up our code a little.

Much nicer.

Now let's see how to set the size property of each animal

dynamically before saving them to the database.

Mongoose offers us something called a pre-save hook.

This is an opportunity to do something to a document before it is saved.

We can take advantage of this opportunity by writing Mongoose specific middleware,

passing it into the pre method on a schema.

Let's implement a prehook middleware on AnimalSchema.

The handler we're passing into as the second parameter will execute

before Mongoose saves the document to the database.

It takes a next parameter that will be used in the same way as in Express.

Once we're done with our code, we can call next to tell Mongoose we're done.

Inside this handler,

the this object will point to the document or model to be saved.

Let's use this handler to examine the mass of an animal.

We can assign the size property based on the mass.

If the mass is greater than or equal to 100,

This size is big.

If the mass of the animal is greater than or equal to 5 or,

Is less than 100, Then its size is medium.

Finally, if it's anything else, it's small.

To test this out and see the results, we can alter the query we had below.

If we pass in an empty object as the first parameter,

the query will return all objects.

Then, inside the callback, we can log each animal's size so

that we see that it was set.

Now if we save this, switch over to our terminal and run our file,

we should see that the sizes are assigned correctly in the output.

As you can hopefully see, pre hooks can give you a lot of power.

Save isn't the only event that has pre hooks.

You can find out more about them in the documentation linked in

the teachers notes.

Let's see how to use this size property in a custom query called a static method.

A static method is a custom function we can call on the model directly

to help us access our data in custom ways.

For example, what if we often find ourselves needing to find small animals?

We could write the query every time, or to save some typing and

dry up our code, we could put the query into a static method.

On the animal schema, there is a statics property.

This is where we can define our static methods.

Let's create a static method on the animal model called findSmall.

We're passing in a call back here, so it can plug into the query inside

the function to preserve the flow of our overall application.

This inside the static method refers to the model.

In this case, it will equal the animal.

We can use this model to query the collection of

documents with the size property of small.

Let's update our query to see the results of the static method.

Now when we run this file, we should see our mouse and fish.

Let's generalize this method.

Instead of just small animals, let's enable this method to work for

any size we specify.

To do that, we can change the function to be called, findSize and

pass in and arguments as the first parameter.

And then modify the query object to include the size too.

Down at our query, change findSmall to findSize.

With the first argument, medium.

I'll let you test that out on your own, if you'd like.

Static methods can be really helpful

when we want to create custom queries from the perspective of the model.

But what if we wanted to find data based on a document that we already have?

For example, what if we want to find an animal, and

then we want to find more animals with the same color?

We can use instance methods for this.

Instance methods exist on all documents.

In instance methods, the this value points to instances of the document itself.

To create an instance method, we'll first place

a function on AnimalSchema's methods property.

Let's call our method findSameColor.

To get a reference to the model, we can call the document's model method and

pass in the name of the model we wish to access as a string.

In this case, it's animal.

From there we can query the usual way.

Passing in the documents color with this this.color.

To see this in action, we'll need to modify our query once again.

Let's use the Animal model's findOne method to retrieve an elephant

This method will search the database for

batches and whichever is first to match is the one returned.

This is good if you only want one matching document in the database.

We can use the resulting document to call the instance method and

print out the results to the console.

Now when we check the results in our terminal,

we see we get all the gray animals.

Success, now that we've seen how to use static and instance methods

to customize the way we handle database interactions with Mongoose.

We've also seen how to implement a pre save hook.

There are other features Mongoose offers, and I'd encourage

you to read the documentation linked in the teacher's notes.

Feel free to play around in the sandbox, too.

When you're ready, we'll start integrating Mongoose into our Express app.