Dans ce tutoriel, nous allons construire une API REST en utilisant Node.js avec la base de données MongoDB.
Qu’est-ce qu’une API ?
API est l’acronyme de Application Programming Interface (interface de programmation d’applications), qui est un intermédiaire logiciel permettant à deux applications de communiquer entre elles. Chaque fois que vous utilisez une application comme Facebook, envoyez un message instantané ou consultez la météo sur votre téléphone, vous utilisez une API.
Prérequis pour le tutoriel :
- Nodejs installé dans votre système
- Connaissance de base de JavaScript
- Compréhension de toute base de données (relationnelle/non relationnelle)
Ne vous inquiétez pas ! Si vous ne connaissez pas tous ces éléments au premier rang, vous les apprendrez tous dans ce tutoriel.
1. Configuration du projet
Ici, j’utilise VS code comme éditeur de code et MongoDB atlas pour stocker toutes les données. La structure entière du projet devrait ressembler à ceci :
Créez un dossier dans votre système et nommez-le « API ». Vous pouvez le nommer comme vous le souhaitez. Ouvrez ce dossier dans votre éditeur de code et allez dans le terminal.
Dans votre terminal, tapez
npm init
La commande npm init va initialiser un projet et créer le fichier package.json.
Après cela, nous devons installer Express.js et toutes les autres dépendances pour le projet.
Encore une fois, tapez ce qui suit dans le terminal :
npm install express dotenv mongoose body-parser cors
Ainsi, express s’occupera de notre serveur.
dotenv vous permet de séparer les secrets de votre code source.
Mongoose est une bibliothèque de modélisation des données d’objets (ODM) pour MongoDB et Node.js. Elle gère les relations entre les données, fournit une validation de schéma et est utilisée pour traduire les objets dans le code et la représentation de ces objets dans MongoDB.
Le module body-parser analyse les données codées JSON, buffer, string et URL soumises à l’aide d’une requête HTTP POST. CORS est l’abréviation de Cross-Origin Resource Sharing (partage de ressources entre origines). Il nous permet de relâcher la sécurité appliquée à une API.
Et maintenant nous allons installer nodemon, donc tapez dans le terminal :
npm install -g nodemon
Le module nodemon est un module qui développe des applications basées sur node.js en redémarrant automatiquement l’application node lorsque des changements de fichiers dans le répertoire sont détectés.
Après l’installation, ajoutez ce qui suit dans la section script de votre fichier package.json :
"scripts": {
"start": "nodemon server.js"
},
2. Configuration du serveur
Créons notre tout premier serveur. Créez un fichier nommé server.js et écrivez ce code :
require('dotent').config();
const express = require('express');
const app = express();
const bodyParser = require('body-parser')
const cors = require('cors');
const PORT = process.env.PORT || 6666 ;
const todoRoutes = require('./routes/todo');
// database connection
require('./config/database');
app.use(cors());
app.use(bodyParser.urlencoded({extended: true}));
// routes
app.use('/api/todos', todoRoutes);
// server running status
app.listen(PORT, () => {
// eslint-disable-next-line no-console
console.log(`The app listening at http://localhost: ${PORT}`)
});
Créez un fichier nommé « .env » et mettez ce code dedans:
PORT=7777 MONGO_URL="mongodb+srv://<USERNAME>:<PASSWORD>@cluster0.dlkzt.mongodb.net/<DATABASE>?retryWrites=true&w=majority"
Ici, nous avons ajouté un numéro de port et l’URL de connexion MongoDB. Laissez-moi vous dire comment vous pouvez obtenir l’URL de MongoDB en premier lieu.
3. Configuration de la base de données
Allez sur MongoDB Atlas et créez un cluster, cela peut prendre quelques minutes à configurer. Après cela, cliquez sur Connecter, puis sur Connecter votre application. Vous obtiendrez alors votre URL de connexion MongoDB.
Vous aller pouvoir créer le fichier config/database.js avec le code suivant
// Import the mongoose module
const mongoose = require('mongoose');
// Set up default mongoose connection
const mongoDB = process.env.MONGO_URL || null;
mongoose.connect(mongoDB, {
useNewUrlParser: true,
useUnifiedTopology: true,
});
// Get the default connection
var db = mongoose.connection;
//Bind connection to error event (to get notification of connection errors)
// eslint-disable-next-line no-console
db.on('error', console.error.bind(console, 'MongoDB connection error:'));
4. Configuration du modèle
Pour chaque donnée dans la base de données, nous avons besoin d’un modèle par lequel nous pouvons télécharger et maintenir les données appropriées. Ici, nous utilisons Mongoose pour créer le modèle de la base de données.
const mongoose = require( 'mongoose')
const Todos = mongoose.model( 'Todos', {
todo: {
type: String,
},
time : {
type : Date,
default: Date.now,
},
})
module.exports = { Todos }
5. Configuration des routes
Créez un dossier nommé routes dans le répertoire principal, créez un fichier nommé todo.js où toutes les routes seront établies. Maintenant ces lignes à votre fichier todo.js dans le dossier routes :
const express = require( 'express');
const router = express.Router();
// Require controller modules.
const todoControllers = require('../controllers/todoControllers')
router.get('/', todoControllers.index);
router.post('/', todoControllers.insert);
router.put('/:id', todoControllers.update);
router.delete('/:id', todoControllers.delete);
module.exports = router;
Dans ce fichier, nous avons créé 4 routes pour obtenir la liste de tous les todo, créer un todo, mettre à jour un todo spécifique, et en supprimer un. Toute la logique de l’entreprise va aller dans la section contrôleur.
Chaque requête entrante sera dirigée vers des méthodes spécifiques du contrôleur.
6. Configuration des contrôleurs
Un contrôleur est la partie principale de l’application où toute votre logique métier résidera. Nous avons besoin de blocs logiques spécifiques pour différentes méthodes.
/* eslint-disable no-console */
var { Todos } = require('../models/todoModel');
var ObjectID = require( 'mongoose'). Types.ObjectId;
exports.index = (req, res ) => {
Todos.find((err, docs) => {
if (!err) {
res.send(docs)
} else {
res.status(500).send(err)
}
})
};
exports.searchById = (req, res) => {
const id = req.params.id;
res.send(`Id found : ${id}`);
}
exports.insert = (req, res ) => {
const todoItem = req.body.todo;
const newTodos = new Todos({todo: todoItem});
newTodos.save((err, docs) => {
if (!err) {
res.status(201).send(docs)
} else {
res.status(500).send(err)
}
});
}
exports.update = (req, res) => {
const id = req.params.id;
console.log(`update with given id: ${id}`);
if(!ObjectID.isValid(id)){
return res.send(400).send(`No record with given id: ${id}`)
}
const todoItem = req.body.todo;
const newTodo = {
todo: todoItem
};
Todos.findByIdAndUpdate(id, {$set: newTodo},{new: true},(err,docs )=>{
if(!err){
res.status(200).send(docs)
} else {
console.log('Error while updating the data' + JSON.stringify(err, undefined, 2))
}
})
}
exports.delete = (req, res ) => {
const id = req.params.id;
if (!ObjectID.isValid(id)) {
return res.send(400).send(`No record with given id: ${id}`)
}
Todos.findByIdAndRemove(id, (err, docs) => {
const result = {
data: docs,
message: 'Todo has been removed successfully.',
status: 200,
}
if (!err) {
res.status(200).send(result)
} else {
res.status(500).send(err)
}
})
}
Ainsi, de cette façon, nous sommes prêts avec les points de terminaison de l’API. Maintenant, la partie la plus cruciale est celle où nous allons tester les APIs. Avant cela, ouvrez votre terminal et exécutez npm start pour démarrer votre application.
7. Postman
Pour les tests d’API, nous utilisons Postman. Vous pouvez télécharger la version de bureau ou l’utiliser dans le navigateur.
8. Test API :
(a). Insérer tâche :
Url : http://localhost:3000/api/todos/
Méthode : POST
Cela signifie que les données ont été insérées avec succès. Si vous voulez toujours le vérifier à partir de la base de données, vous trouverez ceci :
(b) liste des tâches:
Url: http://localhost:3000/api/todos/
Method: GET
De cette façon, nous pouvons obtenir toute la liste des tâches à accomplir.
(c) Mise à jour d’une tâche spécifique:
Url: http://localhost:3000/api/todos/61de2036a402007b4350de07
Method: PUT
Vous devez passer l’identifiant spécifique à la fin de l’URL et passer la valeur mise à jour de la tâche dans les données du formulaire.
(d) Supprimer une tâche spécifique :
Url: http://localhost:3000/api/todos/delete/61de2036a402007b4350de07
Méthode : DELETE
De la même manière que l’API de mise à jour fonctionne, nous devons passer l’ID spécifique à la fin de l’URL et utiliser la méthode delete.
Conclusion
Alors voilà. Nous avons réussi à créer une API REST en utilisant Node.js, Express.js et MongoDB. Nous espérons que ce tutoriel vous aidera à comprendre le concept de base derrière chaque API REST.
Voici le repos github pour les besoins de cet article : github.com/alfreddagenais/kilukru-dev-api-rest-nodejs-express-mongo
Merci beaucoup d’avoir lu jusqu’à la fin. Vous pouvez me contacter si vous avez besoin d’aide.
