Como criar um CLI de validação de CPF em Rust

// Cargo.toml
[package]
name = "cpf-cli"
version = "0.1.0"
edition = "2021"

[dependencies]
clap = { version = "4", features = ["derive"] }
reqwest = { version = "0.12", features = ["json"] }
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
colored = "2"

use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "cpf-cli")]
#[command(about = "Ferramenta de validação e consulta de CPF")]
#[command(version = "1.0")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Validar os dígitos verificadores de um CPF
    Validar {
    /// O CPF a ser validado (apenas dígitos ou formatado)
    cpf: String,
    },
    /// Consultar dados de um CPF na API do CPFHub
    Consultar {
    /// O CPF a ser consultado
    cpf: String,

    /// Chave de API do CPFHub (ou use CPFHUB_API_KEY)
    #[arg(short, long, env = "CPFHUB_API_KEY")]
    api_key: String,
    },
    /// Processar um lote de CPFs a partir de um arquivo
    Lote {
    /// Caminho do arquivo com CPFs (um por linha)
    arquivo: String,

    /// Chave de API do CPFHub
    #[arg(short, long, env = "CPFHUB_API_KEY")]
    api_key: String,
    },
}

use colored::*;

fn validar_cpf(cpf: &str) -> bool {
    let digitos: Vec<u32> = cpf.chars()
    .filter(|c| c.is_ascii_digit())
    .filter_map(|c| c.to_digit(10))
    .collect();

    if digitos.len() != 11 || digitos.iter().all(|&d| d == digitos[0]) {
    return false;
    }

    let soma: u32 = digitos.iter().take(9)
    .enumerate()
    .map(|(i, &d)| d * (10 - i as u32))
    .sum();
    let d1 = if soma % 11 < 2 { 0 } else { 11 - (soma % 11) };

    let soma: u32 = digitos.iter().take(10)
    .enumerate()
    .map(|(i, &d)| d * (11 - i as u32))
    .sum();
    let d2 = if soma % 11 < 2 { 0 } else { 11 - (soma % 11) };

    digitos[9] == d1 && digitos[10] == d2
}

fn executar_validacao(cpf: &str) {
    let cpf_limpo: String = cpf.chars().filter(|c| c.is_ascii_digit()).collect();

    if cpf_limpo.len() != 11 {
    println!("{} CPF deve conter 11 dígitos (recebido: {})",
    "ERRO:".red().bold(), cpf_limpo.len());
    return;
    }

    if validar_cpf(&cpf_limpo) {
    println!("{} CPF {} possui dígitos verificadores válidos",
    "VALIDO:".green().bold(), cpf);
    } else {
    println!("{} CPF {} possui dígitos verificadores inválidos",
    "INVALIDO:".red().bold(), cpf);
    }
}

use serde::Deserialize;
use reqwest::header::{HeaderMap, HeaderValue};

#[derive(Debug, Deserialize)]
pub struct CpfResponse {
    pub success: bool,
    pub data: CpfData,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CpfData {
    pub cpf: String,
    pub name: String,
    pub name_upper: String,
    pub gender: String,
    pub birth_date: String,
    pub day: String,
    pub month: String,
    pub year: String,
}

async fn executar_consulta(cpf: &str, api_key: &str) {
    let mut headers = HeaderMap::new();
    headers.insert("x-api-key", HeaderValue::from_str(api_key).unwrap());

    let client = reqwest::Client::new();
    let url = format!("https://api.cpfhub.io/cpf/{}", cpf);

    match client.get(&url).headers(headers).send().await {
    Ok(response) if response.status().is_success() => {
    match response.json::<CpfResponse>().await {
    Ok(dados) if dados.success => {
    println!("{}", "CPF encontrado!".green().bold());
    println!(" {}: {}", "Nome".bold(), dados.data.name);
    println!(" {}: {}", "CPF".bold(), dados.data.cpf);
    println!(" {}: {}", "Nascimento".bold(), dados.data.birth_date);
    println!(" {}: {}", "Gênero".bold(), dados.data.gender);
    }
    _ => println!("{} CPF não encontrado na base", "AVISO:".yellow().bold()),
    }
    }
    Ok(response) => {
    println!("{} API retornou status {}", "ERRO:".red().bold(), response.status());
    }
    Err(e) => {
    println!("{} {}", "ERRO:".red().bold(), e);
    }
    }
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();

    match cli.command {
    Commands::Validar { cpf } => {
    executar_validacao(&cpf);
    }
    Commands::Consultar { cpf, api_key } => {
    executar_consulta(&cpf, &api_key).await;
    }
    Commands::Lote { arquivo, api_key } => {
    let conteudo = std::fs::read_to_string(&arquivo)
    .expect("Não foi possível ler o arquivo");

    let cpfs: Vec<&str> = conteudo.lines()
    .filter(|l| !l.trim().is_empty())
    .collect();

    println!("Processando {} CPFs...\n", cpfs.len());

    for cpf in cpfs {
    executar_consulta(cpf.trim(), &api_key).await;
    println!("---");
    }
    }
    }
}