Original subtitles

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.