Struct Namespace

pub struct Namespace {
    pub handlers: ApiHandlers,
    pub path: Path,
    pub coercer: Option<Builder>,
    /* private fields */
}

Fields

handlers: ApiHandlers

path: Path

coercer: Option<Builder>

Implementations

impl Namespace

pub fn new(path: &str) -> Namespace

pub fn params<F>(&mut self, builder: F)

where F: FnOnce(&mut Builder),

Examples found in repository

examples/simple.rs (lines 82-84)

fn main() {

    let mut app = rustless::Application::new(rustless::Api::build(|api| {
        api.prefix("api");
        api.version("v1", rustless::Versioning::Path);

        api.mount(swagger::create_api("api-docs"));

        api.error_formatter(|err, _media| {
            match err.downcast::<UnauthorizedError>() {
                Some(_) => {
                    return Some(rustless::Response::from(
                        status::StatusCode::Unauthorized,
                        Box::new("Please provide correct `token` parameter")
                    ))
                },
                None => None
            }
        });

        api.post("greet/:name", |endpoint| {
            endpoint.summary("Sends greeting");
            endpoint.desc("Use this to talk to yourself");
            endpoint.params(|params| {
                params.req_typed("name", json_dsl::string());
                params.req_typed("greeting", json_dsl::string());
            });
            endpoint.handle(|client, params| {
                client.text(
                    format!("{}, {}",
                        params.find("greeting").unwrap().to_string(),
                        params.find("name").unwrap().to_string())
                )
            })
        });

        api.get("echo", |endpoint| {
            endpoint.summary("Sends back what it gets");
            endpoint.desc("Use this to talk to yourself");
            endpoint.handle(|client, params| {
                client.json(params)
            })
        });

        api.namespace("admin", |admin_ns| {

            admin_ns.params(|params| {
                params.req_typed("token", json_dsl::string())
            });

            // Using after_validation callback to check token
            admin_ns.after_validation(|_client, params| {

                match params.find("token") {
                    // We can unwrap() safely because token in validated already
                    Some(token) => if token.as_str().unwrap() == "password1" { return Ok(()) },
                    None => ()
                }

                // Fire error from callback is token is wrong
                return Err(rustless::ErrorResponse{
                    error: Box::new(UnauthorizedError) as Box<Error + Send>,
                    response: None
                })

            });

            // This `/api/admin/server_status` endpoint is secure now
            admin_ns.get("server_status", |endpoint| {
                endpoint.summary("Get server status");
                endpoint.desc("Use this API to receive some useful information about the state of our server");
                endpoint.handle(|client, _params| {
                    {
                        let cookies = client.request.cookies();

                        #[cfg(feature = "ssl")]
                        let signed_cookies = cookies.signed();
                        #[cfg(not(feature = "ssl"))]
                        let signed_cookies = cookies;

                        let user_cookie = Cookie::new("session".to_string(), "verified".to_string());
                        signed_cookies.add(user_cookie);
                    }

                    client.text("Everything is OK".to_string())
                })
            });
        })
    }));

    swagger::enable(&mut app, swagger::Spec {
        info: swagger::Info {
            title: "Example API".to_string(),
            description: Some("Simple API to demonstration".to_string()),
            contact: Some(swagger::Contact {
                name: "Stanislav Panferov".to_string(),
                url: Some("http://panferov.me".to_string()),
                ..std::default::Default::default()
            }),
            license: Some(swagger::License {
                name: "MIT".to_string(),
                url: "http://opensource.org/licenses/MIT".to_string()
            }),
            ..std::default::Default::default()
        },
        ..std::default::Default::default()
    });

    let mut chain = iron::Chain::new(app);
    chain.link(::rustless::batteries::cookie::new("secretsecretsecretsecretsecretsecretsecret".as_bytes()));

    iron::Iron::new(chain).http("0.0.0.0:4000").unwrap();
    println!("On 4000");

}

pub fn build<F>(path: &str, builder: F) -> Namespace

where F: FnOnce(&mut Namespace),

Trait Implementations

impl ApiHandler for Namespace

fn api_call<'a, 'r>( &'a self, rest_path: &str, params: &mut JsonValue, req: &'r mut (dyn Request + 'r), info: &mut CallInfo<'a>, ) -> HandleResult<Response>

impl Nesting for Namespace

fn mount<H>(&mut self, edp: H)

where H: ApiHandler + Send + Sync,

fn namespace<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Namespace),

fn group<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Namespace),

fn resource<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Namespace),

fn resources<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Namespace),

fn segment<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Namespace),

fn get<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Endpoint) -> EndpointHandlerPresent,

fn post<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Endpoint) -> EndpointHandlerPresent,

fn put<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Endpoint) -> EndpointHandlerPresent,

fn delete<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Endpoint) -> EndpointHandlerPresent,

fn options<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Endpoint) -> EndpointHandlerPresent,

fn head<F>(&mut self, path: &str, builder: F)

where F: FnOnce(&mut Endpoint) -> EndpointHandlerPresent,

fn before<F>(&mut self, callback: F)

where F: for<'a> Fn(&'a mut Client<'_>, &JsonValue) -> HandleSuccessResult + Send + Sync + 'static,

fn before_validation<F>(&mut self, callback: F)

where F: for<'a> Fn(&'a mut Client<'_>, &JsonValue) -> HandleSuccessResult + Send + Sync + 'static,

fn after<F>(&mut self, callback: F)

where F: for<'a> Fn(&'a mut Client<'_>, &JsonValue) -> HandleSuccessResult + Send + Sync + 'static,

fn after_validation<F>(&mut self, callback: F)

where F: for<'a> Fn(&'a mut Client<'_>, &JsonValue) -> HandleSuccessResult + Send + Sync + 'static,

fn call_handlers<'a, 'r>( &'a self, rest_path: &str, params: &mut JsonValue, req: &'r mut (dyn Request + 'r), info: &mut CallInfo<'a>, ) -> HandleResult<Response>

impl Node for Namespace

fn get_handlers<'a>(&'a self) -> &'a ApiHandlers

fn get_handlers_mut<'a>(&'a mut self) -> &'a mut ApiHandlers

fn get_before<'a>(&'a self) -> &'a Callbacks

fn get_before_mut<'a>(&'a mut self) -> &'a mut Callbacks

fn get_before_validation<'a>(&'a self) -> &'a Callbacks

fn get_before_validation_mut<'a>(&'a mut self) -> &'a mut Callbacks

fn get_after_validation<'a>(&'a self) -> &'a Callbacks

fn get_after_validation_mut<'a>(&'a mut self) -> &'a mut Callbacks

fn get_after<'a>(&'a self) -> &'a Callbacks

fn get_after_mut<'a>(&'a mut self) -> &'a mut Callbacks

fn push_node<'a>(&'a self, _info: &mut CallInfo<'a>)