Utiliser Node.js et Express avec les pilotes natifs MongoDB : pourquoi et comment

Si vous travaillez avec Node.js et Express, vous avez peut-être rencontré Mongoose, une bibliothèque ODM (Object Data Modeling) populaire pour MongoDB. Bien que Mongoose offre de nombreuses fonctionnalités utiles, il existe des raisons pour lesquelles vous pouvez choisir de travailler directement avec les pilotes natifs de MongoDB. Dans cet article, je vais vous présenter les avantages de l'utilisation des pilotes natifs MongoDB et vous expliquer comment vous pouvez implémenter une API CRUD simple avec eux.

Pourquoi utiliser les pilotes natifs MongoDB ?

1. Performances : les pilotes natifs de MongoDB offrent de meilleures performances en interagissant directement avec MongoDB sans la couche d'abstraction supplémentaire introduite par Mongoose. Cela peut être particulièrement bénéfique pour les applications hautes performances.

2. Flexibilité : les pilotes natifs offrent un meilleur contrôle sur vos requêtes et vos interactions avec les données. Mongoose, avec ses schémas et ses modèles, impose une certaine structure, qui n'est peut-être pas idéale pour tous les cas d'utilisation.

3. Surcharge réduite : en utilisant des pilotes natifs, vous évitez la surcharge supplémentaire liée à la maintenance des schémas et des modèles Mongoose, ce qui peut simplifier votre base de code.

4. Opportunité d'apprentissage : Travailler directement avec des pilotes natifs vous aide à mieux comprendre les opérations de MongoDB et peut être une excellente expérience d'apprentissage.

Implémentation d'une API CRUD avec les pilotes natifs MongoDB

Voici un guide étape par étape sur la façon de configurer une API CRUD simple à l'aide des pilotes natifs Node.js, Express et MongoDB.

1. Configurer la connexion à la base de données

Créez un fichier utils/db.js pour gérer la connexion MongoDB :

require('dotenv').config()
const dbConfig = require('../config/db.config');
const { MongoClient } = require('mongodb');

const client = new MongoClient(dbConfig.url);

let _db;
let connectPromise;

async function connectToDb() {
    if (!connectPromise) {
        connectPromise = new Promise(async (resolve, reject) => {
            try {
                await client.connect();
                console.log('Connected to the database ?', client.s.options.dbName);
                _db = client.db();
                resolve(_db);
            } catch (error) {
                console.error('Error connecting to the database:', error);
                reject(error);
            }
        });
    }
    return connectPromise;
}

function getDb() {
    if (!_db) {
        throw new Error('Database not connected');
    }
    return _db;
}

function isDbConnected() {
    return Boolean(_db);
}

module.exports = { connectToDb, getDb, isDbConnected };

2. Définissez votre modèle

Créez un fichier models/model.js pour interagir avec la collection MongoDB :

const { ObjectId } = require('mongodb');
const db = require('../utils/db');

class AppModel {
    constructor($collection) {
        this.collection = null;

        (async () => {
            if (!db.isDbConnected()) {
                console.log('Waiting for the database to connect...');
                await db.connectToDb();
            }
            this.collection = db.getDb().collection($collection);
            console.log('Collection name:', $collection);
        })();
    }

    async find() {
        return await this.collection.find().toArray();
    }

    async findOne(condition = {}) {
        const result = await this.collection.findOne(condition);
        return result || 'No document Found!';
    }

    async create(data) {
        data.createdAt = new Date();
        data.updatedAt = new Date();
        let result = await this.collection.insertOne(data);
        return `${result.insertedId} Inserted successfully`;
    }

    async update(id, data) {
        let condition = await this.collection.findOne({ _id: new ObjectId(id) });
        if (condition) {
            const result = await this.collection.updateOne({ _id: new ObjectId(id) }, { $set: { ...data, updatedAt: new Date() } });
            return `${result.modifiedCount > 0} Updated successfully!`;
        } else {
            return `No document found with ${id}`;
        }
    }

    async deleteOne(id) {
        const condition = await this.collection.findOne({ _id: new ObjectId(id) });
        if (condition) {
            const result = await this.collection.deleteOne({ _id: new ObjectId(id) });
            return `${result.deletedCount > 0} Deleted successfully!`;
        } else {
            return `No document found with ${id}`;
        }
    }
}

module.exports = AppModel;

3. Configurer des itinéraires

Créez un fichier index.js pour définir vos routes API :

const express = require('express');
const router = express.Router();

const users = require('../controllers/userController');

router.get("/users", users.findAll);
router.post("/users", users.create);
router.put("/users", users.update);
router.get("/users/:id", users.findOne);
router.delete("/users/:id", users.deleteOne);

module.exports = router;

4. Implémenter les contrôleurs

Créez un fichier userController.js pour gérer vos opérations CRUD :

const { ObjectId } = require('mongodb');
const Model = require('../models/model');

const model = new Model('users');

let userController = {
    async findAll(req, res) {
        model.find()
            .then(data => res.send(data))
            .catch(err => res.status(500).send({ message: err.message }));
    },
    async findOne(req, res) {
        let condition = { _id: new ObjectId(req.params.id) };
        model.findOne(condition)
            .then(data => res.send(data))
            .catch(err => res.status(500).send({ message: err.message }));
    },
    create(req, res) {
        let data = req.body;
        model.create(data)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    },
    update(req, res) {
        let id = req.body._id;
        let data = req.body;
        model.update(id, data)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    },
    deleteOne(req, res) {
        let id = new ObjectId(req.params.id);
        model.deleteOne(id)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    }
}

module.exports = userController;

5.Configuration

Stockez votre chaîne de connexion MongoDB dans un fichier .env et créez un fichier db.config.js pour la charger :

module.exports = {
    url: process.env.DB_CONFIG,
};

Conclusion

Le passage des pilotes natifs Mongoose aux pilotes natifs MongoDB peut être un choix stratégique pour certains projets, offrant des avantages en termes de performances et une plus grande flexibilité. L'implémentation fournie ici devrait vous donner une base solide pour commencer à créer des applications avec les pilotes natifs Node.js et MongoDB.

N'hésitez pas à consulter le code complet sur GitHub et à explorer plus de fonctionnalités ou d'améliorations pour vos propres projets !

Si vous avez d'autres questions, n'hésitez pas à commenter.

Bon codage ! ?