Manipuler les Collections MongoDB avec Node.js

Étape 1 : Prérequis

Avant de commencer, assurez-vous d'avoir les outils suivants installés sur votre machine :

• Node.js : Téléchargez la dernière version depuis https://nodejs.org.
• MongoDB : Installez MongoDB Community Edition depuis https://www.mongodb.com/try/download/community.
• Un éditeur de code : Nous recommandons Visual Studio Code.

Créez un dossier pour votre projet et initialisez-le avec npm :

📋 Copier le code

mkdir nodejs-mongodb-tutorial
cd nodejs-mongodb-tutorial
npm init -y
    

Installez ensuite le module mongodb :

📋 Copier le code

npm install mongodb
    

Créer une Base de Données MongoDB avec Node.js

Mais avant de manipuler des collections, il est essentiel de créer une base de données MongoDB. Voici comment créer une base de données et l'utiliser dans vos applications Node.js.

1. Comprendre le Concept

Dans MongoDB, une base de données est un conteneur pour des collections (similaires aux tables dans MySQL). Une base de données peut contenir plusieurs collections, chacune stockant des documents JSON/BSON.

Une base de données est créée automatiquement lorsqu'elle est référencée pour la première fois et que des données y sont insérées. Donc généralement nous n'avons pas besoin de créer une base de données, mais si pour une raison ou une autre vous voulez la créer voici comment:

2. Étapes pour Créer une Base de Données

Pour créer une base de données MongoDB via Node.js, suivez ces étapes :

1. Se connecter au serveur MongoDB
2. Référencer ou créer la base de données
3. Insérer des données pour finaliser la création

3. Exemple de Code

Voici un exemple complet pour créer une base de données MongoDB nommée `myDatabase` :

📋 Copier le code

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

// Définir l'URL de connexion
const url = 'mongodb://localhost:27017'; // URL par défaut

// Fonction asynchrone pour créer une base de données
async function createDatabase() {
    const client = new MongoClient(url);
    try {
        await client.connect();
        console.log('Connexion réussie au serveur.');

        // Référencer ou créer la base de données
        const dbName = 'myDatabase';
        const db = client.db(dbName);

        // Insérer un document pour finaliser la création
        const collection = db.collection('testCollection');
        const result = await collection.insertOne({ message: 'Base de données créée avec succès !' });
        console.log(`Base de données "${dbName}" créée avec succès.`);
    } catch (error) {
        console.error('Erreur lors de la création de la base de données :', error);
    } finally {
        await client.close(); // Fermer la connexion
    }
}

createDatabase();
    

Explication du fonctionnement du code

Ce code en JavaScript utilise la bibliothèque mongodb pour interagir avec une base de données MongoDB.

Importation de MongoClient

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

Cette ligne importe la classe MongoClient de la bibliothèque mongodb. MongoClient est utilisé pour établir une connexion avec un serveur MongoDB.

Définition de l'URL de connexion

const url = 'mongodb://localhost:27017';

Cette ligne définit l'URL de connexion au serveur MongoDB. Dans ce cas, le serveur est hébergé localement sur le port 27017.

Fonction asynchrone pour créer une base de données

async function createDatabase() {
    // ...
}

Cette fonction est définie comme asynchrone (async) pour permettre l'utilisation de la syntaxe await pour gérer les promesses.

Étapes de création de la base de données

1. Connexion au serveur

const client = new MongoClient(url);
try {
    await client.connect();
    console.log('Connexion réussie au serveur.');

Cette section établit une connexion au serveur MongoDB en créant un objet MongoClient avec l'URL de connexion. La méthode connect() est appelée pour établir la connexion. La variable client est utilisée pour stocker l'objet de connexion.

2. Référencer ou créer la base de données

const dbName = 'myDatabase';
const db = client.db(dbName);

Cette section définit le nom de la base de données (dbName) et crée un objet de base de données (db) en appelant la méthode db() sur l'objet de connexion (client).

3. Insérer un document pour finaliser la création

const collection = db.collection('testCollection');
const result = await collection.insertOne({ message: 'Base de données créée avec succès !' });
console.log(`Base de données "${dbName}" créée avec succès.`);

Cette section crée une collection (testCollection) dans la base de données et insère un document ({ message: 'Base de données créée avec succès !' }) dans la collection. La méthode insertOne() est utilisée pour insérer le document.

4. Gestion des erreurs

catch (error) {
    console.error('Erreur lors de la création de la base de données :', error);
}

Cette section gère les erreurs qui pourraient survenir lors de la création de la base de données. Si une erreur est détectée, elle est affichée dans la console.

5. Fermer la connexion

finally {
    await client.close(); // Fermer la connexion
}

Cette section ferme la connexion au serveur MongoDB en appelant la méthode close() sur l'objet de connexion (client). La méthode finally est utilisée pour garantir que la connexion est fermée, même si une erreur est détectée.

Appel de la fonction

createDatabase();

Cette ligne appelle la fonction createDatabase() pour créer une base de données.

6. Bonnes Pratiques

• Nommez vos bases de données avec soin : Utilisez des noms significatifs et évitez les caractères spéciaux ou accentué (é è ....).
• Évitez de créer des bases de données vides : Une base de données ne sera pas réellement créée tant qu'elle ne contient aucune donnée.
• Gérez les erreurs : Toujours encapsuler vos opérations dans des blocs try-catch pour gérer les erreurs potentielles.

Conclusion

Créer une base de données MongoDB avec Node.js est simple et rapide grâce au driver officiel MongoDB. En suivant les étapes ci-dessus, vous pouvez facilement initialiser une nouvelle base de données et commencer à y ajouter des collections et des documents.

🚀 Prochaine étape : Maintenant que vous savez créer une base de données, découvrez comment manipuler ses collections pour stocker et interroger vos données.

Étape 2 : Connexion à MongoDB

Pour interagir avec MongoDB, commencez par importer le module mongodb et créer une connexion :

📋 Copier le code

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

const url = 'mongodb://localhost:27017';
const dbName = 'myDatabase';

const client = new MongoClient(url);

async function connectDB() {
    try {
        await client.connect();
        console.log('Connexion réussie au serveur');
        return client.db(dbName);
    } catch (error) {
        console.error('Erreur lors de la connexion :', error);
        throw error;
    }
}

module.exports = { connectDB, client };
    

2. Explication du Code

2.1 Importation du Module MongoDB

Nous importons MongoClient depuis le package mongodb pour établir la connexion.

2.2 Définition des Paramètres

• url : l'URL du serveur MongoDB (ici en local sur le port 27017).
• dbName : le nom de la base de données.

2.3 Connexion et Gestion des Erreurs

Nous utilisons une fonction asynchrone connectDB() qui :

• Établit la connexion avec await client.connect().
• Affiche un message en cas de succès.
• Retourne l'objet base de données avec client.db(dbName).
• Capture les erreurs et les affiche.

Mettez le script dans un ficher "app.js", pour tester la connexion executez le ficher en tapant le code suivant dans le terminal:

📋 Copier le code

node app.js
    

Si tout se passe bien, vous devriez voir le message "Connexion réussie au serveur".

Étape 3 : Créer une Collection

Une collection dans MongoDB est similaire à une table dans une base de données relationnelle. Voici comment créer une collection, modifier le code dans le fichier "app.js" comme suit :

📋 Copier le code

// Importation du module MongoClient de MongoDB
const { MongoClient } = require('mongodb');

// Définition de l'URL de connexion à MongoDB (serveur local)
const url = 'mongodb://localhost:27017';

// Nom de la base de données à utiliser
const dbName = 'myDatabase';

// Création d'une instance de MongoClient pour gérer la connexion
const client = new MongoClient(url);

/**
 * Fonction pour établir la connexion à la base de données MongoDB
 * @returns {Promise} Instance de la base de données connectée
 */
async function connectDB() {
    try {
        // Connexion au serveur MongoDB
        await client.connect();
        console.log('Connexion réussie au serveur MongoDB');

        // Retourne l'instance de la base de données
        return client.db(dbName);
    } catch (error) {
        // Gestion des erreurs de connexion
        console.error('Erreur lors de la connexion à MongoDB :', error);
        throw error;
    }
}

/**
 * Fonction principale pour gérer la connexion et la création de la collection
 */
async function main() {
    // Connexion à la base de données
    const db = await connectDB();

    try {
        // Accès à la collection "users" (elle sera créée automatiquement si elle n'existe pas)
        const collection = db.collection('users');
        console.log('Collection "users" prête à être utilisée.');
    } catch (error) {
        // Gestion des erreurs liées à la collection
        console.error('Erreur lors de la gestion de la collection :', error);
    } finally {
        // Fermeture de la connexion à MongoDB
        await client.close();
        console.log('Connexion à MongoDB fermée.');
    }
}

// Exécution de la fonction principale et gestion des erreurs globales
main().catch(console.error);

    

📌 Résultat attendu dans la console :

Connexion réussie au serveur MongoDB
Collection "users" prête à être utilisée.
Connexion à MongoDB fermée.

Étape 4 : Insérer des Documents

Les documents sont les unités de base dans MongoDB. Voici comment insérer des documents dans la collection "users" :

Pour inserer des données, modifier le code dans le fichier "app.js" comme suit :

📋 Copier le code

// Importation du module MongoClient de MongoDB
const { MongoClient } = require('mongodb');

// Définition de l'URL de connexion à MongoDB (serveur local)
const url = 'mongodb://localhost:27017';

// Nom de la base de données à utiliser
const dbName = 'myDatabase';

// Création d'une instance de MongoClient pour gérer la connexion
const client = new MongoClient(url);

/**
 * Fonction pour établir la connexion à la base de données MongoDB
 * @returns {Promise} Instance de la base de données connectée
 */
async function connectDB() {
    try {
        // Connexion au serveur MongoDB
        await client.connect();
        console.log('Connexion réussie au serveur MongoDB');

        // Retourne l'instance de la base de données
        return client.db(dbName);
    } catch (error) {
        // Gestion des erreurs de connexion
        console.error('Erreur lors de la connexion à MongoDB :', error);
        throw error;
    }
}

/**
 * Fonction principale pour gérer la connexion et la création de la collection
 */
async function main() {
    // Connexion à la base de données
    const db = await connectDB();

    try {
        // Accès à la collection "users" (elle sera créée automatiquement si elle n'existe pas)
        const collection = db.collection('users');
        console.log('Collection "users" prête à être utilisée.');

        // Insertion de plusieurs documents dans la collection "users"
        const result = await collection.insertMany([
            { name: 'Alice', age: 25, email: 'alice@example.com' },
            { name: 'Bob', age: 30, email: 'bob@example.com' },
            { name: 'Charlie', age: 22, email: 'charlie@example.com' }
        ]);

        console.log(`${result.insertedCount} documents insérés avec succès.`);
    } catch (error) {
        // Gestion des erreurs liées à la collection et à l'insertion des documents
        console.error('Erreur lors de la gestion de la collection ou de l\'insertion des documents :', error);
    } finally {
        // Fermeture de la connexion à MongoDB
        await client.close();
        console.log('Connexion à MongoDB fermée.');
    }
}

// Exécution de la fonction principale et gestion des erreurs globales
main().catch(console.error);

    

Étape 5 : Lire des Documents

Pour lire des documents depuis une collection, utilisez la méthode find() :

Pour lire des données, modifier le code dans le fichier "app.js" comme suit :

📋 Copier le code

// Importation du module MongoClient de MongoDB
const { MongoClient } = require('mongodb');

// Définition de l'URL de connexion à MongoDB (serveur local)
const url = 'mongodb://localhost:27017';

// Nom de la base de données à utiliser
const dbName = 'myDatabase';

// Création d'une instance de MongoClient pour gérer la connexion
const client = new MongoClient(url);

/**
 * Fonction pour établir la connexion à la base de données MongoDB
 * @returns {Promise} Instance de la base de données connectée
 */
async function connectDB() {
    try {
        // Connexion au serveur MongoDB
        await client.connect();
        console.log('Connexion réussie au serveur MongoDB');

        // Retourne l'instance de la base de données
        return client.db(dbName);
    } catch (error) {
        // Gestion des erreurs de connexion
        console.error('Erreur lors de la connexion à MongoDB :', error);
        throw error;
    }
}

/**
 * Fonction principale pour récupérer et afficher les utilisateurs
 */
async function main() {
    // Connexion à la base de données
    const db = await connectDB();

    try {
        // Accès à la collection "users"
        const collection = db.collection('users');
        console.log('Collection "users" trouvée.');

        // Récupération de tous les utilisateurs
        const users = await collection.find({}).toArray();

        // Vérifie si la collection contient des utilisateurs
        if (users.length > 0) {
            console.log('Liste des utilisateurs :', users);
        } else {
            console.log('Aucun utilisateur trouvé dans la collection.');
        }
    } catch (error) {
        // Gestion des erreurs lors de la lecture des données
        console.error('Erreur lors de la lecture des utilisateurs :', error);
    } finally {
        // Fermeture de la connexion à MongoDB
        await client.close();
        console.log('Connexion à MongoDB fermée.');
    }
}

// Exécution de la fonction principale et gestion des erreurs globales
main().catch(console.error);

    

📌 Résultat attendu dans la console :

✅ Si des utilisateurs existent :

✅ Connexion réussie au serveur MongoDB
✅ Collection "users" trouvée.
Liste des utilisateurs : [
  { _id: ObjectId("xxx"), name: 'Alice', age: 25, email: 'alice@example.com' },
  { _id: ObjectId("yyy"), name: 'Bob', age: 30, email: 'bob@example.com' },
  { _id: ObjectId("zzz"), name: 'Charlie', age: 22, email: 'charlie@example.com' }
]
Connexion à MongoDB fermée.

⚠️ Si aucun utilisateur n'existe :

✅ Connexion réussie au serveur MongoDB
✅ Collection "users" trouvée.
⚠️ Aucun utilisateur trouvé dans la collection.
🔒 Connexion à MongoDB fermée.

🚀 Ton code est maintenant optimisé pour uniquement lire et afficher les utilisateurs existants dans MongoDB ! 🎯

Vous pouvez également filtrer les résultats avec des critères spécifiques :

Pour se faire, modifier le code come suit:

📋 Copier le code

try {
	// Accès à la collection "users"
	const collection = db.collection('users');
	console.log('Collection "users" trouvée.');

	// Filtrage des utilisateurs ayant un âge supérieur à 24 ans
	const filteredUsers = await collection.find({ age: { $gt: 24 } }).toArray();

	// Vérifie si des utilisateurs correspondent au critère
	if (filteredUsers.length > 0) {
		console.log('Utilisateurs âgés de plus de 24 ans :', filteredUsers);
	} else {
		console.log('Aucun utilisateur trouvé avec un âge supérieur à 24 ans.');
	}

Étape 6 : Mettre à Jour des Documents

Pour modifier des documents existants, utilisez la méthode updateOne() ou updateMany() :

📋 Copier le code

try {
        // Accès à la collection "users"
        const collection = db.collection('users');
        console.log('Collection "users" trouvée.');

        // Mise à jour de l'utilisateur Alice (modification de son âge à 26 ans)
        const result = await collection.updateOne(
            { name: 'Alice' }, // Filtre : recherche Alice dans la collection
            { $set: { age: 26 } } // Mise à jour : modification de l'âge
        );

        // Vérification du résultat
        if (result.modifiedCount > 0) {
            console.log(`${result.modifiedCount} document(s) mis à jour.`);
        } else {
            console.log('Aucun document mis à jour. Alice est peut-être introuvable.');
        }
    } catch (error) {
        // Gestion des erreurs lors de la mise à jour
        console.error('Erreur lors de la mise à jour :', error);
    

Étape 7 : Supprimer des Documents

Pour supprimer des documents, utilisez la méthode deleteOne() ou deleteMany() :

📋 Copier le code

async function main() {
    // Connexion à la base de données
    const db = await connectDB();

    try {
        // Accès à la collection "users"
        const collection = db.collection('users');
        console.log('Collection "users" trouvée.');

        // Suppression d'un utilisateur nommé "Bob"
        const result = await collection.deleteOne({ name: 'Bob' });

        // Vérification du résultat
        if (result.deletedCount > 0) {
            console.log(`${result.deletedCount} document(s) supprimé(s).`);
        } else {
            console.log('Aucun document supprimé. Bob est peut-être introuvable.');
        }
    } catch (error) {
        // Gestion des erreurs lors de la suppression
        console.error('Erreur lors de la suppression :', error);
    } finally {
        // Fermeture de la connexion à MongoDB
        await client.close();
        console.log('Connexion à MongoDB fermée.');
    }
}
    

🔍 Explication du code :

Utilisation de deleteOne()

Supprime un seul document où name est "Bob".
Si plusieurs "Bob" existent, seul le premier trouvé est supprimé.
Vérification du résultat

Si un document est supprimé, affiche ✅ 1 document(s) supprimé(s).
Si Bob n'existe pas, affiche ⚠️ Aucun document supprimé..
Bonne gestion des erreurs et fermeture propre de la connexion.

Une Collection MongoDB est-elle l'Équivalent d'une Table MySQL ?

Une question que me posent plusieurs personnes. et dont voici ma réponse:

Oui, une collection MongoDB peut être considérée comme l'équivalent d'une table MySQL, mais il existe des différences fondamentales entre les deux concepts en raison de la nature différente des bases de données (NoSQL pour MongoDB et SQL pour MySQL). Voici une comparaison détaillée :

1. Définitions

• Collection MongoDB : Une collection est un ensemble de documents JSON/BSON stockés dans une base de données MongoDB. Les documents dans une même collection n'ont pas besoin d'avoir la même structure (schéma flexible).
• Table MySQL : Une table est un ensemble de lignes et de colonnes structurées dans une base de données relationnelle. Chaque ligne représente un enregistrement, et chaque colonne représente un attribut spécifique avec un type de données défini.

2. Schéma

MongoDB : Les collections sont schéma-less (sans schéma strict), ce qui signifie que chaque document dans une collection peut avoir une structure différente.

📋 Copier le code

{
    "name": "Alice",
    "age": 25,
    "email": "alice@example.com"
}
    

📋 Copier le code

{
    "name": "Bob",
    "age": 30
    // Pas de champ "email" ici
}
    

MySQL : Les tables ont un schéma strictement défini, où chaque ligne doit respecter la structure définie lors de la création de la table (nombre et types de colonnes fixes).

📋 Copier le code

CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    age INT,
    email VARCHAR(100)
);
    

3. Documents vs Lignes

MongoDB : Les données sont stockées sous forme de documents, qui sont similaires à des objets JSON. Chaque document est unique grâce à un identifiant _id automatiquement généré.

📋 Copier le code

{
    "_id": "64c8f9a7b1d8f2e3c4567890",
    "name": "Alice",
    "age": 25,
    "email": "alice@example.com"
}
    

MySQL : Les données sont stockées sous forme de lignes, où chaque ligne correspond à un enregistrement contenant des valeurs pour chaque colonne définie.

4. Relations

MongoDB : Les relations entre collections peuvent être gérées via des références (stocker l'ID d'un document dans un autre) ou des embeddings (inclusion directe de documents imbriqués).

📋 Copier le code

{
    "_id": "64c8f9a7b1d8f2e3c4567890",
    "name": "Alice",
    "orders": [
        { "product": "Laptop", "price": 1000 },
        { "product": "Phone", "price": 500 }
    ]
}
    

MySQL : Les relations entre tables sont généralement gérées via des jointures (JOINS), où les données sont liées à travers des clés primaires et étrangères.

📋 Copier le code

SELECT users.name, orders.product
FROM users
INNER JOIN orders ON users.id = orders.user_id;
    

5. Requêtes

MongoDB : Les requêtes sont basées sur des filtres JSON-like, ce qui permet une grande flexibilité pour interroger des données semi-structurées.

📋 Copier le code

db.users.find({ age: { $gt: 25 } }); // Trouve les utilisateurs âgés de plus de 25 ans
    

MySQL : Les requêtes sont écrites en SQL, un langage formel et structuré pour interroger des données relationnelles.

📋 Copier le code

SELECT * FROM users WHERE age > 25;
    

6. Performances et Évolutivité

• MongoDB : Conçu pour une évolutivité horizontale (sharding), MongoDB est bien adapté aux grandes quantités de données non structurées ou dynamiques.
• MySQL : Optimisé pour une évolutabilité verticale (ajout de ressources matérielles), MySQL est idéal pour les applications nécessitant des transactions ACID strictes et des requêtes complexes.

Conclusion

Bien que une collection MongoDB soit similaire à une table MySQL, elles diffèrent principalement par leur flexibilité de schéma, leur manière de stocker les données et leurs approches de gestion des relations. Le choix entre les deux dépend de vos besoins spécifiques :

• Utilisez MongoDB si vous travaillez avec des données non structurées ou dynamiques et recherchez une évolutivité horizontale.
• Préférez MySQL si vous avez besoin d'une base de données relationnelle robuste avec un support ACID complet pour des données structurées.

Conclusion

Félicitations ! Vous avez appris à manipuler les collections MongoDB avec Node.js. Voici un récapitulatif de ce que nous avons couvert :

• Comment se connecter à MongoDB depuis Node.js.
• Comment créer, insérer, lire, mettre à jour et supprimer des documents dans une collection.
• Comment utiliser des filtres pour affiner vos requêtes.

Ces compétences sont essentielles pour développer des applications backend robustes et évolutives. N'hésitez pas à explorer davantage les fonctionnalités avancées de MongoDB, telles que les index, les aggregations et les transactions ACID.

🚀 Prochain tutoriel : Découvrez comment utiliser Mongoose, un ORM pour simplifier encore plus l'intégration entre Node.js et MongoDB.