elliette/ManyToManyRelationships.md

## ManyToManyRelationships.md

      
    Raw
  

              ManyToManyRelationships.md
            
          
    Defining Many-to-Many Associations in Sequelize

Reference: Sequelize docs on association
Let’s say we have two models: Films and Festivals
We know that a film can be shown at many film festivals and that, conversely, a festival can show many films. This is what is known as a many-to-many relationship.
Knowing this, we can set up our associations:
1. A film can be shown at many festivals - belongsToMany

If a film can be shown at many festivals, we can say that it belongs to many festivals. In Sequelize, we can write this association as follows:
Film.belongsToMany(Festival, {through: FestivalFilm} );
When we use the method belongsToMany, Sequelize will create a join table for us holding the foreign keys of the source and target models that we specified. So, in our example above, Sequelize creates a join table for the source (Film)  and target (Festival). As we specified with the option through, the join table is named FestivalFilm, and it holds the  foreign keys filmId and festivalId.
Furthermore, by using the method  belongsToMany , Sequelize will create a series of methods for us that we can use on any instance of the source model (remember, the source model is the model before the dot).
So in our example above, we can now use the methods:

film.getFestival
film.setFestival
film.addFestival
film.addFestivals

Here is an example where we are using the method setFestival to associate a festival with a film:
app.post('/filmFestival', function(req, res, next) {
        Promise.all([
            Film.create(req.body.film),
            Festival.create(req.body.festival)
        ])
        .spread(function(film, festival) {
                return film.setFestival(associatedFestival); // here we are using the method setFestival 
        })
        .then(function(filmWithAssociatedFestival){
                res.send(filmWithAssociatedFestival); 
        })
        .catch(next)
}); 

2. A festival can show many films - hasMany

Conversely, we could choose instead to say that since a festival can show many films, it has many films. In Sequelize, we can write this association as follows:
Festival.hasMany(Films)
When we use the method hasMany, Sequelize will add a foreign key for our source to our target model. So, in our example above, Sequelize will add the foreign key festival_id  to the Film  model.
Furthermore, by using the method  hasMany, Sequelize will create a series of methods for us that we can use on any instance of the source model (remember, the source model is the model before the dot).
So in our example above, we can now use the methods:

festival.getFilms
festival.setFilms

Some important addendums:


You should not use use belongsToMany and hasMany together, because they do fundamentally different things in regards to SQL. In our film-festival example, you could say a Festival.hasMany(Films) or that a Film.belongsToMany(Festival, {through: FestivalFilm} ) but you should never write both.


You can, however, declare 'symmetric associations' like so:
Film.belongsToMany(Festival, { through: 'film_festival' })
Festival.belongsToMany(Film, { through: 'film_festival' })
or
Film.hasMany(Review)
Review.belongsTo(Film)
Although the "redundant" association does nothing new vis-à-vis the SQL tables, it does mean that the other instance gets the "magic" methods.


Finally, be cognizant of the difference between many-to-many and many-to-one relationships. Let’s imagine we have have a third model that represents film reviews. We could say that a film has many reviews, but not that a review belongs to many films. A review belongs to only one film. Therefore, reviews and films are a many-to-one relationship, not a many-to-many relationship.