post {
var externalKeyValue = null
recover({
    val keyValue = requestHeaderCaching<String>(IDEMPOTENCY_KEY_HEADER).bind()
    externalKeyValue = keyValue
    catch({
      newSuspendeTransaction {
         idempotencyKeyService.insertRecord(record).bind()
      }
    )} { 
        println("Handle exception thrown by the code")
        if (externalKeyValue != null) {
            newSuspendedTransaction {
                idempotencyKeyService.unlockKey(idempotencyKey = externalKeyValue!!).bind()
            }
        }
        throw it
    }
    call.respond(HttpStatusCode.Created)
}) {
  println("BUSINESS ERROR")
  handleLeft(it)
}
}

.mapLeft

effect {
            when (currentKey.recoveryPoint) {
                STARTED -> {
                    catch {
                        newSuspendedTransaction {
                            addLogger(StdOutSqlLogger)
                            throw IllegalStateException()
                        }
                    }.mapLeft {
                        newSuspendedTransaction {
                            // we don't know what happened with the request. Let's unlock the row for retry.
                            idempotencyKeyService.updateKey(currentKey.copy(lockedAt = null)).bind()
                        }
                        throw it
                    }
                }
                else -> {}
            }
        }
    }
        .fold(
            {
                println("CAN RETRY")
                throw it
            },
            {
                println("FINISHED WITH ERROR")
                handleLeft(it)
            },
            {
                println("FINISHED WITH OK")
                call.respond(HttpStatusCode.Created)
            }
        )
}

newSuspendedTransaction(context = IO)

route("/markup-payments-billi") {
    notarizedPost(markupPaymentBillingOASSpec) {
        effect {
          .....
       }
    }
}