O Básico: Express - Rotas
Tags: node, beginners, javascript, braziliandevs
Published: 2022-03-16 21:29:24

## Roteamento

### O que é?
É o aspecto mais básico de uma API HTTP, onde __cada rota representa um endpoint__ e cada endpoint é responsável por uma ação, além de que __cada rota pode tratar de diversos métodos HTTP__.

### O que faz?
Divide a API em diversos _"caminhos"_ pelo quais podemos percorrer, cada caminho deverá ser responsável por uma parte diferente da aplicação e comunicar ao cliente o status da requisição solicitada, bem como retornar dados _(se for o caso)_.

### Acessando rotas
Para acessarmos uma rota de nossa API precisamos respeitar duas condições:

1. a primeira é acessarmos o endpoint correto
2. a segunda é utilizarmos o método que definimos para o endpoint.

### Sintaxe
Podemos definir rotas de duas formas diferentes, a primeira opção consiste em utilizar métodos HTTP e definir a rota nos parâmetros, já a segunda opção consiste em definirmos uma rota e a partir dela utilizarmos os métodos HTTP.

A segunda opção é conhecida como encadeamento de rotas e é mais recomendada, pois diminui as chances de qualquer erro ortográfico.

``` javascript
// sintaxe básica para definição de rotas

api./*método HTTP*/(/*path*/, (req, res) => {}):
api.get('/', (req, res) => {});
```

``` javascript
// encadeamento de rotas

api.route(/*path*/)
  ./*método HTTP*/((req, res) => {})
  ./*método HTTP*/((req, res) => {});
api.route('/')
  .get((req, res) => {})
  .post((req, res) => {});
```

___

## Parâmetros de Rota

### O que são?
São opções que podemos passar para as rotas, a fim de torná-las dinâmicas.

### O que fazem?
Os parâmetros permitem a criação de rotas dinâmicas, afinal podemos passar diferentes valores para acessarmos conteúdos diferentes. Dessa forma podemos criar um único endpoint para a interação com diversas informações.

### Sintaxe
A maneira como definimos parâmetros de rotas no Express é muito similar a maneira como o definimos no React-Router*, tudo que precisamos fazer é utilizar dois pontos `:` antes do que seria nosso parâmetro.

Uma vez definido, podemos desconstruí-lo do objeto de requisição, __respeitando sempre o nome que demos em sua definição__. Para isso acessamos a propriedade `params` da `req`.

``` javascript
api.get(/*rota*/:/*parâmetro*/, (req, res) => {
  const { /*parâmetro*/ } = req.params;
});

api.get('/recipes/:id', (req, res) => {
  const { id } = req.params;
  const recipe = recipes.find((r) => r.id === Number(id));

  return recipe  // se nenuma receita for achada, recipe vai ser undefined
    ? res.status(200).json(recipe)
    : res.status(404).json({ message: 'Recipe not found!' });
});
```

___

## Query String

### O que são?
São parâmetros que podemos passar para as rotas, sendo que diferente dos parâmetros de rotas, vistos anteriormente, podemos encadear quantas Query Strings quisermos.

### O que fazem?
Assim como os parâmetros de rotas, as Query Strings permitem a criação de rotas dinâmicas, porém esse recurso é mais utilizado para pesquisas avançadas, na qual podemos pesquisar pelo termo ou outras características do produto.

### Sintaxe
Para definirmos Query Strings em um endpoint utilizamos a sintaxe de chave-valor, iniciando-as com um ponto de interrogação `?` e concatenando-as com um E comercial `&`.

```
http://localhost:3001/recipes/search?name=panetone&maxPrice=100
```

Frisando que, diferente dos Parâmetros de Rotas, as __Query Strings não são definidas junto do endpoint__, mas sim ao acessar determinada rota. Já para conseguirmos ter acesso às Query Strings, tudo que precisamos fazer é desconstruí-las da propriedade `query` do objeto `req`.

``` javascript
api.get(/*rota*/, (req, res) => {
  const { /*query*/ } = req.query;
});

api.get('/recipes/search', (req, res) => {
  const { name, maxPrice } = req.query;

  const recipe = recipes.filter((r) => (
    r.name === name && r.maxPrice <= maxPrice
  ));

  return recipe.length > 0  // se nenhuma receita atender os requisitos, o Array terá tamanho 0
    ? res.status(200).json(recipe)
    : res.status(404).json({ message: 'Recipes not found!' });
});
```

___

## Informação no Body

### O que é?
São informações contidas dentro do _Body_ da requisição HTTP, normalmente temos essas informação em requisições do tipo POST, PUT ou PATCH.

### O que faz?
Utilizamos o Body para enviar informações sensíveis ao servidor, pois diferente das informações enviadas pelo Header, essas não são visíveis durante a comunicação, sendo possível acessá-las somente no Back-end.

### Sintaxe
Para termos acesso a informação contida no Body da requisição precisamos acessar a propriedade `body` do objeto `req`, mas não apenas isso, também é necessário _"parsear"_ a informação do `body` e para isso podemos utilizar o método `.json()` do próprio Express.

Para garantir que todas as nossas informações provenientes do Body sejam convertidas, executamos o método `.json()` nos parâmetros do `app.use()`.

``` javascript
api.use(express.json());

api.post(/*rota*/, (req, res) => {
  const { /*informações*/ } = req.body;
});

api.post('/recipes/', (req, res) => {
  const { name, maxPrice } = req.body;
  recipes.push({ name, maxPrice });

  res.status(201).json({ message: 'Recipe created successfully!' });
});
```