So in the last lesson, we helped make our code a little bit more dry by extracting reusable code out into our services. In this lesson, we're going to learn how we can clean up our routes even more

by extracting our handlers out into what's called a controller. So let's go ahead and start by actually creating our controller. And just like we used the ACLI to create our service,

we can use it too to create a controller. So let's jump back into our terminal, stop our server with Ctrl+C, clear our terminal out, and let's do node.ace.list to see the list of commands once more.

Since we're looking to make a file, we'll want to look within the Make section. And right here, we can see Make Controller. There's a number of different things that we can actually pass into this command, so let's view the help options for it.

So let's do node.ace.make.controller-help. So just like we have already with our services, we can provide a name in after we type out the command to name our underlying controller.

But then after the name, we can optionally add in any actions or methods inside of that controller that we want the controller to have. In addition to that, there's some options that we can add in as well.

We can specify that we want the name of the controller to be singular. We can make this controller a resourceful controller, which we talked about resources whenever we learned about the HTTP methods that we can use to define our different routes.

So this would be a controller that's automatically created having a method stubbed for each one of those different route options that we covered within that lesson. And then there's also an API variant for that as well,

where it would be created for a resourceful API route. For our case, let's focus on the handlers that we have already. So we'll do node.ace.make.controller.

We'll call this movies, and then we'll want an index method and a show method on it. So let's go ahead and create this. And now within our app directory, we should be able to find a folder

called controllers with a file called movies controller inside of it. So let's jump back into our text editor. And sure enough, there's controllers, and there's our movies controller.

If we open it up, we see a class called movies controller with an index and a show method stubbed out, both of which are ready to accept in the HTTP context.

So for the most part, we should be able to jump into our routes, copy the handler as we have it, cut it out, jump into our controller. That was the index method that we copied the contents for,

so we'll paste it within the curly braces here. The red squiggly on our movie service is just because we need to import it, so we'll type movie, go down the movie service, and hit tab to auto-import it.

And then down here, we have ctx. However, within the controller, they have it stubbed to an object, which we can then use to extract view directly out of the HTTP context object.

So now instead of ctx.view, we could just do view.render. Let's stop here and give this a save. It's going to format it for me, and let's jump back into our routes.

And now what we need to do is replace our handler portion and tell it to point to our controller instead. We can pass in an array where the first argument

is the controller class that we want to use. So this would be our movies controller. I'm going to tab to auto-import that. And then we can do comma,

and the second argument will be the method within there that we want to use. And you'll notice we get a nice autocomplete that allows us to see the methods that we have within the file itself.

So we'll tell it to use the index method there. We can give this a save, and you'll see something nice happen right up here. Our controller import actually went from importing directly, as you see here,

to, if I give it another save, importing lazily. So now the import is behind an arrow function, meaning that Adonis won't actually import the file

until we attempt to use it, which, as we get more and more controllers, will actually help our server boot up just that much more quicker. So at this point, we can go ahead and jump back into our browser,

and it looks like we might have forgot to boot the server back up. So let's go ahead and open up our terminal. Yep, sure enough, npm run dev here. Okay, that looks good. Let's give the page a refresh now.

Okay, cool. So there we go. We still get the same result. The only difference is now the route handler is going through our controller rather than directly inside of our route.

And as you can see here, having just a single line for a route definition is a lot more readable and maintainable. And so multiply this times 50, as we build out different routes for our application,

this becomes a heck of a lot more readable and easier to maintain than if we had 50 of these within here. So let's go ahead and move our show path over into our controller as well.

So we'll just copy everything within the route handler, cut it out, switch over to our movies controller, scroll down to our show method, paste it in between the curly braces, scroll down a little bit more.

Looks like we'll need our params and our view from our HTTP context. So we get a view and params, get rid of the ctx. That's prefixing those. So there, there, and we have one more right there.

And then we just need to import the toHtml method. I'm going to jump back into our routes file, scroll up to the top, and just give it a copy. Jump back into our movies controller, jump up to the top, and give it a paste.

So now if we scroll back down to our show method, everything should be nice and happy. Actually, now that I look at it, we don't have a reason to have this share separated. So we can move this state into the state directly within our render call, just like so.

Give this a save, jump back into our routes. We can get rid of all of these unused imports now. So those and that. Replace the route handler here with an array,

pointing to our movies controller, and specifically the show method within it. Give that a save, and there we go. So now if we jump back into our browser, everything should still work.

We're just now using controllers to make our lives a little bit easier.