Creating a multipart database object with Sequelize: when will the promise complete? - node.js

Question

Imagine you are working with a database of national teams and athletes (like for the Olympic games). When testing your app, you create a new database every time. Here are two models:
const Team = sequelize.define('team', {
name: {type: Sequelize.TEXT, allowNull: false}
})
const Athlete = sequelize.define('athlete', {
name: {type: Sequelize.TEXT, allowNull: false}
})
Team.hasMany(Athlete)
Athlete.belongsTo(Team)
Now, you have a function that creates the teams for you:
function mock_database() {
let team0 = Team.create({
name: 'TeamGB'
}).then(team => {
generate_athletes(team)
// Or maybe I need to return the nested promises?
// return generate_athletes(team)
})
let team1 = Team.create({
name: 'TeamFr'
}).then(team => {
generate_athletes(team)
// Or maybe I need to return the nested promises?
// return generate_athletes(team)
})
return [team0, team1]
}
Now, the generate_athletes creates nested database objects (athletes in the team):
function generate_athletes(team) {
let athlete0 = Athlete.create({
name: 'John Smith'
}).then(athlete => {
team.setAthletes(athlete)
athlete.setTeam(team)
})
let athlete1 = Athlete.create({
name: 'Joanna Smith'
}).then(athlete => {
team.setAthletes(athlete)
athlete.setTeam(team)
})
return [athlete0, athlete1]
}
At this point, I would like to wait until the database has all the data. I can do that with Promise.all(mock_database()).then(() => {/*my application starts here*/}), which would be waiting on the two promises team0 and team1. But does that guarantee that I will be waiting on athlete0 and athlete1 implicitly too? Or do I need to return those promises back up, incorporate them all into a big array of [team0, team1, promises0, promises1] and wait on that?

Answer 1

You would need to return the nested promises. If you don't return the nested promise then your top-level promises will just resolve immediately after creating the teams (since creating the athletes is async and you aren't waiting for it to finish).
Essentially you would want something like this...
function mock_database() {
const team0 = Team.create({ // <-- team0::Promise
// ...
});
const team1 = Team.create({ // <-- team1::Promise
// ...
})
.then(team => {
return generate_athletes(team); // <-- Will only resolve team1 when this resolves
});
return Promise.all([team0, team1]); // Wait for both promises to resolve
}
function generate_athletes(team) {
const athlete1 = Athlete.create({ // athlete1::Promise
// ...
});
const athlete2 = Athlete.create({ // athlete2::Promise
// ...
});
return Promise.all([athlete1, athlete2]); // Wait for both promises to resolve
}
Unless you explicitly return the promises your program does not have access to the then and catch properties of the promise. So always remember, if you want to wait for a promise you will definitely need access to it! So always return it!
Good luck :)
EDIT: You can find a Promise.all explanation here. Essentially though what is happening is that each database action returns a promise. Those promises will resolve if and only if the database action is successful. Since promises are just regular JavaScript objects, they can be saved to a variable.
What I ended up doing was saving a reference to all of the promises I wanted to resolve and then used a builtin promise function to wait for the completion of all of the promises. Since the athletes depend on the team being created, for each team we also need to wait for the list of athletes to be generated.
I marked up the code with some more comments!