Problem z Mono w Either

Mam taką metodę do rejestracji użytkowników:

 public Mono<Either<AppError, UserDTO> > registerUser(RegisterUserDTO dto) {
    Mono<Either<AppError, Mono<UserDTO> > > result = userFactory
            .create(dto.username(), dto.password(), UserRole.COMMON)
            .map(it -> it
                    .map(user -> reactiveUserRepository
                            .add(user)
                            .map(User::toDTO)
                    )
            );
    return result;
  }

Metoda create z UserFactory zwraca Mono<Either<AppError, User>> a metoda add z ReactiveUserRepository Mono<User > i kończę z tym potworkiem Mono<Either<AppError, Mono<UserDTO> > > a chciałbym oczywiscie Mono<Either<AppError, UserDTO> >. Da się to jakoś zrobić?

Jak już jest reactor to bym się tutaj nie pchał w Either tylko korzystał z Mono.error. Wtedy możesz sobie łatwiej to flatmapować i obsługiwać

public Mono<Either<AppError, UserDTO>> registerUser(RegisterUserDTO dto) {
        return userFactory
                .create(dto.username(), dto.password(), UserRole.COMMON)
                .flatMap(it -> it
                        .map(user -> reactiveUserRepository
                                .add(user)
                                .map(u -> Either.<AppError, UserDTO>right(u.toDTO()))
                        )
                        .mapLeft(error -> Mono.just(Either.<AppError, UserDTO>left(error))).getOrElseGet(error -> error) //to jest "merge"
                );
    }

(btw. java jest straszliwa - prawie już zapomniałem jak)

VeloxDigitis napisał(a):

Jak już jest reactor to bym się tutaj nie pchał w Either tylko korzystał z Mono.error. Wtedy możesz sobie łatwiej to flatmapować i obsługiwać

Myślałem o tym. Trochę to ironia losu, że używająć funkcyjnego frameworka muszę rezygnować z funkcyjnej biblioteteki i wrócić do wyjątków.

jarekr000000 napisał(a):

public Mono<Either<AppError, UserDTO>> registerUser(RegisterUserDTO dto) {
        return userFactory
                .create(dto.username(), dto.password(), UserRole.COMMON)
                .flatMap(it -> it
                        .map(user -> reactiveUserRepository
                                .add(user)
                                .map(u -> Either.<AppError, UserDTO>right(u.toDTO()))
                        )
                        .mapLeft(error -> Mono.just(Either.<AppError, UserDTO>left(error))).getOrElseGet(error -> error) //to jest "merge"
                );
    }

(btw. java jest straszliwa - prawie już zapomniałem jak)

Dzięki, działa, ale wygląda okropnie. Rozumiem, że w Javie nie da się lepiej, wiec co myślisz o zrezygnowaniu z Eithera?

Sampeteq napisał(a):

Dzięki, działa, ale wygląda okropnie. Rozumiem, że w Javie nie da się lepiej, wiec co myślisz o zrezygnowaniu z Eithera?

Najlepiej to by zrezygnować z Javy...
W Scali by to lepiej wyglądało (nie mówiąc o tym, że takie rzeczy tam się opiernicza na ZIO, które jest parametryzowane E i A (czyli jakby naturalny Either)).
W Kotlinie też by to nieco lepiej wyglądało (bez szału, chyba, że przeszlibyśmy na magię Arrow-fx).

Jak już chcesz zostać przy javie to można sobie pewne utilsy porobić Mono<Either> -> Either<Mono> itp. i wtedy też jest lepiej.
Tak samo zwykle mam operacje merge - Either<T,T>-> T (zresztą ukradzione ze ScalaZ).

Rezygnacja z Either też wchodzi w grę - nie lubię tej opcji, ale jak kiedyś miałem serwis z dużą ilością reactora to zrezygnowałem z Eithera (inaczej koledzy by mnie zabili :-) - i tak reactor zwykle odstraszał).