Question regarding nesting of calls

[Reef3rm4n]

I have some questions regarding nesting of calls, suppose i have something like the following :

Uni.createFrom().item(whatEverItem)
   .call(
      Whatever -> pgPool.select()
                         .call(item -> performLogic)
                          .call(item -> pgPool.withTransaction(client ->client.update(item)))
     )
   .onFailure().retry().atMost(3)
   .subscribe()
   .with(whatever);

Now with the above pipeline im loosing control after the first selectFromDb() most likely in the pgPool.withTransaction() part. How do i get this to work without placing await() after the call to pgPool.withTransaction()

ps. the following works and performs the retries starting from the top transform() call executing everything within it

Uni.createFrom().item(w)
      .onItem()
      .transform(
        w1 ->   pgPool.select(w1)
                              .call(item -> performLogic(item))
                               .call(item -> pgPool.withTransaction(client -> client.update(item, client)))
                               .await().atMost(Duration.ofMillis(100))
      )
      .onFailure().retry().atMost(5)
      subscribe()
     .with(whatEver);

[Reef3rm4n]

ive' managed to get this to work with the following

Uni.createFrom().item(whatEver) // simulates upstream
.map(
    item ->
        pgPool.select(item.parameters)
        .call(item1 -> performLogic(item1))
        .call(item1 -> pool.withTransaction(client -> client.update(item1.parameters)))
)
.flatMap(item -> item)
.subscribe()
.with(whatEver)

so basically i think i was not flattening the withTransaction that returns a Uni of Uni
but im not convinced of this solution, can anyone weight in ? by the way the withTransaction part is supposed to update various tables using optmistic locking that's why i need to start the operation from the top most map() call

[Reef3rm4n]

Ive just realised that the failure is propagated all the way up the stream, so there's no point in nesting those calls inside the map() block... my intent was to limit the retry to that of the previous called operation, im the example would be the map()