rustbasic-passport 0.1.1

OAuth2 server and personal access tokens for Rust applications, a port of laravel/passport for the RustBasic ecosystem.
Documentation
//! Integrasi axum (feature `axum`): routes dan auth / scope middleware.
//!
//! Handler mengambil [`PassportServer`] lewat _request extension_, bukan
//! router state. Ini membuatnya kompatibel dengan framework di atas axum yang
//! mengunci tipe state router (misalnya `AppContext` milik loco.rs).
//!
//! Contoh penggunaan:
//!
//! ```text
//! let oauth = rustbasic_passport::axum::router::<MyStoreBundle>()
//!     .merge(api_routes);               // atau di-merge ke router milik framework
//!
//! let app = Router::new()
//!     .merge(oauth)
//!     .layer(Extension(server));        // sekali — server tersedia di semua route
//! ```

use axum::extract::{Extension, Form, Request, State};
use axum::http::{HeaderValue, StatusCode, header};
use axum::middleware::Next;
use axum::response::{IntoResponse, Response};
use axum::routing::post;
use axum::{Json, Router};

use crate::error::Error;
use crate::jwt::AccessTokenClaims;
use crate::server::{AuthorizeRequest, DeviceAuthorizationRequest, PassportServer, TokenRequest};
use crate::store::Stores;

#[derive(Debug, Clone)]
pub struct AuthContext {
    pub claims: AccessTokenClaims,
    pub user_id: Option<String>,
    pub client_id: String,
    pub scopes: Vec<String>,
}

impl AuthContext {
    pub fn has_scope(&self, scope: &str) -> bool {
        self.scopes.iter().any(|s| s == scope)
    }

    pub fn has_all_scopes(&self, scopes: &[&str]) -> bool {
        scopes.iter().all(|s| self.has_scope(s))
    }

    pub fn has_any_scope(&self, scopes: &[&str]) -> bool {
        scopes.iter().any(|s| self.has_scope(s))
    }
}

#[derive(Debug, Clone, Default)]
pub struct ScopePolicy {
    pub any_of: Option<Vec<String>>,
    pub all_of: Option<Vec<String>>,
}

impl ScopePolicy {
    pub fn any(scopes: impl IntoIterator<Item = impl Into<String>>) -> Self {
        Self {
            any_of: Some(scopes.into_iter().map(Into::into).collect()),
            all_of: None,
        }
    }

    pub fn all(scopes: impl IntoIterator<Item = impl Into<String>>) -> Self {
        Self {
            any_of: None,
            all_of: Some(scopes.into_iter().map(Into::into).collect()),
        }
    }
}

/// Router `/oauth/*` tanpa server state — server disuplai via `Extension`.
///
/// Router ini inert terhadap tipe state router induk (bertipe [`Router`]`<()>`),
/// sehingga bisa di-`merge` bebas, termasuk ke router ber-state milik framework
/// lain (loco.rs, dll). Cukup pasang satu layer di level app:
///
/// ```text
/// let app = Router::new()
///     .merge(rustbasic_passport::axum::router::<MyStores>())
///     .layer(Extension(server));
/// ```
pub fn router<S: Stores>() -> Router<()> {
    Router::new()
        .route("/oauth/token", post(token_handler::<S>))
        .route("/oauth/authorize", post(authorize_handler::<S>))
        .route("/oauth/revoke", post(revoke_handler::<S>))
        .route("/oauth/device", post(device_authorization_handler::<S>))
        .route("/oauth/device/verify", post(device_approve_handler::<S>))
}

pub async fn token_handler<S: Stores>(
    Extension(server): Extension<PassportServer<S>>,
    Form(form): Form<TokenRequest>,
) -> Response {
    match server.issue_token(&form).await {
        Ok(response) => (StatusCode::OK, Json(response)).into_response(),
        Err(err) => oauth_error_response(&err),
    }
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct RevokeRequest {
    pub token: String,
}

pub async fn revoke_handler<S: Stores>(
    Extension(server): Extension<PassportServer<S>>,
    Form(form): Form<RevokeRequest>,
) -> Response {
    match server.revoke_token(&form.token).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(err) => oauth_error_response(&err),
    }
}

pub async fn authorize_handler<S: Stores>(
    Extension(server): Extension<PassportServer<S>>,
    Form(form): Form<AuthorizeRequest>,
) -> Response {
    let Some(user_id) = form.user_id.clone() else {
        return oauth_error_response(&Error::InvalidRequest("user_id is required".into()));
    };
    match server.authorize(user_id, &form).await {
        Ok(decision) => {
            let mut uri = format!("{}?code={}", decision.redirect_uri, decision.code);
            if let Some(state) = decision.state {
                uri.push_str(&format!("&state={}", state));
            }
            (StatusCode::FOUND, [(header::LOCATION, uri)]).into_response()
        }
        Err(err) => oauth_error_response(&err),
    }
}

pub async fn device_authorization_handler<S: Stores>(
    Extension(server): Extension<PassportServer<S>>,
    Form(form): Form<DeviceAuthorizationRequest>,
) -> Response {
    match server.issue_device_code(&form).await {
        Ok(response) => (StatusCode::OK, Json(response)).into_response(),
        Err(err) => oauth_error_response(&err),
    }
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(default)]
pub struct DeviceApproveRequest {
    pub user_code: String,
    pub user_id: String,
    pub approve: Option<bool>,
    pub deny: Option<bool>,
}

pub async fn device_approve_handler<S: Stores>(
    Extension(server): Extension<PassportServer<S>>,
    Form(form): Form<DeviceApproveRequest>,
) -> Response {
    if form.deny.unwrap_or(false) {
        return (
            StatusCode::BAD_REQUEST,
            Json(serde_json::json!({
                "error": "access_denied",
                "error_description": "The user denied the authorization request",
            })),
        )
            .into_response();
    }
    if form.user_code.is_empty() || form.user_id.is_empty() {
        return oauth_error_response(&Error::InvalidRequest(
            "user_code and user_id are required".into(),
        ));
    }
    match server
        .approve_device_code(&form.user_id, &form.user_code)
        .await
    {
        Ok(_) => StatusCode::OK.into_response(),
        Err(err) => oauth_error_response(&err),
    }
}

pub async fn require_auth<S: Stores>(
    State(server): State<PassportServer<S>>,
    mut req: Request,
    next: Next,
) -> Response {
    let token = req
        .headers()
        .get(header::AUTHORIZATION)
        .and_then(|value| value.to_str().ok())
        .and_then(|value| {
            value
                .strip_prefix("Bearer ")
                .or_else(|| value.strip_prefix("bearer "))
        });
    let Some(token) = token else {
        return unauthorized_response();
    };
    match server.validate_access_token(token).await {
        Ok(validated) => {
            let claims = validated.claims;
            let user_id = (claims.sub != claims.client_id).then(|| claims.sub.clone());
            req.extensions_mut().insert(AuthContext {
                user_id,
                client_id: claims.client_id.clone(),
                scopes: claims.scopes.clone(),
                claims,
            });
            next.run(req).await
        }
        Err(_) => unauthorized_response(),
    }
}

pub async fn check_scopes(State(policy): State<ScopePolicy>, req: Request, next: Next) -> Response {
    let Some(ctx) = req.extensions().get::<AuthContext>() else {
        return unauthorized_response();
    };
    let allowed = match (&policy.all_of, &policy.any_of) {
        (Some(all), _) => all.iter().all(|scope| ctx.has_scope(scope)),
        (None, Some(any)) => any.iter().any(|scope| ctx.has_scope(scope)),
        (None, None) => true,
    };
    if allowed {
        next.run(req).await
    } else {
        (
            StatusCode::FORBIDDEN,
            Json(serde_json::json!({
                "error": "insufficient_scope",
                "error_description": "The request requires higher privileges than provided by the access token",
            })),
        )
            .into_response()
    }
}

fn unauthorized_response() -> Response {
    let mut response = (
        StatusCode::UNAUTHORIZED,
        Json(serde_json::json!({
            "error": "invalid_token",
            "error_description": "The access token is invalid or has expired",
        })),
    )
        .into_response();
    response
        .headers_mut()
        .insert(header::WWW_AUTHENTICATE, HeaderValue::from_static("Bearer"));
    response
}

fn oauth_error_response(err: &Error) -> Response {
    let oauth_error = err.to_oauth_error();
    let status = StatusCode::from_u16(oauth_error.status()).unwrap_or(StatusCode::BAD_REQUEST);
    (status, Json(oauth_error)).into_response()
}