Struct Router 

pub struct Router { /* private fields */ }

Implementations

impl Router

pub fn new() -> Self

Examples found in repository

examples/middleware.rs (line 69)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/routing.rs (line 41)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn get<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

Examples found in repository

examples/middleware.rs (lines 72-77)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

examples/routing.rs (lines 42-47)

fn main() {
    let mut app = Server::new();

    // Basic GET route
    app.get("/", |_req| async {
        Response::text("Welcome to Axeon API server!")
    });

    // Route with path parameter
    app.get("/users/:id", |req| async move {
        let user_id = req.params.get("id").unwrap();
        Response::text(format!("User ID: {}", user_id))
    });

    // POST request with JSON body
    app.post("/users", |req| async move {
        match req.body.json::<User>() {
            Some(user) => Response::ok(&user),
            None => Err(ServerError::BadRequest("Invalid JSON body".to_string())),
        }
    });

    // Group routes under /api prefix
    let mut api = Router::new();
    api.get("/status", |_req| async {
        Response::ok(&serde_json::json!({
            "status": "operational",
            "version": "1.0.0"
        }))
    });

    // Mount the API router to the main server
    app.mount("/api", api);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start")
}

pub fn post<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn put<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn patch<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn delete<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn head<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn connect<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn options<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn trace<F, R>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(Request) -> R + Send + Clone + Sync + 'static, R: IntoResponse + 'static,

pub fn middleware(&mut self, middleware: impl Middleware + 'static)

Examples found in repository

examples/middleware.rs (line 70)

fn main() {
    let mut app = Server::new();

    // Apply logger middleware globally
    app.middleware(Logger);

    // Public route - no auth required
    app.get("/public", |_req| async  {
        Response::text("This is a public endpoint")
    });

    // Protected routes with auth middleware
    let mut protected = Router::new();
    protected.middleware(AuthMiddleware);

    protected.get("/profile", |_req| async  {
        ok_json!({
            "name": "User",
            "email": "user@example.com"
        })
    });

    app.mount("/api", protected);

    app.listen("127.0.0.1:3000")
        .expect("Server failed to start");
}

pub fn mount(&mut self, path: &str, router: Router)

Trait Implementations

impl Clone for Router

fn clone(&self) -> Router

Returns a duplicate of the value.

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

Performs copy-assignment from source.