Express avec MongoDB : guide pratique

Pourquoi Express avec MongoDB : guide pratique ?

Au quotidien, un développeur peut être confronté à divers besoins qui nécessitent une combinaison de technologies robustes et performantes. L'utilisation d'Express.js et MongoDB est une solution idéale pour créer des applications backend efficaces et scalables.

Le contexte réel implique que de nombreuses entreprises utilisent Express.js comme framework pour construire des API RESTful, tandis qu'ils stockent les données dans MongoDB, un système de base de données NoSQL flexible et performant.

Un cas d'utilisation concret serait la création d'une application de gestion de tâches, où chaque utilisateur peut créer, mettre à jour, supprimer et afficher ses tâches. Cela nécessite une API RESTful pour gérer les données côté serveur et MongoDB pour stocker ces tâches de manière distribuée et scalable.

Prerequis

• Connaissance des bases de JavaScript ES6+
• Familiarité avec la programmation asynchrone (async/await)
• Installation de Node.js (version recommandée : 14.x ou ultérieure)
• MongoDB installé et en cours d'exécution

Concepts fondamentaux

Express.js

Express.js est un framework minimaliste pour construire des applications web et les API. Il offre une structure robuste autour du Router, de la gestion des requêtes HTTP et des middleware.

// 👇 Importer express
const express = require('express');

// 👇 Créer une application express
const app = express();

// 👇 Définir un routeur pour les tâches
app.get('/tasks', (req, res) => {
  // 👇 Renvoyer une réponse JSON
  res.json({ tasks: [] });
});

// 👇 Démarrer le serveur sur le port 3000
app.listen(3000, () => {
  console.log('Serveur démarré sur http://localhost:3000');
});

MongoDB

MongoDB est une base de données NoSQL qui utilise des documents JSON pour stocker les données. Elle offre une flexibilité et une performance élevées.

// 👇 Importer mongoose (ORM pour MongoDB)
const mongoose = require('mongoose');

// 👇 Connexion à la base de données
mongoose.connect('mongodb://localhost:27017/task-manager', {
  useNewUrlParser: true,
  useUnifiedTopology: true
}).then(() => {
  console.log('Connexion réussie à MongoDB');
}).catch(err => {
  console.error('Erreur de connexion à MongoDB:', err);
});

Middleware

Le middleware est une fonction qui a accès aux objets request (req), response (res) et la chaîne de middleware suivante dans le cycle de requête-réponse d'Express. Les middlewares peuvent être utilisés pour effectuer diverses tâches comme la validation des données, l'autentification, etc.

// 👇 Middleware simple pour logger les requêtes
app.use((req, res, next) => {
  console.log(`Requête reçue: ${req.method} ${req.url}`);
  next();
});

Schémas et Modèles Mongoose

Mongoose est un ORM pour MongoDB qui facilite la création de schémas et le mapping entre les documents JSON et les objets JavaScript.

// 👇 Importer mongoose
const mongoose = require('mongoose');

// 👇 Définir un schema pour les tâches
const taskSchema = new mongoose.Schema({
  title: String,
  description: String,
  completed: Boolean
});

// 👇 Créer un modèle basé sur le schéma
const Task = mongoose.model('Task', taskSchema);

Mise en pratique : projet fil rouge

Étape 1 : Initialisation du projet

## 👇 Créer un nouveau dossier pour le projet et y naviguer
mkdir express-mongo-todo && cd express-mongo-todo

## 👇 Initialiser un nouveau projet Node.js
npm init -y

## 👇 Installer les dépendances nécessaires
npm install express mongoose body-parser cors dotenv

Créer un fichier .env pour stocker les variables d'environnement :

DB_HOST=mongodb://localhost:27017
DB_NAME=task-manager
PORT=3000

Étape 2 : Configuration de l'application

Créez un fichier app.js avec le contenu suivant :

// 👇 Importer les modules nécessaires
const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');
const cors = require('cors');

// 👇 Charger les variables d'environnement
require('dotenv').config();

// 👇 Créer une application express
const app = express();

// 👇 Middleware de configuration
app.use(bodyParser.json());
app.use(cors());

// 👇 Connexion à la base de données MongoDB
mongoose.connect(`${process.env.DB_HOST}/${process.env.DB_NAME}`, {
  useNewUrlParser: true,
  useUnifiedTopology: true
}).then(() => {
  console.log('Connexion réussie à MongoDB');
}).catch(err => {
  console.error('Erreur de connexion à MongoDB:', err);
});

// 👇 Définir un routeur pour les tâches
app.get('/tasks', async (req, res) => {
  try {
    const tasks = await Task.find();
    res.json(tasks);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 👇 Définir un routeur pour créer une tâche
app.post('/tasks', async (req, res) => {
  const task = new Task(req.body);
  try {
    await task.save();
    res.status(201).json(task);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 👇 Démarrer le serveur sur le port défini
app.listen(process.env.PORT, () => {
  console.log(`Serveur démarré sur http://localhost:${process.env.PORT}`);
});

Étape 3 : Création du modèle de données

Créez un fichier models/Task.js avec le contenu suivant :

// 👇 Importer mongoose
const mongoose = require('mongoose');

// 👇 Définir un schema pour les tâches
const taskSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true
  },
  description: {
    type: String,
    required: true
  },
  completed: {
    type: Boolean,
    default: false
  }
});

// 👇 Créer un modèle basé sur le schéma
const Task = mongoose.model('Task', taskSchema);

module.exports = Task;

Étape 4 : Tester l'application

Démarrez votre application en utilisant la commande suivante :

node app.js

Ouvrez votre navigateur et allez à http://localhost:3000/tasks pour voir la liste des tâches.

Erreurs frequentes et debugging

Erreur 1 : Connection échouée

Code incorrect :

mongoose.connect('mongodb://localhost:27017/task-manager', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

Correction :

mongoose.connect(`${process.env.DB_HOST}/${process.env.DB_NAME}`, {
  useNewUrlParser: true,
  useUnifiedTopology: true
}).then(() => {
  console.log('Connexion réussie à MongoDB');
}).catch(err => {
  console.error('Erreur de connexion à MongoDB:', err);
});

Erreur 2 : Middleware d'authentification manquant

Code incorrect :

app.use(cors());

Correction :

const cors = require('cors');

app.use(cors({
  origin: 'http://localhost:3000'
}));

Erreur 3 : Route non trouvée

Code incorrect :

app.get('/tasks', async (req, res) => {
  const tasks = await Task.find();
  res.json(tasks);
});

Correction :

app.get('/tasks', async (req, res) => {
  try {
    const tasks = await Task.find();
    res.json(tasks);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

Pour aller plus loin

1. Ajout de fonctionnalités avancées

Vous pouvez ajouter des fonctionnalités comme la mise à jour et la suppression de tâches :

app.put('/tasks/:id', async (req, res) => {
  try {
    const task = await Task.findByIdAndUpdate(req.params.id, req.body, { new: true });
    res.json(task);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

app.delete('/tasks/:id', async (req, res) => {
  try {
    const task = await Task.findByIdAndDelete(req.params.id);
    res.json(task);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

2. Utilisation de MongoDB Atlas

MongoDB Atlas est une solution de base de données cloud qui simplifie le déploiement et la gestion des bases de données MongoDB.

3. Ajout d'authentification JWT

Pour sécuriser votre API, vous pouvez utiliser l'authentification avec JSON Web Tokens (JWT).

Défi pratique :

Créez une application simple d'un chaton qui permet aux utilisateurs de s'inscrire et de se connecter en utilisant le système JWT. L'application doit offrir les fonctionnalités suivantes :

• Inscription
• Connexion
• Création, mise à jour et suppression de chats

Commencez par créer un nouveau projet avec Express.js et MongoDB, puis implémentez les routes nécessaires pour l'authentification et la gestion des chats.