Struct Router 

pub struct Router { /* private fields */ }

Implementations

impl Router

pub fn new() -> Self

Examples found in repository

examples/admin_demo.rs (line 34)

async fn main() -> std::io::Result<()> {
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");

    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    seed_demo_data(&db).await;

    let router = with_defaults(Router::new()).wrap(authenticate(db.clone()));
    // No `.model::<T>()` calls: the new engine uses its own
    // `AdminUiModel` registry (Users + Orders are wired in by
    // `Admin::register`). The legacy AdminModel + macro path is
    // intentionally not exercised here so there is exactly one
    // admin surface in the demo.
    let router = Admin::new().register(router, &db);

    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    eprintln!("admin demo: open http://{addr}/admin and sign in as admin@example.com / admin");
    Server::bind(addr).serve_router(router).await
}

examples/homepage.rs (line 60)

async fn main() -> std::io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");
    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    let router = with_defaults(Router::new())
        .get("/whoami", |req, _params| async move {
            let id = req
                .ctx()
                .get::<RequestId>()
                .map(|r| r.0.to_string())
                .unwrap_or_else(|| "unknown".into());
            Ok::<Response, Error>(text(format!("your request id is req-{id}\n")))
        })
        .get("/me", |req, _params| async move {
            let id = require_auth(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello {}\n", id.email)))
        })
        .get("/admin-only", |req, _params| async move {
            let id = require_admin(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello admin {}\n", id.email)))
        })
        .get("/crash", |_req, _params| async {
            Err::<Response, Error>(Error::Internal("simulated failure".into()))
        })
        .get("/unauth", |_req, _params| async {
            Err::<Response, Error>(Error::Unauthorized)
        })
        .wrap(request_id)
        .wrap(authenticate(db))
        .wrap(logger);
    Server::bind(addr).serve_router(router).await
}

pub fn wrap<F, Fut>(self, middleware: F) -> Self

where F: Fn(Request, Next) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Response, Error>> + Send + 'static,

Examples found in repository

examples/admin_demo.rs (line 34)

async fn main() -> std::io::Result<()> {
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");

    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    seed_demo_data(&db).await;

    let router = with_defaults(Router::new()).wrap(authenticate(db.clone()));
    // No `.model::<T>()` calls: the new engine uses its own
    // `AdminUiModel` registry (Users + Orders are wired in by
    // `Admin::register`). The legacy AdminModel + macro path is
    // intentionally not exercised here so there is exactly one
    // admin surface in the demo.
    let router = Admin::new().register(router, &db);

    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    eprintln!("admin demo: open http://{addr}/admin and sign in as admin@example.com / admin");
    Server::bind(addr).serve_router(router).await
}

examples/homepage.rs (line 83)

async fn main() -> std::io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");
    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    let router = with_defaults(Router::new())
        .get("/whoami", |req, _params| async move {
            let id = req
                .ctx()
                .get::<RequestId>()
                .map(|r| r.0.to_string())
                .unwrap_or_else(|| "unknown".into());
            Ok::<Response, Error>(text(format!("your request id is req-{id}\n")))
        })
        .get("/me", |req, _params| async move {
            let id = require_auth(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello {}\n", id.email)))
        })
        .get("/admin-only", |req, _params| async move {
            let id = require_admin(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello admin {}\n", id.email)))
        })
        .get("/crash", |_req, _params| async {
            Err::<Response, Error>(Error::Internal("simulated failure".into()))
        })
        .get("/unauth", |_req, _params| async {
            Err::<Response, Error>(Error::Unauthorized)
        })
        .wrap(request_id)
        .wrap(authenticate(db))
        .wrap(logger);
    Server::bind(addr).serve_router(router).await
}

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

where F: Fn(Request, Params) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Response, Error>> + Send + 'static,

Examples found in repository

examples/homepage.rs (lines 61-68)

async fn main() -> std::io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");
    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    let router = with_defaults(Router::new())
        .get("/whoami", |req, _params| async move {
            let id = req
                .ctx()
                .get::<RequestId>()
                .map(|r| r.0.to_string())
                .unwrap_or_else(|| "unknown".into());
            Ok::<Response, Error>(text(format!("your request id is req-{id}\n")))
        })
        .get("/me", |req, _params| async move {
            let id = require_auth(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello {}\n", id.email)))
        })
        .get("/admin-only", |req, _params| async move {
            let id = require_admin(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello admin {}\n", id.email)))
        })
        .get("/crash", |_req, _params| async {
            Err::<Response, Error>(Error::Internal("simulated failure".into()))
        })
        .get("/unauth", |_req, _params| async {
            Err::<Response, Error>(Error::Unauthorized)
        })
        .wrap(request_id)
        .wrap(authenticate(db))
        .wrap(logger);
    Server::bind(addr).serve_router(router).await
}

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

where F: Fn(Request, Params) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Response, Error>> + Send + 'static,

pub fn has_route(&self, method: &Method, path: &str) -> bool

true when a handler is already registered for (method, path).

Path comparison is literal — :id and other patterns are matched by their textual form. Used by crate::defaults::with_defaults to skip registering defaults the project already owns (e.g. a custom / homepage) so that registration order doesn’t silently shadow user intent.

pub async fn dispatch(&self, req: Request) -> Response

Trait Implementations

impl Default for Router

fn default() -> Self

Returns the “default value” for a type.