Connexion à une base de données MongoDB avec le module mongodb ou Mongoose

Node.js et MongoDB : une alliance naturelle pour les donnees flexibles

MongoDB est une base de données NoSQL orientée document extrêmement populaire dans l'écosystème Node.js. Sa flexibilité schématique et son utilisation de documents BSON (Binary JSON), très similaires au JSON natif de JavaScript, en font un choix naturel pour de nombreuses applications Node.js, en particulier celles nécessitant un développement rapide, une scalabilité horizontale et la gestion de données semi-structurées.

Pour interagir avec une base de données MongoDB depuis votre application Node.js, vous avez principalement deux approches, chacune avec ses avantages :

1. Le pilote natif MongoDB (`mongodb`) : Fourni officiellement par MongoDB, ce module offre un accès direct et de bas niveau aux fonctionnalités de la base de données. Il donne un contrôle total mais demande plus de code pour les opérations courantes.
2. Mongoose : Un ODM (Object-Document Mapper) construit au-dessus du pilote natif. Mongoose ajoute une couche d'abstraction qui facilite grandement la modélisation des données (schémas), la validation, l'exécution de requêtes et la gestion des relations entre documents. Il est extrêmement populaire et souvent préféré pour les applications structurées.

Ce chapitre explore comment établir une connexion à MongoDB en utilisant ces deux méthodes.

Installation des dependances

Avant de pouvoir vous connecter, vous devez installer le package approprié via npm ou Yarn. Choisissez l'une des deux options (ou les deux si vous voulez expérimenter) :

Option 1 : Installer le pilote natif (`mongodb`)

npm install mongodb

Ou avec Yarn :

yarn add mongodb

Option 2 : Installer Mongoose (qui inclut le pilote natif)

npm install mongoose

Ou avec Yarn :

yarn add mongoose

Si vous installez Mongoose, vous n'avez pas besoin d'installer `mongodb` séparément, car Mongoose s'en charge en tant que dépendance.

Methode 1 : Connexion avec le pilote natif (`mongodb`)

Le pilote natif utilise principalement la classe `MongoClient` pour gérer les connexions. L'approche moderne consiste à créer une instance du client puis à appeler sa méthode `connect()`, qui retourne une Promesse.

La connexion nécessite une chaîne de connexion URI MongoDB qui spécifie l'hôte, le port, potentiellement les informations d'authentification, et la base de données cible.

Exemple de connexion de base avec `async/await` :

const { MongoClient } = require('mongodb');

// URI de connexion MongoDB
// !! Utiliser des variables d'environnement en production !!
const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017'; 
const dbName = process.env.DB_NAME || 'maBaseDeDonnees';

// Créer une instance du client
// Les options peuvent inclure useNewUrlParser: true, useUnifiedTopology: true (souvent par défaut maintenant)
const client = new MongoClient(uri);

async function run() {
  try {
    // Se connecter au serveur MongoDB
    await client.connect();
    console.log('Connecté avec succès au serveur MongoDB (pilote natif) !');

    // Sélectionner la base de données
    const db = client.db(dbName);
    console.log(`Connecté à la base de données: ${db.databaseName}`);

    // A partir d'ici, vous pouvez interagir avec les collections
    // Exemple: const collection = db.collection('documents');
    // const findResult = await collection.find({}).toArray();
    // console.log('Documents trouvés:', findResult);

  } catch (err) {
    console.error('Erreur de connexion ou d\'opération MongoDB:', err);
  } finally {
    // S'assurer que le client sera fermé lorsque vous aurez terminé / en cas d'erreur
    // Dans une application serveur, la fermeture se fait généralement à l'arrêt de l'application
    await client.close();
    console.log('Connexion MongoDB fermée.');
  }
}

// Exécuter la fonction de connexion/test
run().catch(console.dir);

Points clés avec le pilote natif :

• Vous gérez explicitement l'objet `client`.
• Vous devez sélectionner la base de données avec `client.db(dbName)`.
• Vous interagissez directement avec les collections via `db.collection('nomCollection')`.
• Le pilote gère un pool de connexions interne par défaut, vous n'avez généralement pas besoin de le gérer manuellement pour les requêtes.
• Il est crucial de fermer la connexion (`client.close()`) lorsque l'application se termine proprement pour libérer les ressources.

Methode 2 : Connexion avec Mongoose

Mongoose simplifie considérablement le processus de connexion et la gestion de l'état de la connexion. Il utilise une approche souvent de type singleton pour la connexion par défaut.

La méthode principale est `mongoose.connect()`, qui prend également l'URI de connexion MongoDB en argument et retourne une Promesse.

Exemple de connexion de base avec Mongoose :

const mongoose = require('mongoose');

// URI de connexion MongoDB
// !! Utiliser des variables d'environnement en production !!
const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017/maBaseDeDonneesMongoose'; 
// Note: On peut inclure le nom de la DB directement dans l'URI avec Mongoose

async function connectDB() {
  try {
    // Se connecter à MongoDB
    // Les options comme useNewUrlParser, useUnifiedTopology sont souvent gérées par défaut
    // dans les versions récentes de Mongoose.
    await mongoose.connect(uri);

    console.log('Connecté avec succès à MongoDB via Mongoose !');

    // Mongoose gère la connexion par défaut. Pas besoin de récupérer db/client explicitement ici.
    // Les modèles Mongoose utiliseront cette connexion par défaut pour interagir avec la base.

  } catch (error) {
    console.error('Erreur de connexion Mongoose:', error);
    process.exit(1); // Arrêter l'application si la connexion échoue
  }
}

// Gérer les événements de connexion (optionnel mais recommandé)
mongoose.connection.on('connected', () => {
  console.log('Mongoose connecté à la base de données.');
});

mongoose.connection.on('error', (err) => {
  console.error('Erreur de connexion Mongoose après connexion initiale:', err);
});

mongoose.connection.on('disconnected', () => {
  console.log('Mongoose déconnecté.');
});

// Fonction pour fermer la connexion Mongoose proprement
async function closeDB() {
  await mongoose.disconnect();
}

// Appeler connectDB() au démarrage de l'application
connectDB();

// Enregistrer un gestionnaire pour fermer la connexion lors de l'arrêt
process.on('SIGINT', async () => {
  await closeDB();
  console.log('Application arrêtée.');
  process.exit(0);
});

// Exportez connectDB ou utilisez directement Mongoose ailleurs si besoin
// module.exports = { connectDB, closeDB };

Points clés avec Mongoose :

• La connexion est généralement plus simple (`mongoose.connect`).
• Mongoose gère la connexion par défaut pour vous (vous n'interagissez pas directement avec le client ou l'objet db pour les opérations via modèles).
• Il est recommandé d'écouter les événements de connexion (`connected`, `error`, `disconnected`) pour surveiller l'état de la connexion.
• La fermeture se fait via `mongoose.disconnect()`.
• Le principal avantage vient après la connexion : la définition de schémas, de modèles, la validation intégrée, les middlewares Mongoose, et une API de requêtes plus riche.

Comprendre les chaines de connexion URI MongoDB

Que vous utilisiez le pilote natif ou Mongoose, vous aurez besoin d'une chaîne de connexion URI. Son format de base est :

mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[database][?options]]

• mongodb:// : Le préfixe obligatoire.
• [username:password@] : (Optionnel) Identifiants si l'authentification est activée. Encodez les caractères spéciaux dans le mot de passe.
• host1[:port1],... : L'adresse du serveur ou des serveurs MongoDB. Pour un cluster replica set, listez plusieurs membres. Le port par défaut est 27017.
• /[database] : (Optionnel) Le nom de la base de données à utiliser par défaut. Peut être spécifié ici ou via `client.db()` (pilote natif) ou dans les options Mongoose.
• [?options] : (Optionnel) Paramètres de connexion supplémentaires (ex: `replicaSet=myReplSet`, `authSource=admin`, `retryWrites=true&w=majority`).

Pour les déploiements sur MongoDB Atlas (le service cloud), vous utiliserez souvent le format `mongodb+srv://` qui simplifie la connexion aux clusters en utilisant les enregistrements DNS SRV pour découvrir les membres du replica set :

mongodb+srv://[username:password@]clusterhost/[database][?options]

Encore une fois, stockez ces URI de manière sécurisée (variables d'environnement) et non directement dans votre code.

Conclusion : choisir l'outil adapte

Se connecter à MongoDB depuis Node.js est une étape fondamentale. Le pilote natif (`mongodb`) offre un contrôle direct et est parfait si vous préférez une interaction de bas niveau ou si vous n'avez pas besoin des abstractions supplémentaires.

Mongoose, quant à lui, est souvent le choix privilégié pour les applications nécessitant une structure de données plus définie, des validations et une API de requêtes plus orientée objet. Il simplifie de nombreuses tâches courantes au prix d'une légère couche d'abstraction supplémentaire.

Le choix dépendra de la complexité de votre application et de vos préférences personnelles. Dans les deux cas, une gestion sécurisée des identifiants et une bonne gestion des erreurs de connexion sont essentielles. Une fois la connexion établie, vous êtes prêt à effectuer des opérations CRUD sur vos données MongoDB.