Sequelize Assocations

Agenda

Phone.belongsTo(Person)

Source

Target

Alternatively, we can think of the two models as owner and possession

Possession
(in this case)

Owner
(in this case)

Phone.belongsTo(Person)	Person.hasOne(Phone)
Foreign Key appears on the source model	Foreign Key appears on the target model

There are two methods to create 1:1 associations:

In both methods, the possession model (Phone) holds the foreign key

These methods always assign association methods (i.e. get, set, create) to the source

.hasMany creates a 1:m relationship where:

A source can have multiple targets
Targets can each only have one source (can be supplemented with .belongsTo method)
Target names will be pluralized automatically by Sequelize; consider assigning foreign keys manually

.belongsToMany creates a m:m relationship where:

Sources can have multiple targets, and vice versa
A "through" option must be specified, creating a join table tracking each association
- Possible to use a predefined table
m:m associations must typically be defined two-ways
- Can be self-referencing

These methods are used to retrieve and create associations
Sources will automatically gain these methods once an association is defined in the model

Aliasing provides context behind associations, for example:

Self-referencing models
- i.e. Person.belongsTo(Person, {as: 'father'})
Aliasing changes naming conventions for methods and foreignKeys
- In the above example, the Person model would now have a 'fatherId' column
- To add a Person as another Person's father, we would use Person.addFather(Person)

At times, foreign keys may be necessary to preserve context and prevent repetition

Asymmetrical aliasing
- Pet.belongsTo(Person, {as: 'owner'})
  Person.hasMany(Pet, {foreignKey: 'ownerId'})
- Without the Foreign Key definition, Pet would have two columns: ownerId and personId

Sequelize allows users to define scopes in model definitions as well as in finder requests (i.e. .findOne and .findAll);
A particularly useful scope is include, allowing us to eagerly load information from associated models
- This is particularly advantageous as associations, and ultimately promise-chaining, become more complex

Person.findById(123, {
    include: [{model: Pet}]
})
.then(function(response) {
    return response.data
});
.catch(console.error);

Person.addScope('defaultScope', {
    include: [{model: Pet}]
}, {
    override: true
});

In Finder	In Model

Both methods will add a Pet object as a property on relevant instances of Person