頑張って Axum を Cloudflare Workers で動かす

worker = { git = "https://github.com/cloudflare/workers-rs", branch="kflansburg/http-fetch", features = ["http"] }

use worker::*;

#[event(fetch)]
pub async fn main(req: Request, env: Env, _ctx: worker::Context) -> Result<Response> {
    let router = Router::new();

    ...

    router
        .get_async("/account/:id", |_req, ctx| async move {
            if let Some(id) = ctx.param("id") {
                let accounts = ctx.kv("ACCOUNTS")?;
                return match accounts.get(id).json::<Account>().await? {
                    Some(account) => Response::from_json(&account),
                    None => Response::error("Not found", 404),
                };
            }

            Response::error("Bad Request", 400)
        })
        // handle files and fields from multipart/form-data requests
        .post_async("/upload", |mut req, _ctx| async move {
            ...

            Response::error("Bad Request", 400)
        })
        ...
        .run(req, env).await
}

[package]
name = "worker-rust"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
axum = { version = "0.7.4", default-features = false }
reqwest = "0.12.1"
tower-service = "0.3.2"
worker = { version = "0.0.21", features = ["http"] }

[profile.release]
opt-level = "s" # optimize for size in release builds
lto = true
codegen-units = 1

use axum::{routing::get, Router};
use tower_service::Service;
use worker::*;

fn router() -> Router {
    Router::new().route("/", get(root))
}

#[event(fetch)]
async fn fetch(
    req: HttpRequest,
    _env: Env,
    _ctx: Context,
) -> Result<axum::http::Response<axum::body::Body>> {
    console_error_panic_hook::set_once();

    Ok(router().call(req).await?)
}

pub async fn root() -> &'static str {
    "Hello Axum!"
}

pub async fn root() -> &'static str {
    let _ = reqwest::get("https://example.com").await;
    "Hello Axum!"
}

error[E0277]: the trait bound `fn() -> impl Future<Output = &'static str> {root}: Handler<_, _>` is not satisfied
   --> src/lib.rs:6:34
    |
6   |     Router::new().route("/", get(root))
    |                              --- ^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn() -> impl Future<Output = &'static str> {root}`
    |                              |
    |                              required by a bound introduced by this call
    |
    = help: the following other types implement trait `Handler<T, S>`:
              <Layered<L, H, T, S> as Handler<T, S>>
              <MethodRouter<S> as Handler<(), S>>
note: required by a bound in `axum::routing::get`
   --> /Users/sadnessOjisan/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.4/src/routing/method_routing.rs:385:1
    |
385 | top_level_handler_fn!(get, GET);
    | ^^^^^^^^^^^^^^^^^^^^^^---^^^^^^
    | |                     |
    | |                     required by a bound in this function
    | required by this bound in `get`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `worker-rust` (lib) due to 1 previous error
Error: Compiling your crate to WebAssembly failed
✘ [ERROR] Custom build failed: UserError: Running custom build `cargo install -q worker-build && worker-build --release` failed. There are likely more logs from your build command above.

      at runCustomBuild
  (/Users/sadnessOjisan/hoge/node_modules/wrangler/wrangler-dist/cli.js:126897:13)
      at process.processTicksAndRejections (node:internal/process/task_queues:95:5) {
    [cause]: Error: Command failed with exit code 1: cargo install -q worker-build && worker-build
  --release
        at makeError
  (/Users/sadnessOjisan/hoge/node_modules/wrangler/wrangler-dist/cli.js:126436:14)
        at handlePromise
  (/Users/sadnessOjisan/hoge/node_modules/wrangler/wrangler-dist/cli.js:126778:29)
        at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
        at async runCustomBuild
  (/Users/sadnessOjisan/hoge/node_modules/wrangler/wrangler-dist/cli.js:126888:7) {
      shortMessage: 'Command failed with exit code 1: cargo install -q worker-build && worker-build
  --release',
      command: 'cargo install -q worker-build && worker-build --release',
      escapedCommand: 'cargo install -q worker-build "&&" worker-build --release',
      exitCode: 1,
      signal: undefined,
      signalDescription: undefined,
      stdout: undefined,
      stderr: undefined,
      failed: true,
      timedOut: false,
      isCanceled: false,
      killed: false
    }
  }

pub async fn root() -> &'static str {
    let _ = reqwest::get("https://example.com");
    "Hello Axum!"
}

/// Rewrites a handler with legacy http types to use axum extractors / response type.
#[cfg(feature = "http")]
macro_rules! handler (
    ($name:path) => {
        |Extension(env): Extension<Env>, Extension(data): Extension<SomeSharedData>, req: axum::extract::Request| async {
            let resp = $name(req.try_into().expect("convert request"), env, data).await.expect("handler result");
            Into::<http::Response<axum::body::Body>>::into(resp)
        }
    }
);

############

.route("/fetch", get(handler!(fetch::handle_fetch)))

###########

#[worker::send]
pub async fn handle_fetch(_req: Request, _env: Env, _data: SomeSharedData) -> Result<Response> {
    let req = Request::new("https://example.com", Method::Post)?;
    let resp = Fetch::Request(req).send().await?;
    let resp2 = Fetch::Url("https://example.com".parse()?).send().await?;
    Response::ok(format!(
        "received responses with codes {} and {}",
        resp.status_code(),
        resp2.status_code()
    ))
}

#[pin_project]
/// Wrap any future to make it `Send`.
///
/// ```rust
/// let fut = SendFuture::new(JsFuture::from(promise));
/// fut.await
/// ```
pub struct SendFuture<F> {
    #[pin]
    inner: F,
}

impl<F> SendFuture<F> {
    pub fn new(inner: F) -> Self {
        Self { inner }
    }
}

unsafe impl<F> Send for SendFuture<F> {}

worker = { git = "https://github.com/cloudflare/workers-rs", branch="kflansburg/http-fetch", features = ["http"] }

.route("/fetch", get(handler!(fetch::handle_fetch)))

#[cfg(feature = "http")]
macro_rules! handler (
    ($name:path) => {
        |Extension(env): Extension<Env>, Extension(data): Extension<SomeSharedData>, req: axum::extract::Request| async {
            let resp = $name(req.try_into().expect("convert request"), env, data).await.expect("handler result");
            Into::<http::Response<axum::body::Body>>::into(resp)
        }
    }
);

use axum::{http::Response, response::IntoResponse, routing::get, Extension, Router};
use tower_service::Service;
use worker::*;

fn router() -> Router {
    Router::new().route(
        "/",
        get(|req: axum::extract::Request| async {
            let resp = handle_fetch(req.try_into().expect("convert request"))
                .await
                .expect("handler result");
            Into::<Response<axum::body::Body>>::into(resp)
        }),
    )
}