Comment utiliser Mongoose dans les applications express

La gestion des données dans une base de données MongoDB peut être difficile, en particulier lorsqu'il s'agit de modèles de données complexes. MongoDB est une base de données sans schéma, ce qui signifie que les données peuvent être ajoutées sans suivre une structure particulière. Cette flexibilité rend MongoDB idéal pour stocker de grandes quantités de données, mais rend également la gestion des données plus difficile.

Mongoose fournit une solution basée sur un schéma qui permet de garantir que les données enregistrées dans MongoDB sont cohérentes et correctement formatées. Avec Mongoose, vous pouvez définir un schéma pour vos modèles de données, qui spécifie la structure des données et les règles de formatage de ces données. Ici, vous découvrirez comment utiliser Mongoose dans une application Express.

Configuration de votre environnement de développement

Avant d'utiliser Mongoose, vous devez l'installer en tant que dépendance dans votre projet.

Vous pouvez installer Mongoose en exécutant la commande ci-dessous :

npm installer la mangouste

Après avoir installé Mongoose dans votre projet, vous devez connecter votre application à MongoDB à l'aide de Mongoose.

Mongoose se connecte à une base de données MongoDB en utilisant le connecter méthode, qui prend un URI MongoDB comme argument.

Voici un exemple :

// index.js
constante mangouste = exiger("mangouste")
mangouste.connect("mongodb://127.0.0.1:27017/exemple", () =>
console.enregistrer("Connecté à la base de données avec succès")
);

Le bloc de code ci-dessus se connecte à une instance MongoDB locale et enregistre un message de réussite lorsque votre application se connecte avec succès à MongoDB.

Création d'un modèle de mangouste

Un modèle Mongoose est une classe basée sur un schéma dans Mongoose qui vous permet d'interagir avec une collection MongoDB.

Un schéma Mongoose définit la structure des documents que vous pouvez stocker dans une collection MongoDB et fournit une interface pour créer, lire, mettre à jour et supprimer des documents dans ce collection.

Lorsque vous définissez un modèle Mongoose, vous définissez le schéma des documents de cette collection, y compris les propriétés, leurs types et toutes les validations.

Voici un exemple de modèle Mongoose pour un Utilisateur collection:

constante mangouste = exiger("mangouste");
constante userSchema = mangouste. Schéma({
 nom: {
 taper: Chaîne,
 requis: [vrai, "Le nom est requis"],
 },
 e-mail: {
 taper: Chaîne,
 requis: vrai,
 },
 âge: {
 taper: Nombre,
 valider: {
 validateur: fonction (valeur) {
retour valeur > 0;
 },
 message: () =>"Veuillez entrer un âge valide",
 },
 },
});
constante Utilisateur = mangouste.model("Utilisateur", userSchema);
module.exports = Utilisateur ;

Le bloc de code ci-dessus définit un schéma Mongoose avec trois propriétés: nom, e-mail, et âge. Chaque propriété a un ensemble défini de règles que vous devez suivre lors du mappage d'une valeur à son champ spécifié. Voici une ventilation des règles:

• nom: Le nom la propriété est un chaîne type marqué comme requis, ce qui signifie que vous devez mapper une chaîne à ce champ. Si vous laissez le champ vide ou entrez un autre Type de données JavaScript, Mongoose génère une erreur.
• e-mail: Le e-mail la propriété est un chaîne type marqué comme requis. Il n'a pas d'autres règles de validation, mais en pratique, vous devez valider si l'e-mail est correct. Vous pouvez valider l'e-mail utiliser des expressions régulières ou des bibliothèques tierces, telles que class-validator.
• âge: Le âge la propriété est un nombre type avec une règle de validation personnalisée qui vérifie si la valeur mappée au champ est supérieure à zéro. Si la valeur ne passe pas la validation, Mongoose génère une erreur avec le message Veuillez entrer un âge valide. Vous pouvez laisser ce champ vide car il n'est pas marqué comme requis.

Après avoir défini le schéma, le bloc de code crée un modèle Mongoose appelé Utilisateur en utilisant mangouste.model() méthode. Cette méthode prend deux arguments: le nom du modèle et le schéma à utiliser pour les documents.

Finalement, le Utilisateur modèle est exporté vers d'autres parties de votre application.

Interagir avec MongoDB à l'aide de Mongoose

Avec votre application connectée à une base de données MongoDB et votre modèle créé et accessible à d'autres parties de votre application, vous pouvez interagir avec votre base de données à l'aide des méthodes fournies par Mongoose.

Pour ce tutoriel, vous effectuerez Opérations CRUD sur une base de données MongoDB.

Note: Assurez-vous d'importer votre modèle Mongoose dans n'importe quel module où vous effectuerez les opérations CRUD.

Par exemple:

// routeur.js
constante Utilisateur = exiger("./userModel")

Création d'un document

Un document est une instance d'un modèle. Il existe plusieurs façons de créer et d'enregistrer un document dans MongoDB à l'aide de Mongoose.

Tout d'abord, vous pouvez créer une instance de la classe de votre modèle, puis appeler le sauvegarder méthode dessus.

Par exemple:

//Création d'un nouvel utilisateur
laisser utilisateur = nouveau Utilisateur({
 nom,
 e-mail,
 âge,
});
// Enregistrement de l'utilisateur dans la base de données
utilisateur
 .sauvegarder()
 .alors(() => {
console.enregistrer("Utilisateur créé avec succès");
 })
 .attraper((erreur) => {
// gérer l'erreur
 });

Le bloc de code ci-dessus crée et enregistre un nouveau Utilisateur document à votre base de données MongoDB.

Vous pouvez également enregistrer des données dans votre base de données à l'aide de la créer méthode. Le créer La méthode instancie votre modèle et appelle la sauvegarder méthode dessus. En d'autres termes, il combine les deux opérations de la technique précédemment mentionnée.

Par exemple:

User.create({ nom, email, age }, (err, data) => {
si (se tromper) lancernouveauErreur("Erreur interne du serveur");
console.enregistrer(`L'utilisateur a été créé avec succès: ${données}`);
 });

Le bloc de code ci-dessus crée un nouveau Utilisateur document avec les propriétés passées en argument au créer méthode.

Vous pouvez également enregistrer des données dans votre base de données à l'aide de la insertMany méthode. Bien que cette méthode ne soit idéale que pour enregistrer des données par lots.

Par exemple:

Utilisateur.insertMany(
 [
 { nom, email, âge },
 { nom_1, e-mail_1, âge_1 },
 ],
 (erreur, résultat) => {
si (erre) {
// gérer l'erreur
 } autre {
//Envoi des résultats
 }
 }
 );

Le bloc de code ci-dessus crée deux nouveaux documents dans le Utilisateur collection en utilisant le tableau passé en argument à la insertMany méthode.

Lire un document

Vous pouvez accéder à tous les documents enregistrés dans votre base de données MongoDB à l'aide de Mongoose trouver méthode.

Par exemple:

Utilisateur.trouver({})
 .alors((données) => {
console.log (données);
 })
 .attraper((se tromper) => {
// gérer l'erreur
 });

Le bloc de code ci-dessus renverra tous les documents dans le Utilisateur collection.

Vous pouvez également rechercher tous les documents correspondant à une requête particulière en transmettant une requête à la méthode de recherche.

Par exemple:

// trouve tous les documents dont l'âge est d'au moins 18 ans
Utilisateur.trouver({ âge: { $gte: 18 } })
 .alors((données) =>console.log (données))
 .attraper((erreur) =>console.log (erreur));

Le bloc de code ci-dessus renverra tous les documents avec une valeur d'âge supérieure à 18 ans dans le Utilisateur collection.

Alternativement, vous pouvez lire des enregistrements uniques en utilisant le findById méthode et en passant un ID de document comme argument ou en utilisant la trouver un méthode et en passant un filtre comme argument.

Par exemple:

//findById
User.findById (id, (erreur, résultat) => {
si (résultat) console.log (résultat);
si (erreur) console.error (erreur)
 });
//findOne
Utilisateur.findOne({ e-mail: "[email protected]" }).alors((utilisateur) => {
si (!utilisateur) {
// gérer l'erreur
 }
//envoyer une réponse
 });

Dans le bloc de code ci-dessus, le findById La méthode renvoie le document avec l'ID correspondant. Le trouver un la méthode renvoie le premier document ayant l'e-mail [email protected].

Mettre à jour un document

Vous pouvez mettre à jour un document sur MongoDB avec Mongoose en utilisant le findByIdAndUpdate méthode. Cette méthode prend un ID et un objet avec les détails mis à jour.

Par exemple:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
si (doc) {
//Envoyer une réponse
 }
si (erre) {
// gérer l'erreur
 }
});

Le bloc de code ci-dessus met à jour le document ayant un ID correspondant à l'ID fourni avec l'objet de mise à jour fourni (corps requis).

Suppression d'un document

Vous pouvez supprimer un document sur MongoDB avec Mongoose en utilisant le findByIdAndDelete méthode. Cette méthode prend un ID comme argument et supprime le document avec l'ID correspondant.

Par exemple:

User.findByIdAndDelete (id, (erreur, résultat) => {
si (résultat) {
//Gérer le résultat
 }
si (erreur) {
//Gérer l'erreur
 }
});

Le bloc de code ci-dessus supprime un document avec l'ID donné de votre base de données MongoDB.

Utilisation de Mongoose dans vos applications express

Cet article a fourni un aperçu de la façon dont vous pourriez utiliser Mongoose dans votre application express. Couvrant comment vous pouvez établir une connexion à MongoDB, structurer et valider les données enregistrées dans votre base de données MongoDB et effectuer des opérations CRUD simples.

En utilisant Mongoose dans vos applications Express, vous pouvez simplifier et rationaliser les interactions entre votre application et une base de données MongoDB.