Trait worker_route::Service

pub trait Service<D> {
    // Required method
    fn service(
        self,
        fns_: fn(_: Router<'static, D>) -> Router<'static, D>
    ) -> Router<'static, D>;
}

A trait that’s implemented for Router that allows you to declutter your main code.

Example

use serde::{Deserialize, Serialize};
use worker::{event, Env, Request, Response, ResponseBody, Result, RouteContext, Router};
use worker_route::{get, Service, Configure, Query};

#[derive(Debug, Serialize, Deserialize)]
struct Bar {
    bar: String,
}

#[get("/bar")]
async fn bar(req: Query<Bar>, _: RouteContext<()>) -> Result<Response> {
    Response::from_body(ResponseBody::Body(req.into_inner().bar.as_bytes().into()))
}

#[derive(Debug, Serialize, Deserialize)]
struct Foo {
    foo: String,
}

#[get("/foo")]
async fn foo(req: Query<Foo>, _: RouteContext<()>) -> Result<Response> {
    Response::from_body(ResponseBody::Body(req.into_inner().foo.as_bytes().into()))
}

#[derive(Debug, Deserialize, Serialize)]
struct Person {
    name: String,
    age: usize,
}

#[get("/person/:name/:age")]
async fn person(req: Query<Person>, _: RouteContext<()>) -> Result<Response> {
    Response::from_json(&req.into_inner())
}

// wrapper function
fn init_routes(router: Router<'static, ()>) -> Router<'static, ()> {
    router.configure(bar).configure(foo).configure(person)
}

#[event(fetch)]
pub async fn main(req: Request, env: Env, _ctx: worker::Context) -> Result<Response> {
    let router = Router::new();
    // before
    // router.configure(bar).configure(foo).configure(person).run(req, env).await
    // after
    // router.service(init_routes).run(req, env).await
    router.service(init_routes).run(req, env).await
}

Required Methods

fn service( self, fns_: fn(_: Router<'static, D>) -> Router<'static, D> ) -> Router<'static, D>

Implementations on Foreign Types

impl<D> Service<D> for Router<'static, D>

fn service( self, fns_: fn(_: Router<'static, D>) -> Router<'static, D> ) -> Router<'static, D>

Implementors