Desenvolver aplicações Node.js com MongoDB é uma escolha popular entre desenvolvedores devido à sua flexibilidade, desempenho e a natureza “JavaScript full-stack”.
A combinação dessas duas tecnologias permite que desenvolvedores trabalhem com o mesmo ecossistema no front-end e back-end, além de aproveitar a escalabilidade e performance do MongoDB, um banco de dados NoSQL orientado a documentos.
Neste artigo, iremos construir uma aplicação Node.js com MongoDB, abordando as melhores práticas e fornecendo exemplos de código para cada etapa do desenvolvimento.
Este guia é voltado tanto para desenvolvedores que estão começando com Node.js quanto para aqueles que já têm alguma experiência e desejam melhorar suas habilidades.
1. O que é Node.js?
Node.js é um ambiente de execução JavaScript construído com o motor V8 do Chrome, projetado para criar aplicações altamente escaláveis e de alta performance. Ele é frequentemente usado para desenvolver servidores web, APIs e aplicativos de tempo real. Sua característica assíncrona e orientada a eventos o torna ideal para tarefas que envolvem alta concorrência.
2. O que é MongoDB?
MongoDB é um banco de dados NoSQL baseado em documentos, onde os dados são armazenados em formato JSON-like (chamado BSON). Diferente de bancos de dados relacionais, o MongoDB não depende de esquemas predefinidos, o que oferece maior flexibilidade ao lidar com dados não estruturados. MongoDB é muito utilizado em aplicações que exigem escalabilidade horizontal e grandes volumes de dados.
3. Configuração Node.js com MongoDB
3.1 Instalando Node.js
Primeiro, precisamos instalar o Node.js e o npm (Node Package Manager), que vem junto com o Node.js. Você pode baixar e instalar o Node.js a partir do site oficial: Node.js Downloads.
Após a instalação, verifique se o Node.js e o npm estão corretamente instalados rodando os comandos:
node -v
npm -v3.2 Instalando o MongoDB
MongoDB pode ser instalado localmente em seu sistema ou usado através de um serviço de banco de dados na nuvem, como o MongoDB Atlas. Vamos usar o MongoDB localmente neste exemplo. Para instalar, siga o guia oficial de instalação para o seu sistema operacional:
Após a instalação, inicie o servidor MongoDB:
mongod
3.3 Criando um Projeto Node.js
Agora que temos Node.js com MongoDB instalados, vamos criar um novo diretório para o projeto e inicializar um novo projeto Node.js:
mkdir node-mongodb-app
cd node-mongodb-app
npm init -y
Isso criará um arquivo package.json com as configurações padrão do projeto.
3.4 Instalando Dependências
Para conectar nossa aplicação Node.js com MongoDB, usaremos a biblioteca Mongoose, que facilita o trabalho com MongoDB, fornecendo uma interface baseada em esquemas.
Instale o Mongoose e outras dependências essenciais com o comando:
npm install express mongoose
- Express: Um framework minimalista para criar servidores web.
- Mongoose: Uma biblioteca ORM que simplifica a interação com o MongoDB.
4. Criando a Aplicação Node.js
4.1 Estrutura do Projeto
Vamos organizar nosso projeto com a seguinte estrutura de diretórios:
node-mongodb-app/
│
├── models/
│ └── userModel.js
├── routes/
│ └── userRoutes.js
├── app.js
└── package.json
4.2 Configurando o Servidor Express
O arquivo app.js será responsável por configurar nosso servidor usando Express. Nele, vamos definir as rotas e conectar ao MongoDB.
// app.js
const express = require('express');
const mongoose = require('mongoose');
const userRoutes = require('./routes/userRoutes');
const app = express();
const PORT = 3000;
// Middleware para interpretar JSON
app.use(express.json());
// Conectando ao MongoDB
mongoose.connect('mongodb://localhost:27017/node-mongodb-app', {
useNewUrlParser: true,
useUnifiedTopology: true,
})
.then(() => console.log('Conectado ao MongoDB'))
.catch((error) => console.error('Erro ao conectar ao MongoDB:', error));
// Rotas
app.use('/api/users', userRoutes);
app.listen(PORT, () => {
console.log(`Servidor rodando na porta ${PORT}`);
});
4.3 Criando o Modelo de Usuário
No MongoDB, trabalhamos com documentos. Para organizar os dados da nossa aplicação, criaremos um modelo de usuário em models/userModel.js utilizando o Mongoose. Isso nos permitirá definir a estrutura de dados e validações.
// models/userModel.js
const mongoose = require('mongoose');
const userSchema = new mongoose.Schema({
name: {
type: String,
required: true,
},
email: {
type: String,
required: true,
unique: true,
},
password: {
type: String,
required: true,
},
}, { timestamps: true });
const User = mongoose.model('User', userSchema);
module.exports = User;
4.4 Criando Rotas para CRUD de Usuários
Agora, vamos criar as rotas para realizar as operações de CRUD (Create, Read, Update, Delete) em routes/userRoutes.js.
// routes/userRoutes.js
const express = require('express');
const User = require('../models/userModel');
const router = express.Router();
// Criar um novo usuário (POST)
router.post('/', async (req, res) => {
try {
const user = new User(req.body);
await user.save();
res.status(201).send(user);
} catch (error) {
res.status(400).send({ message: 'Erro ao criar usuário', error });
}
});
// Buscar todos os usuários (GET)
router.get('/', async (req, res) => {
try {
const users = await User.find();
res.status(200).send(users);
} catch (error) {
res.status(500).send({ message: 'Erro ao buscar usuários', error });
}
});
// Atualizar um usuário (PUT)
router.put('/:id', async (req, res) => {
try {
const user = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
if (!user) {
return res.status(404).send({ message: 'Usuário não encontrado' });
}
res.status(200).send(user);
} catch (error) {
res.status(400).send({ message: 'Erro ao atualizar usuário', error });
}
});
// Excluir um usuário (DELETE)
router.delete('/:id', async (req, res) => {
try {
const user = await User.findByIdAndDelete(req.params.id);
if (!user) {
return res.status(404).send({ message: 'Usuário não encontrado' });
}
res.status(200).send({ message: 'Usuário excluído' });
} catch (error) {
res.status(500).send({ message: 'Erro ao excluir usuário', error });
}
});
module.exports = router;
5. Testando a Aplicação
Com a aplicação configurada, agora é hora de testar as funcionalidades CRUD usando Postman ou qualquer outra ferramenta de API. Para cada operação, você pode utilizar as seguintes rotas:
- Criar usuário (POST):
http://localhost:3000/api/users - Listar usuários (GET):
http://localhost:3000/api/users - Atualizar usuário (PUT):
http://localhost:3000/api/users/:id - Excluir usuário (DELETE):
http://localhost:3000/api/users/:id
Por exemplo, para criar um novo usuário, envie uma requisição POST para /api/users com o seguinte corpo:
{
"name": "João",
"email": "joao@example.com",
"password": "senha123"
}
6. Melhores Práticas
6.1 Validação de Dados
É importante validar corretamente os dados de entrada para evitar inconsistências e falhas na aplicação. Mongoose permite a definição de validações nos modelos, como required, unique e outros tipos de validações customizadas.
6.2 Tratamento de Erros
Sempre implemente um bom tratamento de erros, retornando mensagens de erro claras para o cliente e registrando logs internos que possam ser úteis para a depuração.
6.3 Uso de Variáveis de Ambiente
Nunca codifique credenciais ou URLs diretamente no código. Use variáveis de ambiente para manter dados sensíveis fora do código-fonte, utilizando bibliotecas como o dotenv.
npm install dotenv
require('dotenv').config();
7. Conclusão
Neste tutorial, construímos uma aplicação básica em Node.js com MongoDB usando o Mongoose e o Express.
Essa combinação de ferramentas é extremamente poderosa para o desenvolvimento web, especialmente quando se trata de escalabilidade e performance. Esse passo a passo forneceu a base para criar, ler, atualizar e excluir usuários, além de estabelecer boas práticas para desenvolvimento profissional.
Agora, você pode expandir essa aplicação, adicionando autenticação, autorização, testes unitários, e diversas outras funcionalidades que são comuns em aplicações de produção.
