Começando uma API REST com Node.JS

Tecnologia

Faala galera, hoje vamos dar início a um tutorial sobre API REST com Node.JS.
Nessa primeira parte vamos aprender a configurar nossa API e organizar as rotas!

O que é API REST?

API REST é uma interface que fornece dados em um formato padronizado baseado em requisições HTTP.

REST utiliza dos verbos (GET, POST, DELETE, UPDATE, entre outros, esses são os mais utilizados) do protocolo HTTP como base para as requisições.

Por exemplo:
Podemos ter end-points iguais e que fazem coisas diferentes, de acordo com o método da requisição (verbo).

A url https://exemplo.com.br/usuario/57, se requisitada por um GET, vai trazer as informações pertencentes ao usuário de ID 57, se requisitada por um DELETE vai excluir da base de dados o usuário de ID 57, e se feita com um UPDATE altera os dados do usuário 57.

Por isso é importante prestar atenção aos método da requisição.

Vamos ver isso na prática?

Vamos começar a escrever nossa API, para isso é necessário ter o Node.JS e NPM instalado:

Instalando no Linux

Instalando no Mac e Windows

Após isso, vamos abrir nosso terminal e criar uma pasta para nosso projeto, e caminhar até ela:

mkdir api-rest
cd api-rest

Agora vamos iniciar o npm: 
npm init -y

Vamos utilizar dois pacotes para começar: Express e o Cors.

“O Express é um framework para aplicativo da web do Node.js mínimo e flexível que fornece um conjunto robusto de recursos para aplicativos web e móvel.” Para saber mais sobre express.

O cors é quem vai permitir sua API receber requisições de domínios diferentes.

Podemos também configurar para receber apenas de domínios específicos (se necessário) para maior segurança da API. Para saber mais sobre cors.

Vamos instalá-los:

npm i express cors

Configuração

Podemos criar um arquivo na raiz, chamado server.js, onde vamos configurar o express.

const express = require('express');
const cors = require('cors');
const app = express();
 
app.use(cors());
app.use(express.json());
app.listen(3333);

Com o código acima, configuramos nossa API para aceitar requisições de qualquer origem com o cors, e para retornar tudo em JSON.

Feito isso já temos nossa API, podemos iniciar ela utilizando nodemon.

Nodemon é um auxiliar que vai ficar monitorando os arquivos da nossa API, assim que salvarmos uma alteração ele vai reiniciar o server, para que não precisemos fazer isso manualmente. Para saber mais sobre nodemon.

Vamos instalar o nodemon de forma global, para facilitar.

npm i -g nodemon

Vamos rodar a API

Powered by Rock Convert
nodemon server.js

Controllers

Um controlador é responsável por controlar a maneira como um usuário interage com uma aplicação MVC e possui o fluxo de controle lógico para a aplicação. É o controlador que determina que resposta será enviada de volta ao usuário quando ele faz uma requisição.

Criando um Controller:

Criamos uma pasta dentro de src chamada Controllers, e dentro dela um arquivo chamado UsuarioController.js com seguinte código:

exports.post = (req, res, next) => {
   res.status(201).send('Rota POST!');
};
 
exports.put = (req, res, next) => {
   let id = req.params.id;
   res.status(201).send(`Rota PUT com ID! --> ${id}`);
};
 
exports.delete = (req, res, next) => {
   let id = req.params.id;
   res.status(200).send(`Rota DELETE com ID! --> ${id}`);
};
 
exports.get = (req, res, next) => {
   res.status(200).send('Rota GET!');
};
 
exports.getById = (req, res, next) => {
   let id = req.params.id;
   res.status(200).send(`Rota GET com ID! ${id}`);
};

O que estamos fazendo ai é criar os métodos padrão para cada tipo de verbo, do HTTP.

É muito comum em aplicações reais esses métodos (porém são renomeados para a exata função, mas para fins didáticos vai ser assim hoje), o famoso CRUD.

C – Create (POST)

R – Read (GET)

U – Update (PUT)

D – Delete (DELETE)

Estamos também colocando o status da requisição (200, 201), que significam sucesso, e sucesso sem retorno de objeto, respectivamente. Para saber mais sobre Status de requisição.

Feito isso, vamos criar nossas rotas, para podermos acessar os controladores.

Dentro de src, criamos uma pasta Routes;

Dentro de routes, vamos criar um arquivo index.js (onde vamos juntar todas as rotas) e outro UsuarioRoute.js onde vai ter as rotas referentes a usuario

index.js

const UsuarioRoute = require('./UsuarioRoute');

module.exports = (app) => {
   UsuarioRoute(app)
}

UsuarioRoute.js

const UsuarioController = require('../Controllers/UsuarioController');

module.exports = (app) => {
   app.post('/usuario', UsuarioController.post);
   app.put('/usuario/:id', UsuarioController.put);
   app.delete('/usuario/:id', UsuarioController.delete);
   app.get('/usuarios', UsuarioController.get);
   app.get('/usuario/:id', UsuarioController.getById);
}

Agora toda vez que criarmos um arquivo de rota, basta importar ele no arquivo index de Routes, como fizemos com o de usuário.
E agora precisamos fazer uma pequena alteração em server.js, para as rotas funcionarem.

const express = require('express');
const cors = require('cors');
const app = express();

require('./src/Routes/index')(app); // <--- basta adicionar essa linha

app.use(cors());
app.use(express.json());
app.listen(3333);

Feito isso, podemos testar (se nodemon não estiver rodando > nodemon server.js)

E por hoje é isso, galera!

Nesse artigo vimos o básico para termos nossa API funcionando de forma simples e eficaz.

E nas próximas etapas, vamos fazer conexão com mongodb, colocar autenticação JWT, tratamento de erro e algumas coisas mais, então fiquem ligad@s!