Dans cet article, nous vous montrerons comment utiliser Mongoose pour vos déploiements MongoDB afin de créer une solution plus simple, basée sur un schéma, pour modéliser vos données d'application.
Qu'est-ce que la mangouste ?
Mongoose est une "modélisation élégante d'objets MongoDB pour Node.js “. Si vous avez déjà utilisé MongoDB et essayé des opérations de base de données de base, vous avez peut-être remarqué que MongoDB est "sans schéma". Lorsque vous cherchez à implémenter une base de données plus structurée et que vous souhaitez tirer parti de la puissance de MongoDB, Mongoose est l'un des ODM (O objet D à M application) solutions.
Pour une démonstration rapide, vous exécutez une commande d'insertion dans une collection nommée utilisateurs comme ceci :
db.users.insert({ name : 'Arvind', gender : 'male'});
Et juste après cela, vous pouvez exécuter :
db.users.insert({ name : 'Arvind', gender : 'male', password : '!@#$'});
et MongoDB ne se plaindra jamais de la variation du nombre de colonnes (paires clé-valeur). C'est très flexible. Mais lorsque vous souhaitez que vos données soient mieux organisées et structurées, vous devez les conserver dans le code de votre serveur, en écrivant la validation, en vous assurant que rien d'inutile n'est stocké dans une collection. C'est là que Mongoose vous facilite la vie.
"Mongoose fournit une solution simple, basée sur un schéma, pour modéliser vos données d'application et inclut la conversion de type intégrée, la validation, la création de requêtes, les crochets de logique métier et plus encore , prêt à l'emploi."
Installer Node.js et MongoDB
Pour utiliser Mongoose, nous devons avoir installé Node.js. Vous pouvez trouver des informations ici.
Commencer à développer
Tout d'abord, créons une petite aire de jeux où nous pourrons nous amuser. Créez un nouveau dossier nommé myMongooseApp et ouvrez le terminal/invite ici et exécutez :
npm init
Cela nous aidera à initialiser un nouveau projet de nœud. Remplissez-le au besoin. Ensuite, nous allons installer Mongoose en tant que dépendance de notre projet. Exécuter :
npm install mongoose --save-dev
Ensuite, démarrez le service MongoDB en exécutant :
mongod
Ensuite, créez un nouveau fichier nommé index.js à la racine, puis ouvrez-le dans votre éditeur préféré. Ajoutez le code ci-dessous :
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/myTestDB');
var db = mongoose.connection;
db.on('error', function (err) {
console.log('connection error', err);
});
db.once('open', function () {
console.log('connected.');
});
Ici, nous avons besoin du package Mongoose pour se connecter à la base de données et initialiser la connexion. Le nom de notre base de données est myTestDB.
Ensuite, lancez :
node index.js
Vous devriez maintenant voir le message connecté. Vous pouvez également utiliser un package de nœud nommé nodemon pour redémarrer automatiquement le serveur de nœud en cas de modification.
Maintenant, notre bac à sable est prêt à jouer !
Schémas de mangouste
Les schémas sont comme des squelettes, l'essentiel de l'apparence de votre collecte de données. Si vous avez affaire à une collection d'utilisateurs, votre schéma ressemblera à ceci :
Name - String Age - Number Gender - String Date of Birth - Date
Si vous avez affaire à une collection de produits, votre schéma ressemblera à ceci :
SKU - String Name - String Price - Number InStock - Boolean Quantity - Number
Vous pouvez voir la dérive. Lorsque nos données sont protégées par un schéma comme celui-ci, la possibilité de stocker des données parasites est considérablement réduite.
Maintenant que nous avons compris les schémas, essayons de créer un schéma utilisateur à l'aide de Mongoose. Revenez à index.js et ajoutez le code ci-dessous :
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
Trouvez ici les champs de base liés à l'utilisateur et leurs types de schéma.
Ensuite, nous allons créer un modèle à partir du schéma. Ajouter :
var User = mongoose.model('User', userSchema);
Ça y est, notre modèle utilisateur est prêt ! Nous l'utiliserons comme schéma de base pour insérer des utilisateurs dans la base de données. De cette façon, nous savons que chaque document d'une collection d'utilisateurs aura les champs répertoriés sur le schéma. Créons une nouvelle instance d'utilisateur et enregistrons-la dans la base de données. Ajouter :
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
arvind.save(function (err, data) {
if (err) console.log(err);
else console.log('Saved : ', data );
});
Vous devriez voir quelque chose comme ceci :
Saved : { __v: 0,
name: 'Arvind',
age: 99,
DOB: Fri Jan 01 1915 00:00:00 GMT+0530 (IST),
isAlive: true,
_id: 536a4866dba434390d728216 }
Pas de tracas, pas de problèmes. API simple et facile pour interagir avec les modèles.
Disons que nous voulons que chaque modèle ait une méthode nommée isYounger. Cette méthode renverra vrai si l'âge est inférieur à 50 ans et faux s'il est supérieur. Nous pouvons le faire en interrogeant la base de données pour l'utilisateur actuel, puis en vérifiant le conditionnement et le retour vrai ou faux.
Mais que se passe-t-il si nous voulons implémenter cette méthode à tous les modèles de schéma User ? Voici comment nous procédons dans Mongoose :
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/myTestDB');
var db = mongoose.connection;
db.on('error', function (err) {
console.log('connection error', err);
});
db.once('open', function () {
console.log('connected.');
});
var Schema = mongoose.Schema;
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
});
userSchema.methods.isYounger = function () {
return this.model('User').age < 50 ? true : false;
}
var User = mongoose.model('User', userSchema);
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
arvind.save(function (err, data) {
if (err) console.log(err);
else console.log('Saved ', data );
});
console.log('isYounger : ',arvind.isYounger());
À la ligne 21, nous ajoutons la définition de la méthode, et le résultat à la ligne 39 sera faux. C'est un moyen simple et pratique d'ajouter des méthodes à votre schéma, le rendant plus orienté objet.
Si vous avez un champ de mot de passe, vous pouvez ajouter une méthode comme encryptPassword(), pour chiffrer le mot de passe et comparePassword(), pour comparer les mots de passe lors de la connexion au userSchema lui-même. Vous pouvez en savoir plus sur l'authentification par mot de passe ici.
Prêt à l'emploi, Mongoose fournit également quelques options lors de la création du schéma. Par exemple, si vous regardez la déclaration de schéma ci-dessous, nous passons une option strict:false :
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {strict : false});
L'option stricte est vraie par défaut et elle ne permet pas d'enregistrer les paires clé-valeur « non-schéma ». Par exemple, ceci sera enregistré :
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true
});
Attendu que :
var arvind = new User({
name : 'Arvind',
age : 99,
DOB : '01/01/1915',
isAlive : true,
bucketList : [{...}, {...}, {...} ]
});
Tout ce qui précède sera enregistré moins le tableau bucketList car il n'a pas été déclaré comme faisant partie du schéma. Ainsi, aucun client qui consomme vos services ne pourra déposer de données invalides dans vos collections.
Une autre option intéressante est la collection. Si vous ne voulez pas que le nom de votre modèle soit le même que le nom de la collection, vous pouvez passer le nom en tant qu'option comme :
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
}, {collection : 'appusers'});
Vous pouvez trouver une liste d'autres options ici.
Avec Mongoose, vous pouvez également ajouter des événements à vos schémas comme la pré-sauvegarde ou la post-sauvegarde, où vous pouvez effectuer des validations, traiter des données ou exécuter d'autres requêtes dans les événements respectifs. Ces méthodes sont appelées Middlewares.
Un exemple simple peut être un middleware parallèle comme :
var userSchema = new Schema({
name : String,
age : Number,
DOB : Date,
isAlive : Boolean
})
schema.pre('save', true, function (next, done) {
// calling next kicks off the next middleware in parallel
next();
doAsync(done);
});
Vous pouvez en savoir plus sur les middlewares ici. Dans notre prochain article, nous parlerons davantage de l'utilisation de Yeoman pour générer automatiquement des échafaudages pour vos projets MongoDB.
Merci d'avoir lu. Faites un commentaire.
@arvindr21
