feat: login, logout

Author: kyu08

rust/rust-web-app-book/Cargo.lock

@@ -0,0 +1,72 @@
+use shared::error::{AppError, AppResult};
+use std::str::FromStr;
+
+use kernel::model::{
+    auth::{AccessToken, event::CreateToken},
+    id::UserId,
+};
+
+use crate::redis::model::{RedisKey, RedisValue};
+
+pub struct UserItem {
+    pub user_id: UserId,
+    pub password_hash: String,
+}
+
+pub struct AuthorizationKey(String);
+pub struct AuthorizedUserId(UserId);
+
+pub fn from(event: CreateToken) -> (AuthorizationKey, AuthorizedUserId) {
+    (
+        AuthorizationKey(event.access_token),
+        AuthorizedUserId(event.user_id),
+    )
+}
+
+impl From<AuthorizationKey> for AccessToken {
+    fn from(key: AuthorizationKey) -> Self {
+        Self(key.0)
+    }
+}
+
+impl From<AccessToken> for AuthorizationKey {
+    fn from(token: AccessToken) -> Self {
+        Self(token.0)
+    }
+}
+
+impl From<&AccessToken> for AuthorizationKey {
+    fn from(token: &AccessToken) -> Self {
+        Self(token.0.to_string())
+    }
+}
+
+impl RedisKey for AuthorizationKey {
+    type Value = AuthorizedUserId;
+
+    fn inner(&self) -> String {
+        self.0.clone()
+    }
+}
+
+impl RedisValue for AuthorizedUserId {
+    fn inner(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl TryFrom<String> for AuthorizedUserId {
+    type Error = AppError;
+
+    fn try_from(s: String) -> AppResult<Self> {
+        Ok(Self(UserId::from_str(&s).map_err(|e| {
+            AppError::ConversionEntityError(e.to_string())
+        })?))
+    }
+}
+
+impl AuthorizedUserId {
+    pub fn into_inner(self) -> UserId {
+        self.0
+    }
+}

rust/rust-web-app-book/adapter/src/database/model/auth.rs

@@ -1 +1,2 @@
+pub mod auth;
 pub mod book;

rust/rust-web-app-book/adapter/src/database/model/mod.rs

@@ -0,0 +1,74 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use derive_new::new;
+use kernel::{
+    model::{
+        auth::{AccessToken, event::CreateToken},
+        id::UserId,
+    },
+    repository::auth::AuthRepository,
+};
+use shared::error::{AppError, AppResult};
+
+use crate::{
+    database::{
+        ConnectionPool,
+        model::auth::{AuthorizationKey, AuthorizedUserId, UserItem, from},
+    },
+    redis::RedisClient,
+};
+
+#[derive(new)]
+pub struct AuthRepositoryImpl {
+    db: ConnectionPool,
+    kv: Arc<RedisClient>,
+    ttl: u64,
+}
+
+#[async_trait]
+impl AuthRepository for AuthRepositoryImpl {
+    async fn fetch_user_id_from_token(
+        &self,
+        access_token: &AccessToken,
+    ) -> AppResult<Option<UserId>> {
+        let key: AuthorizationKey = access_token.into();
+        self.kv
+            .get(&key)
+            .await
+            .map(|x| x.map(AuthorizedUserId::into_inner))
+    }
+
+    async fn verify_user(&self, email: &str, password: &str) -> AppResult<UserId> {
+        let user_item = sqlx::query_as!(
+            UserItem,
+            r#"
+                SELECT user_id, password_hash FROM users
+                WHERE email = $1;
+            "#,
+            email
+        )
+        .fetch_one(self.db.inner_ref())
+        .await
+        .map_err(AppError::SpecificOperationError)?;
+
+        let valid = bcrypt::verify(password, &user_item.password_hash)?;
+
+        if !valid {
+            return Err(AppError::UnauthenticatedError);
+        }
+
+        Ok(user_item.user_id)
+    }
+
+    async fn create_token(&self, event: CreateToken) -> AppResult<AccessToken> {
+        let (key, value) = from(event);
+        self.kv.set_ex(&key, &value, self.ttl).await?;
+        Ok(key.into())
+    }
+
+    async fn delete_token(&self, access_token: AccessToken) -> AppResult<()> {
+        let key: AuthorizationKey = access_token.into();
+        self.kv.delete(&key).await
+    }
+}

rust/rust-web-app-book/adapter/src/repository/auth.rs

@@ -1,2 +1,3 @@
+pub mod auth;
 pub mod book;
 pub mod health;

rust/rust-web-app-book/adapter/src/repository/mod.rs

@@ -0,0 +1,29 @@
+use axum::{Json, extract::State, http::StatusCode};
+use kernel::model::auth::event::CreateToken;
+use registry::AppRegistry;
+use shared::error::AppResult;
+
+use crate::model::auth::{AccessTokenResponse, LoginRequest};
+
+pub async fn login(
+    State(registry): State<AppRegistry>,
+    Json(req): Json<LoginRequest>,
+) -> AppResult<Json<AccessTokenResponse>> {
+    let user_id = registry
+        .auth_repository()
+        .verify_user(&req.email, &req.password)
+        .await?;
+    let access_token = registry
+        .auth_repository()
+        .create_token(CreateToken::new(user_id))
+        .await?;
+
+    Ok(Json(AccessTokenResponse {
+        user_id,
+        access_token: access_token.0,
+    }))
+}
+
+pub async fn logout(State(registry): State<AppRegistry>) -> AppResult<StatusCode> {
+    todo!() // ここはいまは実装しない。
+}

rust/rust-web-app-book/api/src/handler/auth.rs

@@ -1,2 +1,3 @@
+pub mod auth;
 pub mod book;
 pub mod health;

rust/rust-web-app-book/api/src/handler/mod.rs

@@ -0,0 +1,16 @@
+use kernel::model::id::UserId;
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LoginRequest {
+    pub email: String,
+    pub password: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AccessTokenResponse {
+    pub user_id: UserId,
+    pub access_token: String,
+}

rust/rust-web-app-book/api/src/model/auth.rs

@@ -1 +1,2 @@
+pub mod auth;
 pub mod book;

rust/rust-web-app-book/api/src/model/mod.rs

@@ -0,0 +1,11 @@
+use axum::{Router, routing::post};
+use registry::AppRegistry;
+
+use crate::handler::auth::{login, logout};
+
+pub fn routes() -> Router<AppRegistry> {
+    let auth_router = Router::new()
+        .route("/login", post(login))
+        .route("/logout", post(logout));
+    Router::new().nest("/auth", auth_router)
+}