‫In this lecture, things will start
‫to get a bit more advanced.
‫And that is because we'll now create multiple routers
‫and use a process called mounting.
‫So let's see how all that works.
‫Now, before doing any of that, let's keep in mind
‫that the ultimate goal will be to separate all the code
‫that we have in this file into multiple files.
‫So what I want, is to have one file
‫that only contains all of these routes
‫then I want to have another file,
‫which has the routes for the users.
‫I will also want to have a file which contains the handlers
‫only for the users and then also one file
‫that will contain all the handlers for the tours, okay?
‫And so that's actually what we're gonna do
‫in the next lecture.
‫But in order to be able to do that,
‫we actually need to now create one separate router
‫for each of our resources.
‫So, let's go back to our routes here and so right now,
‫we can say that all our routes, so these four routes here,
‫we can say that they're all kind of
‫on a same router, okay?
‫And the router, is this app object.
‫But if we want to separate these routes
‫into different files, so again,
‫one file for these two routes
‫and one file for these two routes,
‫then the best thing to do, is to create one router
‫for each of the resources, okay?
‫And so, this is how we're gonna do.
‫It's actually not that complicated,
‫but you will have to wrap your head
‫around a couple of concepts, okay?
‫So, let's start by saying,
‫const tourRouter is equal to express.Router.
‫Okay, so just like this,
‫we create a new router and save it into this variable.
‫Alright, and so now let's use that router
‫for these two routes.
‫So here we use it instead of app.
‫Alright, so now we have two router and then route
‫and then of course, the get and the post routes
‫on that router.
‫Now, how do we actually connect this new router
‫with our application?
‫Well, we'll use it as middleware, alright?
‫And so that is because, this new modular tool router here,
‫is actually a real middleware, alright?
‫And so we can say, (keyboard typing),
‫app.use, and then the route but let's keep that for later.
‫So we can use, the tourRouter on our application
‫and where do we want to use the tourRouter?
‫Well, we want to use it on,
‫/api/version one/tours, okay?
‫So again, this tourRouter here, is a real middleware.
‫And we want to use that middleware for this specific route.
‫Okay, and so we use app.use
‫and specify the middleware function, which is this router,
‫then we specify the the route so the URL,
‫for which, we actually want to use that middleware, okay?
‫And so just like this,
‫we created basically a sub application, okay?
‫Now, there's just one thing
‫that we really need to change here,
‫which is these routes in here, okay?
‫So let me change this here, and then explain
‫why it has to be this way.
‫So here, we only want the route,
‫and in here, we only want the id, okay?
‫Now, why is that?
‫Well, it's because this tourRouter middleware,
‫only runs on this route here anyway, okay?
‫And so once we are in the router,
‫then we already are at this route.
‫So at our tourRoute, and so this first route
‫that we had to before, we only want to run it as,
‫api/version one/tours
‫and so that is what this route here now means, okay?
‫So it's basically the route of this URL, okay?
‫So is this small mini application, alright?
‫So, actually, when we create a router system like this,
‫we actually say that we kind of create a small sub app
‫for each of these resources, okay?
‫So this is the route of or mini application,
‫which is again, at /tours, Okay?
‫And then the second route, is at /id, right?
‫And that's because, before,
‫it was at tours /id, so it was all of this.
‫So like this, but now, this URL here
‫is already in our kind of parent route up here, right?
‫So let's say that we have an incoming request now
‫for /api/version one /tours/version id.
‫So the request goes into the middleware stack
‫and when it hits this line of code here,
‫it will match this URL here, right?
‫So it will match this route and therefore
‫or two router middleware function will run.
‫So or two router is this sub application that we created,
‫which in turn has its own routes, okay?
‫And if the request was for /id, well,
‫then it will inside our mini app,
‫hit this route here, right?
‫And finally, of course,
‫it will run one of these handles here,
‫depending on the method that was used.
‫So I hope that made sense.
‫And so let's now actually go ahead and do the same
‫for all users, alright?
‫So, I will go ahead and create another router here,
‫(keyboard typing) called, the userRouter,
‫and then just like before, it's express.Router
‫not like that, yeah.
‫Okay, so use a router,
‫and then we need to do the same process as here.
‫And by the way, this is called mounting the router, okay?
‫So mounting a new router on a route, basically, okay?
‫So we have now users and here user.
‫And actually, mounting the routers,
‫has to come after all of these definitions
‫or at least after we declared a variable, right?
‫So we cannot use the routers
‫before we actually declare them.
‫Okay, now all we need to do is to go ahead
‫and also change the routes in here.
‫And so just like before, if there is now a request
‫for /api/version one/users/id,
‫the request will enter the middleware stack
‫and when it hits this middleware here,
‫it will run the user router,
‫because this route here is matched, okay?
‫And so then it enters the user router
‫and again, just like before,
‫this error is the route basically in our sub application,
‫and this here, is the entire URL/id, okay?
‫Does that make sense?
‫So before moving on,
‫let's actually test if this still works.
‫So, let's get all the tours here and indeed, it does.
‫So everything still works to the same with the users
‫and also that still works.
‫So we did all these changes and decode the works,
‫meaning that our two new routers are correctly mounted.
‫Alright, and with that, we are ready to actually separate
‫or different routers now into different files.
‫And that we will do right in the next lecture.