Validação de dados em Rust: bibliotecas e abordagens para código confiável

Validação de dados em Rust: visão geral de bibliotecas e abordagens práticas

A validação de dados é uma das pedras angulares do desenvolvimento de software confiável. Em Rust, uma linguagem conhecida por sua segurança de memória e tipagem rigorosa, a verificação da correção dos dados de entrada atinge um novo nível. Neste artigo, vamos explorar quais ferramentas e bibliotecas ajudam os desenvolvedores Rust a implementar validação flexível e eficiente, e ver exemplos concretos de código.

Por que a validação é necessária em Rust?

Rust já detecta muitos erros relacionados a tipos e posse durante a compilação. No entanto, os dados provenientes do mundo externo (entrada do usuário, requisições de API, arquivos) não podem ser verificados pelo compilador. É aqui que a validação entra em ação. Ela permite:

• Garantir a integridade dos dados — verificar se o email está no formato correto e se a idade está dentro de limites razoáveis.
• Aumentar a segurança — prevenir injeções e entradas incorretas.
• Melhorar a experiência do usuário — fornecer mensagens de erro claras.
• Manter o desempenho — as bibliotecas de validação Rust operam com sobrecarga mínima.

Principais bibliotecas para validação em Rust

O ecossistema Rust oferece várias soluções maduras. Vamos analisar as mais populares.

1. Biblioteca validator

validator é, sem dúvida, o crate mais conhecido para validação de estruturas de dados. Ele é baseado em atributos (derive macros) e permite descrever regras de validação diretamente na definição da estrutura.

Exemplo de uso:

use validator::Validate;

#[derive(Validate)]struct User {    #[validate(email)]    email: String,

    #[validate(length(min = 3, max = 50))]    username: String,

    #[validate(range(min = 18, max = 120))]    age: u8,}

fn main() {    let user = User {        email: "invalid-email".to_string(),        username: "Jo".to_string(),        age: 15,    };

    match user.validate() {        Ok(_) => println!("Dados corretos"),        Err(errors) => {            for (field, err) in &errors.field_errors() {                println!("Erro no campo {}: {:?}", field, err);            }        }    }}

A biblioteca suporta validadores embutidos: email, url, length, range, must_match e outros. Também é possível escrever funções validadoras personalizadas.

2. Biblioteca garde

garde é uma alternativa mais moderna e flexível. Ela também usa derive macros, mas oferece mais possibilidades para composição de regras e trabalho com estruturas aninhadas.

Exemplo de uso:

use garde::Validate;

#[derive(Validate)]struct LoginForm {    #[garde(email)]    email: String,

    #[garde(length(min = 8))]    password: String,}

fn main() {    let form = LoginForm {        email: "test@example.com".to_string(),        password: "123".to_string(),    };

    if let Err(errors) = form.validate() {        println!("Erros de validação: {}", errors);    } else {        println!("Formulário correto");    }}

Uma característica distintiva do garde é o suporte a validadores assíncronos, o que é útil para verificações que exigem acesso a banco de dados ou APIs externas.

3. Validação manual usando Result e Option

Às vezes, não é necessário incluir uma biblioteca inteira. Rust permite implementar validação com funções simples e pattern matching. Isso oferece controle total sobre a lógica.

Exemplo de validação manual:

fn validate_username(username: &str)