API Rest com Node.js, Express, Swagger e MySQL – Parte 2

Hoje daremos sequência a uma série de artigos sobre como construir uma API Rest utilizando as tecnologias Node.js, Express, Swagger e MySQL.

Para aproveitar da melhor forma possível o conteúdo deste artigo, é recomendado que você tenha feito o passo-a-passo do primeiro artigo da série, que você encontra aqui:

• API Rest com Node.js, Express, Swagger e MySQL – Parte 1

Também é recomendado que você tenha instalado a ferramenta Postman (ou outra similar) para testar a API.

Então, mãos a obra!

Estrutura de Diretórios da Aplicação Node.js

Vamos iniciar a segunda parte do nosso projeto Node.js adicionando alguns diretórios a ele.

Existem várias formas possíveis de se organizar um projeto em Node.js, pois não há um padrão oficial definido. Porém, existem algumas maneiras mais comuns de se estruturar um projeto. Dentre elas, podemos citar:

• Estruturar o projeto de acordo com as camadas de responsabilidade da aplicação, tais como: configurações, rotas, modelos, controles, etc.
• Estruturar o projeto de acordo com os domínios de negócio da aplicação, tais como: usuários, tarefas, filmes, etc.

Na nossa aplicação vamos usar um mix dessas duas opções citadas, ou seja, vamos organizar nosso projeto tanto por camadas de responsabilidade quanto por domínio.

E, para isso, vamos criar as seguintes pastas na raiz da nossa aplicação: routes, controllers e models.

• routes: pasta que contêm as rotas da nossa API separadas por domínio. Esses arquivos serão responsáveis por chamar os controllers da nossa aplicação.
• controllers: pasta que contêm os controllers da nossa API separados por domínio. Estes arquivos serão responsáveis por tratar as requisições da nossa API e chamar os models.
• models: pasta que contêm os models da nossa API separados por domínio. Estes arquivos serão responsáveis pelas regras de negócio e, portanto, pelo acesso ao banco de dados da nossa API.

Criando as Rotas da API Rest utilizando o Express

Após criar cada diretório, crie o arquivo index.js no diretório routes. Este arquivo será responsável por tratar a requisição HTTP ao endereço base da nossa API. Veja como deve ficar o conteúdo do arquivo index.js:

//define que, qualquer requisição HTTP GET que chegue na rota "/",
//será respondida com esta mensagem

const router = require('express').Router()

router.get('/', (req, res, next) => {
    res.json({ message: 'Seja bem-vindo(a) ao meu catálogo de filmes!'})
})

module.exports = router

Repare agora que surgiu um novo elemento na nossa aplicação: o Router.

O Router é um objeto do Express que nos permite realizar requisições HTTP e funções de middleware no meio da nossa aplicação, sem estar acessando diretamente a aplicação Express que criamos no arquivo app.js. Isto permite um desacoplamento maior do código.

Lembra que no arquivo app.js já havia um tratamento inicial para a requisição feita ao endereço base da nossa API? Então, o trecho de código que fazia isso deve ser removido de lá e, o arquivo, deve ficar deste jeito:

//importando o express
const express = require('express')
const tabelas = require('./database/tabelas')

//cria uma aplicação express
const app = express()

//porta em que a app será executada
const port = 3000

//banco de dados
tabelas.inicializa()

//executando a aplicação na porta definida
app.listen(port, () => {
  console.log(`O servidor está sendo executado em http://localhost:${port}`)
})

Agora vamos criar na pasta routes o arquivo que vai receber todas as requisições feitas a nossa API de filmes. Portanto, crie o arquivo filme.js com o seguinte conteúdo inicial:

const router = require('express').Router()
const filme = require('../controllers/filme')

router.get('/', filme.lista)
router.get('/:id', filme.buscaPorId)
router.post('/', filme.adiciona)
router.patch('/:id', filme.altera)
router.delete('/:id', filme.deleta)

module.exports = router

Você pode verificar que, neste arquivo, também usamos o objeto Router com o mesmo objetivo mencionado anteriormente. Além disso, há alguns elementos que não foram criados ainda, como o controller filme, que está sendo importado no início do arquivo, e todos os métodos do controller: lista, buscaPorId, adiciona, altera e deleta. Estes métodos serão responsáveis por tratar as requisições definidas neste arquivo de roteamento filme.js.

Ao organizarmos nosso código dessa forma, mantemos o desacoplamento na aplicação. Caso fosse necessária uma alteração completa no tratamento das requisições, só precisaríamos criar um novo controller e substituir o atual no início do arquivo por este novo,

Criando o Controller da Aplicação Node.js

Na pasta controllers, vamos criar o arquivo filme.js. Este será o controller da nossa API Rest.

Este arquivo deve conter todos os métodos invocados no nosso arquivo de rotas. Veja:

//lista todos os filmes
exports.lista = async (req, res) => {
    res.status(200).json({"mensagem": "lista"})
}

//busca um filme especifico por id
exports.buscaPorId = async (req, res) => {
    res.status(200).json({"mensagem": "buscaPorId"})
}

//adiciona um novo filme
exports.adiciona = async (req, res) => {
  	console.log(req.body)
    res.status(200).json({"mensagem": "adiciona"})
}

//atualiza os dados de um filme
exports.altera = async (req, res) => {
    res.status(200).json({"mensagem": "altera"})
}

//deleta um filme
exports.deleta = async (req, res) => {
    res.status(200).json({"mensagem": "deleta"})
}

Cada um desses métodos deve ser responsável por tratar os dados da requisição e invocar quem é capaz de acessar o banco de dados, no caso, o modelo.

No momento, para testar nossa aplicação, estamos apenas enviando uma resposta de sucesso (200) em cada um desses métodos quando uma requisição é feita e, no método adiciona, estamos imprimindo no console o conteúdo da requisição feita.

Body-Parser: Middleware Express

O body-parser é um middleware do Express responsável por realizar o parser do corpo (body) das requisições HTTP feitas a nossa API de filmes. Por isso, precisamos adicioná-lo como dependência a nossa aplicação. Portanto, abra o seu prompt de comando/terminal, entre no diretório raiz do projeto e digite o seguinte comando:

npm install --save body-parser

Uma vez instalada a dependência, precisamos configurá-la, ou seja, precisamos informar ao body-parser qual formato de conteúdo nossa API irá receber. Pode ser html, xml, json, dentre outros. No nosso caso, nossa API irá receber requisições com conteúdo no formato json. Para isso, iremos alterar o nosso arquivo app.js e deixá-lo com o seguinte conteúdo:

//importando o express e o bodyparser
const express = require('express')
const bodyParser = require('body-parser')

//importando o script de inicializacao do banco de dados
const tabelas = require('./database/tabelas')

//importando as rotas da API
const indexRouter = require('./routes/index')
const filmeRouter = require('./routes/filme')

//cria uma aplicação express
const app = express()

//parse das requisicoes do tipo application/json
app.use(bodyParser.json())

//porta em que a app será executada
const port = 3000

//inicializacao do banco de dados
tabelas.inicializa()

//define que as requisicoes ao endereco "/" devem ser tratada pelo indexRouter
app.use('/', indexRouter)

//define que as requisicoes ao endereco "/filmes" devem ser tratada pelo filmeRouter
app.use('/filmes', filmeRouter)

//executando a aplicação na porta definida
app.listen(port, () => {
  console.log(`O servidor está sendo executado em http://localhost:${port}`)
})

Veja que também adicionamos as rotas a app.js.

Testando a API no Postman

Para testar o método adiciona da nossa API Rest, ou seja, a requisição HTTP POST:

• Abra o Postman.
• Adicione uma nova aba com o método HTTP POST e o endereço http://localhost:3000/filmes.
• Selecione a aba body, clique na opção raw, escolha o tipo do conteúdo como application/json e crie um json com o conteúdo de sua preferência.

Certifique-se que a a aplicação esteja rodando e envie a requisição no Postman. Você verá o seguinte resultado no Postman e no seu prompt de comando/terminal em que a aplicação estiver executando, respectivamente:

Dê uma olhada no método adiciona do controller filme para relembrar por que que foi respondida esta mensagem a requisição.

No método adiciona, como dito anteriormente, imprimimos o conteúdo do body da requisição no console. Como sugestão, imprima o conteúdo somente de req, veja o que aparece e explore as propriedades.

É isso, pessoal!

No próximo post daremos continuidade a nossa API.

Deixem seus comentários dizendo as suas impressões!

Até o próximo post!