Crate rweb

Source

Expand description

A macro to convert a function to rweb handler.

All parameters should satisfy one of the following.

Has a path parameter with same name.
Annotated with the annotations documented below.
Has a type which implements FromRequest.

§Path parmeters

§Attributes on function item

§`#[header("content-type", "application/json")]`

Make a route matches only if value of the header matches provided value.

use rweb::*;

#[get("/")]
#[header("accept", "*/*")]
fn routes() -> &'static str {
   "This route matches only if accept header is '*/*'"
}

fn main() {
    serve(routes());
}

§`#[cors]`

use rweb::*;

#[get("/")]
#[cors(origins("example.com"), max_age = 600)]
fn cors_1() -> String {
   unreachable!()
}

#[get("/")]
#[cors(origins("example.com"), methods(get), max_age = 600)]
fn cors_2() -> String {
   unreachable!()
}

#[get("/")]
#[cors(origins("*"), methods(get), max_age = 600)]
fn cors_3() -> String {
   unreachable!()
}

#[get("/")]
#[cors(
    origins("*"),
    methods(get, post, patch, delete),
    headers("accept"),
    max_age = 600
)]
fn cors_4() -> String {
   unreachable!()
}

§`#[body_size(max = "8192")]`

use rweb::*;

#[get("/")]
#[body_size(max = "8192")]
fn body_size() -> String {
   unreachable!()
}

§Attributes on parameters

§`#[body]`

Parses request body. Type is bytes::Bytes.

use rweb::*;
use http::Error;
use bytes::Bytes;

#[post("/body")]
fn body(#[body] body: Bytes) -> Result<String, Error> {
   let _ = body;
   Ok(String::new())
}

fn main() {
    serve(body());
}

§`#[form]`

Parses request body. Content-Type should be x-www-form-urlencoded.

use rweb::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct LoginForm {
    id: String,
    password: String,
}

#[post("/form")]
fn form(#[form] body: LoginForm) -> String {
   String::from("Ok")
}

fn main() {
    serve(form());
}

§`#[json]`

Parses request body. Content-Type should be application/json.

use rweb::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct LoginForm {
    id: String,
    password: String,
}

#[post("/json")]
fn json(#[json] body: LoginForm) -> String {
    String::from("Ok")
}

fn main() {
    serve(json());
}

Note that you can mix the order of parameters.

use rweb::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct LoginForm {
    id: String,
    password: String,
}

#[get("/param/{a}/{b}")]
fn body_between_path_params(a: u32, #[json] body: LoginForm, b: u32) ->
String {     assert_eq!(body.id, "TEST_ID");
    assert_eq!(body.password, "TEST_PASSWORD");
    (a + b).to_string()
}

fn main() {
    serve(body_between_path_params());
}

§`#[query]`

Parses query string.

use rweb::*;

#[get("/")]
fn use_query(#[query] qs: String) -> String {
    qs
}

fn main() {
    serve(use_query());
}

§`#[header = "header-name"]`

Value of the header.

use rweb::*;

#[get("/")]
fn ret_accept(#[header = "accept"] accept: String) -> String {
    accept
}
fn main() {
    serve(ret_accept());
}

§`#[cookie = "cookie-name"]`

Value of the header.

use rweb::*;

#[get("/")]
fn cookie(#[header = "sess"] sess_id: String) -> String {
    sess_id
}
fn main() {
    serve(cookie());
}

§`#[filter = "path_to_fn"]`

Calls function.

Note: If the callee returns (), you should use () as type. (Type alias is not allowed)

use std::num::NonZeroU16;
use rweb::*;
use serde::Serialize;

#[derive(Serialize)]
struct Math {
    op: String,
    output: u16,
}

#[get("/math/{num}")]
fn math(num: u16, #[filter = "div_by"] denom: NonZeroU16) -> impl Reply {
    rweb::reply::json(&Math {
        op: format!("{} / {}", num, denom),
        output: num / denom.get(),
    })
}

fn div_by() -> impl Filter<Extract = (NonZeroU16,), Error = Rejection> +Copy
{    rweb::header::<u16>("div-by").and_then(|n: u16| async move {
       if let Some(denom) = NonZeroU16::new(n) {
           Ok(denom)
       } else {
           Err(reject::custom(DivideByZero))
       }
   })
}

#[derive(Debug)]
struct DivideByZero;

impl reject::Reject for DivideByZero {}

fn main() {
    serve(math());
}

§`#[data]`

use futures::lock::Mutex;
use rweb::*;
use std::sync::Arc;

#[derive(Clone, Default)]
struct Db {
   items: Arc<Mutex<Vec<String>>>,
}

#[get("/")]
async fn index(#[data] db: Db) -> Result<String, Rejection> {
   let items = db.items.lock().await;

   Ok(items.len().to_string())
}

fn main() {
    let db = Default::default();
    serve(index(db));
}

§FromRequest

use http::StatusCode;
use rweb::{filters::BoxedFilter, *};

impl FromRequest for User {
   type Filter = BoxedFilter<(User,)>;

   fn new() -> Self::Filter {
       // In real world, you can use a header like Authorization
       header::<String>("x-user-id").map(|id| User { id }).boxed()
   }
}


#[derive(Schema)]
struct User {
   id: String,
}

#[get("/")]
fn index(user: User) -> String {
   user.id
}

fn main() {
    serve(index());
}

§Guards

use rweb::*;

// This handler is invoked only if x-appengine-cron matches 1 (case insensitive).
#[get("/")]
#[header("X-AppEngine-Cron", "1")]
fn gae_cron() -> String {
    String::new()
}

§`#[router]`

#[router] can be used to group routes.

§`#[data]`

You can use #[data] with a router.

use rweb::*;

#[derive(Default, Clone)]
struct Db {}

#[get("/use")]
fn use_db(#[data] _db: Db) -> String {
   String::new()
}

#[router("/data", services(use_db))]
fn data_param(#[data] db: Db) {}

§Guard

use rweb::*;

#[get("/")]
fn admin_index() -> String {
   String::new()
}

#[get("/users")]
fn admin_users() -> String {
   String::new()
}

#[router("/admin", services(admin_index, admin_users))]
#[header("X-User-Admin", "1")]
fn admin() {}

Re-exports§

pub use warp;
pub use self::docs::*;
pub use self::routes::*;

Modules§

docs
filters
Built-in Filters
http
A general purpose library of common HTTP types
hyper
hyper
openapi
Automatic openapi spec generator.
redirect
Redirect requests to a new location.
reject
Rejections
reply
Reply to requests.
routes
test
Test utilities to test your filters.

Macros§

path
Convenient way to chain multiple path filters together.
routes
Helper macro to chain multiple routes with .or(route()) between them.

Structs§

Error
Errors that can happen inside warp.
Form
Represents a request body with www-url-form-encoded content type.
Json
Represents request body or response.
Query
Represents all query parameters.
Rejection
Rejection of a request by a Filter.
Server
A Warp Server ready to filter requests.
TlsServer
A Warp Server ready to filter requests over TLS.

Traits§

Buf
Read bytes from a buffer.
Filter
Composable request filters.
FromRequest
Future
A future represents an asynchronous computation obtained by use of async.
Reply
Types that can be converted into a Response.
Sink
A Sink is a value into which other values can be sent, asynchronously.
Stream
A stream of values produced asynchronously.

Functions§

any
A filter that matches any route.
cookie
Creates a Filter that requires a cookie by name.
cors
Create a wrapping filter that exposes CORS behavior for a wrapped filter.
delete
Create a Filter that requires the request method to be DELETE.
get
Create a Filter that requires the request method to be GET.
head
Create a Filter that requires the request method to be HEAD.
header
Create a Filter that tries to parse the specified header.
log
Create a wrapping filter with the specified name as the target.
method
Extract the Method from the request.
options
Create a Filter that requires the request method to be OPTIONS.
patch
Create a Filter that requires the request method to be PATCH.
path
Create an exact match path segment Filter.
post
Create a Filter that requires the request method to be POST.
put
Create a Filter that requires the request method to be PUT.
query
Creates a Filter that decodes query parameters to the type T.
redirect
A simple 301 permanent redirect to a different location.
reject
Rejects a request with 404 Not Found.
reply
Returns an empty Reply with status code 200 OK.
serve
Create a Server with the provided Filter.
service
Convert a Filter into a Service.
trace
Create a wrapping filter that instruments every request with a custom tracing Span provided by a function.
wrap_fn
Function that receives a filter to be combined with pre and after filters
ws
Creates a Websocket Filter.

Attribute Macros§

delete
get
head
options
patch
post
put
router
Creates a router. Useful for modularizing codes.

Derive Macros§

Schema
Implements Entity for the type.

Crate rwebCopy item path

§Path parmeters

§Attributes on function item

§#[header("content-type", "application/json")]

§#[cors]

§#[body_size(max = "8192")]

§Attributes on parameters

§#[body]

§#[form]

§#[json]

§#[query]

§#[header = "header-name"]

§#[cookie = "cookie-name"]

§#[filter = "path_to_fn"]

§#[data]

§FromRequest

§Guards

§#[router]

§#[data]

§Guard

Re-exports§

Modules§

Macros§

Structs§

Traits§

Functions§

Attribute Macros§

Derive Macros§

Crate rweb

§`#[header("content-type", "application/json")]`

§`#[cors]`

§`#[body_size(max = "8192")]`

§`#[body]`

§`#[form]`

§`#[json]`

§`#[query]`

§`#[header = "header-name"]`

§`#[cookie = "cookie-name"]`

§`#[filter = "path_to_fn"]`

§`#[data]`

§`#[router]`

§`#[data]`