-: In this video, let's implement document updating.
And so, here, in our update tour handler, let's start by
making it an async function.
Then, or try catch block, and so I'm doing this
very quickly now, because we're already used to this
at this point.
Right?
So this goes into the try block and then
I simply get this one, here, from the catch block
of this other function.
All right, so.
Here we go.
And so now, what we need to do here
at the beginning of this try block
is to basically query for the document that
we want to update and then update it, all right?
And we can actually do that
all in one command with mongoose.
And, remember, again, that we're gonna update the tour
based on an ID, okay?
So, it's a similar situation like this one here,
where we find by ID.
And now, we can actually do something very similar,
which is find by ID and update.
So again, everything in one query.
So, let's do tour.findByID
and update.
Okay, so, what do we need to pass in here?
Well, of course, the ID, so that we can first find
the document that is to be updated.
So, just like before, that is req.params.ID,
and then the data that we actually want to change.
And that data will be in the body,
just like in the post request.
So req.body, okay?
And then, actually as a third argument,
we can also patch in some options, and we will do that.
And the first option that I want to specify is new
and set it to true.
Because this way, then the new updated document
is the one that will be returned.
And since we want to send back that updated document
to the client, we always want this method
to actually return that new document, okay?
So this way, it actually then makes sense to
await this query and then save it to a new variable.
So then simply call it tour here,
and then again, await the result of this query.
So all of these methods that we've been using on the tour
so far, so find by ID and update, or,
well, not really create, but find by ID or find,
all of these will return queries, so they are query methods
and let me actually show that to you
in the mongoose documentation.
So, up until this point, we didn't have a look at
the documentation so far.
And so, let's quickly do that.
So, on the model, which in our case is tour,
we have all these query methods, right?
So you see find, you see find one, you see find by ID,
which is just a shorthand for find one.
Then you see find by ID and update,
which is the one that we're currently using,
and which, in fact, is just a shorthand for
find one and update, where we're querying for an ID,
so similar to what we had in the last lecture, okay?
And actually we can click on any one of these,
so let's do the one that we're using currently,
and that will then really take us to the API documentation
which shows us how to really use a certain method.
So you see that we passed the ID, so the value,
off the ID to query by, we passed the object with
the data to be updated, and we passed an options object.
And down here we can actually see
the options that we can set, so remember,
we just set new to true, and so as it says here
that will then return the modified document
rather than the original.
Now, another one that we actually want to set to true
is this run validators, so that each time that we update
a certain document, then the validators that we specified
in the schema will run again, okay?
And we will talk a lot about validators and validation
a bit later in the section,
but I'm gonna leave it here for now so that we, basically,
don't forget it.
Okay?
Give it a save now, and actually I wanna go back here
just to show you how many methods
we actually have in mongoose.
So, on the model, we have all of these methods here
that you see in this list.
So for example we used create before,
we also used find.
Okay?
And so the ones that you see here in the top,
they are available right on the model,
and that, in our case, is the tour.
Now, down here you, for example also see
model.prototype.safe for example.
And this one, we actually also already used
right when we first started to work with mongoose.
So I'm not sure if you are familiar with this,
but in java script model.prototype always means
an object created from a class, or in this case,
created from a model.
And so, the save method here, refers to a save method
called on a document and not on a tour.
And remember that that's exactly what we did.
And I think I still have it here as a comment.
Yeah, right here.
So, we had a tour, this new tour variable here
which was created from the tour model,
and so this new tour here got access to the save method
because that is part of the prototype object of this class.
All right, now I don't want to bore you with the
fundamentals of java script, but it is important
in order to understand the documentation, okay?
Because at some point you will need to use documentation,
because mongoose is yute.
And I will actually teach you a lot of the stuff
that's important in there through all of this course,
but sometimes you will still need something that
I didn't show you in this course.
And so it's important that you really understand
the documentation as well, okay?
And so, again, when you see model.prototype here,
you know that the save method here
is going to be available on all of the instances
created through a model, okay?
And so, not the model itself.
So, for example, if you tried tour.save
you wouldn't be able to use it.
It would give you an error, but instead, if you tried save
on a document created through the tour,
then it would, of course, work, okay?
I hope that makes sense.
And, anyway, you see that we have a lot of other stuff,
so we have to query, which we already talked about,
because, for example, find by ID and update, or find,
or find by ID, all of these will return query objects.
And so, later on, when we're gonna implement stuff like
sorting or filtering we will then use this query object.
Okay?
So, let's go back, we kind of got off the track here
by looking at the documentation,
but, again, I think it's really important
to start looking at the documentation,
because a course like this can only take you so far,
and I hope you already know that at this point, okay?
It's really important that you're also able to
find information on your own, and I wanna show you how
to do that also in this course.
Anyways, let's now actually also send
this newly updated tour back to the client,
which, right now, we're not doing, because we have
simply this updated tour here string.
So let's get rid of that and simply send to tour.
And remember that this, in fact, is actually this.
So, the tour property is set to the tour object,
but, thanks to ES6, we no longer have to do that
when the property name has the same name of the value.
Okay, so let's get rid of that.
That makes our code look a bit better.
Okay, and let's now test it.
Back to postman, here we have the updated tour route.
And so, let's actually do it
on this same ID that we used before.
So, this one.
Then we come to the body, here, and let's change--
Well, what are we gonna change here?
Well, let's change the price to, like, 500.
So, price, 500,
send it, and indeed this gives us
the newly updated object with the price
already set to 500.
And if we now get all tours, then that, of course,
should be reflected here.
And here it is.
But now, let's say that we set it to a string.
Let's take a look at what happens, then.
Well, then we actually get an error.
And that's because we ran the validators again.
So, remember that we have--
Where is that?
Oh yeah, here.
So here we specify that the validators should be run again.
And so, right now the price is no longer a number
as it is expected, right?
So in a schema we say that the price should be a number,
but, of course, java script, or mongoose, actually,
cannot, basically, convert this string here to a number.
But that is what we expect.
So here it says kind should be number.
And so, therefor, it gives us an error,
simply because we're running the validators again.
So, let's put it back to 500 and then, of course,
it's gonna be back.
All right, now, keep in mind that we're actually
doing a patch request here.
Now, if we were doing a put request, remember,
then you would expect that the original object
would be completely replaced
with the new one that is sent in, okay?
So, in that case it would no longer work
the way we implemented here
because this one simply really updated the fields
that are different here in the body, okay?
But anyways, I think that the patch method
is actually way more useful, and so,
that's gonna be the only one that implementing here.
Cool, so we have three of our four correct operations
implemented, only one more left to go,
which is gonna be delete.