# Aplicação de uma pequena restAPI

Neste módulo o foco será em mostrar uma API simples que mostra o básico do que se pode fazer com o node.

## O que é restAPI?

Uma restAPI é uma arquitetura que acessa vários endpoints (caminhos de uma URL) diferentes com vários métodos HTTPs para criar uma aplicação.

## Gerenciadores de requisições

Gerenciadores de requisições são plataformas que fazem requisições, eles servem para entender como sua aplicação se comporta quando se faz algumas requisições para as funcionalidades da API. Os mais conhecidos são o Postman, o Insomnia e o cURL (que pode ser usado via linha de código).&#x20;

No nosso exemplo, iremos utilizar o postman, que pode ser instalado em: <https://www.postman.com/downloads/>.&#x20;

## Exemplo

A fim deste exemplo, a aplicação que será feita é uma lista. Esta lista estará, inicialmente, vazia; então, será possível colocar itens nela, ver todos os itens da lista, acessar um item específico e deletar itens da lista.

### Configuração do repositório

Para começar, iremos criar um repositório e navegar para ele:

```bash
mkdir app
cd app
```

Então preparar o repositório como um repositório node/npm:

```bash
npm init -y
```

Após isso, iremos instalar o express, que é uma biblioteca que facilita a disponibilização das URLs (endpoints) para que o cliente possa usar:

```bash
npm i express
```

Também iremos criar um arquivo em que iremos configurar as funções da API:

```bash
touch index.js
```

Com isso, o seu package.json deve estar:

```javascript
{
  "name": "app",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.17.1"
  }
}
```

Iremos instalar mais uma dependência para habilitar o uso da requisição pela api:

```bash
npm i body-parser
```

E iremos colocar um script a mais no package.json, isto irá habilitar que possamos iniciar a aplicação com o seguinte comando:

```bash
npm start
```

Então, no final, o package.json ficará:

```javascript
{
  "name": "app",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "body-parser": "^1.19.0",
    "express": "^4.17.1"
  }
}
```

### Codificando a API

Agora, iremos realmente fazer as funcionalidades da api, todas elas irão estar colocadas no arquivo index.js do nosso repositório.

Primeiro, iremos importar todas as dependências que necessitamos para fazer a aplicação e colocar a porta de entrada de nossa aplicação em uma variável:

```javascript
const express = require('express')
const bodyparser = require('body-parser')
const PORT = 5000
```

Em seguida, vamos criar a função que permita que a porta que queremos acessar para a aplicação e invocar uma constante que guarde a instância do express, para que as funções dessa dependência possam ser utilizadas

```javascript
const app = express()

app.listen(PORT, () => {
    console.log(`Server is active on http://localhost:${PORT}`)
})
```

Caso esteja correto, quando utilizarmos o script para começar a aplicação, o terminal deverá ter a seguinte mensagem:

```bash
Server is active on http://localhost:5000
```

Então iremos fazer uma função que possa inserir itens em uma lista:

```javascript
let list = []

app.post('/item', (req, res) => {

    const { title } = req.body

    const item = {
        "title": title
    }

    list.push(item)

    return res.json(item)

})
```

Iremos fazer duas funções que visualizem a lista; uma delas vê todos os itens da lista e a outra vê somente um item específico da lista:

```javascript
app.get('/item/all', (req, res) => {

    return res.send(list);

})

app.get(`/item`, (req, res) => {

    if(!list.length) return res.status(400).send(`A lista está vazia`)

    const { title } = req.query

    list.map((item) => {
        if(item.title == title) return res.send(item)
    })

    return res.send('Esse item não está na lista')

})
```

E por último, fazer uma função que deleta os itens da lista:

```javascript
app.delete('/item', (req, res) => {


    const { title } = req.query

    let index = -1

    list.map((item) => {
        index++
        if(item.title == title){
            list.splice(index, 1);
            return res.status(200).send('Item Removido')
        }
    })

    return res.status(400).send('Item não encontrado')

})
```

Com todas as funcionalidades feitas, a nossa aplicação simples está bem feita e pode ser utilizada.

### Testando a aplicação

Iremos utilizar o postman para testar a aplicação e mostrar como que a api reage com as requisições feitas.

Primeiro, iremos iniciar a aplicação:

```bash
npm start
```

E, com a aplicação inicializada, podemos começar a utilizar o postman:

Primeiro, iremos usar o método post na URL <http://localhost:5000/item/>, que requer um corpo para fazer a requisição como mostrado na imagem abaixo:

![Postman pós requisição POST](https://552011742-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MEJ_IxNzk9of-u9NQeq%2F-MLZkflqZiJNOeXfJmWl%2F-MLd3xGYgowZjADcBwGV%2Fpost_items2.png?alt=media\&token=d881842a-8db1-4bd5-8ffa-57d449513e54)

Acima, ns enviamos um corpo em JSON na URL mencionada usando o método POST. Então, como resposta, recebemos um objeto JSON, que mostra o que foi adicionado.

Depois de adicionar mais alguns itens, podemos ver a lista inteira usando o método GET na URL <http://localhost:5000/item/all>, como visto abaixo:

![Requisição GET feita para ver a lista](https://552011742-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MEJ_IxNzk9of-u9NQeq%2F-MLZkflqZiJNOeXfJmWl%2F-MLd4rxPinRN4zLnPM7I%2Fget_all.png?alt=media\&token=361f0749-dbad-45ad-9472-4ce1cfcbe6e8)

Se quisermos remover um dos itens, precisamos fazer a requisição DELETE na URL <http://localhost:5000/item/>, mas para reconhecer qual item deve ser retirado, precisamos colocar um query string (reconhecido pelo ? após a URL, como explicado no capítulo "Revisão de HTTP"). Como nosso identificador dos itens é o parâmetro title, nós colocamos qual item com o title deve ser retirado. Abaixo, mostramos um exemplo:

![Postman após uma requisição DELETE](https://552011742-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MEJ_IxNzk9of-u9NQeq%2F-MLZkflqZiJNOeXfJmWl%2F-MLd66nuR5GKcbXZtGa2%2Fdelete_item.png?alt=media\&token=ba1d9eed-889a-4f41-8341-7bc89dc5d6c0)

E, se vermos, como está a lista atual, vemos que não tem mais o item03:

![Como fica a lista após uma requisição DELETE](https://552011742-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MEJ_IxNzk9of-u9NQeq%2F-MLZkflqZiJNOeXfJmWl%2F-MLd6Zv5zd80A5z4jSPN%2Fget_all2.png?alt=media\&token=e0da001c-91fd-46d3-8492-217e6f99f8a1)

Com isso, podemos ver todas as requisições, e como elas funcionam e mostrar como nossa API reage a elas.
