Uso de Node.js y Express con controladores nativos MongoDB: por qué y cómo

Si está trabajando con Node.js y Express, es posible que haya encontrado Mongoose, una popular biblioteca ODM (Object Data Modeling) para MongoDB. Si bien Mongoose proporciona muchas funciones útiles, existen razones por las que podría optar por trabajar directamente con los controladores nativos de MongoDB. En esta publicación, te explicaré los beneficios de usar controladores nativos de MongoDB y compartiré cómo puedes implementar una API CRUD simple con ellos.

¿Por qué utilizar controladores nativos de MongoDB?

1. Rendimiento: Los controladores nativos de MongoDB ofrecen un mejor rendimiento al interactuar directamente con MongoDB sin la capa de abstracción adicional que introduce Mongoose. Esto puede resultar especialmente beneficioso para aplicaciones de alto rendimiento.

2. Flexibilidad: los controladores nativos brindan un mayor control sobre sus consultas e interacciones de datos. Mongoose, con sus esquemas y modelos, impone cierta estructura, que puede no ser ideal para todos los casos de uso.

3. Gastos generales reducidos: al utilizar controladores nativos, evitas los gastos generales adicionales que supone mantener los esquemas y modelos de Mongoose, lo que puede simplificar tu código base.

4. Oportunidad de aprendizaje: trabajar directamente con controladores nativos le ayuda a comprender mejor las operaciones de MongoDB y puede ser una excelente experiencia de aprendizaje.

Implementación de una API CRUD con controladores nativos MongoDB

Aquí hay una guía paso a paso sobre cómo configurar una API CRUD simple usando controladores nativos de Node.js, Express y MongoDB.

1. Configurar la conexión a la base de datos

Cree un archivo utils/db.js para administrar la conexión 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. Defina su modelo

Cree un archivo models/model.js para interactuar con la colección 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. Configurar rutas

Cree un archivo index.js para definir sus rutas 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. Controladores de implementos

Cree un archivo userController.js para manejar sus operaciones 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. Configuración

Almacene su cadena de conexión MongoDB en un archivo .env y cree un archivo db.config.js para cargarlo:

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

Conclusión

Cambiar de controladores nativos de Mongoose a MongoDB puede ser una opción estratégica para ciertos proyectos, ya que ofrece beneficios de rendimiento y mayor flexibilidad. La implementación proporcionada aquí debería brindarle una base sólida para comenzar a crear aplicaciones con controladores nativos de Node.js y MongoDB.

¡No dudes en consultar el código completo en GitHub y explorar más funciones o mejoras para tus propios proyectos!

Cualquier otra pregunta no dudes en comentar.

¡Feliz codificación! ?