DEV Community: Codificações para mim mesmo

Aprendendo a Validar Dados em APIs Node.js com express-validator

Vítor Oliveira — Tue, 12 Mar 2024 17:17:39 +0000

Introducação

A validação dos dados de entrada é importante porque garante a integridade e a validade dos dados que recebemos, e isso é crucial para um projeto bem sucedido. Pensando nisso comentei com minha esposa — que também é programadora, sobre minha necessidade. Ela então comentou comigo sobre o DataAnnotation do C# que tem essa função, foi então que comecei a pesquisar uma alternativa para minha stack e encontrei o express-validator, que agora vou compartilhar a implementação das validações na minha API.

1. Por que usar o express-validator

É um conjunto de middlewares popular para express.js que envolve a extensa coleção de validadores e higienizadores oferecidos pelo validator.js com a finalidade de validar solicitações HTTP. Com algumas combinações, é possível:

Validação e verificação dos dados/campos aninhados ou arrays de objetos.
Validações em cadeia para um único campo.
Validações personalizadas, como por exemplo validação assíncrona e até mesmo arquivos. Exemplo:

app.post('/users',
    [
        // Verifica se o e-mail já está em uso
        body('email').custom(async (value) => {
            const user = await User.findOne({ email: value });
            if (user) {
                throw new Error('E-mail já está em uso');
            }
        }),
    ],
    // Resto da lógica para criação de usuário
);

Sanitização dos dados, permitindo a manipulação do mesmo para usá-los na aplicação.
Personalização das mensagens de erro.

É relativamente simples, até pensei em usar o Joi para essas validações, mas para o meu contexto express-validator serviu muito bem!

2. Colocando em Prática

Para começar é bem simples, basta instalar. É a única configuração requerida para começar a usar.

npm install express-validator

No meu contexto as regras de validação não estão diretamente na rota, elas foram encapsuladas em um local separado, dessa forma continuo garantindo a validação dos dados e organizo meu código.

//minutes.routes.js
import { Router } from 'express';

import insertMinutesController from '../../controllers/insertMinutesController.js';
import { dataValidation } from '../middlewares/validations.js';

const minutesRoutes = Router();

minutesRoutes.post('/insert', dataValidation, insertMinutesController.insertMinutes);

export default minutesRoutes;

Agora antes de seguirmos para as validações contidas em dataValidation, qualquer dado em não conformidade com as validações será entendido como um erro e capturado pelo validationResult.
No meu caso, adicionei essa função no arquivo insertMinutesController.

//insertMinutesController.js
import { validationResult } from 'express-validator';

const insertMinutes = async (req, res, next) => {
    // Verifica se está tudo certo com a requisição
    const errors = validationResult(req);
    if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() });

    // Resto da lógica para criação da ata
};

export default {
    insertMinutes
}

Também é possível fazer diretamente na rota, logo após o middleware.
Exemplo:

app.post('/users',
    [
        // Verifica se o e-mail já está em uso
    body('email').custom(async (value) => {
        const user = await User.findOne({ email: value });
        if (user) {
            throw new Error('E-mail já está em uso');
        }
        }),
    ],
    // Resto da lógica para criação de usuário
    (req, res) => {
        // Verifica se houve erros de validação
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    }
);

Minhas validações

Não vou colocar o código na integra, no final do artigo deixo o link do repositório dessa solução que estou desenvolvendo.

Na minha API até o momento foi necessário validar quatro casos:

String
Number
Data
3 Tipos de Validações customizadas

String

Alguns campos na minha API não são obrigatórios mas possuem um tipo de dado específico. Neste caso usei isString() assinalando que espero um string.
Exemplo:

//validations.js
body('sacramentMeeting.authorities')
    .isString().withMessage('The value must be text.'),

Sendo assim eu posso receber uma string vazia, mas sempre deve ter esse tipo. Caso seja enviado null no campo. O seguinte erro vai aparecer com a mensagem escolhida:

//Estrutura padrão de erros
{
  "errors": [
    {
      "type": "field",
      "value": null,
      "msg": "The value must be text.",
      "path": "sacramentMeeting.authorities",
      "location": "body"
    }
  ]
}

É possível modificar essa estrutura.

Number

Esse campo da minha API recebe um número correspondente a música escolhida, então isNumeric() me ajudou a garantir o tipo.
Exemplo:

//validations.js
body('sacramentMeeting.specialhymn')
    .isNumeric().withMessage('The value must be numeric.'),

Data

Além do tipo validado que nesse caso é uma data, aqui também entra mais uma função de validação. O notEmpty() ajuda bastante também a garantir que o campo não seja vazio.
Exemplo:

//validations.js
body('sacramentMeeting.date')
    .notEmpty().withMessage('The "date" is required.')
    .isISO8601().withMessage('The data must be in ISO 8601 format (YYYY-MM-DD).'),

1° Validação Customizada

Essa validação me marcou porque esse campo não é tão importante aponto de ter um tabela reservada no banco. Mas também não é tão irrelevante assim, então descobri que no PostgreSQL é possível criar uma coluna varchar como array, isso mesmo que você leu, basta usar VARCHAR(510)[]. Dessa forma posso trabalhar com os dados dessa coluna usando métodos de percorrer, porque um array de strings será retornado.

Primeiro eu começo confirmando se é um array com isArray(), se não for a mensagem contida em withMessage() é lançada.
Na próxima sim, temos a validação personalizada, sinalizada pela função custom() onde o valor enviado na requisição é capturado com value e percorrido em seguida para ser validado.

Exemplo:

//validations.js
body('sacramentMeeting.visitors')
    .isArray().withMessage('The value must be an array.')
    .custom((value) => {
        for (let item of value) {
            if (typeof item !== 'string') {
                throw new Error('All elements in the array must be strings.');
            }
        }
        return true;
    }),

2° Validação Customizada

Essa validação foi mais incrementada porque o campo firstspeaker pode ser opcional apenas no primeiro domingo de cada mês. Então como eu recebo uma data como string ("2024-02-21"), o método createLocalDate() converte esse valor para um objeto do tipo Date.

É importante observar que o mês é decrementado em 1, pois no JavaScript os meses são indexados a partir de 0 (janeiro é 0, fevereiro é 1 e assim por diante).

Dessa forma posso saber em isFirstSunday() se a data atual é o primeiro domingo do mês. Se for, será retornado true, se não será false.

O método getDate() retorna o número do dia do mês, enquanto getDay() retorna o número do dia da semana.

Por último, precisava validar caso não fosse o primeiro domingo do mês, então usando value?.trim() consigo validar se for enviado null ou string vazia, isso porque ambos em um contexto Boleano é entendido como false no javascript. Então se for enviado o valor corretamente, apenas será removido os espaços do começo e fim do valor.
Exemplo:

//validations.js
body('sacramentMeeting.firstspeaker')
    .custom((value, { req }) => {
        if (isFirstSunday(createLocalDate(req.body.sacramentMeeting.date)) || value?.trim()) return true;

        throw new Error('The "third speaker" is missing.');
    }),

3° Validação Customizada

E por último tenho o campo testimonies, um array com objetos contendo os nomes de quem prestou um testemunho. Sendo assim verifico se o array é null ou se é um array com a estrutura esperada, seguindo: array -> objects -> propriedade name (string).
Exemplo:

//validations.js
body('testimonies')
    .custom((array) => array === null || (Array.isArray(array) && array.every((item) => typeof item === 'object' && typeof item.name === 'string')))
    .withMessage('The value must be string array.'),

3. Conclusão

Utilizar o express-validator pode ser uma mão na roda para validar os dados de entrada sem muito esforço e ainda garantir segurança. Dependendo do contexto e preferência pessoal, pode ser interessante utilizar o Joi para essa finalidade.

Se chegou até aqui, muito obrigado pelo seu tempo e atenção!

Criando projeto com TypeScrit

Vítor Oliveira — Wed, 18 Aug 2021 13:54:14 +0000

Para começar, vamos falar um pouquinho sobre TypeScript. O TypeScript é uma linguagem open-source da Microsoft, que traz um conjunto de muitas melhorias do JavaScript, ambas podem trabalhar juntas trazendo benefícios durante o desenvolvimento como tipagem(estática) de parâmetros, impedindo que sofram alteração no tipo do seu valor ao longo do desenvolvimento.
Documentação do TypeScript

Agora sim vamos começar a criação do projeto seguindo um passo a passo bem simples.

Caso você já tenha criado e só falta essa parte do TypeScript, pula pra parte 4 ou 5 — dependendo da sua situação e manda bala que vai dar certo.

Escolha o local onde vai ficar sua API e crie uma pasta, feito isso, acesse a pasta pelo seu terminal e execute o comando abaixo:
1- yarn init -y ⇒ Vai criar o arquivo packege.json
2- yarn add express ⇒ Serve para criarmos nossas rotas
3- yarn add @types/express -D ⇒ Evitando casualidade na hora de acessar diferentes tipos de rota, instalando todos os tipos do Express
4- yarn add typescript -D ⇒ Adiciona TypeScript como dependência de projeto.
5- yarn tsc --init ⇒ Cria o arquivo tsconfig.json
6- yarn add ts-node-dev -D ⇒ Responsável pelo funcionamento e conversão do arquivo TS. Depois de executar o comando, precisamos adicionar um script dentro de packege.json como no exemplo abaixo:

//Pode ficar entre license
"scripts": {
    "dev": "ts-node-dev src/server.ts"
},
//e dependencies

Existem outras flags que podem ser adicionadas no script dev, que auxiliam em diferentes níveis no desenvolvimento da aplicação.

Flag é um parâmetro no comando que tem -- antes.

Vou deixar abaixo como utilizo no meu aprendizado e uma descrição de cada uma delas.

"scripts": {
    "dev": "ts-node-dev --inspect --transpile-only --ignore-watch node_modules --respawn src/server.ts"
},

Descrição das Flags

ts-node-dev ou tsnd ⇒ Como já falamos, é para o funcionamento da aplicação e conversão dos arquivos TS.
--inspect ⇒ Habilita a utilização do debug dentro da aplicação, e para configurar essa parte tem um outro post que fala sobre isso.
--transpile-only ⇒ Desabilita a verificação de erros na aplicação, afinal de contas, o próprio VS Code e o ESLint já fazem isso.
--ignore-watch node_modules ⇒ Não observa alterações dentro da pasta node_modules. Então acaba ajudando a diminuir a lentidão no restart da aplicação.
--respawn ⇒ Da um reload na aplicação quando houver alterações no código.

Outra observação, agora com relação a forma como eu estudo. É sobre desabilitar uma linha dentro de tsconfig.json que verifica alguns erros dentro da aplicação como declaração de variável. Pra isso basta procurar por "strict": "true" e comentar a linha.

—————————————————

📌Para dúvidas ou sugestões:

Deixe seu comentário ou entre em contato.