Sequelize est un ORM pour node.js compatible avec différents moteurs de base de données comme Mysql, Sqlite…etc.
Dans cet article nous allons survoler quelques cas pratiques permettant de définir le modèle de la base, et d’effectuer des requêtes dessus.
Une fois installé nous allons commencer à structurer notre base de données en créant les différents objets la composant. Tout sera situé dans un fichier « Model.js » avec pour commencer les informations de connexion à la base (ici de type mysql) :
var sequelize = new Sequelize('database', 'username', 'password', {
host: 'localhost',
dialect: 'mysql',
logging: false,//passer a true pour voir les différentes requêtes effectuées par l'ORM
});
//on exporte pour utiliser notre connexion depuis les autre fichiers.
var exports = module.exports = {};
exports.sequelize = sequelize;
On va pouvoir créer notre modèle, partons sur un cas pratique simple, ou on va avoir des utilisateurs « User » qui ont un rôle « Role ». On déclare les tables et leurs champs de la manière suivante :
* ROLE
*/
const Role = sequelize.define('role', {
id: {type: Sequelize.INTEGER, autoIncrement: true, primaryKey: true},
name: {type: Sequelize.STRING(255), allowNull: false},
},
{tableName: 'role', timestamps: false, underscored: true}//par default "tableName" serait "roles" (au pluriel), "timestamps" crée 2 champs automatique pour les dates de création et de modification (très pratique si nécessaire) et "underscored" permet de créer automatiquement des champs de "relation" entre les tables de type "role_id" plutôt que "UserId".
);
exports.Role = Role;
/*
* USER
*/
const User = sequelize.define('user', {
id: {type: Sequelize.INTEGER, autoIncrement: true, primaryKey: true},
name: {type: Sequelize.STRING(255), allowNull: false, },
email: {type: Sequelize.STRING(255), allowNull: false, unique: true},
},
{tableName: 'user', timestamps: false, underscored: true}
);
exports.User = User;
On veux maintenant créer une relation entre ces 2 tables. L’utilisateur à un et un seul rôle. Pour cela il suffit d’ajouter la ligne suivante :
Cela va créer un champ « role_id » dans la table « user » (roleId si on laisse la configuration « underscored » à false par default).
Pour générer ces tables on peux utiliser la ligne suivante (tables générées seulement si elles n’existent pas)
Voyons maintenant comment récupérer nos données à travers ces objets :
var Model = require('./Model');
//recherche de tous les utilisateurs
Model.User.findAll().then(users => {
//on récupère ici un tableau "users" contenant une liste d'utilisateurs
console.log(users);
}).catch(function (e) {
//gestion erreur
console.log(e);
});
La partie import du modèle et gestion des erreurs restant toujours la même, ci-dessous des exemple plus concis de différentes requêtes.
Model.User.findAll({
where: {role_id: 2}, //on veux uniquement ceux qui ont le role "2"
order: [['name', 'ASC']] //classer par ordre alphabétique sur le nom
}).then(users => {
//traitement terminé...
});
//requête d'un utilisateur par son identifiant avec inclusion de la relation "Role"
let id = 19; //id
Model.User.findById(id, {
include: [{model: Model.Role}]
}).then(user => {
//on peux directement afficher le nom du rôle de l'utilisateur
console.log(user.role.name);
});
//exemple de création d'un utilisateur, puis de sa suppression dans la foulée. Ce qui permet de voir comment effectuer des requêtes successives.
Model.User.create({
name: 'Test',
email : 'test@testmail.com'
}).then(user => {
return user.destroy();
}).then(destroy => {
//traitement terminé...
}).catch(function (e) {
//gestion erreur
});
//exemple de requête d'update d'un utilisateur
let id = 19;//id
Model.User.update(
{name: 'Numa'},
{where: {id: id}}
).then(user => {
//traitement terminé...
});
Pour la suite et voir une utilisation un peu plus poussé, nous allons apporter des modifications à notre modèle. Pour l’instant on peux récupérer le rôle d’un utilisateur, mais on voudrait aussi pouvoir faire l’inverse. C’est à dire, à partir d’un rôle connaitre la liste des utilisateurs correspondant. Pour cela il nous faut ajouter une relation « hasMany » :
Exemple de requête :
Model.Role.findAll({include: [{model: Model.User}]}).then(roles => {
//pour chaque role on peux parcourir la liste des ses utilisateurs
roles.forEach((role) => {
console.log(role.name);
role.users.forEach((user) => {
console.log(user.name);
});
});
//...
});
Revenons à nouveau sur notre modèle, et regardons comment indiquer une référence sur la même table. Ici nos utilisateurs « Operator » peuvent avoir d’autre utilisateurs qui sont leurs « Manager ».
On veux donc une clé manager_id sur notre table user. Et comme il sera intéressants de récupérer la liste des « Operators » d’un « Manager » nous créons aussi la liaison inverse « hasMany », Voici comment faire :
User.belongsTo(User, {foreignKey: 'manager_id', as: 'Manager'});//l'utilisateur peux avoir un "Manager"
Ici lors des « include » dans nos requêtes nous devrons répéter les éléments « as ». Nous allons aussi voir que nous pouvons imbriquer ces « include », et leur appliquer des critères.
include: [
//j'inclus les roles de mon utilisateur
{model: Model.Role},
//mais aussi la liste de ses "Operators" qui ont comme valeur role_id ="1" je récupére également leur propre role.
{model: Model.User, as: "Operators", where: {role_id: '149999900000000002'}, include: [{model: Model.Role}]}
]
}).then(users => {
users.forEach((user) => {
console.log('----');
console.log(user.name + " : " + user.role.name);
console.log('----');
user.Operators.forEach((operator) => {
console.log(operator.name + " : " + operator.role.name);
});
});
});
On peux bien sur aussi effectuer des requête brutes, et utiliser l’échappement de données dans celles-ci, voici un exemple :
let param_name = '%a%';
let param_role = 1;
//sql brut
let sql = 'SELECT (ROUND(id / 5)+123) as nimportequoi FROM user WHERE name LIKE $1 AND role_id > $2';
Model.sequelize.query(sql, {bind: [param_name, param_role], type: Model.sequelize.QueryTypes.SELECT}).then(results => {
console.log(results);
});
Ce sera tout pour ce premier article au sujet de nodeJs et Sequelize !
Bonjour !
Un grand merci en passant pour cet article qui m’a été très utile pour la découverte de l’ORM et son implémentation pour mon projet.
Les explications sont claires, même si j’aurais voulu plus de détails sur les insertions avec des relations, mais j’avais assez d’éléments pour m’y retrouver.
Beau boulot et merci.