/foo/ 返回 404

axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }
tower-http = { version = "=0.7.1", features = ["normalize-path"] }
tokio = { version = "=1.54.1", features = ["macros", "rt"] }

use axum::body::Body;
use axum::extract::Request;
use axum::http::{header, Method};
use axum::middleware::{from_fn, Next};
use axum::response::{IntoResponse, Redirect, Response};
use axum::routing::get;
use axum::Router;
use tower::{Layer, Service, ServiceExt};
use tower_http::normalize_path::NormalizePathLayer;

// Redirects GET/HEAD `/x/` to `/x`, keeping the query; leaves `/` alone.
async fn redirect_slash(req: Request, next: Next) -> Response {
  if matches!(*req.method(), Method::GET | Method::HEAD) {
    let path = req.uri().path();
    let trimmed = path.trim_end_matches('/');
    if path != "/" && path.ends_with('/') && !trimmed.is_empty() && !trimmed.starts_with("//") {
      let to = match req.uri().query() {
        Some(q) => format!("{trimmed}?{q}"),
        None => trimmed.to_owned(),
      };
      return Redirect::permanent(&to).into_response();
    }
  }
  next.run(req).await
}

async fn row<S>(name: &str, svc: S)
where
  S: Service<Request, Response = Response> + Clone,
  S::Error: std::fmt::Debug,
{
  for uri in ["/foo", "/foo/", "/foo/?a=1", "/foo//"] {
    let res = svc.clone().oneshot(Request::get(uri).body(Body::empty()).unwrap()).await.unwrap();
    let loc = res.headers().get(header::LOCATION).map(|v| v.to_str().unwrap().to_owned());
    let status = res.status().as_u16();
    let body = axum::body::to_bytes(res.into_body(), 1024).await.unwrap();
    println!("{name:<31} {uri:<10} {status} {:<6} location={loc:?}", String::from_utf8_lossy(&body));
  }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let foo = || Router::new().route("/foo", get(|| async { "foo" }));

  row("only /foo", foo()).await;
  row("/foo and /foo/", foo().route("/foo/", get(|| async { "foo/" }))).await;
  row("Router::layer(NormalizePath)", foo().layer(NormalizePathLayer::trim_trailing_slash())).await;
  row("NormalizePath wraps Router", NormalizePathLayer::trim_trailing_slash().layer(foo())).await;
  row("Router::layer(from_fn redirect)", foo().layer(from_fn(redirect_slash))).await;
}

only /foo                       /foo       200 foo    location=None
only /foo                       /foo/      404        location=None
only /foo                       /foo/?a=1  404        location=None
only /foo                       /foo//     404        location=None
/foo and /foo/                  /foo       200 foo    location=None
/foo and /foo/                  /foo/      200 foo/   location=None
/foo and /foo/                  /foo/?a=1  200 foo/   location=None
/foo and /foo/                  /foo//     404        location=None
Router::layer(NormalizePath)    /foo       200 foo    location=None
Router::layer(NormalizePath)    /foo/      404        location=None
Router::layer(NormalizePath)    /foo/?a=1  404        location=None
Router::layer(NormalizePath)    /foo//     404        location=None
NormalizePath wraps Router      /foo       200 foo    location=None
NormalizePath wraps Router      /foo/      200 foo    location=None
NormalizePath wraps Router      /foo/?a=1  200 foo    location=None
NormalizePath wraps Router      /foo//     200 foo    location=None
Router::layer(from_fn redirect) /foo       200 foo    location=None
Router::layer(from_fn redirect) /foo/      308        location=Some("/foo")
Router::layer(from_fn redirect) /foo/?a=1  308        location=Some("/foo?a=1")
Router::layer(from_fn redirect) /foo//     308        location=Some("/foo")

    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
        match self.mode {
            NormalizeMode::Trim => trim_trailing_slash(req.uri_mut()),
            NormalizeMode::Append => append_trailing_slash(req.uri_mut()),
        }
        self.inner.call(req)
    }

use axum::extract::Request;
use axum::routing::get;
use axum::{Router, ServiceExt};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tower::Layer;
use tower_http::normalize_path::NormalizePathLayer;

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let router = Router::new().route("/foo", get(|| async { "foo" }));
  // Wrapping from outside: the result is NormalizePath<Router>, no longer a Router.
  let app = NormalizePathLayer::trim_trailing_slash().layer(router);

  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  tokio::spawn(async move {
    axum::serve(listener, ServiceExt::<Request>::into_make_service(app)).await.unwrap();
  });

  let mut stream = TcpStream::connect(addr).await.unwrap();
  stream
    .write_all(b"GET /foo/ HTTP/1.1\r\nhost: x\r\nconnection: close\r\n\r\n")
    .await
    .unwrap();
  let mut buf = String::new();
  stream.read_to_string(&mut buf).await.unwrap();
  let first = buf.lines().next().unwrap();
  let body = buf.split("\r\n\r\n").nth(1).unwrap();
  println!("{first} | body {body:?}");
}

HTTP/1.1 200 OK | body "foo"

pub async fn trailing_slash_mw(
  req: axum::extract::Request,
  next: axum::middleware::Next,
) -> axum::response::Response {
  use axum::http::Method;
  use axum::response::{IntoResponse, Redirect};
  if matches!(*req.method(), Method::GET | Method::HEAD) {
    let path = req.uri().path();
    let target =
      legacy_blog_target(path).or_else(|| slash_redirect_target(path, req.uri().query()));
    if let Some(to) = target {
      return Redirect::permanent(&to).into_response();
    }
  }
  next.run(req).await
}

fn slash_redirect_target(path: &str, query: Option<&str>) -> Option<String> {
  if path == "/" || !path.ends_with('/') || path.starts_with("/api/") {
    return None;
  }
  let trimmed = path.trim_end_matches('/');
  if trimmed.is_empty() || trimmed.starts_with("//") {
    return None;
  }
  Some(match query {
    Some(q) => format!("{trimmed}?{q}"),
    None => trimmed.to_string(),
  })
}

GET /foo  -> 200 OK "route /foo"
GET /foo/ -> 200 OK "route /foo"