Up next in 10
Build A REST API With Node.js, Express, & MongoDB - Quick
5K views
Feb 7, 2024
Embark on a fast-track journey to building a robust REST API with this quick and practical tutorial. In "Build a REST API with Node.js, Express, & MongoDB," you'll learn the essentials of creating a powerful backend for your applications. The video covers the entire process, from setting up a Node.js environment to utilizing Express for routing and integrating MongoDB for database functionality. Whether you're a developer looking to quickly implement a RESTful API or a Node.js enthusiast seeking hands-on experience, this tutorial offers a concise and step-by-step guide. Elevate your backend development skills and unlock the potential of building scalable and efficient APIs. Join this tutorial to streamline your Node.js, Express, and MongoDB knowledge and create a REST API that empowers your web applications with speed and reliability.
View Video Transcript
0:00
Today we're going to build your very first REST API as quickly as possible. Let's get started now
0:08
Now in order to create this REST API we're going to be using Node.js, Express, and MongoDB. And in order to get started with that we first need to run npm init. So we
0:17
just type in npm init and we just want to hit enter a bunch of times in order to get all the
0:21
default values and as soon as we do that it's going to create a package.json for us. Next we
0:26
want to install all the dependencies that we're going to use. So our dependencies we can just type
0:31
npm i and our first dependency is going to be Express and then the next dependency that we're
0:35
going to be having is Mongoose which is going to allow us to interact with MongoDB easily. Express
0:41
is really useful for when we want to create an application using Node.js because it's just much
0:45
easier to create a web application using Express than standard Node.js. Next we want to use npm to
0:51
install our development dependencies. So we can say npm i and we just want to say dash dash save
0:57
dev which is going to make these be development dependencies that do not get installed in
1:01
production. And we want to use dotenv and we also want to use nodemon. Now dotenv is going to allow
1:08
us to pull in environment variables from a dotenv file and nodemon will allow us to refresh our
1:13
server every time we make changes without having to manually end it and restart it. Now that we
1:17
have all those installed let's remove this test script and create our own script called dev start
1:21
which will allow us to start our server using nodemon and we just want to type in nodemon
1:25
followed by the name of our script which we're going to call server.js. We can save that and
1:30
actually create that new file called server.js and here we go this is where we're going to put all of
1:35
our different server code. And before we get started any further we want to create that dotenv
1:40
folder file right here and this is going to have our environment variables and we also want to
1:44
create a dot git ignore since we're going to be storing this on git using github or bitbucket or
1:49
whatever you want to use and we want to ignore our dotenv file since that's going to have sensitive
1:53
information and we also want to ignore our node modules folder because this can be installed and
1:58
created by just running npm install whenever you download the code from github or wherever it's
2:03
stored. Now with that out of the way let's create our actual server and the first thing we want to
2:07
do is we want to require express so we'll just create a variable which is called require express
2:12
just like that and that's going to pull in the express library. Next we want to create a variable
2:16
called app and we just want to run express function just like this and that's going to
2:20
create an app variable which we can use to configure our server. Next we can just say
2:24
app dot listen tell what the port we want to listen on in our case 3000 and we're just going to pass
2:30
it a function here and this gets run whenever our server gets started so we're just going to log
2:34
out that our server was started so we'll say console dot log and we'll just want to say that
2:39
the server has started. Now if we save that we run that method that we created earlier which is
2:45
npm run dev start hit enter and this is going to start up our server using nodemon and as you can
2:50
see it says server started down here and we can go to this app localhost 3000 and our server is
2:55
going to be running there but right now it doesn't do anything so let's make our application actually
2:59
do something. Next we want to configure mongoose to connect to our mongoDB database so we're going
3:04
to require that library we'll just call it mongoose and we're going to type in require mongoose which
3:09
is going to require the library mongoose and allow us to set it up. The next thing we need to do is
3:14
actually connect to our database so we'll type in mongoose connect and we want to put in here the
3:18
string which is our database connection and in our case this is going to be mongoDB colon backslash
3:24
backslash and then it's going to be localhost since we're on localhost and then again slash
3:28
and we want to type in whatever our database name is going to be called and we're just going to call
3:32
this subscribers because this is going to be a database that holds subscriber information which
3:36
is what our rest api is going to handle and then after that's done we can just save this and you
3:42
can see down here we get this deprecation warning saying use new url parser true needs to be passed
3:47
in because the old one is deprecated so what we can do is we can pass that option into the end of
3:51
our connect just like this now if we save that you see that that warning message goes away and we have
3:56
nothing else to worry about also what we can do is we can actually create a variable here called db
4:00
which is going to be equal to mongoose dot connection and from here we can hook up some
4:04
events to run when our database is connected to so we know it's working correctly we can just say
4:09
db dot on and what we want to do is on error we want to log out that there's an error so we'll
4:14
just say here this is going to take a function with an error and we can come in here and say
4:19
console dot error and we can pass it that error this will just allow us to see if there's a problem
4:25
connecting to our database also what we want to do is once we connect so we'll say data db dot
4:30
once which means this will only run once and whenever we open the database what we want to
4:35
do is we want to console dot log saying that we've opened the database so we can just say connected
4:41
to database just like that and now when we save we should get the message down here saying connected
4:47
to database and that's perfect but one thing that you'll notice immediately is that we have our
4:52
mongo db database string inside of our application and when we deploy our application we're going to
4:57
want to use something that's not our local host so we need to pull this out into an environment
5:01
variable so let's remove this right here go into our dot env we can just create a variable which
5:07
we're going to call database url and we want to set that equal to our mongo db library right here
5:13
and now inside of our server we can come in here and use process dot env dot database url or just
5:21
whatever you name this inside of your dot env folder and this will pull from our dot env but
5:25
you'll notice we get an error and that's because we need to use the dot env library so all the way
5:29
at the beginning we can say require dot env and all we need to do after we require this is call
5:35
the config method so we'll just say dot config and this is going to load all of our environment
5:39
variables from our dot env now when we save that you'll see we no longer get an error down here
5:44
and it says we connected to our database successfully so now we have our database completely done our server is completely hooked up and listening all we need to do is actually
5:51
create routes for our server and also set up our server to accept json so let's first set up our
5:56
server to accept json we can just say app dot use which will allow us to use any middleware that we
6:01
want which is essentially code that runs when the server gets a request but before it gets passed
6:06
to your routes and what we want to do is we want to use express dot json and this essentially just
6:11
lets our server accept json as a body instead of a post element or get element or whatever
6:17
also what we want to do is we want to set up our routes so since we're going to have a subscriber
6:21
api we're going to have some routes that are going to be called subscribers routes whoops
6:26
subscribers router there we go whoops i cannot spell subscribers router there we go and this is
6:33
going to route all of our subscriber information we can just say require and this is going to be
6:37
inside of a folder inside of our application called routes and it's just going to be called
6:42
subscribers so we can create that now let's create a new folder this is going to be called routes
6:47
and inside of this folder we want to create a file which is going to be called subscribers
6:51
dot js it just needs to match the name that we added in here for subscribers right here now once
6:57
we have that we can go in here and tell our app that we want to use that route so we can say app
7:01
dot use we pass it the path we want which in our case we want to use this whenever we query
7:05
subscribers so our url is going to look like this localhost 3000 subscribers and this is going to be
7:14
right here this url everything that has this url or anything after it is going to go into the
7:20
subscribers router which we created right here so now that we have that done we need to actually
7:25
tell it we want to use the subscribers router and there we go our application is set up and
7:30
working and you'll see that we get an error and this is because our router.use requires middleware
7:35
this subscriber router right now is absolutely nothing this is completely blank so let's set
7:39
that up we again need to use express so we're going to say require express in here this is
7:45
because our entire application uses express and what we want is we want the router portion of
7:49
express so we can just say express dot router and this is going to get us the router from express
7:55
and for now all we want to do is export that so we can say module dot exports is going to equal
8:00
to router this is just going to fix our errors down here and as you can see we no longer get
8:04
any errors everything's working fine but we have no routes actually configured yet since this is
8:08
going to be a restful api we're going to use restful endpoints and if you don't already have
8:12
a strong grasp of what rest is and what restful endpoints are i have a really short video going
8:17
over rest in depth which you can check out in the cards and the description linked below so now let's
8:22
start creating our different routes we're going to want some routes for getting all subscribers
8:26
we're going to want a route for getting one we're also going to want a route for creating one we're
8:32
going to want a route for updating a single one whoops updating one and we're also going to want
8:38
a route here for deleting one and let's configure those routes to do that we can just say whoops
8:43
router dot git for example which is going to be git and to get all we just want to use this
8:48
blake path right here and of course all these are going to take a request and a response and that is
8:54
going to be a function and instead of here we're going to do all of our code for our different
8:58
routes so let's get all these routes created for getting one we're going to want an id in here and
9:04
with a colon in front of it like this this means that this is a parameter that we can access by
9:08
typing in request dot params and this would be whoops params dot id and this would give us access
9:15
to whatever they pass in after the first slash next we want to create our create route and this
9:20
is going to be a post instead of a git so we can say dot post and again we're not going to need an
9:25
id here since they're not actually going to be creating it with an id they're going to be creating
9:29
it on just the general route next we need to do update so coming down here and we're going to be
9:35
using patch instead of put for our update because we only want to update based on what the user
9:39
passes us if they only pass us the name of the subscriber we only want to update the name and
9:44
none of the other information about the subscriber because if we used put it would update all the
9:48
information of the subscriber all at once instead of just the information that gets passed now lastly
9:53
we want to create our delete route which is going to be extremely self-explanatory this is just going
9:57
to be delete and again we need an id here as well as on the patch route we're going to need an id
10:03
and this is the basic shell of all the different routes that we're going to create now in order
10:07
to test these routes let's create in here just a res dot send which is just going to send text down
10:12
to the server and we're just going to say hello world so that we know that we actually have called
10:16
this git route here for getting all of our subscribers and normally to test these you may
10:20
go into the browser and open it up but you can't really test a rest api very well in a browser
10:24
because you have nothing to interact with so what we're going to use is we're going to use an extension in visual studio code and this extension is called right here rest client has 2 million
10:33
downloads is incredibly great and it allows you to call a rest api directly from visual studio code
10:38
you can also use a program such as postman if you want to instead but i really like being able to do
10:42
this directly in visual studio code so what we want to do is we want to create a path here a
10:47
file which is going to be called route dot rest you can call it whatever you want it just has to
10:52
end in either dot rest or dot http and in here we can create our request so in our case we want to
10:57
create a git request and we want this git request to go to http slash slash localhost 3000 and we
11:05
want it to be in the subscribers so we're going to say slash subscribers whoops that added a little
11:10
bit more than i wanted and this is actually going to request that route that we just set up right
11:14
here our get all route and what we can do is we can just click send request and it's going to send
11:18
that request and as you see we get hello world back at the top here we have all the different
11:22
headers and statuses we can pretty much ignore this for the most part but down here is going to
11:26
be the actual content of the request that we get sent so as you can see right here we got hello
11:30
world and if we go into this one we can do res dot send and we want to send the request dot params
11:37
dot id for example and we can make a request to that in our routes dot rest we can even do multiple
11:42
so if we just add in here three hashtags and then we do another route this will separate these into
11:48
two different requests and we can do an id let's say 12 for example we click send and we get that
11:52
id 12 back change it to 15 and we get 15 back so we know that our routing is working and we're able
11:58
to call it directly from visual studio code now with all that out of the way let's actually create
12:02
our model that we're going to use for our application so we can create a folder called
12:06
models which is going to hold our model which is going to be a subscriber model so we'll just call
12:10
it subscriber.js and in here we're going to be using mongoose so we're going to require mongoose
12:15
call it mongoose equals require and again mongoose and this is going to allow us to create a model
12:21
which we can use to interact with the database in a really easy way so what we want to do is we want
12:25
to create a schema we're just going to call this our subscriber schema whoops cannot spell there
12:32
we go and we're going to set this equal to a new mongoose dot schema and this is going to take in
12:38
here a javascript object and this object is going to have keys for all the different properties of
12:43
our subscriber in our case we're going to have a name and this is going to have an object as a
12:47
value we'll fill it in later it's going to have a subscribed to channel so this is who the user
12:52
is subscribing to which again we're going to fill in the details later and lastly we're going to
12:56
have a subscribe whoops subscribe date and this is just going to be the date that they subscribe
13:02
to the channel and again this is going to take a value in here and it looks like i spelled this
13:07
incorrectly there we go and what we want to do instead of here is actually define the different
13:13
properties for our schema so we want to put the type in our case the name is going to be a type
13:17
of string and we always want the name to be required so we're just going to have required
13:21
true here we're going to do the exact same thing for the subscribe to channel it's going to be a
13:26
string and it's always going to be required and then lastly we have our date this is going to
13:30
be a type of date it's going to have a required of true as well because we always want to have
13:35
the date they subscribed but lastly we want to default this so we're just going to use here
13:40
default and we want to set this to date dot now so if we don't pass a subscribe date it's just
13:44
going to default it to the current date now with that schema created we can go down here we can
13:49
export that so we can say modules module that exports we want to set that equal to mongoose
13:55
dot model and now this model function takes two properties the first is the name of the model in
14:00
our database in our case we're going to call it subscriber and the next is the schema that
14:03
corresponds to that model which in our case is subscriber schema and the reason we need this
14:08
model function is because when we export this and import it in a different file this model allows us
14:13
to interact directly with the database using this schema which is perfect so now let's save that go
14:18
into our subscriber.js here and we can include that so we can say subscriber is going to be equal to
14:23
require we want to require back one folder in the module models folder subscriber and now this is
14:29
going to pull in our subscriber which we created in this model here and this is where the fun
14:33
really begins so let's do our first to get all route because this is about the easiest one we're
14:38
going to use async await in order to do this so if you don't understand async awake I have a video
14:42
linked in the cards and description which you can check out but essentially what we're going to do
14:47
is we're going to wrap this all in a try catch just like this and inside the try we're going to
14:51
get all of the different subscribers from our model so we're going to say const subscribers
14:56
is going to be equal to our subscriber model dot find and this is just going to get all of the
15:01
different subscribers and we need to make sure we await this because this is an asynchronous method
15:05
so if we await this as soon as it's done executing we're going to get all the subscribers here in this
15:09
method but if for example there's an error we want to make sure that we catch that error so if there
15:14
is an error we want to send that to the user and we want to send it as json because this is a json
15:18
api and in here we're just going to send a message which is going to be error dot message just like
15:24
that and we also want to make sure we set the status so the user know that it was a failure
15:28
so we can say dot status and here we want to send the status code in our case we're going to send a
15:33
status code of 500 now a 500 status code means that there's an error on your server it means
15:39
that the actual server in our case our database had some kind of error which caused the actual
15:44
transaction not to work and it had nothing to do with the actual user or client using the api it
15:49
was entirely our fault that's what 500 means and any error code that's in the 500 range means that
15:54
now if we actually were successful we want to send this using json we just want us to send
16:00
all the subscribers to the user now we can go in here we can test our route and we should get back
16:04
just an empty array and as you can see that's exactly what we get we get an empty array because
16:08
we have no subscribers yet so let's create our create route so we can actually add subscribers
16:13
and see what it looks like we'll scroll down to that and we're also going to make this an asynchronous function because we're going to be trying to save that model which is an asynchronous
16:21
observation so we want to create a variable called subscriber set it equal to new subscriber
16:27
and this is just going to take a javascript object first thing we want to set is the name
16:31
and this is going to come from the request from the body so the body is whatever the user sends
16:36
to us which is going to be json and we want to get the name property of the body we want to do the
16:40
same thing with the subscribed to channel and we want to set this to the request dot body
16:47
dot subscribe to channel and let's close out of this request here and there we go that's our
16:52
subscriber created but now we actually need to save that and that's where the asynchronous part
16:56
comes in so we're just going to wrap this in a try catch again and we want to catch that error of
17:00
course and inside of the try here what we want to do is we want to try to save our subscriber so
17:05
we're going to say new subscriber is going to be equal to awaiting the subscriber which we just
17:12
created dot save and this is going to try to persist that to the database and if it's successful
17:17
it's going to put it into this new subscriber variable and if it is successful we want to send
17:22
this to our user using json so we'll say new subscriber and we also want to set a specific
17:28
status here we want to set a status of 201 and the status 201 means successfully created an object
17:35
by default if you don't send any status it sends a status at 200 which means everything was
17:39
successful but 201 is just a more specific way to say that you created something so when you're
17:45
using the post route you always want to make sure to send 201 when you're successful instead of 200
17:50
now let's catch that error so we want to say res dot status and this time we're going to send a
17:56
status of 400 instead of 500 and this is because our thing is going to fail here if the user doesn't
18:02
pass in the name or they don't pass in a subscribe channel for example so if the user gives us bad
18:07
data it'll fail and whenever the user gives you bad data the client you want to send a 400 error
18:13
because that means there's something wrong with the user input and not something wrong with your server and of course we want to send that error message to them so we'll say dot json error dot
18:22
message and of course we want to make sure we wrap this in an object just like that and there we go
18:28
we can save that and now let's actually test that so down here make sure we put in our three hashtags
18:34
and we want to do a post route and we want to post to essentially the same exact place http
18:39
localhost 3000 subscribers and that's exactly perfect and now to send data to it we need to
18:45
make sure we leave a blank line here but and then here we can put our json so let's type it in we
18:51
want to send a name whoops make sure it's in quotes name and we want this person to be amazing
18:57
person is their name and the subscribe to channel whoops type that out correctly subscribed
19:05
to channel is of course going to be web dev simplified because all of my subscribers are
19:10
amazing people web dev simplified and there we go and now that we want our server to know that this
19:16
is going to be json that we send to it so we need to set the content type to be aqua application
19:22
json now we can click send request and you'll see that we get a message that says subscriber
19:27
validation failed subscriber to channel path subscriber to channel is required and this means
19:33
i spelled something wrong i spelled subscribe to channel as subscriber to channel so let's see
19:38
where i did that we can just do a search all hit enter and it looks like in here in our schema i
19:43
just misspelled this it should be subscribed to channel instead of subscriber to channel
19:48
now let's go back and test our route we can click send request again and you see that we
19:52
get our model back it has an automatically generated id as well as the name subscribe
19:57
to channel and subscribe date which you can see is set to whatever the current date that i'm
20:01
recording this is and if we don't pass in the name for example and we hit send request we're
20:06
going to get back that error message and you'll also notice we get that 400 status which says
20:10
bad request which is perfect because it'll come back as an error to the user using our api let's
20:16
put that back to how it was so that we have a successfully working api now let's go back to
20:20
our route here and you may notice that all the rest of our routes are going to be taking an id
20:24
our update our delete as well as our git all have an id that we're going to pass to it and they're
20:28
all going to do the exact same code at the beginning in order to get the subscriber so
20:32
instead of writing that code in every single one of our routes we're going to use what's called a
20:36
middleware so we're going to create a function which will be that middleware and these functions
20:40
have the exact same syntax as this function right here we're going to call this one git subscriber
20:46
because essentially that's all it's going to do it's going to take an id and get us a subscriber
20:50
and as i mentioned it has request response and next as the final property and essentially all
20:55
that this next function does is this says if we call this move on to the next section of our code
20:59
which is going to be this callback right here and this is what the middleware is and of course we're
21:04
going to make this asynchronous because we're going to be accessing the database inside of this code and now of course we want to wrap everything inside of a try catch so we'll put
21:11
the try right here and of course we want to catch our error and now inside of this try we want to
21:17
get a subscriber so we're just going to say subscriber is going to be equal to awaiting
21:23
the subscriber dot find by id and this all we have to do is pass an id which as you remember
21:29
i said that request dot params dot id is going to be correlating to the variable that they pass
21:35
inside of the route here so this is going to try to get a user based on the id that they pass us
21:40
inside of the url and then what we can do is we can check to see if that subscriber actually exists
21:45
so we can say subscriber equals null so if the subscriber does not exist what we want to do is
21:51
we want to return here and we want to set the status right here to be equal to 404 and a 404
21:58
status means that you could not find something and which is exactly what happened in our case
22:01
we're not able to find this subscriber and then of course we want to send back a message so the
22:05
user knows that whoops so we'll send back a message here and this message is just going to
22:10
say cannot find subscriber there we go now that we have out of the way let's actually create our
22:17
subscriber up here we're just going to default this to undefined and what we want to do is we
22:21
want to set our response dot subscriber this is just a variable we're creating on the response
22:26
object we're going to set that equal to subscriber and this way inside of all these other functions
22:32
we can just call res dot subscriber right here and this is going to be the subscriber that we set
22:38
down here so let's leave that now and the reason we're calling return here is because if there is
22:44
no subscriber we want to immediately leave this function and no longer go any further and inside
22:49
of this catch here we just want to do essentially the same thing we want to do a return we want to
22:53
set the status this case it's going to be a 500 because there's something wrong with our server
22:58
that's causing this problem and we want to send that message back to the user so we're going to
23:02
say message is going to be equal to error dot message just like that which is perfect and then
23:07
lastly that next function we want to call all the way down here because we successfully completed
23:12
this entire get subscriber function so next will allow us to move on to the next piece of middleware
23:17
or the actual request itself so now let's use that get subscriber middleware we'll go up here and all
23:22
you do is put it before your actual function you don't actually call it you just put the name of
23:27
that function right there and that'll be your entire middleware setup now instead of here we
23:31
can say that we want to send the request response dot subscriber dot name for example and if we save
23:39
that since we have this get subscriber in here this is actually going to get the name of the
23:44
subscriber and send it back to us this is just for testing purposes so let's get all of our
23:48
subscribers here we'll send a request we're going to take an id and we want to use that inside of
23:53
this request to get a single subscriber and if we click on that you'll see that we get the name of
23:57
that subscriber which is amazing person and that's perfect if for example we send a different id which
24:03
does not exist and we click send you'll see we get a message that says cannot find subscriber
24:07
so we know that our middleware that we created is working so now we can apply that middleware
24:11
to the rest of all of our routes so let's copy this down and do this inside of here and we also
24:17
want to do this inside of here for our deleting let's exit out of this so we have a little bit
24:21
more room to work with and now we can actually create our route right here for getting one and
24:25
this is really straightforward all we want to do is send that actual subscriber so we'll say
24:29
res dot whoops not res.json res.subscriber and this is just going to send us a json version
24:35
of that subscriber and of course we can try calling that right here and you'll see we get
24:39
the json version of that back which is perfect now back to our routes we can work on the delete route
24:44
because that one's also really straightforward we want to make sure this is asynchronous because
24:48
we're going to be calling this using try catch so let's set up that try catch just like that
24:56
and we of course want to be able to catch an error in here if something for example happens
25:00
and inside of here all we want to do is we just want to await res.subscriber.remove and this is
25:07
just going to try to remove that subscriber from the database and if it fails we're going to get
25:11
an error down here which we can just send back a status of 500 because something obviously is wrong
25:16
on our end if we get an error trying to remove it and we'll just want to send back the message
25:20
as the error dot message and if we did successfully remove the subscriber we can just send back some
25:26
json that says that we did that so we can just say in here we want to send a message that says
25:32
deleted subscriber so now let's try to call that we can just come down here separate it with three
25:39
hashtags just like this and we want to call delete and we just want to call it on the route up here
25:45
for the user with the correct id so let's copy that down and let's call send request and you'll
25:50
see message deleted subscriber and if we try it again you'll see cannot find subscriber because
25:55
we deleted that subscriber and if we try to get all of our subscribers we now get an empty array
25:59
again because no more subscribers exist so let's send that request to add a new subscriber back
26:04
so we have at least one subscriber here as you can see inside of our database so we can use that
26:09
with our new patch route that we're going to be creating now. Now in order to update we need to
26:13
as I said only update for things that actually are sent to us in the request so what we want to
26:19
do is we want to check the request we can say if the request dot body dot name is not equal to null
26:26
so if the user actually passed a name to us we want to take that res dot subscriber and we want
26:31
to set the name equal to the request dot body dot name and we want to do the exact same thing but
26:37
we're going to do this for the subscribed to channel so in here we'll type in subscribe to
26:42
channel and we want to set the subscribe to channel to the subscribe to channel that's passed
26:46
in try saying that 10 times fast now we can actually use the try catch down here in order
26:51
to try to update our user we of course want to catch that error and inside of here all we're
26:56
going to do is we want to say this is going to be our updated subscriber whoops subscriber
27:03
is going to be equal to await res dot subscriber which is going to get our subscriber and again
27:09
we're going to use that save function so this is going to give us the updated version of our subscriber if they successfully saved and then of course we can use res dot json here in order
27:18
to send back that updated subscriber and if we have an error we can set the status here equal
27:24
to 400 because again if the user is passing like a name that's not acceptable or a subscribe to
27:29
channel that's not acceptable that's their fault and not ours so we want to make sure we send a
27:33
400 error instead of a 500 and we want to send in a message which is just going to be error dot
27:38
message so now we can actually try testing that but before we do that you can see we get an error
27:43
and it says a weight is only valid in async functions so we need to just make sure that
27:47
this is an asynchronous function and now everything is green which is perfect we can come in here
27:52
let's just copy this delete for now put in the three hashtags and we can just say here we want
27:58
to do a patch and we want to patch this user we want to send application.json as our content type
28:04
just like here and let's say we want to change the name so we're going to set the name here
28:10
to new name and now if we actually send this request you'll see that it says it cannot find
28:17
the subscriber with this id and that's because this id no longer exists so let's get a new a
28:21
new id from our currently existing subscriber you see their name is amazing person so we'll copy
28:26
that id paste it down here in our patch and we'll send that request and you'll see we get back a new
28:31
object here which is the updated object and it has that new name and now if we query all of our
28:36
subscribers you see the subscriber now has the name of new name and that's it the entire rest
28:41
api is complete if you want to go deeper into node.js and express make sure to check out my
28:45
completely free full stack course on youtube which is linked over here also subscribe to
28:50
the channel to not miss any more videos like this thank you all very much for watching and have a
28:54
good day
#Computer Education
#Development Tools
#Programming