tide-validator

/!\ Currently waiting for a new release of Tide before release this one on crates.io /!\

tide-validator is a middleware working with Tide, a web framework in Rust which let you validate your data coming from a request. You'll be able to create custom validators to validate your HTTP parameters, query parameters, cookies and headers.

Features

Custom validators: you can chain multiple validators and develop a custom validator is very easy. It's just a closure.
Validate everything: with the enum HttpField you can validate different fields like cookies, headers, query parameters and parameters.
Your own errors: thanks to generics in Rust you can use your own custom error when the data is invalid. need.

Validators

To create your own validator it's just a closure to create with this form:

rust // The first closure's parameter is the parameter/queryparameter/cookie/header name. // The second parameter is the value of this HTTP element. // None means the field doesn't exist in the request (useful to force specific fields to be required). Fn(&str, Option<&str>) -> Result<(), T> + Send + Sync + 'static where T: Serialize + Send + Sync + 'static

Documentation

The full documentation is available here

Examples

simple validation ```rust // Our own validator is a simple closure to check if the field is a number fn isnumber(fieldname: &str, fieldvalue: Option<&str>) -> Result<(), String> { if let Some(fieldvalue) = fieldvalue { if fieldvalue.parse::().iserr() { return Err(format!("field '{}' = '{}' is not a valid number", fieldname, field_value)); } }

Ok(()) }

//... in main function let mut app = tide::new(); let mut validatormiddleware = ValidatorMiddleware::new(); // 'age' is the parameter name inside the route '/test/:age' validatormiddleware.addvalidator(HttpField::Param("age"), isnumber); // You can assign different middleware for each routes therefore different validators for each routes app.at("/test/:age") .middleware(validatormiddleware) .get(|: tide::Request<()>| async move { let cat = Cat { name: "Gribouille".into(), }; tide::Response::new(StatusCode::Ok).body_json(&cat).unwrap() }); app.listen("127.0.0.1:8080").await?; ```

chain multiple validators ```rust // This validator force element to be required fn isrequired(fieldname: &str, fieldvalue: Option<&str>) -> Result<(), String> { if fieldvalue.isnone() { Err(format!("'{}' is required", fieldname)) } else { Ok(()) } }

// ... your main function

let mut app = tide::new(); let mut validatormiddleware = ValidatorMiddleware::new(); // Here 'age' is a query parameter, the validator stay the same as in previous example validatormiddleware.addvalidator(HttpField::QueryParam("age"), isnumber); // You can also add multiple validators on a single query parameter to check different things validatormiddleware.addvalidator(HttpField::QueryParam("age"), is_required);

// You can assign different middleware for each routes therefore different validators for each routes app.at("/test") .middleware(validatormiddleware) .get(|: tide::Request<()>| async move { let cat = Cat { name: "Mozart".into(), }; tide::Response::new(StatusCode::Ok).body_json(&cat).unwrap() }, );

app.listen("127.0.0.1:8080").await?; ```

Use your own custom error ```rust // Your custom error which your api will send if an error occurs
[derive(Debug, Serialize)]

struct CustomError { status_code: usize, message: String, }

// Your validator can also return your own error type fn isnumber(fieldname: &str, fieldvalue: Option<&str>) -> Result<(), CustomError> { if let Some(fieldvalue) = fieldvalue { if fieldvalue.parse::().iserr() { return Err(CustomError { statuscode: 400, message: format!( "field '{}' = '{}' is not a valid number", fieldname, fieldvalue ), }); } } Ok(()) }

// ... your main function ```

Dynamic validators ```rust // Validator inside a function as a closure to be dynamic with maxlength fn islengthunder( maxlength: usize, ) -> Box) -> Result<(), CustomError> + Send + Sync + 'static> { Box::new( move |fieldname: &str, fieldvalue: Option<&str>| -> Result<(), CustomError> { if let Some(fieldvalue) = fieldvalue { if fieldvalue.len() > maxlength { let myerror = CustomError { statuscode: 400, message: format!( "element '{} which is equals to '{}' have not the maximum length of {}", fieldname, fieldvalue, maxlength ), }; return Err(myerror); } } Ok(()) }, ) }

// Simply call it on a cookie session for example: validatormiddleware.addvalidator(HttpField::Cookie("session"), islengthunder(20)); ```

Todo