Struct Handler 

pub struct Handler { /* private fields */ }

Configurable request handler with before/after middleware hooks.

Example

use dioxus_cloudflare::Handler;
use worker::*;

#[event(fetch)]
async fn fetch(req: Request, env: Env, _ctx: Context) -> Result<Response> {
    unsafe { __wasm_call_ctors(); }

    Handler::new()
        .before(|req| {
            // Short-circuit OPTIONS requests for CORS preflight
            if req.method() == worker::Method::Options {
                let mut resp = Response::empty()?;
                resp.headers_mut().set("Access-Control-Allow-Origin", "*")?;
                resp.headers_mut().set("Access-Control-Allow-Methods", "GET,POST,OPTIONS")?;
                return Ok(Some(resp));
            }
            Ok(None) // continue to Axum dispatch
        })
        .after(|resp| {
            resp.headers_mut().set("Access-Control-Allow-Origin", "*")?;
            Ok(())
        })
        .handle(req, env)
        .await
}

Implementations

impl Handler

pub fn new() -> Self

Create a new handler with no middleware hooks.

pub fn before( self, hook: impl Fn(&Request) -> Result<Option<Response>> + 'static, ) -> Self

Add a before-dispatch hook.

Runs after context is set (so cf::env(), cf::d1(), etc. work), before Axum dispatch. Return Ok(None) to continue, Ok(Some(resp)) to short-circuit with a custom response.

Hooks run in the order they were added.

pub fn after(self, hook: impl Fn(&mut Response) -> Result<()> + 'static) -> Self

Add an after-dispatch hook.

Runs after cookies are applied, before returning the response. Use this to add headers, log, or modify the final response.

After hooks also run on short-circuited responses from before hooks. Hooks run in the order they were added.

pub async fn handle(&self, req: Request, env: Env) -> Result<Response>

Dispatch the request through registered #[server] functions.

This is the async entry point — call it from #[event(fetch)].

Trait Implementations

impl Default for Handler

fn default() -> Self

Returns the “default value” for a type.