All language subtitles for 005 Modelling Tour Guides_ Embedding_Downloadly.ir_en

So remember how in the video

about our data model, we said that

we could either embed or reference

the tour guide data, so in this video

I'm gonna show you how we could implement embedding

tour guide documents into a tour document.

So again, in this lecture we are going to

embed user documents into tour documents,

and then in the next video, I will show you

how we can actually reference users

instead of embedding, all right?

So the idea here is that when creating

a new tour document, the user will simply

add an array of user IDs, and we will then

get the corresponding user documents

based on these IDs, and add them

to our tour documents.

So in other words, we embed them into our tour, okay?

So, let's do that here now.

So guides will be of the type array, okay?

Very simple, and actually before we implement

any code, let me show you as an example

how this would work when creating a new tour.

So, let's go back to Postman here,

and create new tour,

okay, and so here in our body

we of course would now add the guides,

quotes, and then specify an array of IDs, okay?

So, let's get some user IDs.

So, get all users, let's see what we have here.

So we have a guide here, actually,

and so let's get this ID

along with the quotes, actually,

and so let's put that here,

and let's add some other ones.

So, this here as well and actually just these two.

That should be enough for testing this stuff, okay,

and so this is then how we're gonna create

a new tour with two guides, okay,

and again once we then save this tour,

we will then, behind the scenes,

retrieve the two user documents

corresponding to these two IDs, all right?

So, let's implement that,

and back in our model

the best place of doing that

is a pre-saved middleware, right?

So, that will then happen automatically

behind the scenes, basically,

each time that a new tour is saved,

and actually, I don't want to do it here.

So we have query, here,

here's the document "Middleware,"

so let's do that here.

So tourSchema.pre,

All right, let's call next right away here,

so that we don't forget it in the end.

Okay, so we get this.guides as an input,

and remember this is gonna be an array

of all the user IDs, right, and so we

will loop through them using a .map,

and then in each iteration get the

user document for the current ID, all right,

and we're gonna store that inside of guides, all right?

So, the current element, which is gonna be the ID,

well let's actually call it ID

to make it a bit easier understand,

and so now we actually need the user, right,

so let's go ahead and import that.

So, const User,

require,

and it's actually in the same folder here, all right,

so User.findByID

with the current ID, all right?

But now, keep in mind that we actually

do need to await this promise here, right

and so, therefore, the function needs

to be marked as async,

but now we actually get a problem, all right,

because the .map method will assign

the result of each iteration to the new element

in the guides array, okay, and so now

we have an asynchronous function here

and, as you know, that returns a promise,

and so right now this guides array here

is basically an array full of promises, okay.

Let's actually call this guidesPromises

and so we now actually need to run

all of these promises, basically at the same time.

As I showed you a bit earlier in this code,

at least if you didn't skip the

asynchronous JavaScript section,

all we need to do is await Promise.all

and then guidesPromise,

okay, and we can directly assign the result

of this to this.guides,

and so basically override that temple array

of IDs with an array of user documents, okay,

and since we're now using await here,

we need to mark this function as async, okay?

Give it a save, and I think that's actually it, okay?

So again, we need to use Promise.all here because

the result of all of this here is a promise, okay,

and so this array here is gonna be an array

full of promises which we then run

by awaiting Promise.all, okay?

So, let's actually test this out now,

and we already have all of this code here ready,

we should just change this name here.

So, 'Test Tour,' but the IDs are already here.

So let's send this, and our tour name

needs to be longer, 'New Task Tour.'

Okay, but now let's take a look at our results,

and so indeed we get our guides here, okay?

So these are the complete documents,

and indeed not just the IDs, right?

Great, and so this is how we could

implement embedding for this tour guides example.

Now, this simple code that we implemented here

of course only works for creating new documents,

not for updating them, right?

So now, we would have to do go ahead

and implement this same logic also for updates.

However, I'm not going to do that because,

remember from the video where we modeled our data,

that there are actually some drawbacks

of embedding this data in this case.

For example, imagine that a tour guide

updates his email address, or they change

their role from guide to lead guide.

Each time one of these changes would happen,

then you'd have to check if a tour

has that user as a guide, and if so,

then update the tour as well,

and so that's really a lot of work

and we're not gonna go

in that direction, all right?

Now, I still wanted to show you

how embedding really works, and how

we could implement it in this situation

because I really believe it's very important

that you still know how to do everything

in case you ever need it

in your own applications, okay,

but in this particular situation we will,

instead of embedding, use referencing,

and I talked about reasons for doing so

back in that video, okay?

So, let's actually go ahead and do that

right in the next lecture.