Real road distance and travel time in Laravel with OSRM

wget https://download.geofabrik.de/south-america/brazil/sudeste-latest.osm.pbf

docker run -t -v "${PWD}:/data" ghcr.io/project-osrm/osrm-backend osrm-extract -p /opt/car.lua /data/sudeste-latest.osm.pbf
docker run -t -v "${PWD}:/data" ghcr.io/project-osrm/osrm-backend osrm-partition /data/sudeste-latest.osrm
docker run -t -v "${PWD}:/data" ghcr.io/project-osrm/osrm-backend osrm-customize /data/sudeste-latest.osrm
docker run -t -i -p 5000:5000 -v "${PWD}:/data" ghcr.io/project-osrm/osrm-backend osrm-routed --algorithm mld /data/sudeste-latest.osrm

GET /table/v1/driving/-46.6333,-23.5505;-46.6559,-23.5614;-46.6820,-23.5880?sources=0&annotations=duration,distance

// config/services.php
'osrm' => [
    'url' => env('OSRM_URL', 'http://localhost:5000'),
],

<?php

namespace App\Services\Routing;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Http;
use Throwable;

class RoadDistances
{
    /** How far OSRM may move a point to reach a road before we stop trusting the route. */
    private const MAX_SNAP_METERS = 500;

    /**
     * @param  array{lat: float, lng: float}  $origin
     * @param  list<array{id: int|string, lat: float, lng: float}>  $destinations
     * @return list<array{id: int|string, meters: int, seconds: int|null, routed: bool}>
     */
    public function from(array $origin, array $destinations): array
    {
        if ($destinations === []) {
            return [];
        }

        $key = 'road-distances:'.md5(json_encode([
            $this->rounded($origin),
            array_map(fn (array $d) => [$d['id'], ...$this->rounded($d)], $destinations),
        ]));

        if (($cached = Cache::get($key)) !== null) {
            return $cached;
        }

        $table = $this->table($origin, $destinations);
        $rows = [];

        foreach (array_values($destinations) as $i => $destination) {
            $meters = $table['distances'][0][$i + 1] ?? null;
            $seconds = $table['durations'][0][$i + 1] ?? null;
            $snapped = $table['destinations'][$i + 1]['distance'] ?? INF;

            $rows[] = $meters !== null && $seconds !== null && $snapped <= self::MAX_SNAP_METERS
                ? ['id' => $destination['id'], 'meters' => (int) round($meters), 'seconds' => (int) round($seconds), 'routed' => true]
                : ['id' => $destination['id'], 'meters' => (int) round($this->straightLine($origin, $destination)), 'seconds' => null, 'routed' => false];
        }

        // Only cache real answers. A fallback caused by an outage shouldn't stick for a day.
        if ($table !== null) {
            Cache::put($key, $rows, now()->addDay());
        }

        return $rows;
    }

    /** Great-circle distance in meters (haversine). */
    public function straightLine(array $from, array $to): float
    {
        $dLat = deg2rad($to['lat'] - $from['lat']);
        $dLng = deg2rad($to['lng'] - $from['lng']);

        $h = sin($dLat / 2) ** 2
            + cos(deg2rad($from['lat'])) * cos(deg2rad($to['lat'])) * sin($dLng / 2) ** 2;

        return 2 * 6371000 * asin(sqrt($h));
    }

    private function table(array $origin, array $destinations): ?array
    {
        $coordinates = collect([$origin, ...$destinations])
            ->map(fn (array $point) => $point['lng'].','.$point['lat'])
            ->implode(';');

        try {
            $table = Http::baseUrl(config('services.osrm.url'))
                ->timeout(5)
                ->get("/table/v1/driving/{$coordinates}", [
                    'sources' => 0,
                    'annotations' => 'duration,distance',
                ])
                ->throw()
                ->json();
        } catch (Throwable $e) {
            report($e);

            return null;
        }

        if (($table['code'] ?? null) !== 'Ok') {
            return null;
        }

        // An origin far from any road makes every route meaningless.
        return ($table['sources'][0]['distance'] ?? INF) <= self::MAX_SNAP_METERS ? $table : null;
    }

    /** ~11 m precision: close enough to share a cache entry, far enough to not lie. */
    private function rounded(array $point): array
    {
        return [round($point['lat'], 4), round($point['lng'], 4)];
    }
}

<?php

namespace App\Http\Controllers;

use App\Models\Store;
use App\Services\Routing\RoadDistances;
use Illuminate\Http\Request;

class NearbyStoresController
{
    public function __invoke(Request $request, RoadDistances $roads)
    {
        $data = $request->validate([
            'lat' => ['required', 'numeric', 'between:-90,90'],
            'lng' => ['required', 'numeric', 'between:-180,180'],
        ]);

        $origin = ['lat' => (float) $data['lat'], 'lng' => (float) $data['lng']];

        // Pre-filter by straight line: routing 2,000 stores to show 10 is wasted work,
        // and osrm-routed caps table size (100 locations by default, see --max-table-size).
        $stores = Store::query()
            ->get(['id', 'name', 'lat', 'lng'])
            ->sortBy(fn (Store $store) => $roads->straightLine($origin, ['lat' => $store->lat, 'lng' => $store->lng]))
            ->take(25)
            ->values();

        $distances = collect($roads->from($origin, $stores->map->only(['id', 'lat', 'lng'])->all()))
            ->keyBy('id');

        return $stores
            ->map(fn (Store $store) => ['name' => $store->name, ...$distances[$store->id]])
            ->sortBy(fn (array $row) => $row['seconds'] ?? PHP_INT_MAX)
            ->values();
    }
}

// routes/api.php
Route::get('/nearby-stores', NearbyStoresController::class)->middleware('throttle:30,1');