Difference between using map or flatmap to handle errors

[adampoplawski]

Hello
Is there some (major) difference between:

service.returnsUni()
.invoke (item -> 
       if(logic(item)) throw Exception();
)

service.returnsUni()
.call(item ->
        if(logic(item)) Uni.createFrom().failure(Exception())
        else Uni.createFrom().item(null);
)

If we handle errors in Mutiny should we prefer one way over other way, or is there some logical difference?

Thx for help

[jponge]

The second option works better IMHO, because you can have fine control and report a failed Uni if needed.

[adampoplawski]

So I have followup question :)

return userRepository.getByUsername(username)
      .map { userDto ->
        val user = userDto.toDomain()
        if (logic(user))) {
          throw CustomException("")
        }
        return user.toResponseDto()
      }

return userRepository.getByUsername(username)
      .map {user.toDomain()}
      .call { user ->
         if(logic(user)) Uni.createFrom().failure(CustomException(""))
         else  else Uni.createFrom().item(null);
        }
      .map {user.toResponseDto()}
      }

In pseudo-code like that, wrapping error in Uni is making us do map + call + map. Is it my overinterpretation, that this is more proper? Since we have here sync code and do now throw in call/flatMap, first option seems better in this case.

The second option works better IMHO, because you can have fine control and report a failed Uni if needed.

I have tested that

.onFailure(CustomException:class.java).transform { OtherCustomException() }

also is working without wrapping in Uni

so we have same control on failed Uni or you had other issue in mind?

[jponge]

If you are not doing any I/O or CPU-intensive work both are ~ the same.