Oracle Lock-Free Reservation with Micronaut Data JDBC

package example.micronaut.domain

import groovy.transform.CompileStatic
import io.micronaut.core.annotation.Nullable
import io.micronaut.data.annotation.GeneratedValue
import io.micronaut.data.annotation.Id
import io.micronaut.data.annotation.MappedEntity
import io.micronaut.data.annotation.Reservable
import io.micronaut.serde.annotation.Serdeable
import jakarta.validation.constraints.NotBlank
import jakarta.validation.constraints.PositiveOrZero

@CompileStatic
@Serdeable // 
@MappedEntity('ACCOUNT') // 
class Account {
    @Id
    @GeneratedValue
    @Nullable
    Long id // 

    @NotBlank
    String name // 

    @Reservable
    @PositiveOrZero
    Long balance // 

    Account() {
    }

    Account(@Nullable Long id, String name, Long balance) {
        this.id = id
        this.name = name
        this.balance = balance
    }
}

package example.micronaut

import example.micronaut.domain.Account
import io.micronaut.data.annotation.Id
import io.micronaut.data.jdbc.annotation.JdbcRepository
import io.micronaut.data.model.query.builder.sql.Dialect
import io.micronaut.data.repository.CrudRepository

@JdbcRepository(dialect = Dialect.ORACLE) // 
interface AccountRepository extends CrudRepository<Account, Long> { // 

    /**
     *
     * @param id Account unique identifier
     * @param balance balance increment
     * @return rows updated
     */
    long reserveIncrementBalance(@Id Long id, Long balance) // 

    /**
     *
     * @param id Account unique identifier
     * @param balance balance decrement
     * @return rows updated
     */
    long reserveDecrementBalance(@Id Long id, Long balance) // 
}

package example.micronaut

import example.micronaut.domain.Account
import groovy.transform.CompileStatic
import io.micronaut.http.HttpStatus
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Post
import io.micronaut.http.annotation.QueryValue
import io.micronaut.http.annotation.Status
import io.micronaut.http.exceptions.HttpStatusException
import io.micronaut.scheduling.TaskExecutors
import io.micronaut.scheduling.annotation.ExecuteOn

@CompileStatic
@ExecuteOn(TaskExecutors.BLOCKING) // 
@Controller('/accounts') // 
class AccountController {

    private final AccountRepository repository

    AccountController(AccountRepository repository) { // 
        this.repository = repository
    }

    @Post
    @Status(HttpStatus.CREATED)
    Account create(@Body Account account) {
        repository.save(account)
    }

    @Get
    List<Account> findAll() {
        repository.findAll()
    }

    @Post('/{id}/deposit')
    Account deposit(Long id, @QueryValue Long amount) {
        if (repository.reserveIncrementBalance(id, amount) == 0L) { // 
            throw new HttpStatusException(HttpStatus.NOT_FOUND, 'Account not found')
        }
        repository.findById(id).orElseThrow() // 
    }

    @Post('/{id}/withdraw')
    Account withdraw(Long id, @QueryValue Long amount) {
        if (repository.reserveDecrementBalance(id, amount) == 0L) {
            throw new HttpStatusException(HttpStatus.NOT_FOUND, 'Account not found')
        }
        repository.findById(id).orElseThrow()
    }
}

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.data.exceptions.DataIntegrityViolationException
import io.micronaut.http.HttpRequest
import io.micronaut.http.HttpResponse
import io.micronaut.http.HttpStatus
import io.micronaut.http.annotation.Produces
import io.micronaut.http.server.exceptions.ExceptionHandler
import io.micronaut.http.server.exceptions.response.ErrorContext
import io.micronaut.http.server.exceptions.response.ErrorResponseProcessor
import jakarta.inject.Singleton

@CompileStatic
@Produces
@Singleton
class ReservationExceptionHandler
        implements ExceptionHandler<DataIntegrityViolationException, HttpResponse<?>> { // 

    private final ErrorResponseProcessor<?> errorResponseProcessor

    ReservationExceptionHandler(ErrorResponseProcessor<?> errorResponseProcessor) {
        this.errorResponseProcessor = errorResponseProcessor
    }

    @Override
    HttpResponse<?> handle(HttpRequest request, DataIntegrityViolationException exception) {
        ErrorContext errorContext = ErrorContext.builder(request)
                .cause(exception)
                .errorMessage('The operation violates an account constraint') // 
                .build()
        errorResponseProcessor.processResponse(errorContext, HttpResponse.status(HttpStatus.CONFLICT)) // 
    }
}

package example.micronaut

import example.micronaut.domain.Account
import io.micronaut.data.exceptions.DataIntegrityViolationException
import io.micronaut.http.HttpRequest
import io.micronaut.http.HttpResponse
import io.micronaut.http.HttpStatus
import io.micronaut.http.client.HttpClient
import io.micronaut.http.client.annotation.Client
import io.micronaut.http.client.exceptions.HttpClientResponseException
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

@MicronautTest(transactional = false) // 
class AccountSpec extends Specification {

    @Inject
    AccountRepository repository

    @Inject
    @Client('/')
    HttpClient httpClient

    void 'deposit increments balance'() {
        given:
        Account account = repository.save(new Account(null, 'Checking', 100L))

        when:
        long updated = repository.reserveIncrementBalance(account.id, 25L) // 

        then:
        updated == 1L
        Account found = repository.findById(account.id).orElseThrow()
        found.balance == 125L
    }

    void 'withdrawal beyond balance is rejected'() {
        given:
        Account account = repository.save(new Account(null, 'Checking', 100L))

        when:
        repository.reserveDecrementBalance(account.id, 1000L) // 

        then:
        thrown(DataIntegrityViolationException)
        Account found = repository.findById(account.id).orElseThrow()
        found.balance == 100L // 
    }

    void 'withdrawal beyond balance responds with conflict'() {
        given:
        Account account = repository.save(new Account(null, 'Checking', 100L))

        when:
        httpClient.toBlocking().exchange(
                HttpRequest.POST("/accounts/${account.id}/withdraw?amount=1000", null))

        then:
        HttpClientResponseException e = thrown()
        e.status == HttpStatus.CONFLICT // 
        e.response.getBody(String).orElse('').contains('The operation violates an account constraint') // 
    }

    void 'account is created, deposited and withdrawn over HTTP'() {
        when:
        HttpResponse<Account> created = httpClient.toBlocking().exchange(
                HttpRequest.POST('/accounts', new Account(null, 'Savings', 100L)), Account) // 

        then:
        created.status == HttpStatus.CREATED

        when:
        Account deposited = httpClient.toBlocking().retrieve(
                HttpRequest.POST("/accounts/${created.body().id}/deposit?amount=25", null), Account) // 

        then:
        deposited.balance == 125L

        when:
        Account withdrawn = httpClient.toBlocking().retrieve(
                HttpRequest.POST("/accounts/${created.body().id}/withdraw?amount=50", null), Account)

        then:
        withdrawn.balance == 75L
    }

    void 'deposit for unknown account responds with not found'() {
        when:
        httpClient.toBlocking().exchange(HttpRequest.POST('/accounts/-1/deposit?amount=1', null))

        then:
        HttpClientResponseException e = thrown()
        e.status == HttpStatus.NOT_FOUND // 
    }
}