pubky-homeserver 0.5.2

Pubky core's homeserver.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! The controller part of the [super::HomeserverCore]

use axum::{
    body::Body,
    extract::Request,
    http::{header, HeaderValue},
    middleware::{self, Next},
    response::Response,
    routing::{get, post},
    Router,
};
use tower::ServiceBuilder;
use tower_cookies::CookieManagerLayer;
use tower_http::cors::CorsLayer;

use crate::{core::AppState, AppContext};

use super::layers::{
    pubky_host::PubkyHostLayer, rate_limiter::RateLimiterLayer, trace::with_trace_layer,
};

mod auth;
mod feed;
mod root;
mod tenants;

static HOMESERVER_VERSION: &str = concat!("pubky.org", "@", env!("CARGO_PKG_VERSION"),);
const TRACING_EXCLUDED_PATHS: [&str; 1] = ["/events/"];

fn base() -> Router<AppState> {
    Router::new()
        .route("/", get(root::handler))
        .route("/signup", post(auth::signup))
        .route("/session", post(auth::signin))
        // Events
        .route("/events/", get(feed::feed))
    // TODO: add size limit
    // TODO: revisit if we enable streaming big payloads
    // TODO: maybe add to a separate router (drive router?).
}

pub fn create_app(state: AppState, context: &AppContext) -> Router {
    let app = base()
        .merge(tenants::router(state.clone()))
        .layer(CookieManagerLayer::new())
        .layer(CorsLayer::very_permissive())
        .layer(ServiceBuilder::new().layer(middleware::from_fn(add_server_header)))
        .layer(RateLimiterLayer::new(
            context.config_toml.drive.rate_limits.clone(),
        ))
        .layer(PubkyHostLayer)
        .with_state(state);

    // Apply trace and pubky host layers to the complete router.
    with_trace_layer(app, &TRACING_EXCLUDED_PATHS)
}

// Middleware to add a `Server` header to all responses
async fn add_server_header(request: Request<Body>, next: Next) -> Response {
    let mut response = next.run(request).await;

    // Add a custom header to the response
    response
        .headers_mut()
        .insert(header::SERVER, HeaderValue::from_static(HOMESERVER_VERSION));

    response
}