Let's start by creating a module to handle the routes.

First we'll create a new file and save it to the root folder as routes.js.

At the top of the file don't forget to put use strict.

Now let's bring in Express in requiring the Express package.

var express = require("express").

Then we can setup a new router.

You can read more about the express router in the teacher's notes.

The router object is what we'll pass into the main app.

To do this at the bottom of the file we'll export the router.

Let's save that and move back to the app.js file to connect the two together.

Underneath these two dependencies,

let's bring in the router module that we created.

Let's use the variable routes.

And require our routes file.

Routes can be connected to the app in the same way as middleware

using the use method.

We only want the router to kick in when any route starts with /questions.

So we'll pass in the string /questions as the first parameter.

When a request comes in for

any route that starts with questions they will be ushered into the routs module.

The routes module will try to apply one of the handlers were trying to code.

Let's switch back to the routes J.S. file.

Let's build a fast route handler.

The first route is slash questions with the get verb

one the router objects we can call the get method.

The first parameter will be the rank string that we want to handle.

Inside this particular router this will be represented by a single slash.

That's because the app handles the request to the router.

It strips away what was already matched /questions.

So any sub routes to questions would be built onto the slash.

For example If

the app gets a request to /questions/5/answers

it would see that the URL meets the criteria for

our router and it gets handed The route.

/5/answers.

The second parameter in this method is a callback function.

This is our route handler.

It will execute when a request comes in that matches the route and verb.

When the handler is called, it will receive the request and response subject

which we'll abbreviate to (rec,

res).

And we want this route to // Return all the questions.

Notice that this function looks a lot like middleware

without the next function as the third parameter.

It works in the same way and we could have put the next in.

But because this is likely to be the last stop in our application before

the response is sent back to the client, we wouldn't need the next function now.

We will use it in future videos as it can help us handle errors.

To handle this request to read all questions we would need to

talk to a database and we haven't set up a connection yet.

We'll need the database connection for all these routes eventually but for

now let's send some hard coded responses from them to see the API working.

To send a json response to the clients we'll use their responses json method.

This call will end the life cycle of the request process,

we can put javascript objects into the jsson method.

And it will take care of the serializing and

the stringifying of the json before sending it out.

Let's follow the same

pattern to handle

post requests using

post instead of get.

We'll include one more property to send back the data we

received as an extra check that we're able to access the data.

Now we can create the route for retrieving specific questions.

We'll use the ID parameter to represent the question ID portion of the route.

We can update the response so it says for a specific ID.

Now when we test these we should see the results in Postman rather than

the terminal.

Let's save the file.

Stop the server.

Switch over to Postman.

Create a GET request on localhost/questions and click Send.

You should see a json response showing up in postman's response window,

now we'll send a POST request To localhost:3000/questions.

For the body you may already have the json from our last POST

request we made, but if not puts it back in.

Hit Send.

And you should see the response we expected with a reference to the json

we sent.

Finally let's test localhost:3000/questions/89

with a GET request to verify if we can see the ID in the response.

It works, great job.

Let's take a peek in the terminal and

as you can see there's not much happening there.

We've got the notification that the express server has started but

nothing after that it would be nice to see some

information about the requests in the API, and its responses while we're developing.

In the next video will add locking functionality that build and

test the rest of our routes.