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]`