Retour
3. Express + Mongoose: Les Queries
Apprenants de comprendre comment effectuer des requêtes sur une base de données MongoDB en utilisant le module Mongoose de Node.js.
À la fin du cours, vous serez en mesure de manipuler les données en utilisant des queries et filtres.
0
Description
Le cours se concentrera sur comment utiliser les requêtes de base et avancées pour récupérer des données selon des critères spécifiques, ainsi que les méthodes de tri pour ordonner ces données. Et comment utiliser la pagination pour récupérer des données en lots.
Cours suivra un fil rouge pratique pour permettre d'appliquer ces concepts dans le contexte de la création d'une application qui gère des auteurs et des livres.
Prérequis
Pour suivre cette d'inititaion, vous devez avoir une compréhension de base de la manipulation de données avec MongoDB et de la création de modèles de données avec Mongoose.
Il faut aussi avoir des connaissances dans la création d'application avec Express.js:
- Opération simples avec Mongoose.js.
Objectifs
À la fin de ce chapitre, vous serez en mesure de :
- Comprendre les différentes opérations de requête disponibles dans Mongoose pour interagir avec une base de données MongoDB.
- Comprendre comment utiliser les filtres pour filtrer les données récupérées.
- Savoir utiliser les requêtes avancées pour interroger des données plus complexes.
- Être capable d'utiliser les méthodes de tri pour trier les données récupérées selon les critères souhaités.
- Savoir utiliser les méthodes de pagination pour récupérer des données par lots.
Structure du projet
Vous pouvez récuperer le projet le départ sur GitHub.
git clone https://github.com/Djemai-Samy/expressjs-mongoose
Ou récupérer le projet de départ sur GitLab.
git clone https://gitlab.com/tutoriels-dev/expressjs/expressjs-mongoose/-/tree/main
Puis déplacez vous sur le répertoire:
cd ./expressjs-mongoose
Installer toutes les dépendances:
npm install
📦expressjs-mongoose
┣ 📂node_modules
┣ 📜package.json
┗ 📜app.js
Dans app.js:
import express from "express";
// Librairie pour intéragir avec une BDD MongoDB
import mongoose from "mongoose";
/**------------------------------------------------------------
* Définition du schéma pour l'exemple
*/
const AuthorSchema = mongoose.Schema({
name: { type: String, required: true, unique:true },
age: { type: Number, required: true },
alive: { type: Boolean, required: true, default: false },
adress:{
country: {type: String, required: true},
city: String
},
books:[
{
title:{type: String, required: true, unique: true},
date: String,
genre: String
}
]
});
/**
* -------------------------------------------------------------
*/
// Instanciation du model pour manipuler les données:
const Author = mongoose.model('Author', AuthorSchema)
// L'URI de la base de données locale
const MONGODB_URI = "mongodb://127.0.0.1:27017/library-queries";
// Le port de l'application
const PORT = 3001;
// Instanciation d'express
const app = express();
// Utilisation du middleware pour parser le JSON
app.use(express.json());
/**------------------------------------------------------------
* Connexion à la BDD et
* Lacement du serveur
*/
mongoose
.connect(MONGODB_URI)
.then(() => {
// Afficher dans la console que la BDD est connecté
console.log("Connecté à la BDD: library-queries");
// Lancer le serveur sur le port sépcifié plus haut
app.listen(PORT, () => {
console.log("Serveur lancé sur le port : " + PORT);
});
})
.catch((err) => {
// Erreur dans le then
console.log("Pas connecté à la BDD");
console.log("Serveur pas lancé");
console.log(err);
});
/**
* -------------------------------------------------------------
*/
Lancez l'application en mode developpement:
npm run dev
1. Les méthodes de récupération
Les Queries ou requêtes sont des opérations qui permettent de récupérer des données depuis une base de données.
Avec Mongoose, on peut utiliser différentes méthodes pour effectuer des requêtes sur la base de données.
Ces requêtes peuvent être effectuées en utilisant des filtres pour trier et sélectionner les données.
Les requêtes avec Mongoose sont effectuées en utilisant les méthodes de requête fournies par Mongoose.
Ces méthodes sont utilisées pour construire une requête et retourner les résultats de la base de données.
Les méthodes de requête sont chainées ensemble pour construire une requête complète.
1. Récuperer un seule
La méthode findOne() est utilisée pour récupérer un document à partir de la base de données en fonction de certains critères.
On peut fournir des filtres à la méthode findOne() pour sélectionner un document spécifique. La méthode findOne() retourne un objet de type Query.
Par exemple pour séléctionner le premier auteur avec le prenom réçue dans :firstname, nous pouvois utilisé la méthodes find({ name }):
app.get("/arthors/name/:name", async (req, res) =>{
// Récuperer la valeur du prénom dans les paramètre
const { name } = req.params;
// récuperer le premier auteur dont e nom égal name
const author = await Author.findOne({ name });
// Si l'utilisateur n'existe pas, retourner 404
if (!author) return res.status(404).json({ message: "Author not found!" });
// Si l'auteur est trouvé, retourner status 200 avec l'auteur
res.status(200).json({ author });
})
2. Récuperer plusieurs
La méthode find() est utilisée pour récupérer plusieurs document à partir de la base de données en fonction de certains critères.
On peut fournir des filtres à la méthode find() pour sélectionner un document spécifique. La méthode find() retourne un objet de type Query.
Par exemple pour séléctionner tous les auteurs vivant nous pouvons utilisé la méthodes find({ alive: true }):
app.get("/arthors/alive", async (req, res) => {
// Récuperer la valeur du prénom dans les paramètre
const { name } = req.params;
// récuperer tous les auteurs dont la propriètes alive est à true
const authors = await Author.find({ alive: true });
// Rétrouner la liste des auteurs vivant
res.status(200).json({ authors });
})
Vous pouvez aussi combiner plusieurs critères pour affiner les récherche.
Par exemple pour séléctionner tous les auteurs vivant provenant d'un pay donné dans les paramètres et l'utilisé la méthodes find({ alive: true, "address.country": country }):
app.get("/arthors/alive/:country", async (req, res) => {
// Récuperer la valeur du pays recherché dans les paramètres
const { country } = req.params;
// Récuperer tous les auteurs vivant et provenant du pays recherché
const authors = await Author.find({ alive: true, "address.country": country });
// Rétrouner la liste des auteurs vivant dans le pays recherché
res.status(200).json({ authors });
})
3. Récuperer le nombre
La méthode count() est utilisée pour récupérer le nombre de documents présent la base de données en fonction de certains critères.
On peut fournir des filtres à la méthode count() pour sélectionner des documents spécifiques. La méthode find() retourne un objet de type Query.
Par exemple pour séléctionner le nombres d'auteurs provenant d'un pays fournit en paramètre nous pouvons utilisé la méthodes count({ 'address.country':country }):
app.get("/arthors/country/:country", async (req, res) => {
// Récuperer la valeur du pays dans les paramètres
const { country } = req.params;
// Récuperer tous les auteurs dont le pays est égale au pays recherché
const authors = await Author.count({ 'address.country':country })
// Rétrouner la liste des auteurs vivant dans ce pays
res.status(200).json({ authors })
})
2. Les opérateurs
Dans cette partie, nous allons explorer les queries avancées que nous pouvons utiliser avec Mongoose pour filtrer et rechercher des données dans notre base de données MongoDB.
Nous allons continuer à utiliser le modèle et le schéma des auteurs que nous avons définis précédemment pour illustrer ces concepts.
Les filtres sont utilisés pour extraire des données à partir d'une collection en appliquant un ensemble de critères spécifiés.
Ces critères peuvent être basés sur des conditions d'égalité, de comparaison, de logiques...
1. Logiques
On peut également combiner plusieurs critères de recherche en utilisant les opérateurs logiques $and, $or, $nor.
Par exemple, pour rechercher tous les auteurs provenant du pays ou de la ville données en paramètre:
app.get('/authors/from/:place', async (req, res) => {
const place = req.params.place;
const authors = await Author.find({ address: {$or: [{ country: place }, { city: place }]} });
res.status(200).json({authors});
});
3. Opérateurs d'égalité
Dans certains cas, les critères de recherche sont plus complexes que simplement un champ égal à une certaine valeur.
Par exemple, nous pouvons avoir besoin de chercher des documents qui ont un champ qui est supérieur à une certaine valeur, ou qui se trouve entre deux valeurs.
Pour effectuer ces types de recherches, Mongoose fournit des opérateurs de comparaison pour les requêtes.
On peut filtrer le resultat suivant si un nombre est supérieure, infèrieure... avec les opérateur suivant:
- $gt : pour chercher des documents avec un champ qui est supérieur à une certaine valeur.
- $gte : pour chercher des documents avec un champ qui est supérieur ou égal à une certaine valeur.
- $lt : pour chercher des documents avec un champ qui est inférieur à une certaine valeur.
- $lte : pour chercher des documents avec un champ qui est inférieur ou égal à une certaine valeur.
Par exemple, pour rechercher tous les auteurs ayant un âge compris entre un min et un max fournit dans les paramètres:
app.get('/authors/age/:min/:max', async (req, res) => {
try {
const min = req.params.min;
const max = req.params.max;
const authors = await Author.find({ age: { $gte: min, $lte: max } });
res.status(200).json({authors});
} catch (error) {
console.error(error);
res.status(500).json('Error searching authors');
}
});
Conclusion
En conclusion, nous avons vu comment utiliser Mongoose et ExpressJS pour créer des modèles et effectuer des opérations CRUD sur une base de données MongoDB.
Nous avons commencé par comprendre la définition des schémas et modèles, et comment les utiliser dans les routes ExpressJS pour créer, lire, mettre à jour et supprimer des données.
Ensuite, nous avons exploré les différentes méthodes pour effectuer une recherche de données, que ce soit avec des critères simples ou complexes.
Nous avons également appris à mettre en place une pagination des données pour améliorer les performances de notre application.
Le prochain chapitre portera sur les relations entre modèles dans Mongoose.
Dans la création d'applications, il est courant de devoir manipuler des données qui ont des liens entre elles.
Les relations permettent de définir comment les données sont associées et de créer des requêtes pour récupérer les données liées.
Nous verrons les différents types de relations entre modèles et comment les définir avec Mongoose.
Nous explorerons également comment utiliser ces relations dans les routes ExpressJS.
Aller plus loin
Express.js + Mongoose.js
Un cours complèt qui vous permettra de maîtriser l'utilisation de Mongoose avec ExpressJS pour la gestion de bases de données MongoDB dans vos projets de développement web.
Javascript
NodeJS
ExpressJS
Serveurs
HTTP
Back-End
Mongoose
MongoDB
1
