Instructor: So we embedded users
into tours in the last video,
and also talked about the drawbacks
of that approach in our specific situation.
And so in this video let's actually connect tours
and users not by embedding but instead by a reference.
And so to start, let's actually get rid
of the code we wrote in the last lecture.
Okay, so this one here,
responsible for performing the embedding basically.
And now let's go here to our guides field.
Okay?
So this time in this video,
the idea is that tours and users will always remain
completely separate entities in our database.
Okay?
So all we save on a certain tour document
is the IDs of the users that are the tour guides
for that specific tour.
Then when we query the tour,
we want to automatically get access to the tour guides.
But again, without them being actually
saved on the tour document itself.
And that exactly is referencing.
So just as we talked about by the beginning of this section.
All right?
And so let me now show you
how we can implement referencing using Mongoose.
Okay?
So, here in the guides we will now want to specify an array.
Okay?
So just like we did before with the locations.
And so that then again means
that these will be some sub-documents.
So embedded documents.
All right?
And now the type is going to be
a new type that we never saw before.
And that is mongoose.Schema.objectId.
Okay?
And what this means is that we expect
a type of each of the elements
in the guides array to be a MongoDB ID.
All right?
And here actually it needs to be a capital O,
okay, otherwise it's not gonna work,
and also all of this here needs to be inside of an object,
just like any other schema type definition.
Okay, because that's all this really is.
Okay, so the type is of this MongoDB ID, basically,
and then we also need to now specify the reference.
And this is where the magic happens behind the scenes,
because here, now we say that the reference should be user.
Okay, and so this really is how we establish references
between different data sets in Mongoose.
And for this we actually do not even need
to have the user to be imported into this document.
So we actually had that here, but we don't even need it.
We had that here for the previous lecture,
but we can comment it out,
because what we just did here is still gonna work.
Okay?
So, let's now go ahead and create a new tour,
and actually I'm going to do it just the way we did before.
So let's just go ahead and delete this one.
Where is the ID?
Here we go.
So delete tour.
So we can use our API for that already.
All right, and now we create a new tour.
And so just like before,
all we pass into the guides is an array of the IDs.
All right?
But this time we actually specified
that an object ID is exactly what we expect.
Right?
So, this here is of the type object ID.
But behind the scenes, it's also referenced to the user.
All right?
So, when we now create this tour here,
it will actually only contain these IDs,
and not the user corresponding to the IDs.
So let's take a look at that.
And so yeah, here we go.
So this is exactly the data that we put in.
Just the IDs of the tour guides.
Okay, and that's exactly what we were expecting.
Because for now, all we really have
is the references inside Mongoose.
And we will then take care of actually getting the data
to show up in our output in the next video.
Okay, because we will do that in two different ways.
Let's also take a look here at Compass really quick,
just to see that as well where is that, yeah, here.
So you see object ID actually,
and then of course, the IDs that we passed in.
So just as we expected with tours and users,
still two completely different entities.
And as I said before, in the next video,
we will then take care of actually displaying
the user data in the output,
using a process called populating.