Rust で Railway Oriented Programming を実践してみた

#[derive(Debug, thiserror::Error)]
pub enum CreateUserUseCaseError {
    // エラー型の定義
}

pub trait UsesCreateUserUseCase {
    /// Workflow
    fn handle(
        &self,
        input: CreateUserInputData,
    ) -> impl Future<
        Output = Result<CreateUserOutputData, CreateUserUseCaseError>,
    > + Send;
}

pub trait CreateUserUseCase:
    // 依存関係
    ProvidesUserFactory
    + ProvidesUserRepository
{
}

impl<T: CreateUserUseCase + Sync> UsesCreateUserUseCase for T {
    async fn handle(
        &self,
        input: CreateUserInputData,
    ) -> Result<CreateUserOutputData, CreateUserUseCaseError> {
        // railway モジュールで定義した関数のチェーン
    }
}

mod railway {
    type RailwayResult<T> = Result<T, super::CreateUserUseCaseError>;

    pub(super) fn validate_input(/* ... */) -> RailwayResult<(Email, UserName)> { /* ... */ }
    pub(super) async fn check_email_not_exists(/* ... */) -> RailwayResult<(Email, UserName)> { /* ... */ }
    pub(super) fn build_user(/* ... */) -> RailwayResult<User> { /* ... */ }
    pub(super) async fn save_user(/* ... */) -> RailwayResult<User> { /* ... */ }
    pub(super) fn end(/* ... */) -> CreateUserOutputData { /* ... */ }
}

#[derive(Debug, thiserror::Error)]
pub enum CreateUserUseCaseError {
    // エラー型の定義
    #[error("メールアドレスが既に存在します。")]
    AlreadyExistsEmail,
    #[error("無効なメールアドレスです。")]
    InvalidEmail,
    #[error("無効なユーザー名です。")]
    InvalidUserName,
    #[error("UserFactoryError")]
    UserFactoryError(#[from] UserFactoryError),
    #[error("UserRepositoryError")]
    UserRepositoryError(#[from] UserRepositoryError),
}

mod railway {
    // このユースケース専用のResult型
    type RailwayResult<T> = Result<T, CreateUserUseCaseError>;
}

mod railway {
    /// 入力値を検証し、値オブジェクトに変換します。
    pub(super) fn validate_input(
        input: CreateUserInputData,
    ) -> RailwayResult<(Email, UserName)> {
        let email = Email::try_from(input.email)
            .map_err(|_| CreateUserUseCaseError::InvalidEmail)?;
        let name = UserName::try_from(input.name)
            .map_err(|_| CreateUserUseCaseError::InvalidUserName)?;
        Ok((email, name))
    }

    /// メールアドレスが存在していないことを確認します。
    pub(super) async fn check_email_not_exists(
        (email, name): (Email, UserName),
        impl_repository: &impl UsesUserRepository,
    ) -> RailwayResult<(Email, UserName)> {
        impl_repository
            .find_by_email(&email)
            .await
            .map_err(CreateUserUseCaseError::UserRepositoryError)?
            .map_or(Ok((email, name)), |_| Err(CreateUserUseCaseError::AlreadyExistsEmail))
    }

    /// ユーザーを新規作成します。
    pub(super) fn build_user(
        (email, name): (Email, UserName),
        impl_factory: &impl UsesUserFactory,
    ) -> RailwayResult<User> {
        impl_factory
            .build(UserFactoryParams { email, name })
            .map_err(CreateUserUseCaseError::UserFactoryError)
    }

    /// ユーザーを保存します。
    pub(super) async fn save_user(
        output: User,
        impl_repository: &impl UsesUserRepository,
    ) -> RailwayResult<User> {
        impl_repository
            .save(output)
            .await
            .map_err(CreateUserUseCaseError::UserRepositoryError)
    }

    /// 戻り値を返し、処理を終了します。
    pub(super) fn end(
        output: User,
    ) -> CreateUserOutputData {
        CreateUserOutputData {
            user: output.into(),
        }
    }
}

impl<T: CreateUserUseCase + Sync> UsesCreateUserUseCase for T {
    async fn handle(
        &self,
        input: CreateUserInputData,
    ) -> Result<CreateUserOutputData, CreateUserUseCaseError> {
        railway::validate_input(input)
            .map(|output| {
                railway::check_email_not_exists(output, self.user_repository())
            })?
            .await
            .and_then(|output| railway::build_user(output, self.user_factory()))
            .map(|output| railway::save_user(output, self.user_repository()))?
            .await
            .map(railway::end)
    }
}

# LLDB でバイナリを起動する
rust-lldb target/debug/your-bin

# 実行
run

# Stack Overflow が発生したらバックトレースを確認
thread backtrace all

async fn handle(&self, input: InputData) -> Result<OutputData, UseCaseError> {
    railway::begin(self.uow()).await?;
    let output = railway::validate_email(&input.email)?;
    let output = railway::authenticate(output, input.password, self.authenticator()).await?;
    let output = railway::update_last_access(output, self.user_repository()).await?;
    let output = railway::commit(output, self.uow()).await?;
    railway::end(output)
}

impl<T: CreateUserUseCase + Sync> UsesCreateUserUseCase for T {
    async fn handle(
        &self,
        input: CreateUserInputData,
    ) -> Result<CreateUserOutputData, CreateUserUseCaseError> {
        // 入力値の検証
        let email = Email::try_from(input.email)
            .map_err(|_| CreateUserUseCaseError::InvalidEmail)?;
        let name = UserName::try_from(input.name)
            .map_err(|_| CreateUserUseCaseError::InvalidUserName)?;

        // メールアドレスの重複チェック
        let existing_user = self
            .user_repository()
            .find_by_email(&email)
            .await
            .map_err(CreateUserUseCaseError::UserRepositoryError)?;
        if existing_user.is_some() {
            return Err(CreateUserUseCaseError::AlreadyExistsEmail);
        }

        // ユーザーの作成
        let user = self
            .user_factory()
            .build(UserFactoryParams { email, name })
            .map_err(CreateUserUseCaseError::UserFactoryError)?;

        // ユーザーの保存
        let saved_user = self
            .user_repository()
            .save(user)
            .await
            .map_err(CreateUserUseCaseError::UserRepositoryError)?;

        // 結果の変換
        Ok(CreateUserOutputData {
            user: saved_user.into(),
        })
    }
}