pubky-homeserver 0.9.1

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
69
70

use axum::{
    extract::State,
    http::{header, HeaderValue},
    response::IntoResponse,
};
use axum_extra::extract::Host;
use tower_cookies::{Cookie, Cookies};

use crate::{
    client_server::{
        extractors::PubkyHost, layers::authz::session_secret_from_cookies,
        routes::auth::configure_session_cookie, AppState,
    },
    persistence::sql::session::SessionRepository,
    shared::{HttpError, HttpResult},
};

pub async fn session(
    State(state): State<AppState>,
    cookies: Cookies,
    pubky: PubkyHost,
) -> HttpResult<impl IntoResponse> {
    state
        .user_service
        .get_or_http_error(pubky.public_key(), false)
        .await?;

    if let Some(secret) = session_secret_from_cookies(&cookies, pubky.public_key()) {
        if let Ok(session) =
            SessionRepository::get_by_secret(&secret, &mut state.sql_db.pool().into()).await
        {
            let legacy_session = session.to_legacy();
            let mut resp = legacy_session.serialize().into_response();
            resp.headers_mut().insert(
                header::CONTENT_TYPE,
                HeaderValue::from_static("application/octet-stream"),
            );
            resp.headers_mut()
                .insert(header::VARY, HeaderValue::from_static("cookie, pubky-host"));
            resp.headers_mut().insert(
                header::CACHE_CONTROL,
                HeaderValue::from_static("private, must-revalidate"),
            );
            return Ok(resp);
        };
    }

    Err(HttpError::not_found())
}
pub async fn signout(
    State(state): State<AppState>,
    cookies: Cookies,
    Host(host): Host,
    pubky: PubkyHost,
) -> HttpResult<impl IntoResponse> {
    if let Some(secret) = session_secret_from_cookies(&cookies, pubky.public_key()) {
        SessionRepository::delete(&secret, &mut state.sql_db.pool().into()).await?;
    }

    // Always instruct the client to drop the session cookie, even if the
    // database record was already gone. This keeps repeated signout calls
    // idempotent and lets browsers wipe stale cookies immediately.
    let mut removal = Cookie::new(pubky.public_key().z32(), String::new());
    removal.make_removal();
    configure_session_cookie(&mut removal, &host);
    cookies.add(removal);

    // Idempotent Success Response (200 OK)
    Ok(())
}