Struct rocket_validation::Validated

pub struct Validated<T>(pub T);

Tuple Fields

0: T

Implementations

impl<T> Validated<Json<T>>

Impl to get type T of Json

pub fn into_deep_inner(self) -> T

impl<T> Validated<T>

Impl to get type T

pub fn into_inner(self) -> T

Trait Implementations

impl<T: Clone> Clone for Validated<T>

fn clone(&self) -> Validated<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Validated<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'r, D: Validate + Deserialize<'r>> FromData<'r> for Validated<Json<D>>

Implementation of Validated for Json An example with Json

use rocket::serde::{json::Json, Deserialize, Serialize};
use rocket_validation::{Validate, Validated};
  
#[derive(Debug, Deserialize, Serialize, Validate)]
#[serde(crate = "rocket::serde")]
pub struct HelloData {
    #[validate(length(min = 1))]
    name: String,
    #[validate(range(min = 0, max = 100))]
    age: u8,
}
#[post("/hello", format = "application/json", data = "<data>")]
fn validated_hello(data: Validated<Json<HelloData>>) -> Json<HelloData> {
    Json(data.into_deep_inner())
}
  
#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![validated_hello])
        .register("/", catchers![rocket_validation::validation_catcher])
}

type Error = Result<ValidationErrors, Error<'r>>

The associated error to be returned when the guard fails.

fn from_data<'life0, 'async_trait>(
    req: &'r Request<'life0>,
    data: Data<'r>
) -> Pin<Box<dyn Future<Output = DataOutcome<'r, Self>> + Send + 'async_trait>>where
    'r: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Asynchronously validates, parses, and converts an instance of Self from the incoming request body data.

impl<'r, T: Validate + FromForm<'r>> FromForm<'r> for Validated<T>

Implementation of Validated for FromForm

An example validating a query struct

use rocket::serde::{json::Json, Deserialize, Serialize};
use rocket_validation::{Validate, Validated};
  
#[derive(Debug, Deserialize, Serialize, Validate, FromForm)]
#[serde(crate = "rocket::serde")]
pub struct HelloData {
    #[validate(length(min = 1))]
    name: String,
    #[validate(range(min = 0, max = 100))]
    age: u8,
}
#[get("/validated-hello?<params..>", format = "application/json")]
fn validated_hello(params: Validated<HelloData>) -> Json<HelloData> {
    Json(params.into_inner())
}
  
#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![validated_hello])
        .register("/", catchers![rocket_validation::validation_catcher])
}

type Context = <T as FromForm<'r>>::Context

The form guard’s parsing context.

fn init(opts: Options) -> Self::Context

Initializes and returns the parsing context for Self.

fn push_value(ctxt: &mut Self::Context, field: ValueField<'r>)

Processes the value field field.

fn push_data<'life0, 'life1, 'async_trait>(
    ctxt: &'life0 mut Self::Context,
    field: DataField<'r, 'life1>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    'r: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Processes the data field field.

fn finalize(this: Self::Context) -> Result<'r, Self>

Finalizes parsing. Returns the parsed value when successful or collection of Errors otherwise.

fn push_error(_ctxt: &mut Self::Context, _error: Error<'r>)

Processes the external form or field error _error.

fn default(opts: Options) -> Option<Self>

Returns a default value, if any, to use when a value is desired and parsing fails.

impl<'r, D: Validate + FromRequest<'r>> FromRequest<'r> for Validated<D>

Implementation of Validated for FromRequest implementing Validate Anything you implement FromRequest for as well as Validate

type Error = Result<ValidationErrors, <D as FromRequest<'r>>::Error>

The associated error to be returned if derivation fails.

fn from_request<'life0, 'async_trait>(
    req: &'r Request<'life0>
) -> Pin<Box<dyn Future<Output = Outcome<Self, Self::Error>> + Send + 'async_trait>>where
    'r: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Derives an instance of Self from the incoming request metadata.