Leodario.com

Leodario.com – Tudo sobre Tecnologia

Aula 48 – API JavaScript, Node.js e Express – MongoDB with Mongoose – ODM para MongoDB

Imagem destacada da aula de API

Introdução (3 min)

Bem-vindos, desenvolvedores! Nesta aula, vamos desvendar um dos recursos mais valiosos para quem trabalha com Node.js e MongoDB. Imagine que você está organizando uma grande biblioteca, mas em vez de livros com formatos rígidos, você tem documentos de todos os tipos: alguns com capa, outros sem, alguns com índice, outros apenas com o conteúdo. Essa flexibilidade é fantástica, mas pode levar a uma certa bagunça se não houver um sistema.

É aqui que entra o Mongoose! Ele atua como um “assistente bibliotecário” superinteligente. Em vez de você ter que verificar cada documento manualmente ou escrever instruções complexas para o sistema de arquivos da biblioteca (o MongoDB), o Mongoose oferece formulários padronizados (esquemas) para você preencher. Ele garante que, ao “arquivar” um novo documento, ele tenha as informações esperadas, e ao “buscar” um documento, ele o entregue em um formato fácil de usar.

Compreender o Mongoose é imprescindível para construir APIs modernas e robustas. Ele simplifica enormemente a interação com o MongoDB, possibilitando que você manipule dados de forma consistente e segura, algo vital em qualquer aplicação de sucesso. Sem ele, a gestão de dados pode se tornar um calcanhar de Aquiles, consumindo tempo e energia preciosos com validações manuais e manipulação de objetos complexos.

Nesta jornada de conhecimento, você vai compreender o papel de um ODM (Object-Document Mapper), aprenderá a definir esquemas e modelos de dados, e dominará as operações básicas de CRUD (Criar, Ler, Atualizar, Deletar) de uma maneira elegante e eficiente. Nosso objetivo é que, ao final, você seja capaz de integrar o MongoDB em suas aplicações Node.js/Express com maestria.

No contexto do ecossistema Node.js/Express, o Mongoose se posiciona como a ponte essencial entre o seu código JavaScript e o banco de dados MongoDB. Enquanto o Express lida com as requisições HTTP e a lógica da API, o Mongoose cuida da persistência dos dados, garantindo que a informação flua de maneira ordenada e validada entre a sua aplicação e o armazenamento.

Conceito Fundamental (7 min)

O Mongoose é um ODM (Object-Document Mapper) para o Node.js e MongoDB. Mas o que exatamente significa isso? Pense em um ODM como uma camada de abstração que se situa entre a sua aplicação JavaScript e o banco de dados MongoDB.

No MongoDB, os dados são armazenados como documentos BSON (Binary JSON) dentro de coleções, que são equivalentes a tabelas em bancos de dados relacionais. A beleza do MongoDB é sua flexibilidade: você não precisa definir previamente a estrutura exata de um documento. No entanto, para a consistência e integridade dos dados em uma aplicação, é frequentemente desejável ter alguma estrutura.

O Mongoose resolve isso introduzindo dois conceitos-chave:

    • Schema (Esquema): Um Schema Mongoose define a estrutura do documento, os tipos de dados para cada campo, valores padrão, e validadores. É como um “contrato” ou um “projeto” para seus documentos. Ele habilita a validação de dados antes que sejam enviados ao banco, garantindo que seus dados estejam sempre no formato esperado. Por exemplo, você pode definir que um campo ‘nome’ deve ser uma string e é obrigatório, ou que um campo ‘idade’ deve ser um número e ter um valor mínimo.
    • Model (Modelo): Um Model é uma “classe” construída a partir de um Schema. Ele fornece uma interface programática para interagir com uma coleção específica no MongoDB. Através de um Model, você pode criar, buscar, atualizar e deletar documentos. Ele encapsula toda a lógica de interação com o banco de dados para uma coleção específica. Quando você diz Product.find(), Product é o seu modelo.

A terminologia da indústria é clara: Mongoose é um ODM. Ele mapeia seus objetos JavaScript (instâncias de Model) para documentos no MongoDB. Um objeto JavaScript que segue um Schema é chamado de Documento Mongoose antes de ser persistido no MongoDB.

Casos de uso reais em produção que se beneficiam enormemente do Mongoose incluem:

    • Sistemas de e-commerce: Gerenciamento de produtos (nome, preço, descrição, estoque), pedidos (itens, status, endereço de entrega), usuários (informações de perfil, histórico de compras). O Mongoose assegura que todos os produtos tenham um preço válido e um nome, por exemplo.
    • Plataformas de blog ou CMS: Artigos (título, conteúdo, autor, tags), comentários (texto, autor, data). A validação de um título não vazio ou de um autor existente é facilmente configurada.
    • Aplicações de redes sociais: Perfis de usuário, postagens, curtidas, seguidores. O Mongoose viabiliza a estruturação e interconexão dessas informações complexas.

Como isso se integra com outras tecnologias? O Mongoose funciona perfeitamente com o Node.js e o framework Express.js. Suas rotas Express recebem requisições, e então utilizam os Models do Mongoose para interagir com o MongoDB, processando e persistindo os dados. É a camada de persistência de dados em uma arquitetura de API RESTful típica.

Vantagens de utilizar o Mongoose:

    • Validação de dados: Garante a integridade e consistência dos dados antes que cheguem ao banco.
    • Definição de esquemas: Permite impor uma estrutura aos seus documentos, facilitando o desenvolvimento e a manutenção.
    • Middleware: Possibilita a execução de funções pré e pós-salvamento, atualização, remoção, etc., para lógica de negócios adicional (ex: criptografar senhas antes de salvar).
    • Construção de queries mais fácil: Oferece uma API fluida para realizar buscas, atualizações e agregações, tornando o código mais legível e menos propenso a erros do que as queries diretas do driver MongoDB.
    • Gerenciamento de relacionamentos: Embora o MongoDB seja um banco de dados NoSQL, o Mongoose possui recursos como ‘population’ que facilitam a gestão de referências entre documentos, simulando uniões.

No entanto, há algumas desvantagens:

    • Camada de abstração: Adiciona uma camada extra que pode, ocasionalmente, esconder a flexibilidade nativa do MongoDB ou impor um overhead de desempenho mínimo em operações de volume extremamente alto.
    • Curva de aprendizado: Embora simplifique muito, a compreensão dos conceitos de Schema, Model e das peculiaridades do Mongoose requer um tempo inicial de estudo.

Implementação Prática (10 min)

Agora, vamos colocar as mãos na massa e desenvolver uma API REST simples para gerenciar produtos, utilizando Node.js, Express e, é claro, o Mongoose para interagir com o MongoDB. Nosso foco será a robustez e as melhores práticas, incluindo configurações para ambiente de produção como o HostGator Plano M.

Primeiro, crie um novo projeto e instale as dependências:

mkdir meu-app-mongoose
cd meu-app-mongoose
npm init -y
npm install express mongoose dotenv --save

Crie um arquivo .env na raiz do seu projeto para as variáveis de ambiente:

# .env
MONGO_URI=mongodb+srv://:@.mongodb.net/nomedobanco?retryWrites=true&w=majority
PORT=3000

Substitua , , e nomedobanco com as suas credenciais do MongoDB Atlas ou sua instância MongoDB.

Vamos estruturar nosso projeto para clareza e manutenibilidade, seguindo padrões enterprise:

meu-app-mongoose/
├── .env
├── server.js
├── models/
│   └── Product.js
└── routes/
    └── productRoutes.js

1. Configuração do Modelo (models/Product.js)

Aqui definimos o schema do nosso produto, com validações e tipos de dados. Isso garante que todo produto salvo no banco de dados siga esta estrutura.

// models/Product.js


const mongoose = require('mongoose'); // Importa a biblioteca Mongoose.


// Define o esquema para o modelo de Produto.
// Este esquema descreve a estrutura dos documentos de produto no MongoDB.
const productSchema = new mongoose.Schema({
    nome: {
        type: String, // O campo 'nome' deve ser uma string.
        required: [true, 'O nome do produto é obrigatório.'], // É obrigatório e exibe uma mensagem de erro personalizada.
        trim: true, // Remove espaços em branco do início e do fim.
        minlength: [3, 'O nome do produto deve ter pelo menos 3 caracteres.'], // Validação de tamanho mínimo.
        maxlength: [100, 'O nome do produto não pode exceder 100 caracteres.'] // Validação de tamanho máximo.
    },
    descricao: {
        type: String, // O campo 'descricao' deve ser uma string.
        required: [true, 'A descrição do produto é obrigatória.'], // É obrigatório.
        minlength: [10, 'A descrição do produto deve ter pelo menos 10 caracteres.'] // Validação de tamanho mínimo.
    },
    preco: {
        type: Number, // O campo 'preco' deve ser um número.
        required: [true, 'O preço do produto é obrigatório.'], // É obrigatório.
        min: [0, 'O preço do produto não pode ser negativo.'], // Validação de valor mínimo (preço não pode ser abaixo de zero).
        set: (v) => Math.round(v * 100) / 100 // Setter para arredondar o preço para duas casas decimais.
    },
    estoque: {
        type: Number, // O campo 'estoque' deve ser um número.
        required: [true, 'A quantidade em estoque é obrigatória.'], // É obrigatório.
        min: [0, 'O estoque não pode ser negativo.'], // Validação de valor mínimo.
        default: 0 // Valor padrão se não for fornecido.
    },
    disponivel: {
        type: Boolean, // O campo 'disponivel' deve ser um booleano.
        default: true // Valor padrão.
    },
    dataCriacao: {
        type: Date, // O campo 'dataCriacao' deve ser do tipo Date.
        default: Date.now // Valor padrão é a data e hora atuais.
    }
});


// Cria e exporta o modelo 'Product' baseado no 'productSchema'.
// O Mongoose pluraliza automaticamente 'Product' para 'products' para o nome da coleção no MongoDB.
module.exports = mongoose.model('Product', productSchema);

2. Definição das Rotas (routes/productRoutes.js)

Aqui implementamos os endpoints da API para realizar as operações CRUD. Notem o uso de try-catch para um error handling fantástico, que captura exceções e retorna mensagens amigáveis ao cliente.

// routes/productRoutes.js


const express = require('express'); // Importa o Express.
const Product = require('../models/Product'); // Importa o Modelo de Produto que acabamos de definir.


const router = express.Router(); // Cria um roteador Express.


// --- ROTAS CRUD PARA PRODUTOS ---


// [GET] /api/products - Obter todos os produtos
router.get('/', async (req, res) => {
    try {
        const produtos = await Product.find({}); // Busca todos os documentos na coleção 'products'.
        res.status(200).json(produtos); // Retorna os produtos com status 200 (OK).
    } catch (error) {
        console.error('Erro ao buscar produtos:', error.message); // Logging profissional: registra o erro no console.
        res.status(500).json({ mensagem: 'Erro interno do servidor ao buscar produtos.', erro: error.message }); // Retorna erro 500.
    }
});


// [GET] /api/products/:id - Obter um produto por ID
router.get('/:id', async (req, res) => {
    try {
        // Validação básica do ID antes de tentar buscar.
        if (!mongoose.Types.ObjectId.isValid(req.params.id)) {
            return res.status(400).json({ mensagem: 'ID de produto inválido.' });
        }
        const produto = await Product.findById(req.params.id); // Busca um produto pelo ID.


        if (!produto) {
            return res.status(404).json({ mensagem: 'Produto não encontrado.' }); // Retorna 404 se não encontrar.
        }
        res.status(200).json(produto); // Retorna o produto encontrado.
    } catch (error) {
        console.error(Erro ao buscar produto ${req.params.id}:, error.message);
        res.status(500).json({ mensagem: 'Erro interno do servidor ao buscar produto.', erro: error.message });
    }
});


// [POST] /api/products - Criar um novo produto
router.post('/', async (req, res) => {
    try {
        const novoProduto = new Product(req.body); // Cria uma nova instância de Produto com os dados do corpo da requisição.
        await novoProduto.save(); // Salva o novo produto no banco de dados. O Mongoose aplica as validações do schema aqui.
        res.status(201).json({ mensagem: 'Produto criado com sucesso!', produto: novoProduto }); // Retorna o produto criado com status 201 (Created).
    } catch (error) {
        // MongooseValidationError é um tipo de erro comum durante a validação.
        if (error.name === 'ValidationError') {
            const errosValidacao = Object.values(error.errors).map(err => err.message);
            console.warn('Erro de validação ao criar produto:', errosValidacao);
            return res.status(400).json({ mensagem: 'Dados de produto inválidos.', erros: errosValidacao }); // Retorna 400 (Bad Request) com detalhes da validação.
        }
        console.error('Erro ao criar produto:', error.message);
        res.status(500).json({ mensagem: 'Erro interno do servidor ao criar produto.', erro: error.message });
    }
});


// [PUT] /api/products/:id - Atualizar um produto existente
router.put('/:id', async (req, res) => {
    try {
        if (!mongoose.Types.ObjectId.isValid(req.params.id)) {
            return res.status(400).json({ mensagem: 'ID de produto inválido.' });
        }
        // findByIdAndUpdate busca e atualiza um documento.
        // { new: true } retorna o documento atualizado.
        // { runValidators: true } garante que as validações do schema sejam executadas na atualização.
        const produtoAtualizado = await Product.findByIdAndUpdate(
            req.params.id,
            req.body,
            { new: true, runValidators: true }
        );


        if (!produtoAtualizado) {
            return res.status(404).json({ mensagem: 'Produto não encontrado para atualização.' });
        }
        res.status(200).json({ mensagem: 'Produto atualizado com sucesso!', produto: produtoAtualizado });
    } catch (error) {
        if (error.name === 'ValidationError') {
            const errosValidacao = Object.values(error.errors).map(err => err.message);
            console.warn('Erro de validação ao atualizar produto:', errosValidacao);
            return res.status(400).json({ mensagem: 'Dados de atualização inválidos.', erros: errosValidacao });
        }
        console.error(Erro ao atualizar produto ${req.params.id}:, error.message);
        res.status(500).json({ mensagem: 'Erro interno do servidor ao atualizar produto.', erro: error.message });
    }
});


// [DELETE] /api/products/:id - Deletar um produto
router.delete('/:id', async (req, res) => {
    try {
        if (!mongoose.Types.ObjectId.isValid(req.params.id)) {
            return res.status(400).json({ mensagem: 'ID de produto inválido.' });
        }
        const produtoRemovido = await Product.findByIdAndDelete(req.params.id); // Busca e deleta um documento.


        if (!produtoRemovido) {
            return res.status(404).json({ mensagem: 'Produto não encontrado para exclusão.' });
        }
        res.status(200).json({ mensagem: 'Produto removido com sucesso!', produto: produtoRemovido });
    } catch (error) {
        console.error(Erro ao remover produto ${req.params.id}:, error.message);
        res.status(500).json({ mensagem: 'Erro interno do servidor ao remover produto.', erro: error.message });
    }
});


module.exports = router; // Exporta o roteador.

3. Configuração do Servidor (server.js)

Este é o ponto de entrada da nossa aplicação. Ele configura o Express, conecta-se ao MongoDB e integra nossas rotas.

// server.js


require('dotenv').config(); // Carrega variáveis de ambiente do arquivo .env. Essencial para HostGator Plano M.
const express = require('express'); // Importa o Express.
const mongoose = require('mongoose'); // Importa o Mongoose.
const productRoutes = require('./routes/productRoutes'); // Importa as rotas de produto.


const app = express(); // Inicializa a aplicação Express.
const PORT = process.env.PORT || 3000; // Define a porta, usando a variável de ambiente ou 3000 como padrão.
const MONGO_URI = process.env.MONGO_URI; // Obtém a URI de conexão do MongoDB das variáveis de ambiente.


// --- Middlewares Essenciais ---
app.use(express.json()); // Habilita o Express para parsear o corpo das requisições como JSON.


// --- Conexão com o MongoDB ---
mongoose.connect(MONGO_URI)
    .then(() => {
        console.log('MongoDB conectado com sucesso!'); // Logging profissional.
        // Inicia o servidor Express somente após a conexão bem-sucedida com o banco de dados.
        app.listen(PORT, () => {
            console.log(Servidor rodando na porta ${PORT});
            console.log(Para acessar a API, use: http://localhost:${PORT}/api/products);
        });
    })
    .catch((err) => {
        console.error('Erro na conexão com o MongoDB:', err.message); // Logging de erro crítico.
        process.exit(1); // Encerra o processo da aplicação em caso de falha na conexão.
    });


// --- Rotas da Aplicação ---
// Todas as rotas definidas em productRoutes serão prefixadas com '/api/products'.
app.use('/api/products', productRoutes);


// --- Tratamento de Rotas Não Encontradas (404) ---
app.use((req, res, next) => {
    res.status(404).json({ mensagem: 'Rota não encontrada.' });
});


// --- Middleware de Tratamento de Erros Global ---
// Este middleware captura quaisquer erros não tratados nas rotas.
app.use((err, req, res, next) => {
    console.error('Erro GERAL da aplicação:', err.stack); // Registra o stack trace do erro.
    res.status(500).json({ mensagem: 'Ocorreu um erro inesperado no servidor.', erro: err.message });
});

Rodando a aplicação e Testes Básicos

Para iniciar o servidor, execute:

node server.js

Você deverá ver as mensagens de conexão do MongoDB e do servidor.

Agora, vamos testar a API usando curl (ou uma ferramenta como Postman/Insomnia):

1. Criar um produto (POST):

curl -X POST -H "Content-Type: application/json" -d '{
    "nome": "Smartphone Avançado X",
    "descricao": "Um smartphone de última geração com câmera incrível.",
    "preco": 1299.99,
    "estoque": 50
}' http://localhost:3000/api/products

Saída esperada (status 201):

{
    "mensagem": "Produto criado com sucesso!",
    "produto": {
        "nome": "Smartphone Avançado X",
        "descricao": "Um smartphone de última geração com câmera incrível.",
        "preco": 1299.99,
        "estoque": 50,
        "disponivel": true,
        "dataCriacao": "2023-10-27T10:00:00.000Z",
        "_id": "653b6f0e..."
    }
}

2. Criar um produto com dados inválidos (POST – Teste de validação):

curl -X POST -H "Content-Type: application/json" -d '{
    "nome": "SP",
    "descricao": "Curta",
    "preco": -10,
    "estoque": 1
}' http://localhost:3000/api/products

Saída esperada (status 400, com erros de validação):

{
    "mensagem": "Dados de produto inválidos.",
    "erros": [
        "O nome do produto deve ter pelo menos 3 caracteres.",
        "A descrição do produto deve ter pelo menos 10 caracteres.",
        "O preço do produto não pode ser negativo."
    ]
}

3. Obter todos os produtos (GET):

curl http://localhost:3000/api/products

Saída esperada (status 200, array de produtos):

[
    { "_id": "653b6f0e...", "nome": "Smartphone Avançado X", "preco": 1299.99, ... }
]

4. Obter um produto por ID (GET – use o _id do produto criado):

curl http://localhost:3000/api/products/

5. Atualizar um produto (PUT – use o _id do produto criado):

curl -X PUT -H "Content-Type: application/json" -d '{
    "preco": 1199.99,
    "estoque": 45
}' http://localhost:3000/api/products/

6. Deletar um produto (DELETE – use o _id do produto criado):

curl -X DELETE http://localhost:3000/api/products/

Melhores Práticas e HostGator Plano M

    • Variáveis de Ambiente (.env): A utilização do pacote dotenv é fundamental para a segurança e flexibilidade. Credenciais de banco de dados, chaves secretas e configurações de porta nunca devem ser codificadas diretamente no código. Em ambientes como o HostGator Plano M, você configuraria essas variáveis através do painel de controle ou upload do .env.
    • Estrutura Modular: Separar models, routes e o servidor principal em arquivos distintos (como models/Product.js, routes/productRoutes.js, server.js) facilita a organização do código, a manutenção e a expansão.
    • Validação de Entrada Robusta: O Mongoose oferece validação de esquema poderosa. Utilize-a! Para validações mais complexas em outros contextos, considere bibliotecas como joi ou express-validator.
    • Tratamento de Erros: A implementação de blocos try-catch em todas as operações assíncronas e um middleware global de tratamento de erros no Express é uma prática enterprise que garante que sua API responda de forma consistente e informativa, sem expor detalhes internos sensíveis do servidor.
    • Logging Profissional:console.error e console.warn são simples para demonstração. Em produção, use uma biblioteca de logging como Winston ou Pino para ter logs estruturados e configuráveis.
    • Compatibilidade HostGator Plano M: O código apresentado é 100% compatível. O Node.js é executado como um processo normal, a conexão com o MongoDB é feita remotamente (via Atlas ou outra instância), e as variáveis de ambiente são carregadas do .env ou configuradas no ambiente de hospedagem. Sem dependências complexas de sistema.

Exercício Hands-On (5 min)

Chegou a sua vez de demonstrar o aprendizado! O desafio prático a seguir consolidará sua compreensão sobre o Mongoose e a construção de APIs.

Desafio Prático

Nossa API de produtos está funcionando bem, mas e se quisermos categorizar os produtos? Seu objetivo é adicionar um campo categoria ao modelo de Product e, em seguida, implementar uma nova rota para permitir a busca de produtos por essa categoria específica.

Requisitos:

    • Modifique o ProductSchema em models/Product.js para incluir um campo categoria. Este campo deve ser uma string, ser obrigatório e ter um valor padrão como “Geral”.
    • Adicione uma nova rota GET em routes/productRoutes.js (por exemplo, /api/products/categoria/:nomeCategoria) que retorne todos os produtos pertencentes à categoria especificada na URL.
    • Garanta que a nova rota tenha tratamento de erros robusto.

Solução Detalhada Passo a Passo

Passo 1: Modificar o Modelo (models/Product.js)

Abra o arquivo models/Product.js e adicione o campo categoria ao productSchema:

// models/Product.js (trecho do schema)


const productSchema = new mongoose.Schema({
    // ... campos existentes ...
    categoria: {
        type: String, // O campo 'categoria' deve ser uma string.
        required: [true, 'A categoria do produto é obrigatória.'], // É obrigatório.
        trim: true, // Remove espaços em branco.
        default: 'Geral' // Valor padrão.
    },
    // ... restante dos campos ...
});

Lembre-se de reiniciar seu servidor (node server.js) após esta alteração para que o Mongoose recarregue o novo schema.

Passo 2: Adicionar a Nova Rota (routes/productRoutes.js)

Abra o arquivo routes/productRoutes.js e adicione a nova rota logo abaixo das rotas GET existentes:

// routes/productRoutes.js (trecho das rotas)


// ... Rotas GET, POST, PUT, DELETE existentes ...


// [GET] /api/products/categoria/:nomeCategoria - Obter produtos por categoria
router.get('/categoria/:nomeCategoria', async (req, res) => {
    try {
        const nomeCategoria = req.params.nomeCategoria; // Obtém o nome da categoria da URL.


        // Busca todos os produtos onde o campo 'categoria' corresponde ao 'nomeCategoria'.
        // Usamos uma expressão regular (new RegExp) com a flag 'i' para busca case-insensitive.
        const produtosPorCategoria = await Product.find({ categoria: new RegExp(nomeCategoria, 'i') });


        if (produtosPorCategoria.length === 0) {
            return res.status(404).json({ mensagem: Nenhum produto encontrado para a categoria '${nomeCategoria}'. });
        }


        res.status(200).json(produtosPorCategoria); // Retorna os produtos encontrados.
    } catch (error) {
        console.error(Erro ao buscar produtos pela categoria '${req.params.nomeCategoria}':, error.message);
        res.status(500).json({ mensagem: 'Erro interno do servidor ao buscar produtos por categoria.', erro: error.message });
    }
});


module.exports = router;

Passo 3: Testar e Validar o Resultado

Reinicie o servidor (node server.js). Agora, você pode testar a nova funcionalidade:

Primeiro, crie alguns produtos com categorias diferentes (ou atualize os existentes):

# Criar um produto na categoria 'Eletrônicos'
curl -X POST -H "Content-Type: application/json" -d '{
    "nome": "Smart TV 4K",
    "descricao": "TV de alta definição com recursos inteligentes.",
    "preco": 2500.00,
    "estoque": 20,
    "categoria": "Eletrônicos"
}' http://localhost:3000/api/products




Criar um produto na categoria 'Eletrodomésticos'





    

📚 Informações da Aula


    
Curso: API Completo - Node.js & Express


    
Tempo estimado: 25 minutos


    
Pré-requisitos: JavaScript básico





curl -X POST -H "Content-Type: application/json" -d '{
    "nome": "Geladeira Frost Free",
    "descricao": "Geladeira moderna com grande capacidade.",
    "preco": 3000.00,
    "estoque": 15,
    "categoria": "Eletrodomésticos"
}' http://localhost:3000/api/products




Criar um produto na categoria padrão (Geral)


curl -X POST -H "Content-Type: application/json" -d '{
    "nome": "Cadeira Ergonômica",
    "descricao": "Cadeira confortável para escritório.",
    "preco": 500.00,
    "estoque": 10
}' http://localhost:3000/api/products

Agora, busque por categoria:

# Buscar produtos da categoria 'Eletrônicos'
curl http://localhost:3000/api/products/categoria/Eletronicos




Buscar produtos da categoria 'Geral'


curl http://localhost:3000/api/products/categoria/Geral




Buscar por uma categoria que não existe


curl http://localhost:3000/api/products/categoria/Livros

Você deverá ver os produtos filtrados por categoria ou a mensagem “Nenhum produto encontrado” para categorias inexistentes, demonstrando o funcionamento da nova rota.

Troubleshooting dos Erros Mais Comuns

    • “ValidationError: O nome do produto é obrigatório.”
      • Causa: Você está tentando salvar um produto sem o campo nome ou outro campo marcado como required.
      • Solução: Verifique o corpo da sua requisição POST/PUT para garantir que todos os campos obrigatórios estão presentes e válidos de acordo com o productSchema.
    • “MongooseError: MongooseServerSelectionError: connect ECONNREFUSED…”
      • Causa: O Node.js não conseguiu se conectar ao seu banco de dados MongoDB. Isso pode ser devido a MONGO_URI incorreta, problema de rede, ou o servidor MongoDB não está rodando/acessível.
      • Solução: Revise sua MONGO_URI no arquivo .env. Verifique se as credenciais (usuário, senha, cluster) estão corretas. Se estiver usando MongoDB Atlas, certifique-se de que seu endereço IP foi adicionado à lista de IPs permitidos na seção Network Access.
    • “CastError: Cast to ObjectId failed for value…”
      • Causa: Você está tentando buscar, atualizar ou deletar um produto usando um ID que não está no formato de ObjectId válido do MongoDB (por exemplo, um ID muito curto ou com caracteres inválidos).
      • Solução: Verifique o ID que você está passando na URL. Ele deve ser um ID válido retornado pelo MongoDB (uma string de 24 caracteres hexadecimais).

Próximos Passos Sugeridos

Parabéns por completar o desafio! Você deu um passo significativo no desenvolvimento de APIs robustas. Para aprofundar ainda mais seus conhecimentos:

    • Populate: Explore o recurso de populate do Mongoose para gerenciar relacionamentos entre documentos (ex: um produto que tem um campo de referência para o _id de um usuário que o criou).
    • Middleware do Mongoose: Experimente criar middlewares pre e post para o seu ProductSchema (ex: logar a data de atualização automaticamente ou executar alguma lógica antes de deletar).
    • Paginação e Filtragem Avançada: Implemente recursos de paginação e mais opções de filtro para suas rotas GET, permitindo que os clientes da API controlem a quantidade e o tipo de dados recebidos.
    • Testes Automatizados: Comece a escrever testes unitários e de integração para sua API, garantindo a qualidade e a estabilidade do seu código ao longo do tempo. Bibliotecas como Jest ou Mocha/Chai são excelentes para isso.

Continue praticando, e você se tornará um mestre na arte de construir APIs com Node.js e Mongoose!

🚀 Pronto para a próxima aula?

Continue sua jornada no desenvolvimento de APIs e domine Node.js & Express!

📚 Ver todas as aulas

Categories:

Tags:

, , , ,

Leodario