Rust로 헥사고날 아키텍처 구현 - 의존성 역전

// domain/src/user.rs

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct User {
    pub id: UserId,
    pub email: Email,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UserId(String);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Email(String);

#[derive(Debug, thiserror::Error)]
pub enum DomainError {
    #[error("invalid email")]
    InvalidEmail,
}

impl Email {
    pub fn parse(raw: &str) -> Result<Self, DomainError> {
        // 단순화된 검증
        if raw.contains('@') {
            Ok(Self(raw.to_string()))
        } else {
            Err(DomainError::InvalidEmail)
        }
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl UserId {
    pub fn new(raw: String) -> Self {
        Self(raw)
    }
}

// application/src/ports.rs

use async_trait::async_trait;
use domain::user::{Email, User};

#[derive(Debug, thiserror::Error)]
pub enum RepoError {
    #[error("db error: {0}")]
    Db(String),
}

#[async_trait]
pub trait UserRepository: Send + Sync {
    async fn find_by_email(&self, email: &Email) -> Result<Option<User>, RepoError>;
    async fn save(&self, user: &User) -> Result<(), RepoError>;
}

// application/src/usecases/register_user.rs

use domain::user::{Email, User, UserId};
use crate::ports::{RepoError, UserRepository};

#[derive(Debug, thiserror::Error)]
pub enum RegisterError {
    #[error("email already exists")]
    EmailAlreadyExists,

    #[error("repo error: {0}")]
    Repo(#[from] RepoError),

    #[error("domain error: {0}")]
    Domain(#[from] domain::user::DomainError),
}

pub struct RegisterUser<'a, R: UserRepository> {
    repo: &'a R,
}

impl<'a, R: UserRepository> RegisterUser<'a, R> {
    pub fn new(repo: &'a R) -> Self {
        Self { repo }
    }

    pub async fn execute(&self, raw_email: &str) -> Result<User, RegisterError> {
        let email = Email::parse(raw_email)?;

        if self.repo.find_by_email(&email).await?.is_some() {
            return Err(RegisterError::EmailAlreadyExists);
        }

        // 예제 단순화를 위해 ID 생성은 문자열로 처리
        let user = User {
            id: UserId::new(format!("user-{}", email.as_str())),
            email,
        };

        self.repo.save(&user).await?;
        Ok(user)
    }
}

// adapters/src/inmemory_user_repo.rs

use async_trait::async_trait;
use std::collections::HashMap;
use tokio::sync::RwLock;

use application::ports::{RepoError, UserRepository};
use domain::user::{Email, User};

pub struct InMemoryUserRepository {
    by_email: RwLock<HashMap<String, User>>,
}

impl InMemoryUserRepository {
    pub fn new() -> Self {
        Self {
            by_email: RwLock::new(HashMap::new()),
        }
    }
}

#[async_trait]
impl UserRepository for InMemoryUserRepository {
    async fn find_by_email(&self, email: &Email) -> Result<Option<User>, RepoError> {
        let map = self.by_email.read().await;
        Ok(map.get(email.as_str()).cloned())
    }

    async fn save(&self, user: &User) -> Result<(), RepoError> {
        let mut map = self.by_email.write().await;
        map.insert(user.email.as_str().to_string(), user.clone());
        Ok(())
    }
}

// application/tests/register_user_test.rs

use adapters::inmemory_user_repo::InMemoryUserRepository;
use application::usecases::register_user::RegisterUser;

#[tokio::test]
async fn register_user_rejects_duplicate_email() {
    let repo = InMemoryUserRepository::new();
    let uc = RegisterUser::new(&repo);

    let _ = uc.execute("a@b.com").await.unwrap();
    let err = uc.execute("a@b.com").await.unwrap_err();

    let msg = format!("{}", err);
    assert!(msg.contains("email already exists"));
}

// adapters/src/postgres_user_repo.rs

use async_trait::async_trait;
use sqlx::PgPool;

use application::ports::{RepoError, UserRepository};
use domain::user::{Email, User, UserId};

pub struct PostgresUserRepository {
    pool: PgPool,
}

impl PostgresUserRepository {
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
}

#[async_trait]
impl UserRepository for PostgresUserRepository {
    async fn find_by_email(&self, email: &Email) -> Result<Option<User>, RepoError> {
        let row = sqlx::query!(
            "SELECT id, email FROM users WHERE email = $1",
            email.as_str()
        )
        .fetch_optional(&self.pool)
        .await
        .map_err(|e| RepoError::Db(e.to_string()))?;

        Ok(row.map(|r| User {
            id: UserId::new(r.id),
            email: Email::parse(&r.email).map_err(|e| RepoError::Db(e.to_string()))?,
        }))
    }

    async fn save(&self, user: &User) -> Result<(), RepoError> {
        sqlx::query!(
            "INSERT INTO users (id, email) VALUES ($1, $2)",
            user.id.clone().0,
            user.email.as_str()
        )
        .execute(&self.pool)
        .await
        .map_err(|e| RepoError::Db(e.to_string()))?;

        Ok(())
    }
}

// src/main.rs

use adapters::postgres_user_repo::PostgresUserRepository;
use application::usecases::register_user::RegisterUser;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let pool = sqlx::PgPool::connect("postgres://...").await?;
    let repo = PostgresUserRepository::new(pool);

    let uc = RegisterUser::new(&repo);
    let user = uc.execute("hello@example.com").await?;

    println!("registered: {:?}", user);
    Ok(())
}

use std::sync::Arc;
use application::ports::UserRepository;

pub struct RegisterUser {
    repo: Arc<dyn UserRepository>,
}

impl RegisterUser {
    pub fn new(repo: Arc<dyn UserRepository>) -> Self {
        Self { repo }
    }
}