Usando Node.js e Express com drivers nativos do MongoDB: por que e como

Se você estiver trabalhando com Node.js e Express, poderá ter encontrado o Mongoose, uma biblioteca ODM (Object Data Modeling) popular para MongoDB. Embora o Mongoose forneça muitos recursos úteis, há motivos pelos quais você pode optar por trabalhar diretamente com os drivers nativos do MongoDB. Nesta postagem, mostrarei os benefícios de usar drivers nativos do MongoDB e compartilharei como você pode implementar uma API CRUD simples com eles.

Por que usar drivers nativos do MongoDB?

1. Desempenho: Os drivers nativos do MongoDB oferecem melhor desempenho ao interagir diretamente com o MongoDB sem a camada de abstração adicional que o Mongoose introduz. Isso pode ser particularmente benéfico para aplicações de alto desempenho.

2. Flexibilidade: drivers nativos fornecem maior controle sobre suas consultas e interações de dados. O Mongoose, com seus esquemas e modelos, impõe alguma estrutura, que pode não ser ideal para todos os casos de uso.

3. Sobrecarga reduzida: ao usar drivers nativos, você evita a sobrecarga adicional de manutenção de esquemas e modelos do Mongoose, o que pode simplificar sua base de código.

4. Oportunidade de aprendizado: Trabalhar diretamente com drivers nativos ajuda você a entender melhor as operações do MongoDB e pode ser uma ótima experiência de aprendizado.

Implementando uma API CRUD com drivers nativos do MongoDB

Aqui está um guia passo a passo sobre como configurar uma API CRUD simples usando drivers nativos Node.js, Express e MongoDB.

1. Configure a conexão com o banco de dados

Crie um arquivo utils/db.js para gerenciar a conexão 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 o seu modelo

Crie um arquivo models/model.js para interagir com a coleção 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 rotas

Crie um arquivo index.js para definir suas rotas de 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. Implementar Controladores

Crie um arquivo userController.js para lidar com suas operações 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. Configuração

Armazene sua string de conexão MongoDB em um arquivo .env e crie um arquivo db.config.js para carregá-lo:

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

Conclusão

Mudar de drivers nativos do Mongoose para MongoDB pode ser uma escolha estratégica para determinados projetos, oferecendo benefícios de desempenho e maior flexibilidade. A implementação fornecida aqui deve fornecer uma base sólida para começar a construir aplicativos com drivers nativos Node.js e MongoDB.

Sinta-se à vontade para conferir o código completo no GitHub e explorar mais recursos ou melhorias para seus próprios projetos!

Qualquer dúvida adicional sinta-se à vontade para comentar.

Boa codificação! ?