@fleetbase/fleetops-engine 0.6.53 → 0.6.55

package/server/src/Support/Telematics/TelematicService.php

@@ -2,12 +2,17 @@
 
 namespace Fleetbase\FleetOps\Support\Telematics;
 
+use Fleetbase\FleetOps\Contracts\TelematicProviderInterface;
+use Fleetbase\FleetOps\Events\VehicleLocationChanged;
 use Fleetbase\FleetOps\Jobs\SyncTelematicDevicesJob;
 use Fleetbase\FleetOps\Jobs\TestTelematicConnectionJob;
 use Fleetbase\FleetOps\Models\Device;
 use Fleetbase\FleetOps\Models\DeviceEvent;
 use Fleetbase\FleetOps\Models\Sensor;
 use Fleetbase\FleetOps\Models\Telematic;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\LaravelMysqlSpatial\Types\Point as SpatialPoint;
+use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Crypt;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Support\Str;
@@ -21,6 +26,14 @@ use Illuminate\Validation\ValidationException;
  */
 class TelematicService
 {
+    protected const PROTECTED_DEVICE_STATUSES = [
+        'disabled',
+        'decommissioned',
+        'maintenance',
+        'provisioning',
+        'pending_activation',
+    ];
+
     protected TelematicProviderRegistry $registry;
 
     public function __construct(TelematicProviderRegistry $registry)
@@ -168,42 +181,34 @@ class TelematicService
             'device_id'      => $externalId,
         ]);
 
-        $device->company_uuid     = $telematic->company_uuid;
-        $device->name             = $deviceData['name'] ?? $deviceData['device_name'] ?? $device->name ?? 'Unknown Device';
-        $device->model            = $deviceData['model'] ?? $deviceData['device_model'] ?? $device->model;
-        $device->provider         = $deviceData['provider'] ?? $deviceData['device_provider'] ?? $telematic->provider;
-        $device->type             = $deviceData['type'] ?? null;
-        $device->internal_id      = $deviceData['internal_id'] ?? $externalId;
-        $device->imei             = $deviceData['imei'] ?? null;
-        $device->imsi             = $deviceData['imsi'] ?? null;
-        $device->serial_number    = $deviceData['serial_number'] ?? null;
-        $device->firmware_version = $deviceData['firmware_version'] ?? null;
-        $device->status           = $deviceData['status'] ?? $device->status ?? 'active';
+        $this->reconcileDeviceTelemetry($device, $telematic, array_merge($deviceData, [
+            'external_id' => $externalId,
+        ]));
 
-        if (array_key_exists('online', $deviceData) && $deviceData['online'] !== null) {
-            $device->online = (bool) $deviceData['online'];
-        } elseif (!$device->exists) {
-            $device->online = $device->status === 'active';
-        }
+        $device->save();
 
-        if (!empty($deviceData['last_online_at']) || !empty($deviceData['last_seen_at'])) {
-            $device->last_online_at = $deviceData['last_online_at'] ?? $deviceData['last_seen_at'];
-        }
+        return $device;
+    }
 
-        $device->meta             = array_merge($device->meta ?? [], [
-            'external_id' => $externalId,
-        ], $deviceData['meta'] ?? []);
+    public function ingestDeviceSnapshot(Telematic $telematic, TelematicProviderInterface $provider, array $payload): array
+    {
+        $device = $this->linkDevice($telematic, $provider->normalizeDevice($payload));
 
-        $location = $this->normalizeLocation($deviceData['location'] ?? null);
-        if ($location) {
-            $device->last_position = $location;
-        } elseif (!$device->exists || !$device->last_position) {
-            $device->last_position = $this->defaultLocation();
+        $event = null;
+        try {
+            $eventData = $provider->normalizeEvent($payload);
+            if ($this->hasEventSignal($eventData)) {
+                $event = $this->storeDeviceEvent($telematic, $eventData, $device);
+            }
+        } catch (\Throwable) {
+            $event = null;
         }
 
-        $device->save();
-
-        return $device;
+        return [
+            'device'  => $device,
+            'event'   => $event,
+            'sensors' => $this->storeSnapshotSensors($telematic, $provider, $payload, $device),
+        ];
     }
 
     public function storeDeviceEvent(Telematic $telematic, array $eventData, ?Device $device = null): DeviceEvent
@@ -214,6 +219,7 @@ class TelematicService
 
         $eventKey            = $this->makeEventKey($telematic, $eventData, $device);
         $event               = $eventKey ? DeviceEvent::firstOrNew(['_key' => $eventKey]) : new DeviceEvent();
+        $wasRecentlyCreated  = !$event->exists;
         $event->company_uuid = $telematic->company_uuid;
         $event->device_uuid  = $device?->uuid;
         $event->event_type   = $eventData['event_type'] ?? $eventData['type'] ?? 'telemetry_update';
@@ -228,6 +234,7 @@ class TelematicService
         $event->data         = $eventData['data'] ?? array_filter([
             'speed'      => $eventData['speed'] ?? null,
             'heading'    => $eventData['heading'] ?? null,
+            'altitude'   => $eventData['altitude'] ?? null,
             'odometer'   => $eventData['odometer'] ?? null,
             'ignition'   => $eventData['ignition'] ?? null,
             'fuel_level' => $eventData['fuel_level'] ?? null,
@@ -241,6 +248,7 @@ class TelematicService
             'occurred_at'       => $eventData['occurred_at'] ?? null,
             'speed'             => $eventData['speed'] ?? null,
             'heading'           => $eventData['heading'] ?? null,
+            'altitude'          => $eventData['altitude'] ?? null,
             'odometer'          => $eventData['odometer'] ?? null,
             'ignition'          => $eventData['ignition'] ?? null,
             'fuel_level'        => $eventData['fuel_level'] ?? null,
@@ -252,6 +260,7 @@ class TelematicService
         }
 
         $event->save();
+        $this->applyDeviceEventTelemetry($event, $eventData, $device, $wasRecentlyCreated, $telematic);
 
         return $event;
     }
@@ -470,6 +479,297 @@ class TelematicService
         return ['latitude' => (float) $lat, 'longitude' => (float) $lng];
     }
 
+    protected function reconcileDeviceTelemetry(Device $device, ?Telematic $telematic, array $payload): void
+    {
+        $externalId = $this->resolveExternalId($payload);
+
+        if ($telematic) {
+            $device->company_uuid = $telematic->company_uuid;
+        }
+
+        $this->setDeviceAttributeIfPresent($device, 'name', $payload['name'] ?? $payload['device_name'] ?? (!$device->exists ? 'Unknown Device' : null));
+        $this->setDeviceAttributeIfPresent($device, 'model', $payload['model'] ?? $payload['device_model'] ?? null);
+        $this->setDeviceAttributeIfPresent($device, 'provider', $payload['provider'] ?? $payload['device_provider'] ?? $telematic?->provider);
+        $this->setDeviceAttributeIfPresent($device, 'type', $payload['type'] ?? null);
+        $this->setDeviceAttributeIfPresent($device, 'internal_id', $payload['internal_id'] ?? $externalId);
+        $this->setDeviceAttributeIfPresent($device, 'imei', $payload['imei'] ?? null);
+        $this->setDeviceAttributeIfPresent($device, 'imsi', $payload['imsi'] ?? null);
+        $this->setDeviceAttributeIfPresent($device, 'serial_number', $payload['serial_number'] ?? null);
+        $this->setDeviceAttributeIfPresent($device, 'firmware_version', $payload['firmware_version'] ?? null);
+
+        $location = $this->normalizeLocation($payload['location'] ?? null);
+        if ($location) {
+            $device->last_position = $location;
+        } elseif (!$device->exists || !$device->last_position) {
+            $device->last_position = $this->defaultLocation();
+        }
+
+        $lastSeen       = $this->resolveTelemetryTimestamp($payload);
+        $reportedOnline = $this->resolveReportedOnline($payload);
+
+        if (!$lastSeen && $reportedOnline === true) {
+            $lastSeen = now();
+        }
+
+        if ($lastSeen) {
+            $device->last_online_at = $lastSeen;
+        }
+
+        $connectionStatus = $this->connectionStatusForDevice($device, $lastSeen, $reportedOnline);
+        $device->online   = $connectionStatus === 'online';
+
+        if (!$this->isProtectedDeviceStatus($device->status)) {
+            $device->status = $connectionStatus;
+        }
+
+        $device->meta = array_merge($device->meta ?? [], [
+            'external_id'       => $externalId,
+            'provider_status'   => array_filter([
+                'status'    => $payload['status'] ?? null,
+                'state'     => $payload['state'] ?? null,
+                'active'    => $payload['active'] ?? data_get($payload, 'meta.active'),
+                'online'    => $payload['online'] ?? null,
+                'is_online' => $payload['is_online'] ?? null,
+            ], fn ($value) => $value !== null),
+            'telemetry_summary' => array_filter([
+                'last_seen_at' => $lastSeen?->toDateTimeString(),
+                'status'       => $connectionStatus,
+                'speed'        => $payload['speed'] ?? null,
+                'heading'      => $payload['heading'] ?? null,
+                'altitude'     => $payload['altitude'] ?? null,
+                'odometer'     => $payload['odometer'] ?? null,
+                'ignition'     => $payload['ignition'] ?? null,
+                'fuel_level'   => $payload['fuel_level'] ?? null,
+            ], fn ($value) => $value !== null),
+        ], $payload['meta'] ?? []);
+    }
+
+    protected function setDeviceAttributeIfPresent(Device $device, string $key, mixed $value): void
+    {
+        if ($value === null || $value === '') {
+            return;
+        }
+
+        $device->{$key} = $value;
+    }
+
+    protected function resolveTelemetryTimestamp(array $payload): ?Carbon
+    {
+        $value = $payload['last_online_at']
+            ?? $payload['last_seen_at']
+            ?? $payload['occurred_at']
+            ?? $payload['recorded_at']
+            ?? $payload['timestamp']
+            ?? data_get($payload, 'meta.last_update.occurred_at')
+            ?? data_get($payload, 'meta.occurred_at')
+            ?? null;
+
+        if (!$value) {
+            return null;
+        }
+
+        try {
+            return $value instanceof Carbon ? $value : Carbon::parse($value);
+        } catch (\Throwable) {
+            return null;
+        }
+    }
+
+    protected function resolveReportedOnline(array $payload): ?bool
+    {
+        $value = $payload['online'] ?? $payload['is_online'] ?? null;
+
+        if ($value === null) {
+            return null;
+        }
+
+        return filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE) ?? (bool) $value;
+    }
+
+    protected function connectionStatusForDevice(Device $device, ?Carbon $lastSeen = null, ?bool $reportedOnline = null): string
+    {
+        if ($reportedOnline === true) {
+            return 'online';
+        }
+
+        $lastSeen ??= $device->last_online_at;
+
+        if (!$lastSeen) {
+            return 'never_connected';
+        }
+
+        $minutesOffline = Carbon::parse($lastSeen)->diffInMinutes(now());
+
+        if ($minutesOffline <= 10) {
+            return 'online';
+        }
+
+        if ($minutesOffline <= 60) {
+            return 'recently_offline';
+        }
+
+        if ($minutesOffline <= 1440) {
+            return 'offline';
+        }
+
+        return 'long_offline';
+    }
+
+    protected function isProtectedDeviceStatus(?string $status): bool
+    {
+        return in_array($status, self::PROTECTED_DEVICE_STATUSES, true);
+    }
+
+    protected function applyDeviceEventTelemetry(DeviceEvent $event, array $eventData, ?Device $device = null, bool $wasRecentlyCreated = true, ?Telematic $telematic = null): void
+    {
+        $location = $this->normalizeLocation($eventData['location'] ?? null);
+
+        $device ??= $event->device;
+        if ($device) {
+            $this->reconcileDeviceTelemetry($device, $telematic, $eventData);
+            $device->save();
+            $device->loadMissing('attachable');
+        }
+
+        if (!$location) {
+            return;
+        }
+
+        $positionData = $this->makePositionData($location, $eventData);
+        if ($wasRecentlyCreated && $positionData) {
+            $event->createPosition($positionData);
+        }
+
+        $attachable = $device?->attachable;
+        if ($attachable instanceof Vehicle) {
+            $this->updateVehicleTelemetry($attachable, $location, $eventData, $event);
+        }
+    }
+
+    protected function updateVehicleTelemetry(Vehicle $vehicle, array $location, array $eventData, DeviceEvent $event): void
+    {
+        $vehicle->location = new SpatialPoint($location['latitude'], $location['longitude']);
+        $vehicle->online   = array_key_exists('online', $eventData) && $eventData['online'] !== null ? (bool) $eventData['online'] : true;
+
+        if (array_key_exists('speed', $eventData) && $eventData['speed'] !== null) {
+            $vehicle->speed = $eventData['speed'];
+        }
+
+        if (array_key_exists('heading', $eventData) && $eventData['heading'] !== null) {
+            $vehicle->heading = $eventData['heading'];
+        }
+
+        if (array_key_exists('altitude', $eventData) && $eventData['altitude'] !== null) {
+            $vehicle->altitude = $eventData['altitude'];
+        }
+
+        $vehicle->telematics = array_merge($vehicle->telematics ?? [], [
+            'last_event_uuid'     => $event->uuid,
+            'last_event_id'       => $event->public_id,
+            'last_event_type'     => $event->event_type,
+            'last_event_at'       => optional($event->occurred_at)->toDateTimeString() ?? now()->toDateTimeString(),
+            'last_device_uuid'    => $event->device_uuid,
+            'last_provider'       => $event->provider,
+            'last_telemetry_data' => array_filter([
+                'speed'      => $eventData['speed'] ?? null,
+                'heading'    => $eventData['heading'] ?? null,
+                'altitude'   => $eventData['altitude'] ?? null,
+                'odometer'   => $eventData['odometer'] ?? null,
+                'ignition'   => $eventData['ignition'] ?? null,
+                'fuel_level' => $eventData['fuel_level'] ?? null,
+            ], fn ($value) => $value !== null),
+        ]);
+        $vehicle->save();
+
+        broadcast(new VehicleLocationChanged($vehicle, [
+            'source'            => 'telematics',
+            'device_event_uuid' => $event->uuid,
+            'provider'          => $event->provider,
+        ]));
+    }
+
+    protected function makePositionData(array $location, array $eventData): array
+    {
+        return array_filter([
+            'latitude'  => $location['latitude'],
+            'longitude' => $location['longitude'],
+            'heading'   => $eventData['heading'] ?? null,
+            'bearing'   => $eventData['heading'] ?? null,
+            'speed'     => $eventData['speed'] ?? null,
+            'altitude'  => $eventData['altitude'] ?? null,
+        ], fn ($value) => $value !== null);
+    }
+
+    protected function hasEventSignal(array $eventData): bool
+    {
+        return (bool) array_filter([
+            $eventData['event_id'] ?? null,
+            $eventData['external_event_id'] ?? null,
+            $eventData['ident'] ?? null,
+            $eventData['event_type'] ?? null,
+            $eventData['occurred_at'] ?? null,
+            $eventData['recorded_at'] ?? null,
+            $eventData['timestamp'] ?? null,
+            $eventData['location']['lat'] ?? null,
+            $eventData['location']['latitude'] ?? null,
+            $eventData['speed'] ?? null,
+            $eventData['heading'] ?? null,
+            $eventData['altitude'] ?? null,
+            $eventData['odometer'] ?? null,
+            $eventData['ignition'] ?? null,
+            $eventData['fuel_level'] ?? null,
+        ], fn ($value) => $value !== null);
+    }
+
+    protected function storeSnapshotSensors(Telematic $telematic, TelematicProviderInterface $provider, array $payload, Device $device): int
+    {
+        $rawSensors = $payload['sensors'] ?? $payload['sensors_last_val'] ?? [];
+        if (!is_array($rawSensors) || empty($rawSensors)) {
+            return 0;
+        }
+
+        $stored     = 0;
+        $externalId = $this->resolveExternalId($payload);
+
+        foreach ($this->normalizeRawSensorList($rawSensors) as $rawSensor) {
+            try {
+                $sensorData = $provider->normalizeSensor(array_merge([
+                    'device_id' => $externalId,
+                ], $rawSensor));
+                $sensorData['device_id'] ??= $externalId;
+
+                $this->storeSensor($telematic, $sensorData, $device);
+                $stored++;
+            } catch (\Throwable) {
+                continue;
+            }
+        }
+
+        return $stored;
+    }
+
+    protected function normalizeRawSensorList(array $rawSensors): array
+    {
+        if (array_is_list($rawSensors)) {
+            return array_filter($rawSensors, fn ($sensor) => is_array($sensor));
+        }
+
+        return collect($rawSensors)
+            ->map(function ($sensor, $name) {
+                if (is_array($sensor)) {
+                    return array_merge(['name' => $name], $sensor);
+                }
+
+                return [
+                    'name'  => $name,
+                    'type'  => $name,
+                    'value' => $sensor,
+                ];
+            })
+            ->values()
+            ->all();
+    }
+
     protected function defaultLocation(): array
     {
         return ['latitude' => 0, 'longitude' => 0];

package/server/src/routes.php

@@ -476,7 +476,6 @@ Route::prefix(config('fleetops.api.routing.prefix'))->namespace('Fleetbase\Fleet
                                 $router->delete('bulk-delete', $controller('bulkDelete'));
                                 $router->get('for-route', $controller('getServicesForRoute'));
                                 $router->match(['get', 'post'], 'export', $controller('export'));
-                                $router->get('for-route', $controller('getServicesForRoute'));
                             }
                         );
                         $router->fleetbaseRoutes('tracking-numbers');
@@ -612,6 +611,7 @@ Route::prefix(config('fleetops.api.routing.prefix'))->namespace('Fleetbase\Fleet
                                         $router->get('coordinates', 'LiveController@coordinates');
                                         $router->get('routes', 'LiveController@routes');
                                         $router->get('orders', 'LiveController@orders');
+                                        $router->get('operations-monitor', 'LiveController@operationsMonitor');
                                         $router->get('drivers', 'LiveController@drivers');
                                         $router->get('vehicles', 'LiveController@vehicles');
                                         $router->get('places', 'LiveController@places');

package/server/tests/DeviceFilterTest.php

@@ -0,0 +1,45 @@
+<?php
+
+test('device filter exposes telematics detail filter contract', function () {
+    $filter     = file_get_contents(dirname(__DIR__) . '/src/Http/Filter/DeviceFilter.php');
+    $model      = file_get_contents(dirname(__DIR__) . '/src/Models/Device.php');
+    $controller = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Internal/v1/DeviceController.php');
+
+    expect($model)
+        ->toContain("'vehicle'")
+        ->toContain("'connection_status'")
+        ->toContain("'device_id'")
+        ->toContain("'type'")
+        ->toContain("'serial_number'")
+        ->toContain("'last_online_at'")
+        ->toContain("'updated_at'");
+
+    expect($filter)
+        ->toContain('public function query(?string $searchQuery)')
+        ->toContain('public function deviceId(?string $deviceId)')
+        ->toContain("where('device_id', 'like'")
+        ->toContain('public function type(string|array|null $type)')
+        ->toContain("whereIn('type', \$type)")
+        ->toContain('public function serialNumber(?string $serialNumber)')
+        ->toContain("where('serial_number', 'like'")
+        ->toContain('public function vehicle(?string $vehicle)')
+        ->toContain("where('attachable_uuid', \$vehicle)")
+        ->toContain("where('public_id', \$vehicle)")
+        ->toContain('public function connectionStatus')
+        ->toContain("'online'")
+        ->toContain("'recently_offline'")
+        ->toContain("'offline'")
+        ->toContain("'long_offline'")
+        ->toContain("'never_connected'")
+        ->toContain('public function lastOnlineAt')
+        ->toContain('public function updatedAt')
+        ->toContain('Utils::dateRange')
+        ->toContain('protected function filterDate');
+
+    expect($controller)
+        ->toContain("withCount('sensors')")
+        ->toContain("filled('connection_status')")
+        ->toContain("filled('serial_number')")
+        ->toContain("filled('last_online_at')")
+        ->toContain("filled('updated_at')");
+});

package/server/tests/DriverVehicleStatusDefaultTest.php

@@ -1,16 +1,19 @@
 <?php
 
 use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
 use Fleetbase\FleetOps\Models\Vehicle;
 
-test('driver and vehicle statuses default to available', function () {
+test('driver vehicle and equipment statuses default to available', function () {
     expect((new Driver())->status)
         ->toBe('available')
         ->and((new Vehicle())->status)
+        ->toBe('available')
+        ->and((new Equipment())->status)
         ->toBe('available');
 });
 
-test('legacy active and null driver and vehicle statuses normalize to available', function () {
+test('legacy active and null driver vehicle and equipment statuses normalize to available', function () {
     $driver         = new Driver();
     $driver->status = 'active';
     expect($driver->status)->toBe('available');
@@ -24,6 +27,20 @@ test('legacy active and null driver and vehicle statuses normalize to available'
 
     $vehicle->status = null;
     expect($vehicle->status)->toBe('available');
+
+    $equipment         = new Equipment();
+    $equipment->status = 'active';
+    expect($equipment->status)->toBe('available');
+
+    $equipment->status = null;
+    expect($equipment->status)->toBe('available');
+});
+
+test('equipment preserves explicit non default status values', function () {
+    $equipment         = new Equipment();
+    $equipment->status = 'maintenance';
+
+    expect($equipment->status)->toBe('maintenance');
 });
 
 test('dispatch driver availability queries use available status', function () {

package/server/tests/EquipmentAssignmentMorphTypeTest.php

@@ -0,0 +1,35 @@
+<?php
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Equipment;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Illuminate\Database\Eloquent\Relations\Relation;
+
+test('equipment assignment type aliases normalize to model classes', function () {
+    $equipment = new Equipment();
+
+    $equipment->equipable_type = 'fleet-ops:vehicle';
+    expect($equipment->equipable_type)->toBe(Vehicle::class);
+
+    $equipment->equipable_type = 'fleet-ops:driver';
+    expect($equipment->equipable_type)->toBe(Driver::class);
+});
+
+test('equipment assignment type preserves null and existing model classes', function () {
+    $equipment = new Equipment();
+
+    $equipment->equipable_type = null;
+    expect($equipment->equipable_type)->toBeNull();
+
+    $equipment->equipable_type = Vehicle::class;
+    expect($equipment->equipable_type)->toBe(Vehicle::class);
+});
+
+test('legacy equipment assignment aliases are registered for morph reads', function () {
+    new Equipment();
+
+    expect(Relation::getMorphedModel('fleet-ops:vehicle'))
+        ->toBe(Vehicle::class)
+        ->and(Relation::getMorphedModel('fleet-ops:driver'))
+        ->toBe(Driver::class);
+});

package/server/tests/OperationsMonitorEndpointTest.php

@@ -0,0 +1,38 @@
+<?php
+
+test('operations monitor live route is registered on the internal fleetops surface', function () {
+    $routes = file_get_contents(__DIR__ . '/../src/routes.php');
+
+    expect($routes)
+        ->toContain("\$router->get('operations-monitor', 'LiveController@operationsMonitor');")
+        ->toContain("['prefix' => 'live']");
+});
+
+test('operations monitor endpoint returns a cached flat resource snapshot with id linked fleets', function () {
+    $controller = file_get_contents(__DIR__ . '/../src/Http/Controllers/Internal/v1/LiveController.php');
+
+    expect($controller)
+        ->toContain("LiveCacheService::remember('operations-monitor'")
+        ->toContain("'drivers'  => \$drivers->map")
+        ->toContain("'vehicles' => \$vehicles->map")
+        ->toContain("'fleets'   => \$this->buildOperationsMonitorFleetTree")
+        ->toContain("'driver_ids'            => \$driverIds->all()")
+        ->toContain("'vehicle_ids'           => \$vehicleIds->all()")
+        ->toContain("'meta'     => [")
+        ->not->toContain("'drivers'               => \$this->whenLoaded('drivers'")
+        ->not->toContain("'vehicles'              => \$this->whenLoaded('vehicles'");
+});
+
+test('operations monitor cache is invalidated by live cache and resource mutations', function () {
+    $cache           = file_get_contents(__DIR__ . '/../src/Support/LiveCacheService.php');
+    $driverObserver  = file_get_contents(__DIR__ . '/../src/Observers/DriverObserver.php');
+    $vehicleObserver = file_get_contents(__DIR__ . '/../src/Observers/VehicleObserver.php');
+    $fleetObserver   = file_get_contents(__DIR__ . '/../src/Observers/FleetObserver.php');
+    $fleetController = file_get_contents(__DIR__ . '/../src/Http/Controllers/Internal/v1/FleetController.php');
+
+    expect($cache)->toContain("'operations-monitor'");
+    expect($driverObserver)->toContain("LiveCacheService::invalidateMultiple(['drivers', 'operations-monitor'])");
+    expect($vehicleObserver)->toContain("LiveCacheService::invalidateMultiple(['vehicles', 'operations-monitor'])");
+    expect($fleetObserver)->toContain("LiveCacheService::invalidate('operations-monitor')");
+    expect(substr_count($fleetController, "LiveCacheService::invalidate('operations-monitor')"))->toBe(4);
+});

package/server/tests/OrderQueuedClosureRegressionTest.php

@@ -0,0 +1,36 @@
+<?php
+
+use Fleetbase\FleetOps\Jobs\FinalizeApiOrderCreation;
+use Fleetbase\FleetOps\Jobs\FinalizeInternalOrderCreation;
+use Fleetbase\FleetOps\Jobs\NotifyBulkAssignedDriver;
+use Illuminate\Contracts\Queue\ShouldQueue;
+
+test('order workflows dispatch named queue jobs instead of signed closures', function () {
+    $apiController      = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Api/v1/OrderController.php');
+    $internalController = file_get_contents(dirname(__DIR__) . '/src/Http/Controllers/Internal/v1/OrderController.php');
+
+    expect($apiController)
+        ->not->toContain('dispatch(function')
+        ->toContain('FinalizeApiOrderCreation::dispatch(')
+        ->toContain(')->afterCommit()')
+        ->and($internalController)
+        ->not->toContain('dispatch(function')
+        ->toContain('FinalizeInternalOrderCreation::dispatch($order->uuid)->afterCommit()')
+        ->toContain('NotifyBulkAssignedDriver::dispatch($orderUuids->all(), $driver->uuid)->afterCommit()');
+});
+
+test('order queue jobs serialize only scalar identifiers and options', function () {
+    $apiJob      = new FinalizeApiOrderCreation('order-uuid', 'service-quote-uuid', true);
+    $internalJob = new FinalizeInternalOrderCreation('order-uuid');
+    $bulkJob     = new NotifyBulkAssignedDriver(['order-uuid-1', 'order-uuid-2'], 'driver-uuid');
+
+    expect($apiJob)->toBeInstanceOf(ShouldQueue::class)
+        ->and($apiJob->orderUuid)->toBe('order-uuid')
+        ->and($apiJob->serviceQuoteUuid)->toBe('service-quote-uuid')
+        ->and($apiJob->shouldDispatch)->toBeTrue()
+        ->and($internalJob)->toBeInstanceOf(ShouldQueue::class)
+        ->and($internalJob->orderUuid)->toBe('order-uuid')
+        ->and($bulkJob)->toBeInstanceOf(ShouldQueue::class)
+        ->and($bulkJob->orderUuids)->toBe(['order-uuid-1', 'order-uuid-2'])
+        ->and($bulkJob->driverUuid)->toBe('driver-uuid');
+});