[MUSIC]

We have one final thing today, connect incoming requests to the database.

This will take place inside the route handlers.

The handlers will receive the requests from the outside world and

to use Mongoose to persist or retrieve the data.

Let's connect Mongoose to the route handlers and response to requests.

In the routes file, let's start by importing our question model.

We'll require it at the top and assign it to question.

Now we'll be able to use question to create documents and query the database.

We can start with the root routes get request handler.

For this, we want the API to return all question documents.

On the question model, we can call the find method,

and pass in an empty object literal followed by a callback function.

To make sure the question objects are sorted so

that the most recent ones come first,

we need to add additional parameters to find the method before the callback.

If the second parameter is not a function,

in other words our callback function, the find method expects it to be

what Mongo calls a projection to limit the fields returned by the query.

In other words, a projection is a way to return excerpts of a document.

Since we don't want partial documents, we want full documents,

we'll pass in null as the second parameter.

And then we can specify how we'd like our ordered results as the third parameter.

Passing in an object literal.

By entering the property of sort, we can specify another

object literal with the key we want it to be sorted by.

Entering -1 means the documents will be sorted in descending order.

This means the most recent data will be at the beginning of our results array.

Without this null placeholder, Mongoose would try to

use this object as a projection.

So we need this null value here.

This tells mongoose how to sort our results.

The callback is now our fourth parameter.

In the body of a callback function

we first want to handle any errors that may result from executing this query.

So we'll need to access the next function and

hand it off to express's error handler.

If there are no errors, we can send the results to the client's request.

Because we're getting JavaScript objects back from Mongo, we can

drop them straight into the JSON method on the response object and send them out.

I want to show you a slightly different way to query the database with Mongoose.

One but you might find a little easier to use

than this full parameter method signature.

If we don't pass in a callback function to the find method,

it doesn't execute the query immediately but rather returns a query builder.

You can use this builder to modify the query with additional methods.

When you're ready to execute the query,

we can call the exec method on the builder and pass in the callback function into it.

So first, we'll call find with an empty object literal

as we did before to get all the results, then call sort on it.

And passing in that same sourcing object that we used before.

At this point the query hasn't been executed yet,

the sort method returns another query builder so

you can chain any number of modifications together through additional method calls.

This is the only one we'll need, so we can call the exec,.

And pass in our callback function.

This executes the query and calls the callback function.

If you'd like to read more about this style of building queries,

there is a link in the documentation in the teacher's notes.

The style you choose is up to you.

Now let's handle the post action for this route.

To create a new question document from the incoming JSON on the request body,

we can pass it in directly to the model constructor.

Then we can call save on it.

And pass in a callback function.

Don't forget that add in next, as this will help with errors.

We can use an HTTP status of 201 to indicate to the client that

the document was saved successfully.

Finally the document can be returned as JSON to the client.

The next handler to complete is the get request for a single question.

For this we can use the findById query method on the model,

passing in the questions ID from the URL.

Let's pass in a callback, With an error and the document.

Let's handle the error like we did before.

And return the question document to the client as JSON.

Now this is a fine way to do it but there is a better way.

Express allows us to trigger a handler whenever a URL parameter is present.

In this case, if qID exists, we can preload

the question document in the handler so it will be present on any matching route.

To do this, let's go to the top of our router file.

And on the router object, Call the param method.

The param method takes two parameters,

the name of the route parameter as a string, and a callback function.

This callback will get executed when qID is present.

The callback takes the same parameters as other middleware.

Except for the last one which takes a value from the route parameter,

in this case qID.

So first we can load the question document and if there's an error,

it will pass it forward to the error handler.

If the document can't be found,

we want to return a follow for 404 error to the client

Remember to set the status property on the error

object since the error handler will look for

that and use it if it's there.

Finally, if it exists, let's set it on the request object, so

it can be used in other middleware and route handlers that receive this request.

Finally, let's call next to trigger the next middleware.

Now, we can go back to the route handler we just made, and simplify it.

We won't need to query the database anymore because the param handler will be

doing that, so we can delete that.

And we don't need to handle the errors since the param handler is doing that too.

All we really need to do now is send out the document to the client.

Now we're ready to tackle the answers collection route.

Since we're already having the question loaded by the param method, we can

start to see here how it's relieving us from typing a query for each route.

It's just there in the request.

After getting the reference to the pre-loaded question and

accessing the collection of answers We

can simply push the object literal version of the document we want to add.

Mongoose will create the document for us.

To save it, we need to call save on the question document.

And in the callback,

We can set the http status to 201, which tells the client that their resource

was successfully created, and then send the response back to the client.

But the specific answer route, we can say that another

parameter handler would be useful here to preload answer documents.

Let's go ahead and make that now.

Under the parameter handler for qID, we can create a similar handler for

the answers using the aID parameter.

Mongoose has a special method on sub documents array called ID.

The ID method takes an ID of a sub-document, and

returns the sub-document with that matching ID.

If the answer can't be found, We want to send a 404 error.

Otherwise, we'll call next to pass control back to the router.

Now that the answer is loaded, let's use it in our put route,

we can use the update instance method.

Remember, we'll pass in an updates objectm which will contain the properties and

values we want to modify on our existing document.

In this case, it's the requests body.

Then a callback to fire, after saving the updates to the database.

We'll just send the results in question document back to the client.

The next route is the one that deletes answers.

Mongoose documents have a remove method.

We can use the remove method on our answer.

Then in the callback, we'll save the parent question.

This will take another callback where we can send the resulting

question back to the client.

Finally let's complete the vote route.

First, let's add a line to the validator

to make everything a little more coherent and readable.

Now we're putting the vote string directly on the object.

It allows the reader to quickly understand what the value of the variable is about

when they read it in the next callback function here.

This is opposed to rec.params.dir, which probably wouldn't

help them understand it's holding the vote direction up or down.

Now let's call our instance method vote on the answer, passing in the vote string and

then a callback with a response back to the client.

And don't forget to include the next in your handler.

See how clean the instance method makes it easier to apply the vote to the answer?

Nice work.

This step completes our API.

We now have an express server that receives restful requests,

communicates with the database, and sends responses back to clients.

Great job.