Validation

use garde::Validate;
use navree::validation::rules;
use serde::Deserialize;

#[derive(Debug, Deserialize, Validate)]
pub struct CreateContact {
    #[garde(length(chars, min = 1, max = 100))]
    pub first_name: String,
    #[garde(length(chars, min = 1, max = 100))]
    pub last_name: String,
    #[garde(email)]
    pub email: String,
    #[garde(range(min = 16, max = 120))]
    pub age: Option<u8>,
    #[garde(length(max = 10), inner(length(min = 1, max = 30)))]
    pub tags: Vec<String>,
    #[garde(custom(rules::one_of(&["lead", "customer", "churned"])))]
    pub status: String,
}

#[derive(Debug, Deserialize, Validate)]
pub struct ContactFilters {
    #[garde(length(min = 2))]
    pub search: Option<String>,
    #[garde(range(min = 1, max = 100))]
    pub per_page: Option<u32>,
}

[dependencies]
garde = { version = "0.23", features = ["derive", "email"] }

use navree::prelude::*;
use serde::Serialize;
use uuid::Uuid;

#[derive(Debug, Serialize)]
pub struct ContactView {
    pub name: String,
}

#[injectable]
pub struct ContactsController;

#[controller("/contacts", version = "1")]
#[authenticated]
impl ContactsController {
    #[get("/")]
    async fn index(&self, Valid(Query(filters)): Valid<Query<ContactFilters>>) -> Json<Vec<String>> {
        Json(filters.search.into_iter().collect())
    }

    #[post("/")]
    async fn store(&self, Valid(Json(input)): Valid<Json<CreateContact>>) -> Created<ContactView> {
        let id = Uuid::now_v7();
        let name = format!("{} {}", input.first_name, input.last_name);
        Created(format!("/api/v1/contacts/{id}"), ContactView { name })
    }
}

{
  "first_name": "",
  "last_name": "Lovelace",
  "email": "ada@",
  "age": 12,
  "tags": ["vip", ""],
  "status": "prospect"
}

{
  "statusCode": 400,
  "message": [
    "age must not be less than 16",
    "email must be a valid email address",
    "first_name must be longer than or equal to 1 characters",
    "status must be one of the following values: lead, customer, churned",
    "tags.1 must be longer than or equal to 1 characters"
  ],
  "error": "Bad Request",
  "errors": {
    "age": ["age must not be less than 16"],
    "email": ["email must be a valid email address"],
    "first_name": ["first_name must be longer than or equal to 1 characters"],
    "status": ["status must be one of the following values: lead, customer, churned"],
    "tags.1": ["tags.1 must be longer than or equal to 1 characters"]
  }
}

use navree::validation::confirmed;
use navree::validation::rules;

#[derive(Debug, Deserialize, Validate)]
pub struct Register {
    #[garde(length(min = 8), custom(confirmed(&self.password_confirmation)))]
    pub password: String,
    #[garde(skip)]
    pub password_confirmation: String,
    #[garde(custom(rules::uuid))]
    pub team_id: String,
    #[garde(custom(rules::date_ymd))]
    pub starts_on: Option<String>,
}

#[derive(Debug, Deserialize, Validate)]
pub struct NewSubscription {
    #[garde(skip)]
    pub plan: Plan, // "starter", "team" or "enterprise"
    #[garde(range(min = 1))]
    pub seats: u32,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Plan {
    Starter,
    Team,
    Enterprise,
}

{
  "statusCode": 400,
  "message": ["last_name should not be empty"],
  "error": "Bad Request",
  "errors": { "last_name": ["last_name should not be empty"] }
}

#[derive(Debug, Default, Deserialize, Validate, ToSchema)]
pub struct CreateDeal {
    #[garde(required, custom(not_blank), length(max = 255))]
    pub title: Option<String>,
    #[garde(required)]
    pub company_id: Option<Uuid>,
    #[garde(required, range(min = 0, max = MAX_AMOUNT_CENTS))]
    pub amount_cents: Option<i64>,
    // ...
}

{
  "statusCode": 400,
  "message": [
    "amount_cents should not be empty",
    "company_id should not be empty",
    "title should not be empty"
  ],
  "error": "Bad Request",
  "errors": {
    "amount_cents": ["amount_cents should not be empty"],
    "company_id": ["company_id should not be empty"],
    "title": ["title should not be empty"]
  }
}

{
  "statusCode": 400,
  "message": ["body must be a valid JSON string"],
  "error": "Bad Request",
  "errors": { "body": ["body must be a valid JSON string"] }
}

{
  "statusCode": 400,
  "message": [
    "per_page must not be greater than 100",
    "search must be longer than or equal to 2 characters"
  ],
  "error": "Bad Request",
  "errors": {
    "per_page": ["per_page must not be greater than 100"],
    "search": ["search must be longer than or equal to 2 characters"]
  }
}

use std::collections::BTreeMap;

use navree::validation::ValidationOptions;

let options = ValidationOptions {
    messages: BTreeMap::from([
        ("required".to_owned(), "Please fill in :attribute.".to_owned()),
        ("email.unique".to_owned(), "This e-mail is already registered.".to_owned()),
    ]),
    attributes: BTreeMap::from([("first_name".to_owned(), "first name".to_owned())]),
};
let app = Navree::app().module(ValidationModule::with_options(options));

[validation.messages]
required = ":Attribute is required."
"email.unique" = "This e-mail is already registered."

# Nested tables flatten to dotted keys: this sets `min.string`.
[validation.messages.min]
string = ":Attribute needs at least :min characters."

[validation.attributes]
first_name = "first name"
"address.city" = "city"

use navree::validation::rule_error;

pub fn even(value: &u32, _ctx: &()) -> garde::Result {
    if value.is_multiple_of(2) {
        Ok(())
    } else {
        Err(rule_error("even", &[("value", value)]))
    }
}

pub fn not_blank(value: &str, _ctx: &()) -> garde::Result {
    if value.trim().is_empty() {
        Err(garde::Error::new(":attribute must not be blank"))
    } else {
        Ok(())
    }
}

#[derive(Debug, Deserialize, Validate)]
pub struct Teams {
    #[garde(custom(even))]
    pub size: u32,
    #[garde(custom(not_blank))]
    pub name: String,
}

use navree::validation::{AsyncRule, AsyncRules};

#[derive(Debug, Deserialize, Validate)]
pub struct UpdateUser {
    #[garde(email)]
    pub email: String,
    #[garde(skip)]
    pub team_id: Option<Uuid>,
}

impl AsyncRules for UpdateUser {
    fn async_rules(&self) -> Vec<AsyncRule> {
        vec![
            AsyncRule::unique("email", "users", "email", self.email.clone(), None)
                .ignore_path_param("id"),
            AsyncRule::exists("team_id", "teams", "id", self.team_id),
        ]
    }
}

#[controller("/users", version = "1")]
#[authenticated]
impl UsersController {
    #[patch("/{id}")]
    async fn update(
        &self,
        uow: Uow,
        Path(id): Path<Uuid>,
        ValidAsync(Json(input)): ValidAsync<Json<UpdateUser>>,
    ) -> Result<Json<UserResource>> {
        // `input` passed the garde rules, then both database rules.
        // ...
    }
}

#[derive(Debug, Deserialize, Validate)]
pub struct CreateOrder {
    #[garde(dive)]
    pub customer: Customer,
    #[garde(length(min = 1), dive)]
    pub items: Vec<OrderItem>,
}

#[derive(Debug, Deserialize, Validate)]
pub struct Customer {
    #[garde(email)]
    pub email: String,
    #[garde(dive)]
    pub address: Address,
}

#[derive(Debug, Deserialize, Validate)]
pub struct Address {
    #[garde(length(min = 1))]
    pub city: String,
}

#[derive(Debug, Deserialize, Validate)]
pub struct OrderItem {
    #[garde(length(min = 1))]
    pub sku: String,
    #[garde(range(min = 1, max = 99))]
    pub quantity: u32,
}

{
  "customer.address.city": ["customer.address.city must be longer than or equal to 1 characters"],
  "items.1.quantity": ["items.1.quantity must not be less than 1"],
  "items.1.sku": ["items.1.sku must be longer than or equal to 1 characters"]
}

use navree::validation::ValidationErrors;

pub fn check_dates(starts_on: &str, ends_on: &str) -> Result<()> {
    let mut errors = ValidationErrors::new();
    if ends_on < starts_on {
        errors.add("ends_on", "ends_on must be after starts_on");
    }
    if !errors.is_empty() {
        return Err(errors.into_app_error());
    }
    Ok(())
}

client
    .post("/api/v1/contacts")
    .json(&json!({
        "first_name": "Ada",
        "last_name": "Lovelace",
        "email": "nope",
        "tags": [],
        "status": "lead"
    }))
    .send()
    .await
    .assert_validation_error("email")
    .assert_error(400, "email must be a valid email address");