API REST manipulant une base de données MongoDB
Etape 1 :
Création de de dossier de l’application : api_crud_23
Tapez la commande npm init -y
La commande "npm init -y" est utilisée pour initialiser un nouveau projet [Link] avec un fichier
[Link] par défaut, sans aucune interaction. Voici ce que chaque partie de la commande fait :
npm : C'est l'outil en ligne de commande pour la gestion des packages [Link].
init : C'est une commande utilisée pour initialiser un nouveau package dans un répertoire.
-y : C'est un indicateur facultatif qui signifie "oui" et répond automatiquement "oui" à toutes les
invitations, créant ainsi le fichier [Link] avec des valeurs par défaut.
Lorsque vous exécutez npm init -y, la commande va créer un fichier [Link] dans le
répertoire courant, en utilisant des valeurs par défaut pour les métadonnées du projet telles que le
nom, la version, la description, le point d'entrée, la commande de test, le dépôt, l'auteur et la
licence. Cela est utile lorsque vous souhaitez créer rapidement un nouveau projet et que vous
n'avez pas besoin de personnaliser la configuration initiale.
Etape 2 :
Pour installer les packages Express, body-parser et MongoDB dans un projet [Link], vous pouvez exécuter
les commandes suivantes :
1.
Express :
npm install express
2. body-parser :
npm install body -parser
3. MongoDB :
npm install mongodb
4. Mongoose :
npm install mongoose
Ces commandes utiliseront l'outil npm pour télécharger et installer les packages dans le répertoire de votre
projet, en ajoutant les dépendances nécessaires au fichier [Link]. Assurez-vous d'exécuter ces commandes
dans le répertoire racine de votre projet [Link].
1. Express : Express est un framework web populaire pour [Link]. Il simplifie le processus de création
d'applications web en fournissant des fonctionnalités et des outils puissants. Le rôle d'Express est de gérer les
requêtes HTTP, de router les différentes routes vers les fonctions appropriées, de gérer les middlewares (comme
bodyParser) et de renvoyer des réponses aux clients. En somme, Express facilite le développement d'applications
web en fournissant une structure et des fonctionnalités pour gérer les requêtes et les réponses.
2. Body-parser : Body-parser est un middleware pour Express (ou d'autres frameworks [Link]) qui permet de
traiter les données envoyées dans le corps (body) d'une requête HTTP. Lorsqu'un client envoie des données dans
une requête POST, PUT ou PATCH, par exemple, ces données sont incluses dans le corps de la requête. Le rôle de
body-parser est de récupérer et de parser ces données, afin de les rendre disponibles pour le traitement ultérieur
dans l'application. Body-parser prend en charge différents formats de données, tels que JSON, URL-encoded,
etc., et facilite leur manipulation dans le code.
3. MongoDB : MongoDB est une base de données NoSQL orientée document. Contrairement aux bases de
données relationnelles traditionnelles, MongoDB stocke les données sous forme de documents BSON (Binary
JSON), qui sont similaires aux objets JSON. Le rôle de MongoDB est de stocker, récupérer et gérer les données
de manière efficace. Il offre une grande flexibilité en permettant de stocker des données non structurées ou
semi-structurées, et facilite l'évolutivité horizontale grâce à son architecture distribuée. MongoDB est souvent
utilisé dans le développement d'applications web modernes, où la flexibilité et les performances sont
essentielles.
4. Mongoose : Mongoose est une bibliothèque [Link] qui facilite l'interaction avec MongoDB. Elle fournit une
couche d'abstraction supplémentaire pour travailler avec MongoDB en introduisant des schémas (schemas) pour
les modèles de données et en offrant des fonctionnalités avancées telles que la validation des données, les
hooks (pré et post middleware), les références entre les documents, etc. Mongoose simplifie le processus de
création, de lecture, de mise à jour et de suppression (CRUD) des données dans MongoDB, et offre une API plus
conviviale et expressive pour interagir avec la base de données.
En résumé, Express est un framework web pour [Link] qui facilite le développement d'applications web, body-
parser est un middleware pour Express qui analyse les données des requêtes HTTP, MongoDB est une base de
données NoSQL orientée document pour le stockage des données, et Mongoose est une bibliothèque qui
simplifie l'interaction avec MongoDB en fournissant des fonctionnalités supplémentaires.
Etape 3 :
Creation de server avec et on inclus les bibliothèques :
-------------------------------------------------------------------------------------------------------------
var express = require("express");
const mongoose = require("mongoose");
var bodyParser = require("body-parser");
var app = express();
// parse application/x-www-form-urlencoded
[Link]([Link]({ extended: true }));
// parse application/json
[Link]([Link]());
[Link](3000,()=>{
[Link]('Server Lisning on port 3000')
});
-------------------------------------------------------------------------------------------------------------
Dans ce code, nous pouvons voir les différentes étapes de configuration d'une application Express
avec l'utilisation de Mongoose et de body-parser :
1. var express = require("express"); : Cette ligne de code importe le module "express" et le
stocke dans la variable "express". Cela permet d'accéder aux fonctionnalités d'Express pour créer et
configurer notre application web.
2. const mongoose = require("mongoose"); : Cette ligne de code importe le module "mongoose"
et le stocke dans la constante "mongoose". Mongoose est une bibliothèque [Link] qui facilite
l'interaction avec MongoDB. L'importation de ce module nous permettra d'utiliser les
fonctionnalités avancées de Mongoose pour interagir avec la base de données MongoDB.
3. var bodyParser = require("body-parser"); : Cette ligne de code importe le module "body-
parser" et le stocke dans la variable "bodyParser". Body-parser est un middleware pour Express qui
permet de traiter les données envoyées dans le corps (body) des requêtes HTTP.
4. var app = express(); : Cette ligne de code crée une instance de l'application Express en
appelant la fonction "express()". L'application est ensuite stockée dans la variable "app". Nous
utiliserons cette instance pour configurer et exécuter notre application.
5. [Link]([Link]({ extended: true })); : Cette ligne de code configure le
middleware body-parser pour traiter les données au format "application/x-www-form-
urlencoded". Cela permet de parser les données envoyées dans le corps des requêtes HTTP et de
les rendre disponibles pour le traitement ultérieur dans notre application.
6. [Link](3000,()=>{ [Link]('Server Listening on port 3000') }); : Cette ligne
de code indique à notre application d'écouter les requêtes entrantes sur le port 3000. Lorsque le
serveur démarre, la fonction de rappel est exécutée, affichant
7. parse application/json [Link]([Link]());
Cette ligne de code configure le middleware body-parser pour traiter les données au format
"application/json". Cela permet de parser les données JSON envoyées dans le corps des requêtes
HTTP et de les rendre disponibles pour le traitement ultérieur dans notre application.
En utilisant [Link]([Link]()), toutes les requêtes entrantes avec un en-tête "Content-
Type" défini sur "application/json" seront traitées par le middleware body-parser, qui analysera le
corps de la requête et rendra les données JSON disponibles dans [Link] pour être utilisées dans
les routes ou les fonctions de gestion des requêtes.
Cette configuration est utile lorsque vous avez besoin de recevoir et de traiter des données JSON
dans votre application, par exemple lors de l'envoi de données depuis un client en utilisant la
méthode POST avec des données JSON dans le corps de la requête.
le message "Server Listening on port 3000" dans la console. Cela signifie que notre serveur est prêt
à recevoir des requêtes et à y répondre.
En résumé, ce code configure une application Express, utilise le middleware body-parser pour
parser les données des requêtes HTTP et lance le serveur sur le port 3000. Cela prépare notre
application à recevoir et à traiter les requêtes entrantes.
Etape 4 :
On se connecte au mongoDB et en créant notre Base :
--------------------------------------------------------------------------------------------------------------
const initmongo = async () => {
try {
await [Link]("mongodb://[Link]/BDStockK");
[Link]("connected to mongoDB....");
} catch (error) {
[Link](error);
}
};
initmongo()
--------------------------------------------------------------------------------------------------------------
C’est une fonction asynchrone appelée initmongo, qui se connecte à une base de données
MongoDB en utilisant le module Mongoose.
1. La fonction initmongo est définie avec le mot-clé const, ce qui signifie que cette fonction ne peut
pas être redéfinie ultérieurement dans le code.
2. La fonction initmongo est déclarée comme une fonction asynchrone en utilisant le mot-clé async.
Cela permet d'utiliser l'opérateur await à l'intérieur de la fonction pour attendre la résolution d'une
promesse.
3. Le corps de la fonction initmongo est entouré par des accolades {} pour délimiter son bloc de code.
4. À l'intérieur du bloc try-catch, il y a un appel à la méthode [Link]. Cette méthode est
utilisée pour établir une connexion à la base de données MongoDB.
5. Le premier argument de [Link] est l'URL de connexion à la base de données. Dans cet
exemple, l'URL est "mongodb://[Link]/BDStockK". Cela indique que la base de données est
hébergée localement à l'adresse [Link], et le nom de la base de données est BDStockK.
6. L'opérateur await est utilisé avant l'appel à [Link] pour attendre que la promesse soit
résolue. Cela signifie que l'exécution de la fonction sera mise en attente jusqu'à ce que la connexion
à la base de données soit établie avec succès ou qu'une erreur survienne.
7. Si la connexion à la base de données est établie avec succès, le code à l'intérieur du bloc try est
exécuté, et la chaîne de caractères "connected to mongoDB...." est affichée dans la console.
8. Si une erreur se produit lors de la connexion à la base de données, le code à l'intérieur du bloc catch
est exécuté, et l'erreur est affichée dans la console.
9. Enfin, la fonction initmongo est appelée en invoquant initmongo(). Cela déclenche l'exécution de
la fonction et tente de se connecter à la base de données MongoDB.
En résumé, le code fourni définit une fonction asynchrone initmongo qui se connecte à une base de
données MongoDB en utilisant Mongoose. Lorsque vous appelez initmongo(), il tente d'établir une
connexion à la base de données et affiche un message de réussite ou d'erreur en fonction du résultat
de la connexion.
Etape 5 :
Création de [Link] : qui représente le schéma de la collection :
-------------------------------------------------------------------------------------------------------
const mongoose = require("mongoose");
const produitSchema = [Link](
{
nom: { type: String, required: true },
prix: { type: Number, required: true },
},
{ timestamps: true }
);
const Produit = [Link]("Produit", produitSchema);
[Link] = Produit;
-------------------------------------------------------------------------------------------------------
Ce code définit un modèle de données pour les produits dans une application utilisant MongoDB et
Mongoose :
1. const mongoose = require("mongoose"); : Cette ligne importe le module Mongoose, qui est un
package [Link] utilisé pour simplifier l'interaction avec MongoDB.
2. const produitSchema = [Link](...); : Ici, un schéma de produit est défini en utilisant
la méthode [Link](). Un schéma est une description de la structure des données d'un
modèle dans MongoDB. Le schéma spécifie les propriétés (champs) attendues pour chaque
document dans la collection.
Le schéma des produits contient deux propriétés : "nom" et "prix". Les deux propriétés sont de type
String et Number respectivement. De plus, elles sont déclarées comme étant obligatoires (required:
true).
{ timestamps: true } est un deuxième argument passé au schéma. Cela indique à Mongoose
d'ajouter automatiquement des champs "createdAt" et "updatedAt" à chaque document du modèle
pour suivre les horodatages de création et de mise à jour.
3. const Produit = [Link]("Produit", produitSchema); : La méthode
[Link]() est utilisée pour créer un modèle basé sur le schéma. Elle prend deux arguments
: le nom du modèle (ici "Produit") et le schéma défini précédemment. Le modèle créé permettra
d'effectuer des opérations CRUD (Create, Read, Update, Delete) sur les documents de la collection
associée.
4. [Link] = Produit; : Cette ligne exporte le modèle "Produit" en tant que module pour
être utilisé dans d'autres parties de l'application. Cela permet à d'autres fichiers d'importer le modèle
et d'interagir avec les produits dans la base de données.
En résumé, ce code définit un modèle de données pour les produits en utilisant Mongoose. Le
modèle spécifie les propriétés attendues pour chaque document dans la collection "Produit" de
MongoDB. Le modèle peut être exporté en tant que module pour être utilisé dans d'autres parties
de l'application.
Etape 6 :
Inclure le fichier [Link] dans l’index :
const produit = require("./produit");
Etape 7 :
Route GET pour afficher les Produits :
//---------------------------GET-------------------------------
[Link]("/", async (req, res) => {
try {
let data = await [Link]({});
[Link](data);
} catch (error) {
[Link](error);
}
});
//----------------------------------------------------------
Cette route est configurée pour la méthode HTTP GET à l'adresse racine ("/") de l'application.
Lorsqu'un client envoie une requête GET à cette adresse, la fonction de rappel asynchrone associée
à cette route est exécutée. Voici une explication étape par étape du code :
1. Lorsqu'une requête GET est reçue à l'adresse racine ("/"), la fonction de rappel asynchrone est
exécutée.
2. À l'intérieur de la fonction de rappel, le code commence par utiliser le mot-clé "await" pour attendre
que la fonction "[Link]({})" soit exécutée. Cette fonction est utilisée pour rechercher des
documents dans une base de données, probablement une base de données MongoDB, en utilisant
un modèle de données appelé "produit". Le paramètre vide {} signifie qu'il recherche tous les
documents dans la collection "produit".
3. Une fois que la recherche est terminée et que les données sont récupérées depuis la base de
données, les données sont stockées dans la variable "data".
4. Ensuite, la réponse est envoyée au client en utilisant la méthode "[Link](data)". Cela envoie les
données récupérées en tant que réponse JSON au client qui a effectué la requête.
5. Si une erreur se produit lors de la recherche des données dans la base de données, l'erreur est
capturée par le bloc catch et affichée dans la console en utilisant "[Link](error)".
En résumé, cette route répond à une requête GET à l'adresse racine ("/") de l'application. Elle effectue
une recherche dans la base de données pour récupérer tous les documents de la collection "produit"
et renvoie ces données en tant que réponse JSON au client. Si une erreur se produit, elle est affichée
dans la console.
Etape 8 :
Route POST pour Ajouter les Produits :
//-----------------------------POST-----------------------------
[Link]("/data", async (req, res, next) => {
try {
const { nom, prix } = [Link];
let Newproduit = new produit({ nom, prix });
let saved = await [Link]();
[Link](201).send(saved);
} catch (error) {
[Link](error);
}
});
//------------------------------------------------------
C’est une autre route définie dans une application web utilisant [Link]. Cette fois, il s'agit d'une
route configurée pour la méthode HTTP POST à l'adresse "/data" de l'application. Voici une
explication étape par étape :
1. Lorsqu'une requête POST est reçue à l'adresse "/data", la fonction de rappel asynchrone est
exécutée.
2. À l'intérieur de la fonction de rappel, le code commence par extraire les valeurs des champs "nom"
et "prix" du corps de la requête. Cela est fait en utilisant la syntaxe de décomposition
(destructuring) de l'objet "[Link]". Le corps de la requête contient généralement les données
envoyées par le client dans une requête POST.
3. Ensuite, une nouvelle instance du modèle "produit" est créée en utilisant les valeurs extraites du
corps de la requête. Le modèle "produit" est probablement lié à une base de données, comme
MongoDB, et représente la structure des documents dans cette base de données.
4. Ensuite, la méthode "save()" est appelée sur la nouvelle instance "Newproduit" pour enregistrer les
données dans la base de données. Cette méthode renvoie une promesse, donc le mot-clé "await"
est utilisé pour attendre la résolution de la promesse et stocker le résultat dans la variable "saved".
5. Ensuite, la réponse est envoyée au client avec le statut HTTP 201 (Created) en utilisant la méthode
"[Link](201).send(saved)". Cela renvoie l'objet "saved" en tant que réponse au client.
6. Si une erreur se produit lors de la création et de l'enregistrement du produit dans la base de
données, l'erreur est capturée par le bloc catch et affichée dans la console en utilisant
"[Link](error)".
En résumé, cette route répond à une requête POST à l'adresse "/data" de l'application. Elle extrait
les valeurs des champs "nom" et "prix" du corps de la requête, crée une nouvelle instance du
modèle "produit" avec ces valeurs, enregistre cette instance dans la base de données, puis renvoie
l'objet enregistré en tant que réponse JSON avec le statut HTTP 201 au client. Si une erreur se
produit, elle est affichée dans la console.
Etape 9 :
Route PUT pour Modifier un Produits :
//-----------------------------PUT-----------------------------
[Link]("/data/:id", async (req, res, next) => {
try {
let updateproduit = await
[Link]([Link],[Link],{new:true});
[Link](updateproduit);
} catch (error) {
[Link](error);
}
});
//------------------------------------------------------
Ce code représente une route d'API utilisant le framework [Link], qui gère une requête HTTP
PUT pour mettre à jour une ressource spécifique identifiée par son ID.
Voici une explication étape par étape du code :
1. La route est définie avec [Link]("/data/:id", ...), ce qui signifie que cette route répondra
aux requêtes HTTP PUT envoyées à l'URL "/data/:id", où ":id" est un paramètre dynamique qui
représente l'ID de la ressource à mettre à jour.
2. L'argument async (req, res, next) => {...} est une fonction asynchrone qui sera exécutée
lorsque la route sera atteinte. Les paramètres req, res, et next représentent respectivement l'objet
de requête (request), l'objet de réponse (response) et la fonction suivante à appeler dans le
middleware.
3. À l'intérieur du bloc try {...}, le code commence par appeler await
[Link]([Link], [Link], {new:true}). Cela utilise le modèle
produit (probablement une classe ou un schéma de base de données) pour trouver et mettre à
jour la ressource correspondante à l'ID fourni dans les paramètres de la requête. [Link]
représente l'ID extrait de l'URL de la requête. [Link] contient les données envoyées dans le
corps (body) de la requête, qui sont utilisées pour mettre à jour la ressource.
4. L'option {new:true} indique à Mongoose (bibliothèque d'accès aux bases de données MongoDB)
de renvoyer la version mise à jour de la ressource après la mise à jour.
5. Une fois la mise à jour effectuée, le résultat est stocké dans la variable updateproduit.
6. Ensuite, [Link](updateproduit) est utilisé pour envoyer la réponse HTTP en format JSON
contenant la ressource mise à jour en tant que corps de réponse.
7. Si une erreur se produit lors de l'exécution du bloc try, elle est capturée par le bloc catch
(error) {...}. Dans cet exemple, l'erreur est simplement affichée dans la console avec
[Link](error).
Cela résume le fonctionnement de ce code, qui met à jour une ressource spécifique dans une base
de données à l'aide d'une requête HTTP PUT et renvoie la version mise à jour de la ressource en
réponse.
Etape 10 :
Route DELETE pour Supprimer un Produits :
//-----------------------------DELETE-----------------------------
[Link]("/data/:id", async (req, res, next) => {
try {
let deleteproduit = await [Link]([Link]);
[Link](deleteproduit);
} catch (error) {
[Link](error);
}
});
//------------------------------------------------------
Le code que vous avez fourni est une route d'API utilisant Express, un framework [Link] pour la
création d'applications web. Cette route est configurée pour gérer les requêtes de suppression de
données à partir d'un endpoint spécifique.
Voici une explication ligne par ligne du code :
1. [Link]("/data/:id", async (req, res, next) => {: Cela définit une route de
suppression (méthode DELETE) avec le chemin "/data/:id". Le :id est un paramètre dynamique
dans l'URL qui représente l'identifiant unique de l'élément de données à supprimer.
2. try {: Le code est enveloppé dans un bloc try-catch pour gérer les erreurs potentielles de manière
appropriée.
3. let deleteproduit = await [Link]([Link]);: Dans cette ligne,
la méthode findByIdAndRemove est utilisée pour trouver et supprimer un document dans la base
de données. [Link] récupère la valeur de l'ID de la requête HTTP et est utilisée pour
spécifier l'élément de données à supprimer. Cette opération est asynchrone, donc le mot-clé await
est utilisé pour attendre que la suppression soit terminée avant de continuer.
4. [Link](deleteproduit);: Une fois que la suppression est terminée, la réponse est renvoyée
sous forme de JSON en utilisant la méthode [Link](). Cela renvoie l'objet deleteproduit qui
représente le document supprimé de la base de données.
5. } catch (error) {: Si une erreur se produit lors de la suppression, elle est capturée par le bloc
catch et l'erreur est affichée dans la console à l'aide de [Link](error).
En résumé, cette route d'API est utilisée pour supprimer un élément de données spécifique de la
base de données en utilisant l'ID fourni dans l'URL de la requête. Une fois que l'élément est
supprimé, la réponse renvoie l'objet supprimé en tant que JSON.
Etape 11 :
Recherche par query string :
//---------------------------Recherche par GET-------------------------------
[Link]("/data", async (req, res) => {
try {
// let data = await [Link]({ nom: [Link] });
let data = await [Link]([Link]).limit(2);
[Link](data);
} catch (error) {
[Link](error);
}
});
//----------------------------------------------------------
Ce code représente une route dans une application web utilisant un framework ou une bibliothèque
comme [Link]. La route est configurée pour l'URL "/data" et utilise la méthode HTTP GET.
Lorsqu'un utilisateur effectue une requête GET vers cette URL, la fonction callback associée sera
exécutée.
La fonction callback utilise une fonction asynchrone, ce qui permet d'effectuer des opérations
asynchrones telles que des appels à une base de données sans bloquer le thread principal. Elle est
définie avec les paramètres req (pour la requête) et res (pour la réponse).
À l'intérieur de la fonction callback, le code est enveloppé dans un bloc try-catch pour gérer les
erreurs potentielles. Si une erreur se produit, elle sera capturée et affichée dans la console.
Le code commenté // let data = await [Link]({ nom: [Link] }); semble être
une ligne précédente qui a été mise en commentaire. Cela suggère que la recherche dans la
collection "produit" était précédemment basée sur le champ "nom" spécifié dans le paramètre de
requête "nom". Cependant, cette ligne a été remplacée par la ligne suivante.
La ligne suivante let data = await [Link]([Link]).limit(2); effectue une recherche
dans la collection "produit" en utilisant les paramètres de requête fournis. Les paramètres de requête
sont accessibles via [Link], qui est un objet contenant les clés et les valeurs des paramètres de
requête.
La méthode find() est utilisée pour rechercher des documents dans la collection "produit". En
utilisant [Link] comme argument, elle récupère les paramètres de requête et les utilise comme
critères de recherche. Par exemple, si la requête GET contient "?nom=produit1&prix=10", la
méthode find() recherchera les documents ayant le champ "nom" égal à "produit1" et le champ
"prix" égal à 10.
La méthode limit(2) est utilisée pour limiter le nombre de documents renvoyés à 2. Cela signifie
que seuls les deux premiers documents correspondants seront renvoyés dans la réponse.
Enfin, la réponse est renvoyée au client sous forme de JSON en utilisant la méthode [Link](data).
"data" contient les documents correspondants récupérés à partir de la base de données.
====================================================================================
Ajout de l’extension(Thunder Client) équivalent a Postman :
-Installation
Utilisation
====================================================================================