This course will be retired on August 10, 2021. We recommend "REST APIs with Express" for up-to-date content.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
As long as we're doing common CRUD operations with our data, we most likely won't need to extend mongoose beyond what it does out-of-the-box. But real world applications will almost always have some atypical behavior they will need to implement, and ours is no exception.
Resources:
Blog series about Modelling one-to-many (AKA parent-child) relationships in MongoDB:
6 Rules of Thumb for MongoDB Schema Design, By William Zola, Lead Technical Support Engineer at MongoDB:
Part 1
Part 2
Part 3
MongoDB documentation on data modelling
MDN page detailing Array.prototype.sort
JavaScript Patterns, by Stoyan Stefanov, is a great book on writing solid JavaScript code. On page 134, Stoyan Stafanov shows how to write a recursive deep-extend function.
Also, studying source code is a great way to learn! Here's jQuery's implementation of $.extend.
Skip down to line 124 (the line may move, so you can also use the browser's find in page and type in 'extend' to see where it is defined (jQuery.extend = …).
Real world applications will almost
always have some atypical behavior.
0:00
And our application is no exception.
0:04
Consider the sorting behavior we want for
our API.
0:08
When the API serves the answers.
0:11
We'd like them to be
ordered by votes first, and
0:14
then their updated app property.
0:16
This means that any time
an answer is edited,
0:19
or voted on the order will be affected.
0:22
When an answer is saved to the database.
0:25
We want our application
to sort the answers array
0:28
on the parent question document.
0:31
As we saw earlier Mongoose offers
us a way to run code before
0:33
any save event with the pre method.
0:37
To save a child document in Mongoose
you have to save its parent document.
0:40
Let's implement a pre save
hook on the question schema.
0:45
Let's open up the models JS file,
and under the question schema.
0:50
Let's set up a pre save callback
0:55
Inside, we'll sort the answers
array before calling next.
1:26
There is a problem here though.
1:44
The default sort function supplied
by JavaScript doesn't know how
1:46
we want to sort our array of answers.
1:51
If we leave it as is, it will sort
the answer objects by the strings.
1:54
Resulting in the calling of two
string on each of the answers,
1:59
which would all be identical.
2:03
It would be the string of object.
2:06
In other words, this line as it
currently stands, does nothing at all.
2:15
To address this issue, we'll pass in a
sorting function into the sorting method.
2:24
There's a link in the teacher's notes to
read up on JavaScript arrays sort method.
2:30
In case this is the first
time you're encountering it.
2:34
What our sorting function will need to
do is compare two unsorted objects and
2:37
say which order they should go in.
2:42
The array sort method will then take that
information and sort the array for us.
2:45
Let's put this sort function up at the top
with the other variable declarations.
2:59
We'll call it sortAnswers.
3:04
This is a function that will accept two
objects, a and b, and compare them.
3:13
It will need to return a negative.
3:29
If A should appear before B.
3:32
A zero to leave the order unchanged.
3:43
And a positive if A is
to be sorted after B.
3:49
Let's think about how we
want our answers ordered.
4:03
First, let's order them by vote.
4:06
So that the answers with the most
votes appear at the top of the list
4:10
if the votes match.
4:15
Let's resort to ordering them by
the last time they were updated.
4:16
The most recently updated answers
appear above the least recent ones.
4:21
Let's start by ordering answers by votes.
4:27
We can return the value of A's
votes subtracted from B's votes.
4:31
If A has more votes.
4:38
The number returned will be negative,
and A will be placed before B.
4:40
If B has more votes.
4:46
The difference will be positive,
and B will be placed before A.
4:49
If the votes match,
5:00
we want to place the answers with
the most recent updated here first.
5:01
Let's first check the equality of votes.
5:20
Now, if the votes match.
5:24
We can compare the a.updatedAt
to the b.updatedAt app.
5:26
And return the sorting order
based on what we find there.
5:30
As you may or may not know,
5:34
JavaScript thinks about dir objects
as numbers of milliseconds.
5:36
That have elapsed since midnight
Thursday the 1st of January 1970.
5:40
More recent times are bigger
in number than less recent.
5:46
So if a.updatedAt is greater
5:51
than b.updatedAt.
5:57
We'll want A to proceed B which
requires a negative number to achieve.
6:04
So we'll return minus one.
6:11
Let's check the reverse of this case and
reverse the elements order if it's true.
6:15
If both of these fall through.
6:43
We'll just return zero to
leave the ordering unchanged.
6:45
There's a much simpler method we
could use for comparing date objects.
6:52
Even though dates
are objects in JavaScript.
6:57
You can subtract them.
7:00
When you do,
you get the difference in milliseconds.
7:02
So we can return the value of
A updatedAt subtracted from BupdatedAt.
7:07
[BLANK AUDIO] Just
7:13
as with votes this will order the larger,
or later dates first.
7:20
Now we can supply the source answers
function to the sort method.
7:27
Mongoose will now sort the answers
right every time it is saved.
7:39
Keeping the state of our
database up to date.
7:43
Now let's think about when
the answer is updated.
7:53
We'll want to do a couple of things for
this to happen.
7:58
We want to apply the updates
to unanswered document.
8:03
And we also want the answers updated
property to be the current time.
8:07
Let's do this with an instance method.
8:14
So we can call it directly on
the answer when we want to update it.
8:16
Although the answer schemas declaration.
8:20
Let's create an instance
method called update.
8:23
We want the update method
to accept two parameters.
8:44
An update subject and a callback for
when the operation is completed.
8:47
Make sure you create this method above
the question schema declaration.
8:52
Where the answerschema becomes a sub
document, or else you'll get an error.
8:56
Remember that we learned
to write instance methods
9:05
by placing the property on the methods
property on the answer schema.
9:09
Mongoose gives us an alternative
way to create instance methods.
9:13
So let's use that here to see in action.
9:17
Instead of setting a property of methods
on the schema we can call the method
9:21
method.
9:26
Passing in two parameters.
9:30
The first, a string of the name
of the method you want to create.
9:35
And then the second, a function that
you want to become the actual method.
9:42
We can't name our instance method Save.
9:50
That's because there's already
an instance method called Saved.
9:53
And overwriting it will conflict
with Mongoose internal logic in
9:56
unpredictable ways.
10:00
The first thing we'll want to do is merge
the updates into the answer document.
10:03
We can do this with object.assign.
10:08
We'll pass in the document
first referenced by this.
10:16
Then the updates object.
10:23
And then we want to set a fresh
date on the updated app.
10:29
We can pass that in as a third parameter,
and objects assigned will match that too.
10:42
After that,
we'll need to save the parent document.
10:48
In other words,
the question associated with the answer.
10:52
To access the question,
we can use the answers parent method.
10:56
Since the save is the last
thing we want to do.
11:04
We can pass in the callback
as a parameter.
11:09
There's just one other addition we'll
need to make on the answer schema.
11:20
A vote instance method to help
with translating strings from
11:25
the URL into math that moves
the counts up or down.
11:30
Let's start with the function signature,
11:40
which is almost identical to
the last instance method.
11:43
Since we've all ready validated the string
that is passed into the vote parameter.
11:52
There are only two possibilities.
11:57
If the vote is equal to up.
12:03
We want to add one to the votes.
12:10
If it's down.
12:17
It's minus one.
12:28
And just like the last method call,
we need to save the parent and
12:36
pass in the callback to save.
12:40
Our data modeling seems to be complete.
12:46
It would be nice to test
what we've done so far.
12:48
Let's take the final step in building
our API, and connect it to the database.
12:51
Then we can use Postman to test
our fully functional routes.
12:57
You need to sign up for Treehouse in order to download course files.
Sign up