Find Nearby Delivery Drivers with Micronaut Data JDBC and PostGIS

package example.micronaut

import io.micronaut.data.jdbc.annotation.JdbcRepository
import io.micronaut.data.model.geo.Point
import io.micronaut.data.model.query.builder.sql.Dialect
import io.micronaut.data.repository.CrudRepository

@JdbcRepository(dialect = Dialect.POSTGRES) // 
interface DeliveryDriverRepository : CrudRepository<DeliveryDriver, Long> {

    fun findByStatusAndLocationNear(status: DeliveryDriver.Status, orderLocation: Point, maxDistanceMeters: Double): List<DeliveryDriver> // 
}

package example.micronaut

import io.micronaut.data.model.geo.Point
import jakarta.inject.Singleton

@Singleton
class DispatchService(private val deliveryDriverRepository: DeliveryDriverRepository) {

    private companion object {
        private const val MAX_DISTANCE_METERS = 5_000.0 // 
        private const val WGS84_A = 6378137.0
        private const val WGS84_F = 1.0 / 298.257223563
        private const val EPS = 1e-15
    }

    fun findClosestAvailableDriver(orderLocation: Point): DriverMatch? {
        val candidates = deliveryDriverRepository.findByStatusAndLocationNear(
            DeliveryDriver.Status.AVAILABLE,
            orderLocation,
            MAX_DISTANCE_METERS
        ) // 

        return candidates
            .map { driver ->
                DriverMatch(
                    driver.id,
                    driver.name,
                    distanceMeters(orderLocation, driver.location)
                )
            }
            .minByOrNull { it.distanceMeters } // 
    }

    private fun distanceMeters(left: Point, right: Point): Double { // 
        val lon1Deg = left.x()
        val lat1Deg = left.y()

        val lon2Deg = right.x()
        val lat2Deg = right.y()

        validate(lon1Deg, lat1Deg)
        validate(lon2Deg, lat2Deg)

        val lon1 = Math.toRadians(lon1Deg)
        val lat1 = Math.toRadians(lat1Deg)
        val lon2 = Math.toRadians(lon2Deg)
        val lat2 = Math.toRadians(lat2Deg)

        if (near(lon1, lon2) && near(lat1, lat2)) {
            return 0.0
        }

        val dLon = lon2 - lon1

        val sinLat1 = Math.sin(lat1)
        val cosLat1 = Math.cos(lat1)
        val sinLat2 = Math.sin(lat2)
        val cosLat2 = Math.cos(lat2)

        var cosD = sinLat1 * sinLat2 + cosLat1 * cosLat2 * Math.cos(dLon)
        cosD = cosD.coerceIn(-1.0, 1.0)

        val d = Math.acos(cosD)
        val sinD = Math.sin(d)

        val k = square(sinLat1 - sinLat2)
        val l = square(sinLat1 + sinLat2)

        val h = if (near(1.0 - cosD, 0.0)) 0.0 else (d + 3.0 * sinD) / (1.0 - cosD)
        val g = if (near(1.0 + cosD, 0.0)) 0.0 else (d - 3.0 * sinD) / (1.0 + cosD)

        val correction = -(WGS84_F / 4.0) * (h * k + g * l)

        return WGS84_A * (d + correction)
    }

    private fun validate(lon: Double, lat: Double) {
        require(java.lang.Double.isFinite(lon) && java.lang.Double.isFinite(lat)) {
            "Coordinates must be finite numbers"
        }
        require(lon > -180.0 && lon <= 180.0) {
            "Longitude must be in (-180, 180]"
        }
        require(lat >= -90.0 && lat <= 90.0) {
            "Latitude must be in [-90, 90]"
        }
    }

    private fun near(a: Double, b: Double): Boolean {
        return Math.abs(a - b) <= EPS
    }

    private fun square(x: Double): Double {
        return x * x
    }
}

package example.micronaut

import io.micronaut.data.model.geo.Point
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.QueryValue

@Controller("/orders") // 
class DeliveryDispatchController(private val dispatchService: DispatchService) {

    @Get("/nearest-driver") // 
    fun nearestDriver(@QueryValue longitude: Double, @QueryValue latitude: Double): DriverMatch? { // 
        return dispatchService.findClosestAvailableDriver(Point(longitude, latitude))
    }
}

package example.micronaut

import io.micronaut.data.model.geo.Point
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.junit5.annotation.MicronautTest
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

@MicronautTest(transactional = false) // 
class DeliveryDispatchControllerTest(
    private val deliveryDriverRepository: DeliveryDriverRepository,
    @Client("/") private val httpClient: HttpClient // 
) {

    @BeforeEach
    fun clean() {
        deliveryDriverRepository.deleteAll()
    }

    @Test
    fun findsClosestAvailableDriverWithinFiveKilometers() {
        deliveryDriverRepository.save(
            DeliveryDriver(
                "Nearby Driver",
                DeliveryDriver.Status.AVAILABLE,
                Point(-73.9757, 40.7554)
            )
        )
        val closest = deliveryDriverRepository.save(
            DeliveryDriver(
                "Closest Driver",
                DeliveryDriver.Status.AVAILABLE,
                Point(-73.9827, 40.7504)
            )
        )
        deliveryDriverRepository.save(
            DeliveryDriver(
                "Busy Driver",
                DeliveryDriver.Status.BUSY,
                Point(-73.9850, 40.7488)
            )
        ) // 
        deliveryDriverRepository.save(
            DeliveryDriver(
                "Far Driver",
                DeliveryDriver.Status.AVAILABLE,
                Point(-73.9000, 40.8000)
            )
        ) // 

        val client = httpClient.toBlocking()
        val response: HttpResponse<DriverMatch> = client.exchange(
            HttpRequest.GET<Any>("/orders/nearest-driver?longitude=-73.9857&latitude=40.7484"),
            DriverMatch::class.java
        ) // 

        assertEquals(HttpStatus.OK, response.status)
        assertEquals(closest.id, response.body()!!.driverId) // 
    }

    @Test
    fun returnsNotFoundWhenNoAvailableDriverIsCloseEnough() {
        deliveryDriverRepository.save(
            DeliveryDriver(
                "Busy Driver",
                DeliveryDriver.Status.BUSY,
                Point(-73.9850, 40.7488)
            )
        )
        deliveryDriverRepository.save(
            DeliveryDriver(
                "Far Driver",
                DeliveryDriver.Status.AVAILABLE,
                Point(-73.9000, 40.8000)
            )
        )

        val client = httpClient.toBlocking()
        val thrown = assertThrows<HttpClientResponseException> {
            client.exchange(
                HttpRequest.GET<Any>("/orders/nearest-driver?longitude=-73.9857&latitude=40.7484"),
                DriverMatch::class.java
            )
        } // 

        assertEquals(HttpStatus.NOT_FOUND, thrown.status)
    }
}