ClassyGitshadowzzh

auth.rs

auth.rs
use std::time::{SystemTime, UNIX_EPOCH};

use axum::{
    Json,
    extract::State,
    http::{HeaderMap, StatusCode},
    response::{IntoResponse, Response},
};
use jsonwebtoken::{Algorithm, EncodingKey, Header, encode};
use serde::{Deserialize, Serialize};
use serde_json::json;

use crate::{
    auth::{bearer_token, verify_jwt},
    error::AppError,
    state::AppState,
};

#[derive(Debug, Deserialize, utoipa::ToSchema)]
pub struct LoginBody {
    #[serde(default)]
    username: Option<String>,
    #[serde(default)]
    password: Option<String>,
}

/// `POST /api/auth/login` —— 管理員密碼登入(bcrypt 驗證 → 簽 7d JWT)。
/// 純讀(查 users + 簽 token,不寫 DB),邏輯與回應逐字照抄 Express。
#[utoipa::path(
    post, path = "/api/auth/login", tag = "auth",
    responses(
        (status = 200, description = "登入成功,回 JWT + 使用者(動態 JSON)"),
        (status = 401, description = "帳密錯誤"),
    ),
)]
pub async fn login(
    State(state): State<AppState>,
    crate::error::JsonBody(body): crate::error::JsonBody<LoginBody>,
) -> Result<Response, AppError> {
    let username = body.username.unwrap_or_default();
    let password = body.password.unwrap_or_default();

    // Express: `if (!username || !password)` —— 空字串也算缺。
    if username.is_empty() || password.is_empty() {
        return Ok(
            (StatusCode::BAD_REQUEST, Json(json!({ "message": "請提供用戶名和密碼" }))).into_response()
        );
    }

    // 查使用者。DB 錯 → 500 {"message":"伺服器錯誤"}(對齊 Express,非 AppError 的 error key)
    let Ok(user) = sqlx::query_as::<_, (i64, String, String, Option<String>)>(
        "SELECT id, username, password_hash, role FROM users WHERE username = ?",
    )
    .bind(&username)
    .fetch_optional(&state.pool)
    .await
    else {
        return Ok(
            (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "message": "伺服器錯誤" }))).into_response()
        );
    };

    let invalid =
        || (StatusCode::UNAUTHORIZED, Json(json!({ "message": "用戶名或密碼錯誤" }))).into_response();
    let Some((id, uname, hash, role)) = user else {
        return Ok(invalid());
    };

    // bcrypt 驗證(相容 bcryptjs 的 $2a/$2b/$2y)。cost-10 ≈ 數十 ms 純 CPU,
    // 丟 spawn_blocking 避免卡住 tokio worker。驗證失敗或 hash 壞 → 視為密碼錯。
    let pw = password.clone();
    let ok = tokio::task::spawn_blocking(move || bcrypt::verify(&pw, &hash).unwrap_or(false))
        .await
        .unwrap_or(false);
    if !ok {
        return Ok(invalid());
    }

    // 簽 JWT:payload {id, username, role} + iat/exp(7 天),對齊 Express jwt.sign(expiresIn:'7d')。
    let now = SystemTime::now().duration_since(UNIX_EPOCH).map_or(0, |d| d.as_secs());
    let exp = now + 7 * 24 * 60 * 60;
    let claims = json!({ "id": id, "username": uname, "role": role, "iat": now, "exp": exp });
    let token = encode(
        &Header::new(Algorithm::HS256),
        &claims,
        &EncodingKey::from_secret(state.jwt_secret.as_bytes()),
    )
    .map_err(|e| AppError::Anyhow(anyhow::anyhow!("sign jwt: {e}")))?;

    Ok(Json(json!({
        "message": "登入成功",
        "token": token,
        "user": { "id": id, "username": uname, "role": role },
    }))
    .into_response())
}

/// 單一 OAuth provider 的公開設定。clientId 是公開值(前端組授權 URL 要用),
/// 沒設定時是空字串而不是缺欄位——所以 enabled 才是「這個 provider 能不能用」的判準。
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct OAuthProviderInfo {
    #[serde(rename = "clientId")]
    pub client_id: String,
    pub enabled: bool,
}

/// `GET /api/auth/providers` 回應。兩個 provider 一律都在,用 enabled 區分。
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct AuthProvidersResponse {
    pub google: OAuthProviderInfo,
    pub github: OAuthProviderInfo,
}

/// `GET /api/auth/providers` —— 回前端 OAuth 設定(clientId 為公開值;enabled = clientId 非空)。
/// clientId 由 env `GOOGLE_CLIENT_ID`/`GITHUB_CLIENT_ID` 提供(與 Express 同源)。
/// 原本回 `Json<serde_json::Value>`(json! 手捏)→ specta 生不出型別,前端只好手寫一份
/// 對應的 interface,而手寫的那份把 clientId 標成可選、把 provider 標成可能缺席,
/// 都與後端實際行為不符。改成 struct 之後前端直接吃生成型別。
#[utoipa::path(get, path = "/api/auth/providers", tag = "auth",
    responses((status = 200, description = "可用 OAuth provider 清單", body = AuthProvidersResponse)))]
pub async fn providers() -> Json<AuthProvidersResponse> {
    let g = std::env::var("GOOGLE_CLIENT_ID").unwrap_or_default();
    let gh = std::env::var("GITHUB_CLIENT_ID").unwrap_or_default();
    Json(AuthProvidersResponse {
        google: OAuthProviderInfo { enabled: !g.is_empty(), client_id: g },
        github: OAuthProviderInfo { enabled: !gh.is_empty(), client_id: gh },
    })
}

/// `POST /api/auth/logout` —— JWT 無狀態,前端清 token 即可;這裡僅回 ok。
#[utoipa::path(post, path = "/api/auth/logout", tag = "auth",
    responses((status = 200, description = "登出(stateless JWT,client 端清 token)")))]
pub async fn logout() -> Json<serde_json::Value> {
    Json(json!({ "message": "ok" }))
}

/// role || 'USER':null 或空字串都退回 "USER"(對齊 Express `user.role || 'USER'`)。
fn role_or_user(role: Option<String>) -> String {
    role.filter(|r| !r.is_empty()).unwrap_or_else(|| "USER".to_string())
}

/// oauth_users 一列(/auth/me 用到的欄位)。
type OauthRow =
    (i64, Option<String>, Option<String>, Option<String>, Option<String>, Option<String>, Option<i64>);
//                id   display_name     email            avatar_url       provider         role             linked_to

fn me_user_json(u: &OauthRow) -> serde_json::Value {
    json!({
        "id": u.0,
        "displayName": u.1,
        "email": u.2,
        "avatar": u.3,
        "provider": u.4,
        "role": role_or_user(u.5.clone()),
    })
}

/// `GET /api/auth/me` —— 前端用來恢復 session。錯誤回應用 `{"error":...}`(注意:非 message)。
#[utoipa::path(get, path = "/api/auth/me", tag = "auth", security(("bearer" = [])),
    responses((status = 200, description = "當前登入使用者(動態 JSON)"), (status = 401, description = "未登入")))]
pub async fn me(State(state): State<AppState>, headers: HeaderMap) -> Result<Response, AppError> {
    let unauth = |msg: &str| (StatusCode::UNAUTHORIZED, Json(json!({ "error": msg }))).into_response();

    let Some(token) = bearer_token(&headers) else {
        return Ok(unauth("Not authenticated"));
    };
    let Some(claims) = verify_jwt(token, &state.jwt_secret) else {
        return Ok(unauth("Invalid token"));
    };

    let user_id = claims.get("userId").and_then(serde_json::Value::as_i64).filter(|&u| u != 0);
    let provider_truthy = claims.get("provider").and_then(|v| v.as_str()).is_some_and(|s| !s.is_empty());

    // OAuth token(userId && provider)
    if let (Some(uid), true) = (user_id, provider_truthy) {
        // Express:DB 錯 或 查無 → 401 {"error":"User not found"}
        let Ok(user) = sqlx::query_as::<_, OauthRow>(
            "SELECT id, display_name, email, avatar_url, provider, role, linked_to FROM oauth_users WHERE id = ?",
        )
        .bind(uid)
        .fetch_optional(&state.pool)
        .await
        else {
            return Ok(unauth("User not found"));
        };
        let Some(user) = user else {
            return Ok(unauth("User not found"));
        };
        // 關聯帳號 → 回主帳號資料;主帳號查不到 → 退回自身資料
        if let Some(linked) = user.6 {
            let primary = sqlx::query_as::<_, OauthRow>(
                "SELECT id, display_name, email, avatar_url, provider, role, linked_to FROM oauth_users WHERE id = ?",
            )
            .bind(linked)
            .fetch_optional(&state.pool)
            .await
            .ok()
            .flatten();
            return Ok(match primary {
                Some(p) => Json(me_user_json(&p)).into_response(),
                None => Json(me_user_json(&user)).into_response(),
            });
        }
        return Ok(Json(me_user_json(&user)).into_response());
    }

    // legacy admin token(username)
    if let Some(username) = claims.get("username").and_then(|v| v.as_str()).filter(|s| !s.is_empty()) {
        return Ok(Json(json!({
            "id": 0,
            "displayName": username,
            "email": "",
            "avatar": "",
            "provider": "admin",
            "role": "OWNER",
            "isAdmin": true,
        }))
        .into_response());
    }

    Ok(unauth("Invalid token"))
}

#[derive(Debug, Deserialize, utoipa::ToSchema)]
pub struct ResetAdminBody {
    username: Option<String>,
    password: Option<String>,
}

/// `POST /api/auth/reset-admin` —— 開發用密碼重置。行為清理版(原 Express 靠
/// NODE_ENV==='production' 擋、容器沒設=在正式環境是活的=安全發現 #3):
/// **fail-safe 預設關閉**,需顯式 `ENABLE_RESET_ADMIN=1` 才開。
#[utoipa::path(post, path = "/api/auth/reset-admin", tag = "auth",
    responses((status = 200, description = "重置成功"), (status = 403, description = "未啟用 ENABLE_RESET_ADMIN")))]
pub async fn reset_admin(
    State(state): State<AppState>,
    body: Option<Json<ResetAdminBody>>,
) -> Result<Response, AppError> {
    if std::env::var("ENABLE_RESET_ADMIN").as_deref() != Ok("1") {
        return Ok((StatusCode::NOT_FOUND, Json(json!({ "message": "Not found" }))).into_response());
    }
    let b = body.map_or(ResetAdminBody { username: None, password: None }, |Json(x)| x);
    let env_user = std::env::var("ADMIN_USERNAME").ok().filter(|s| !s.is_empty());
    let env_pass = std::env::var("ADMIN_PASSWORD").ok().filter(|s| !s.is_empty());
    let username =
        env_user.or_else(|| b.username.filter(|s| !s.is_empty())).unwrap_or_else(|| "admin".to_string());
    let Some(password) = env_pass.or_else(|| b.password.filter(|s| !s.is_empty())) else {
        return Ok((
            StatusCode::BAD_REQUEST,
            Json(json!({ "message": "ADMIN_PASSWORD is not configured. Set ADMIN_PASSWORD in env or pass password in request body for dev reset." })),
        )
            .into_response());
    };

    // bcrypt cost-10 hash ≈ 數十 ms 純 CPU → spawn_blocking
    let pw = password.clone();
    let Ok(Ok(hash)) = tokio::task::spawn_blocking(move || bcrypt::hash(&pw, 10)).await else {
        return Ok(
            (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "message": "密碼處理失敗" }))).into_response()
        );
    };

    let updated = match sqlx::query("UPDATE users SET password_hash = ? WHERE username = ?")
        .bind(&hash)
        .bind(&username)
        .execute(&state.pool)
        .await
    {
        Ok(r) => r.rows_affected(),
        Err(_) => {
            return Ok((StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "message": "更新密碼失敗" })))
                .into_response());
        }
    };
    if updated == 0 {
        if sqlx::query("INSERT INTO users (username, password_hash, role) VALUES (?, ?, 'admin')")
            .bind(&username)
            .bind(&hash)
            .execute(&state.pool)
            .await
            .is_err()
        {
            return Ok((StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "message": "創建用戶失敗" })))
                .into_response());
        }
        return Ok(Json(json!({ "message": format!("管理員用戶 {username} 已創建"), "username": username }))
            .into_response());
    }
    Ok(Json(json!({ "message": format!("管理員 {username} 密碼已重置"), "username": username }))
        .into_response())
}