Can I separate my primary middleware from my routes

[Naginipython]

Summary

The middleware that includes Cors, Tracing, etc typically take up a lot of space, and I don't like to look at it, so I was wondering if there is anything like the .merge() that was for middleware. I've noticed using .merge() doesn't appear to, or possibly its an issue with the Tracing subscriber.

use axum::{
    routing::post,
    Router,
    middleware,
};
use crate::modules::*;

//middleware
use tower::ServiceBuilder;
use http::Method;
use tracing::Level;
use tower_http::{
    trace::{ self, TraceLayer },
    cors::{ Any, CorsLayer },
    validate_request::ValidateRequestHeaderLayer,
};

async fn hello() -> &'static str {
    // exists purely to error-handle middleware
    "hello"
}
async fn hello_two() -> &'static str {
    // exists purely to error-handle middleware
    "hello, everyone in the world"
}

// Ideally, I want to put this in a mod
pub fn middleware() -> Router {
    Router::new()
        .layer(
            ServiceBuilder::new()
                .layer(
                    TraceLayer::new_for_http()
                        .make_span_with(trace::DefaultMakeSpan::new().level(Level::INFO))
                        .on_response(trace::DefaultOnResponse::new().level(Level::INFO))
                )
                .layer(ValidateRequestHeaderLayer::accept("application/json"))
                .layer(
                    CorsLayer::new()
                        .allow_methods([Method::POST])
                        .allow_origin(Any)
                )
        )
}

#[tokio::main]
async fn main() {

    tracing_subscriber::fmt()
        .with_target(false)
        .compact()
        .init();

    let app = Router::new()
        .route("/hello", post(hello))
        .route("/helloeveryoneintheworld", post(hello_two))
        .merge(middleware());

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    println!("Server is running on localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

axum version

0.7.1

[davidpdrsn]

You can define a function that takes a router, adds the middleware, and returns the updated router.

[Naginipython]

That's funny. So yeah, this works:
main.rs

use axum::{
    routing::post,
    Router,
    middleware,
};
use crate::modules::*;

mod the_middleware;

async fn hello() -> &'static str {
    // exists purely to error-handle middleware
    "hello"
}

#[tokio::main]
async fn main() {

    tracing_subscriber::fmt()
        .with_target(false)
        .compact()
        .init();

    let mut app = Router::new()
        .route("/hello", post(hello))
    app = the_middleware::add_middleware(app);

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    println!("Server is running on localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

the_middleware.rs

use axum::Router;
use tower::ServiceBuilder;
use http::Method;
use tracing::Level;
use tower_http::{
    trace::{ self, TraceLayer },
    cors::{ Any, CorsLayer },
    validate_request::ValidateRequestHeaderLayer,
};

pub fn add_middleware(app: Router) -> Router {
    app.layer(
        ServiceBuilder::new()
            .layer(
                TraceLayer::new_for_http()
                    .make_span_with(trace::DefaultMakeSpan::new().level(Level::INFO))
                    .on_response(trace::DefaultOnResponse::new().level(Level::INFO))
            )
            .layer(ValidateRequestHeaderLayer::accept("application/json"))
            .layer(
                CorsLayer::new()
                    .allow_methods([Method::POST])
                    .allow_origin(Any)
            )
    )
}