Rustとレイヤードアーキテクチャの相性を徹底分析｜所有権・トレイトが設計に与える影響

// アプリケーション層からドメイン層への値の移動
fn create_user(input: CreateUserInput) -> Result<User, DomainError> {
    // inputの所有権はこの関数に移動している
    let name = UserName::new(input.name)?;  // input.nameの所有権が移動
    let email = Email::new(input.email)?;   // input.emailの所有権が移動
    Ok(User::new(name, email))
}

// ドメイン層でリポジトリのインターフェースを定義
#[async_trait]
pub trait UserRepository: Send + Sync {
    async fn find_by_id(&self, id: &UserId) -> Result<Option<User>, RepositoryError>;
    async fn save(&self, user: &User) -> Result<(), RepositoryError>;
}

// アプリケーション層はトレイトに依存（具体実装には依存しない）
pub struct UserService<R: UserRepository> {
    repository: R,
}

impl<R: UserRepository> UserService<R> {
    pub fn new(repository: R) -> Self {
        Self { repository }
    }

    pub async fn get_user(&self, id: &UserId) -> Result<Option<User>, AppError> {
        self.repository
            .find_by_id(id)
            .await
            .map_err(AppError::from)
    }
}

my-app/
├── Cargo.toml          # workspace定義
├── domain/
│   ├── Cargo.toml      # 依存: なし（外部crateも最小限）
│   └── src/lib.rs
├── application/
│   ├── Cargo.toml      # 依存: domain
│   └── src/lib.rs
├── infrastructure/
│   ├── Cargo.toml      # 依存: domain, application
│   └── src/lib.rs
└── presentation/
    ├── Cargo.toml      # 依存: application, infrastructure
    └── src/main.rs

[workspace]
members = ["domain", "application", "infrastructure", "presentation"]
resolver = "2"

// プレゼンテーション層のリクエスト型
#[derive(Deserialize)]
pub struct CreateUserRequest {
    pub name: String,
    pub email: String,
}

// アプリケーション層のコマンド型
pub struct CreateUserCommand {
    pub name: String,
    pub email: String,
}

// 変換はFromトレイトで実装
impl From<CreateUserRequest> for CreateUserCommand {
    fn from(req: CreateUserRequest) -> Self {
        Self {
            name: req.name,
            email: req.email,
        }
    }
}

use async_trait::async_trait;

#[async_trait]
pub trait OrderRepository: Send + Sync {
    async fn find_by_id(&self, id: &OrderId) -> Result<Option<Order>, RepositoryError>;
    async fn save(&self, order: &Order) -> Result<(), RepositoryError>;
    async fn delete(&self, id: &OrderId) -> Result<(), RepositoryError>;
}

// ドメイン層: 具体的なエラー型を定義
#[derive(Debug, thiserror::Error)]
pub enum DomainError {
    #[error("ユーザー名は1〜50文字で入力してください")]
    InvalidUserName,
    #[error("メールアドレスの形式が不正です")]
    InvalidEmail,
}

// アプリケーション層: ドメインエラーをラップ
#[derive(Debug, thiserror::Error)]
pub enum AppError {
    #[error(transparent)]
    Domain(#[from] DomainError),
    #[error(transparent)]
    Repository(#[from] RepositoryError),
    #[error("ユーザーが見つかりません: {0}")]
    UserNotFound(String),
}

// プレゼンテーション層: HTTPステータスコードへ変換
impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, message) = match &self {
            AppError::Domain(_) => (StatusCode::BAD_REQUEST, self.to_string()),
            AppError::UserNotFound(_) => (StatusCode::NOT_FOUND, self.to_string()),
            AppError::Repository(_) => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "内部エラーが発生しました".to_string(),
            ),
        };
        (status, Json(json!({ "error": message }))).into_response()
    }
}

// main.rsでの組み立て例
#[tokio::main]
async fn main() {
    let pool = PgPool::connect("postgres://localhost/mydb")
        .await
        .expect("DB接続に失敗");

    // インフラ層の具体実装を生成
    let user_repo = PgUserRepository::new(pool.clone());
    let order_repo = PgOrderRepository::new(pool.clone());

    // アプリケーション層にインフラ層の実装を注入
    let user_service = UserService::new(user_repo);
    let order_service = OrderService::new(order_repo);

    // プレゼンテーション層（axumのRouter）にサービスを登録
    let app = Router::new()
        .route("/users/:id", get(get_user))
        .route("/users", post(create_user))
        .with_state(AppState {
            user_service: Arc::new(user_service),
            order_service: Arc::new(order_service),
        });

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

mkdir my-layered-app && cd my-layered-app
cargo init --name presentation
cargo init --lib --name domain domain
cargo init --lib --name application application
cargo init --lib --name infrastructure infrastructure

// domain/src/lib.rs
pub mod model;
pub mod repository;
pub mod error;

// domain/src/model/user.rs
#[derive(Debug, Clone)]
pub struct User {
    id: UserId,
    name: UserName,
    email: Email,
}

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

#[derive(Debug, Clone)]
pub struct UserName(String);

impl UserName {
    pub fn new(value: String) -> Result<Self, DomainError> {
        if value.is_empty() || value.len() > 50 {
            return Err(DomainError::InvalidUserName);
        }
        Ok(Self(value))
    }

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

// application/src/usecase/create_user.rs
use domain::model::user::{User, UserName, Email};
use domain::repository::UserRepository;
use domain::error::DomainError;

pub struct CreateUserUseCase<R: UserRepository> {
    user_repository: R,
}

impl<R: UserRepository> CreateUserUseCase<R> {
    pub fn new(user_repository: R) -> Self {
        Self { user_repository }
    }

    pub async fn execute(&self, input: CreateUserInput) -> Result<User, AppError> {
        let name = UserName::new(input.name)?;
        let email = Email::new(input.email)?;
        let user = User::new(name, email);
        self.user_repository.save(&user).await?;
        Ok(user)
    }
}

pub struct CreateUserInput {
    pub name: String,
    pub email: String,
}

#[cfg(test)]
mod tests {
    use super::*;
    use domain::repository::MockUserRepository;

    #[tokio::test]
    async fn ユーザーを正常に作成できる() {
        let mut mock_repo = MockUserRepository::new();
        mock_repo
            .expect_save()
            .times(1)
            .returning(|_| Ok(()));

        let usecase = CreateUserUseCase::new(mock_repo);
        let input = CreateUserInput {
            name: "田中太郎".to_string(),
            email: "tanaka@example.com".to_string(),
        };

        let result = usecase.execute(input).await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn 空のユーザー名はエラーになる() {
        let mock_repo = MockUserRepository::new();
        let usecase = CreateUserUseCase::new(mock_repo);
        let input = CreateUserInput {
            name: "".to_string(),
            email: "test@example.com".to_string(),
        };

        let result = usecase.execute(input).await;
        assert!(matches!(
            result,
            Err(AppError::Domain(DomainError::InvalidUserName))
        ));
    }
}