NodeJS

Appearance

Relation entre deux modèles ​

Pour créer une relation entre deux modèles dans Sequelize, vous devez d'abord définir les modèles, puis spécifier la nature de leur relation (par exemple, hasOne, belongsTo, hasMany, belongsToMany).

Supposons que vous ayez un modèle Article et que vous souhaitiez créer une relation où chaque User peut avoir plusieurs Article. Voici comment vous pouvez le faire :

Définition du Modèle Article ​

Créons d'abord un modèle simple pour Article :

javascript
const Article = sequelize.define('article', {
  title: {
    type: Sequelize.STRING,
    allowNull: false
  },
  content: {
    type: Sequelize.TEXT,
    allowNull: false
  }
  // Vous pouvez ajouter d'autres champs ici
}, {
  // options
});
const Article = sequelize.define('article', {
  title: {
    type: Sequelize.STRING,
    allowNull: false
  },
  content: {
    type: Sequelize.TEXT,
    allowNull: false
  }
  // Vous pouvez ajouter d'autres champs ici
}, {
  // options
});

Création de la Relation entre User et Article ​

Ensuite, nous définissons la relation entre User et Article. Dans cet exemple, nous supposons que vous avez déjà défini le modèle User comme décrit précédemment (voir les chapitres précédents)

javascript
// User a plusieurs Article
User.hasMany(Article, {
  foreignKey: 'userId',
  as: 'articles'
});

// Article appartient à User
Article.belongsTo(User, {
  foreignKey: 'userId',
  as: 'user'
});
// User a plusieurs Article
User.hasMany(Article, {
  foreignKey: 'userId',
  as: 'articles'
});

// Article appartient à User
Article.belongsTo(User, {
  foreignKey: 'userId',
  as: 'user'
});

Explication ​

  • User.hasMany(Article, {...}) : Cela crée une relation one-to-many de User à Article. Chaque utilisateur peut avoir plusieurs articles. foreignKey: 'userId' ajoute une clé étrangère userId au modèle Article, reliant chaque article à un utilisateur spécifique. as: 'articles' est utilisé pour donner un nom personnalisé à cette relation.

  • Article.belongsTo(User, {...}) : Cela indique que chaque Article appartient à un User. La clé étrangère userId dans Article pointe vers User.

Utilisation de la Relation ​

Après avoir défini ces relations, vous pouvez effectuer des requêtes pour récupérer les données en tenant compte de la relation. Par exemple, pour récupérer tous les articles d'un utilisateur spécifique avec Sequelize, vous pouvez faire :

javascript
User.findOne({
  where: { id: userId },
  include: [{
    model: Article,
    as: 'articles'
  }]
}).then(userWithArticles => {
  console.log(userWithArticles);
});
User.findOne({
  where: { id: userId },
  include: [{
    model: Article,
    as: 'articles'
  }]
}).then(userWithArticles => {
  console.log(userWithArticles);
});

Dans cet exemple, User.findOne inclut tous les Article associés à cet utilisateur spécifique. La relation est utilisée pour joindre les tables et récupérer les données associées.

hasOne et belongsToMany ​

Les méthodes hasOne et belongsToMany dans Sequelize sont utilisées pour définir des types spécifiques de relations entre les modèles dans une base de données relationnelle. Ces relations sont essentielles pour modéliser comment les données dans une table sont liées à celles dans une autre.

hasOne ​

La relation hasOne est utilisée pour indiquer une relation un-à-un entre deux modèles. Cela signifie que chaque instance du modèle source peut être associée à une, et une seule, instance du modèle cible.

Exemple : ​

Supposons que vous ayez un modèle User et un modèle UserProfile, où chaque utilisateur a un seul profil utilisateur. Vous pouvez définir cette relation comme suit :

javascript
User.hasOne(UserProfile, {
  foreignKey: 'userId',
  as: 'profile'
});
User.hasOne(UserProfile, {
  foreignKey: 'userId',
  as: 'profile'
});

Ici, User.hasOne(UserProfile) signifie qu'une instance de User peut avoir un seul UserProfile associé. La foreignKey 'userId' dans UserProfile indique la colonne qui relie le UserProfile à son User. L'alias as: 'profile' est utilisé pour accéder à cette relation dans les requêtes.

belongsToMany ​

La relation belongsToMany est utilisée pour représenter une relation plusieurs-à-plusieurs entre deux modèles. Dans cette relation, une instance du modèle source peut être associée à plusieurs instances du modèle cible et vice versa.

Exemple : ​

Prenons un exemple avec des modèles Student et Course, où un étudiant peut s'inscrire à plusieurs cours et un cours peut avoir plusieurs étudiants inscrits.

javascript
Student.belongsToMany(Course, {
  through: 'StudentCourses',
  foreignKey: 'studentId',
  otherKey: 'courseId'
});
Course.belongsToMany(Student, {
  through: 'StudentCourses',
  foreignKey: 'courseId',
  otherKey: 'studentId'
});
Student.belongsToMany(Course, {
  through: 'StudentCourses',
  foreignKey: 'studentId',
  otherKey: 'courseId'
});
Course.belongsToMany(Student, {
  through: 'StudentCourses',
  foreignKey: 'courseId',
  otherKey: 'studentId'
});

Ici, Student.belongsToMany(Course) et Course.belongsToMany(Student) définissent une relation plusieurs-à-plusieurs. La table StudentCourses est une table de jointure (ou table d'association) qui contient les clés étrangères référençant à la fois Student et Course. Les propriétés foreignKey et otherKey définissent les noms des colonnes de clé étrangère dans la table de jointure.