Em outra postagem mostrei os passos para se criar uma API REST usando ExpressJS, hoje vou mostrar como integrar uma API REST com o Banco de Dados.
Usaremos a API criada nessa postagem, se você ainda não leu pode clicar aqui.
Para ter acesso todo o código fonte clique aqui.

O banco de dados que vamos utilizar é mongoDB, caso ainda não tenha em sua máquina basta clicar aqui para baixá-lo.

Após instalado você abrira o mongoDB e criara uma conexão clicando no + na barra lateral esquerda. No endereço da conexão colocaremos /api ao final, porém pode ser o nome que você quiser.

Depois de criada a conexão você poderá visualizar na Dashboard do mongoDB.

Código

Em nosso projeto iremos abrir na raiz e instalaremos o mongoose, ele vai auxiliar para modelarmos os objetos do mongoDB e efetuar a conexão com o banco.

npm i mongoose

No arquivo principal, o server.js que fica na raiz do projeto iremos alterar alguns pontos. Primeiramente importaremos o mongoose e depois integraremos com a conexão que criamos no mongoDB após a declaração das rotas. Lembre-se de colocar a URL que foi colocada na criação da conexão no mongoDB.

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/api').then(() => {
  console.log('Conectado ao MongoDB');
}).catch((error) => {
  console.log('Erro ao conectar ao MongoDB:', error);
});

Para verificarmos se tudo ocorreu corretamente iniciaremos o projeto com o comando npm run dev e a saída deve ser igual a imagem abaixo.

Agora criaremos um schema para definirmos a estrutura dos dados dentro da nossa coleção. Para isso criaremos uma pasta na raiz do projeto chamada model e dentro dela um arquivo chamado userModel.js. Importaremos o mongoose e definiremos o nosso schema e após isso o exportaremos.

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  nome: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true
  },
  idade: {
    type: Number,
    required: true
  }
});

const User = mongoose.model('User', userSchema);
module.exports = User;

Rotas

Com o modelo já criado podemos utilizá-lo para efetuar nosso GET e POST no mongoDB. Dentro da nossa pasta routes temos o nosso arquivo users.js que ficam as nossas rotas.
Dentro dele importaremos nosso modelo e alteraremos nossa rota GET que anteriormente utilizava uma variável local para armazenar os dados.

const User = require('../model/userModel');
router.get('/', async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (error) {
    res.status(500).json({ message: 'Erro ao buscar usuarios });
  }
});

Agora nosso GET tem o callback assíncrono, assim poderemos lidar com as promises. Já dentro do nosso try utilizamos o await que garante que o User.find() será executado. O .find() é um método no mongoDB para retornar todos os documentos da coleção.

Seguiremos a mesma lógica para modificarmos nosso POST. Alteraremos dentro dele a nossa verificação para que nenhum campo seja enviado vazio. E dentro do nosso try usaremos o .save(), é um método do mongoDB para persistir dados na coleção.

router.post('/', async (req, res) => {
  if (!req.body.nome || !req.body.email || !req.body.idade) {
    return res.status(400).json({ message: 'Todos os campos são obrigatórios!' });
  }
  const novoUsuario = new User({
    nome: req.body.nome,
    email: req.body.email,
    idade: req.body.idade
  });
  
  try {
    const usuarioSalvo = await novoUsuario.save();
    res.status(201).json(usuarioSalvo);
  } catch (error) {
    res.status(400).json({ message: 'Erro ao criar usuario' });
  }
});

Após todos os arquivos modificados podemos testar no Postman. Vamos efetuar um POST e a resposta deverá ser parecida com a imagem abaixo.

Para efetuar uma requisição POST siga os passos abaixo:

1. Selecione o método POST e insira os endpoint;
2. Vá na aba body;
3. Selecione a opção raw;
4. Altere o método de inserção de dados de Text para JSON;
5. Agora só informa os dados.

{
  "nome": "Front Master",
  "email": "[email protected]",
  "idade": 25
}

Para verificar os dados persistidos podemos olhar diretamente no mongoDB ou efetuar um GET no Postman. No mongoDB ao selecionar a coleção, clique em Documents e depois em Find para mostrar todos os documentos.

O código completo:

//server.js
const express = require('express');
const mongoose = require('mongoose');
const app = express();
const userRoutes = require('./routes/users');

const PORT = process.env.PORT || 3000;

app.use(express.json());

app.use('/api/users', userRoutes);

mongoose.connect('mongodb://localhost:27017/api').then(() => {
  console.log('Conectado ao MongoDB');
}).catch((error) => {
  console.log('Erro ao conectar ao MongoDB:', error);
});

app.listen(PORT, () => {
  console.log(`Servidor rodando na porta ${PORT}`);
});

//userModel.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  nome: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true
  },
  idade: {
    type: Number,
    required: true
  }
});

const User = mongoose.model('User', userSchema);

module.exports = User;

//users.js
const express = require('express');
const User = require('../model/userModel');

const router = express.Router();

router.get('/', async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (error) {
    res.status(500).json({ message: 'Erro ao buscar usuarios' });
  }
});

router.post('/', async (req, res) => {
  if (!req.body.nome || !req.body.email || !req.body.idade) {
    return res.status(400).json({ message: 'Todos os campos são obrigatórios!' });
  }
  const novoUsuario = new User({
    nome: req.body.nome,
    email: req.body.email,
    idade: req.body.idade
  });
  
  try {
    const usuarioSalvo = await novoUsuario.save();
    res.status(201).json(usuarioSalvo);
  } catch (error) {
    res.status(400).json({ message: 'Erro ao criar usuario' });
  }
});

module.exports = router;

Estrutura do projeto.

Referência: mongoDB