Nest.js Crash Course #3 - Controllers

Key Takeaways

in this video we're going to go over controllers in sjs in the previous video we talked about creating you know maybe a ninjas API that allows you to manage an Army of Ninjas so in order to have an API right you probably will have some kind of routes I defined so let's write a couple comments here imagine that perhaps you want to have a get slash ninjas right which returns you maybe a collection of ninjas typically in rest you might also have a route that allows you to get a single ninja where you provide a an ID for that Ninja on the path of your request you also want to be able to create ninjas right so typically in breast it'll probably be the same endpoint as this except we're using post HTTP post and then similarly you might have a put or a patch on the slash ID path to update that record and finally you might have a delete also taking in a ID parameter so that you know you can delete ninjas you know maybe you're trying to remove them from the battlefield so at a high level controllers are in charge of defining exactly this right it defines what are the paths what are the the HTTP methods for each of these paths so you can see that in this controller we have this string ninjas that basically says that everything within this controller is going to have that prefix X right so that's one of the things that we want in our paths is that ultimately each and every one of them has a prefix ninjas so in order to create these routes again you need a class that is annotated with the controller decorator and then optionally some kind of path that you provided in here and then within your controller you can Define methods for each one of your routes so for example if we were trying to do get ninjas let's define a method for that let's start with just returning an empty array we'll update this later in the series and right now this is just a method for a class Nest doesn't yet know that this is meant to represent a route the way we do that is to include another decorator get from this JS common and that basically provides Nest an idea that hey this method is to create an HTTP get on slash ninjas now you might be wondering what about other paths that are Beyond just ninjas so if we were to implement get one ninja and this is also a get but notice that in the definition of get you can provide an optional path to append to the controller's path so if we did ID like this that pretty much defines this route now let's go ahead and test this real quick to make sure it's working our application is already running if you're following along and your application is not running make sure to run npm run start Dev but we're back on thunderclient localhost 3000 if we go to slash ninjas HTTP get and hit send we're going to get back that array and if we were to pass any ID right now we're gonna get back that object right and as an example the next thing we need to implement is to post on slash ninjas if we try to request that right now without it being defined we should expect a 404 not found because it doesn't know where to bring that to so just to save you a little bit of time I went ahead and implemented the rest of that boilerplate for you but it's all the same idea notice that we got methods for each of these routes there's a dedicated decorator for post put and delete and other ones that you might assume like you know patch and then again remember to provide the parameters inside the decorators here and that's really routing in a nutshell now of course there's a couple other parts here that we need to add in for example uh how do we get how do we parse out this ID from the request so that our logic down here can work with it so that's where the param decorator comes into play you usually provide this within the method definition here and you can see that the parameter decorator can also expect a string in our case we're trying to parse this ID out of the URL so we're going to say ID here and then just for typescript we're going to say that this is a string so what effectively happens here is that you know behind the scenes Nest is parsing out the URL and auto injects it into our method here when it gets invoked so if we just print out perhaps the ID and response here if we go back to our get ninjas slash some kind of ID hit send you'll see that the ID is the thing that we passed in right so you can probably imagine that we also need the same thing in our other routes down here all right so that's URL params now the URL can also include a query for some of these right so for example uh for ninjas maybe you want to be able to filter uh the type of ninja that you're getting back right so your url might look something like this with a question mark type to do fast you know maybe you have I don't know a fast ninja and a slow ninja right so same thing we need a way to be able to parse that out of the URL and a lot of it is very similar to what we're doing here except instead of param we're going to use Query and same thing you can provide the string here that you're trying to parse out uh say this is a string and again just to kind of mock it out let's provide the type that we inputted into the response so if we did then just type equals fast we should expect a response of you know it's got fast in there so I hope you see where we're going with this later on we are going to do some kind of filtering on a real collection but let's move on and learn other things about the controller so typically with a post request like this right you could think of it as you're creating a a new Ninja for your army we need to be able to also parse the request body and again it's all the same pattern as you might imagine there is a body decorator that allows you to parse out that request body so maybe let's call this create ninja dto now it would be nice if we had typing for this right so that we can kind of figure out what's the shape of this object so what you typically would want to do and notice that in our generated users research earlier it kind of did it for us there's a TTL folder here where there's a create user dto and an update user dto we're going to do something similar let's go ahead and actually just copy this into our ninjas folder so that it also has its own detail folder and then let's rename these two uh create ninja dto and update Ninja dto and let's also update the class theme Here to create ninja detail same thing for update all right and you can see that this update dto just extends the create ninja detail we're going to use this later in our update Route but let's focus on the create ninja dto first right so imagine that maybe as you're creating Ninjas for your army maybe you want to have a name for each of those ninjas and we can add more fields to this later but for now we can take this and add a typing to our create ninja dto in here make sure to import that and just to make sure that you know this is working correctly let's go ahead and just create a mock created ninja here where the name is the same one that's passed through I had a dto right so if you go to our thunderclient let's go to post ninjas where we need to provide a request body with a name field give a name here send and it's going to give us back an object with the same name right so that just proves that we're able to parse this out and later we're going to work with that and add validation you know if you keep watching the series we'll come back to this ninja dto to kind of improve it and add validation and all of other fun stuff now to wrap up our controller here similarly for an update Route besides the uh the ID parameter we also need its own request body there that provides the updates so very similarly we're going to add body here with update Ninja ETO and then we can provide our update ninja dto type right and same thing we'll return the name now our controller right now is really not doing much but you can see that it's its primary responsibility in sjs is to really just Define the routes it's uh in charge of parsing things out of the request from the URL from the request body and then ultimately for forwarding that down to services or providers which will do a lot of the underlying logic that we want to actually happen so think of controllers as very lean routers they really don't do much other logic besides what we've done here alright so that pretty much wraps up our initial controller here in the next video we're going to talk about providers and dependency injection so that you know we can start using those services within these controllers that we can start actually implementing these crud endpoints to behave as we expect them to