Find Nearby Delivery Drivers with Micronaut Data JDBC and SQL Server Geospatial

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.SQL_SERVER) // 
interface DeliveryDriverRepository extends CrudRepository<DeliveryDriver, Long> {

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

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.data.model.geo.Point
import jakarta.inject.Singleton

@CompileStatic
@Singleton
class DispatchService {

    private static final double MAX_DISTANCE_METERS = 5_000d // 
    private static final double WGS84_A = 6378137.0d
    private static final double WGS84_F = 1.0d / 298.257223563d
    private static final double EPS = 1e-15d

    private final DeliveryDriverRepository deliveryDriverRepository

    DispatchService(DeliveryDriverRepository deliveryDriverRepository) {
        this.deliveryDriverRepository = deliveryDriverRepository
    }

    DriverMatch findClosestAvailableDriver(Point orderLocation) {
        List<DeliveryDriver> candidates = deliveryDriverRepository.findByStatusAndLocationNear(
            DeliveryDriver.Status.AVAILABLE,
            orderLocation,
            MAX_DISTANCE_METERS
        ) // 

        DriverMatch closest = null
        for (DeliveryDriver driver : candidates) {
            DriverMatch match = new DriverMatch(
                driver.id,
                driver.name,
                distanceMeters(orderLocation, driver.location)
            )
            if (closest == null || match.distanceMeters < closest.distanceMeters) {
                closest = match
            }
        }
        return closest // 
    }

    private static double distanceMeters(Point left, Point right) { // 
        double lon1Deg = left.x()
        double lat1Deg = left.y()

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

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

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

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

        double dLon = lon2 - lon1

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

        double cosD = sinLat1 * sinLat2 + cosLat1 * cosLat2 * Math.cos(dLon)
        cosD = Math.max(-1.0d, Math.min(1.0d, cosD))

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

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

        double h = near(1.0d - cosD, 0.0d) ? 0.0d : (d + 3.0d * sinD) / (1.0d - cosD)
        double g = near(1.0d + cosD, 0.0d) ? 0.0d : (d - 3.0d * sinD) / (1.0d + cosD)

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

        WGS84_A * (d + correction)
    }

    private static void validate(double lon, double lat) {
        if (!Double.isFinite(lon) || !Double.isFinite(lat)) {
            throw new IllegalArgumentException('Coordinates must be finite numbers')
        }
        if (lon <= -180.0d || lon > 180.0d) {
            throw new IllegalArgumentException('Longitude must be in (-180, 180]')
        }
        if (lat < -90.0d || lat > 90.0d) {
            throw new IllegalArgumentException('Latitude must be in [-90, 90]')
        }
    }

    private static boolean near(double a, double b) {
        Math.abs(a - b) <= EPS
    }

    private static double square(double x) {
        x * x
    }
}

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.core.annotation.Nullable
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

@CompileStatic
@Controller('/orders') // 
class DeliveryDispatchController {

    private final DispatchService dispatchService

    DeliveryDispatchController(DispatchService dispatchService) {
        this.dispatchService = dispatchService
    }

    @Get('/nearest-driver') // 
    @Nullable
    DriverMatch nearestDriver(@QueryValue double longitude, @QueryValue double latitude) { // 
        dispatchService.findClosestAvailableDriver(new 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.BlockingHttpClient
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 DeliveryDispatchControllerSpec extends Specification {

    @Inject
    DeliveryDriverRepository deliveryDriverRepository

    @Inject
    @Client('/') // 
    HttpClient httpClient

    void setup() {
        deliveryDriverRepository.deleteAll()
    }

    void "finds closest available driver within five kilometers"() {
        given:
        deliveryDriverRepository.save(new DeliveryDriver(
            'Nearby Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9757d, 40.7554d)
        ))
        DeliveryDriver closest = deliveryDriverRepository.save(new DeliveryDriver(
            'Closest Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9827d, 40.7504d)
        ))
        deliveryDriverRepository.save(new DeliveryDriver(
            'Busy Driver',
            DeliveryDriver.Status.BUSY,
            new Point(-73.9850d, 40.7488d)
        )) // 
        deliveryDriverRepository.save(new DeliveryDriver(
            'Far Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9000d, 40.8000d)
        )) // 

        when:
        BlockingHttpClient client = httpClient.toBlocking()
        HttpResponse<DriverMatch> response = client.exchange(
            HttpRequest.GET('/orders/nearest-driver?longitude=-73.9857&latitude=40.7484'),
            DriverMatch
        ) // 

        then:
        response.status() == HttpStatus.OK
        response.body().driverId == closest.id // 
    }

    void "returns not found when no available driver is close enough"() {
        given:
        deliveryDriverRepository.save(new DeliveryDriver(
            'Busy Driver',
            DeliveryDriver.Status.BUSY,
            new Point(-73.9850d, 40.7488d)
        ))
        deliveryDriverRepository.save(new DeliveryDriver(
            'Far Driver',
            DeliveryDriver.Status.AVAILABLE,
            new Point(-73.9000d, 40.8000d)
        ))

        when:
        BlockingHttpClient client = httpClient.toBlocking()
        client.exchange(
            HttpRequest.GET('/orders/nearest-driver?longitude=-73.9857&latitude=40.7484'),
            DriverMatch
        ) // 

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