Walidacja danych i tworzenie konta z Either - lepszy zapis

public Either<Error, AccountDto> create(AccountCreateDto accountCreateDto) {

        final var errorType = ErrorType.ACCOUNT_PERSISTENCE_ERROR;

        final var errorMessage = "Not unique user name: " + accountCreateDto.userName;

        final var error = new Error(errorType,errorMessage);

        return UserName
                .create(accountCreateDto.userName)
                .flatMap(userName ->

                        userNameUniquenessChecker.isUnique(userName.text) ?

                                Password
                                        .create(accountCreateDto.password)
                                        .flatMap(password -> {

                                            final var createdAccount = new Account(
                                                    userName,
                                                    password,
                                                    AccountStatus.OPEN,
                                                    LocalDateTime.now(),
                                                    new ArrayList<>());

                                            final var addedAccount= accountRepository.add(createdAccount);

                                            final var accountDto = new AccountDto(
                                                    addedAccount.userName.text,
                                                    addedAccount.password.text,
                                                    addedAccount.status,
                                                    addedAccount.creationDate,
                                                    (long) addedAccount.tasks.size());

                                            return Either.right(accountDto);

                                        }) : Either.left(error));

import io.vavr.control.Either;

class AccountDto {
}

record AccountCreateDto(String userName, String password) {
}

class Error {
}

class UsernameUniquenessChecker {
    Either<Error, String> validateUnique(String name) {
        // if unique....
        return Either.right(name);
    }
}

class UniqueUsernameCreator {
    private final UsernameUniquenessChecker checker = null

    public Either<Error, UniqueUserName> create(String name) {
        return checker.validateUnique(name)
                .map(UniqueUserName::new);
    }
}

class ValidPasswordCreator {
    public Either<Error, ValidPassword> create(String name) {
        return Either.right(new ValidPassword(name));
    }
}

record UniqueUserName(String username) {
}

record ValidPassword(String password) {
}

record Account(UniqueUserName username, ValidPassword password) {
    public AccountDto toDto() {
        return new AccountDto();
    }
}

class AccountRepository {
    public Either<Error, Account> add(Account account) {
        return Either.right(account);
    }
}

public class Accounty {
    private final AccountRepository accountRepository = null;
    private final UniqueUsernameCreator uniqueUsernameCreator = null;
    private final ValidPasswordCreator passwordCreator = null;

    public Either<Error, AccountDto> create(AccountCreateDto accountCreateDto) {
        return uniqueUsernameCreator
                .create(accountCreateDto.userName())
                .flatMap(username -> passwordCreator.create(accountCreateDto.password())
                        .map(password -> new Account(username, password))
                )
                .flatMap(accountRepository::add)
                .map(Account::toDto);
    }
}

public final class AccountCreator {

    private final UserNameUniquenessChecker userNameUniquenessChecker;
    private final AccountRepository accountRepository;

    public AccountCreator(UserNameUniquenessChecker userNameUniquenessChecker, AccountRepository accountRepository) {
        this.userNameUniquenessChecker = userNameUniquenessChecker;
        this.accountRepository = accountRepository;
    }
    
    private Account createAccount(UserName userName, Password password) {
        
        return new Account(userName,password,AccountStatus.OPEN,LocalDateTime.now(),new ArrayList<>());
    }
    
    private AccountDto toDto(Account account) {
        
        return new AccountDto(
                account.userName.text,
                account.password.text,
                account.status,
                account.creationDate,
                (long) account.tasks.size());
    }

    public Either<Error, AccountDto> create(AccountCreateDto accountCreateDto) {
        
        return UserName
                .create(accountCreateDto.userName,userNameUniquenessChecker)
                .flatMap(userName -> Password
                        .create(accountCreateDto.password)
                        .map(password -> createAccount(userName,password))
                        .map(accountRepository::add)
                        .map(this::toDto));
    }
}

public final class UserName {

    public final String text;

    public UserName(String text) {
        this.text = text;
    }

    public static Either<Error,UserName> create(String userName,UserNameUniquenessChecker userNameUniquenessChecker) {

        final var minUserNameLength = 3;

        final var maxUserNameLength = 10;

        final var isUserNameLengthWrong =
                userName.length() < minUserNameLength || userName.length() > maxUserNameLength;

        if (isUserNameLengthWrong) {

            return Either.left(ErrorFactory.createWrongUserNameLength(
                    userName,
                    minUserNameLength,
                    maxUserNameLength));
        }

        else if (userNameUniquenessChecker.isDuplicate(userName)) {

            return Either.left(ErrorFactory.createNotUniqueUserNameError(userName));
        }

        else {

            return Either.right(new UserName(userName));
        }
    }
}

public final class Password {

    public final String text;

    private Password(String text) {
        this.text = text;
    }

    public static Either<Error, Password> create(String text) {

        final var minPasswordLength = 5;

        return text.length() < minPasswordLength ?

                Either.left(ErrorFactory.createWrongPasswordLengthError(text,minPasswordLength)) :

                Either.right(new Password(text));
    }
}