@fleetbase/fleetops-engine 0.6.63 → 0.6.65

package/server/src/Http/Filter/TrailerFilter.php

@@ -0,0 +1,269 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\FleetOps\Models\Device;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Filter\Filter;
+use Fleetbase\Models\Category;
+use Fleetbase\Support\Http;
+
+class TrailerFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function queryForPublic()
+    {
+        $this->queryForInternal();
+    }
+
+    public function query(?string $value)
+    {
+        $this->builder->search($value);
+    }
+
+    public function publicId(?string $value)
+    {
+        $this->builder->searchWhere('public_id', $value);
+    }
+
+    public function name(?string $value)
+    {
+        $this->builder->searchWhere('name', $value);
+    }
+
+    public function code(?string $value)
+    {
+        $this->builder->searchWhere('code', $value);
+    }
+
+    public function trailerType($value)
+    {
+        $this->whereOneOf('type', $value);
+    }
+
+    public function status($value)
+    {
+        $this->whereOneOf('status', $value);
+    }
+
+    public function trailerMake(?string $value)
+    {
+        $this->builder->searchWhere('make', $value);
+    }
+
+    public function trailerModel(?string $value)
+    {
+        $this->builder->searchWhere('model', $value);
+    }
+
+    public function trailerYear($value)
+    {
+        $this->whereOneOf('year', $value);
+    }
+
+    public function plateNumber(?string $value)
+    {
+        $this->builder->searchWhere('plate_number', $value);
+    }
+
+    public function vin(?string $value)
+    {
+        $this->builder->searchWhere('vin', $value);
+    }
+
+    public function serialNumber(?string $value)
+    {
+        $this->builder->searchWhere('serial_number', $value);
+    }
+
+    public function bodyType(?string $value)
+    {
+        $this->builder->searchWhere('body_type', $value);
+    }
+
+    public function length($value)
+    {
+        $this->whereOneOf('length', $value);
+    }
+
+    public function axleCount($value)
+    {
+        $this->whereOneOf('axle_count', $value);
+    }
+
+    public function gvwr($value)
+    {
+        $this->whereOneOf('gvwr', $value);
+    }
+
+    public function payloadCapacity($value)
+    {
+        $this->whereOneOf('payload_capacity', $value);
+    }
+
+    public function ownershipType($value)
+    {
+        $this->whereOneOf('ownership_type', $value);
+    }
+
+    public function refrigerated($value)
+    {
+        $this->builder->where('refrigerated', filter_var($value, FILTER_VALIDATE_BOOLEAN));
+    }
+
+    public function devicesCount($value)
+    {
+        $this->builder->has('devices', '=', (int) $value);
+    }
+
+    public function equipmentCount($value)
+    {
+        $this->builder->has('equipments', '=', (int) $value);
+    }
+
+    /**
+     * Connectivity is derived from `last_online_at`, mirroring
+     * Trailer::getConnectivityStatusAttribute(). Multiple states combine with OR.
+     */
+    public function connectivityStatus($value)
+    {
+        $states = array_values(array_filter(array_map('strval', (array) $value), 'strlen'));
+
+        if (empty($states)) {
+            return;
+        }
+
+        $this->builder->where(function ($query) use ($states) {
+            foreach ($states as $state) {
+                $query->orWhere(function ($query) use ($state) {
+                    match ($state) {
+                        'never_connected'  => $query->whereNull('last_online_at'),
+                        'online'           => $query->where('last_online_at', '>=', now()->subMinutes(10)),
+                        'recently_offline' => $query->whereBetween('last_online_at', [now()->subDay(), now()->subMinutes(10)]),
+                        'offline'          => $query->where('last_online_at', '<', now()->subDay()),
+                        default            => $query->whereRaw('0 = 1'),
+                    };
+                });
+            }
+        });
+    }
+
+    public function attachmentState($value)
+    {
+        $states = array_unique(array_values(array_filter(array_map('strval', (array) $value), 'strlen')));
+
+        // Asking for both states is the same as not filtering.
+        if (empty($states) || count($states) > 1) {
+            return;
+        }
+
+        $method = $states[0] === 'attached' ? 'whereHas' : 'whereDoesntHave';
+        $this->builder->{$method}('currentConnection');
+    }
+
+    public function vehicle($value)
+    {
+        $uuids = $this->resolveRelationUuids(Vehicle::class, $value);
+
+        $this->builder->whereHas('currentConnection', fn ($query) => $query->whereIn('connector_uuid', $uuids));
+    }
+
+    public function vendor($value)
+    {
+        $this->builder->whereIn('vendor_uuid', $this->resolveRelationUuids(Vendor::class, $value));
+    }
+
+    /**
+     * Trailers with any of the given devices installed.
+     */
+    public function device($value)
+    {
+        $uuids = $this->resolveRelationUuids(Device::class, $value);
+
+        $this->builder->whereHas('devices', fn ($query) => $query->whereIn('uuid', $uuids));
+    }
+
+    public function category($value)
+    {
+        $this->builder->whereIn('category_uuid', $this->resolveRelationUuids(Category::class, $value, false));
+    }
+
+    public function createdAt($value)
+    {
+        $this->dateFilter('created_at', $value);
+    }
+
+    public function updatedAt($value)
+    {
+        $this->dateFilter('updated_at', $value);
+    }
+
+    public function lastOnlineAt($value)
+    {
+        $this->dateFilter('last_online_at', $value);
+    }
+
+    public function purchasedAt($value)
+    {
+        $this->dateFilter('purchased_at', $value);
+    }
+
+    /**
+     * Console multi-option filters submit arrays; the public API submits scalars.
+     */
+    private function whereOneOf(string $column, $value): void
+    {
+        $values = array_values(array_filter(array_map('strval', (array) $value), 'strlen'));
+
+        if (empty($values)) {
+            return;
+        }
+
+        count($values) === 1 ? $this->builder->where($column, $values[0]) : $this->builder->whereIn($column, $values);
+    }
+
+    /**
+     * Resolve related record identifiers to UUIDs. The console filters by the record's
+     * UUID; the public API filters by public id (or a vehicle's internal id).
+     */
+    private function resolveRelationUuids(string $modelClass, $identifiers, bool $scopeToCompany = true): array
+    {
+        $identifiers = array_values(array_filter(array_map('strval', (array) $identifiers), 'strlen'));
+
+        if (empty($identifiers)) {
+            return [];
+        }
+
+        $instance = new $modelClass();
+        $query    = $modelClass::query()->where(function ($query) use ($identifiers, $instance) {
+            $query->whereIn('public_id', $identifiers);
+
+            if (in_array('internal_id', $instance->getFillable(), true)) {
+                $query->orWhereIn('internal_id', $identifiers);
+            }
+
+            if (Http::isInternalRequest($this->request)) {
+                $query->orWhereIn('uuid', $identifiers);
+            }
+        });
+
+        if ($scopeToCompany) {
+            $query->where('company_uuid', $this->session->get('company'));
+        }
+
+        return $query->pluck('uuid')->all();
+    }
+
+    private function dateFilter(string $column, $value): void
+    {
+        $range = Utils::dateRange($value);
+
+        is_array($range) ? $this->builder->whereBetween($column, $range) : $this->builder->whereDate($column, $range);
+    }
+}

package/server/src/Http/Filter/VehicleFilter.php

@@ -3,8 +3,10 @@
 namespace Fleetbase\FleetOps\Http\Filter;
 
 use Fleetbase\FleetOps\Http\Filter\Concerns\ResolvesPublicRelationUuids;
+use Fleetbase\FleetOps\Models\Device;
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Fleet;
+use Fleetbase\FleetOps\Models\Trailer;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Models\Vendor;
 use Fleetbase\FleetOps\Support\Utils;
@@ -55,8 +57,18 @@ class VehicleFilter extends Filter
      * is the console that gets the exception. An unknown request context is
      * treated as public: exact is the safe default of the two.
      */
-    public function internalId(?string $internalId)
+    public function internalId($internalId)
     {
+        // The console's tag-input filter sends several ids at once (batch scans);
+        // any list is an exact match on each id.
+        $ids = array_values(array_filter(array_map('trim', explode(',', (string) $internalId)), 'strlen'));
+
+        if (count($ids) > 1) {
+            $this->builder->whereIn('internal_id', $ids);
+
+            return;
+        }
+
         if (Http::isInternalRequest($this->request)) {
             $this->builder->searchWhere('internal_id', $internalId);
 
@@ -107,7 +119,7 @@ class VehicleFilter extends Filter
         $this->builder->searchWhere('year', $vehicleYear);
     }
 
-    public function driver(?string $driverId)
+    public function driver($driverId)
     {
         if ($driverId === 'unassigned') {
             $this->builder->whereDoesntHave('driver');
@@ -125,7 +137,62 @@ class VehicleFilter extends Filter
         );
     }
 
-    public function vendor(?string $vendor)
+    /**
+     * Vehicles currently towing any of the given trailers (public id, internal id or,
+     * for the console, uuid). Several trailers combine with OR.
+     */
+    public function trailer($trailer)
+    {
+        $uuids = $this->resolvePublicRelationUuids(Trailer::class, $trailer);
+
+        $this->builder->whereHas('currentTrailers', function ($query) use ($uuids) {
+            $query->whereIn('assets.uuid', $uuids);
+        });
+    }
+
+    /**
+     * Vehicles with any of the given devices installed.
+     */
+    public function device($device)
+    {
+        $uuids = $this->resolvePublicRelationUuids(Device::class, $device);
+
+        $this->builder->whereHas('devices', function ($query) use ($uuids) {
+            $query->whereIn('uuid', $uuids);
+        });
+    }
+
+    public function hasTrailer($value)
+    {
+        $this->whereRelationPresence('currentTrailers', $value);
+    }
+
+    public function hasDriver($value)
+    {
+        $this->whereRelationPresence('driver', $value);
+    }
+
+    public function hasDevice($value)
+    {
+        $this->whereRelationPresence('devices', $value);
+    }
+
+    /**
+     * `true` keeps vehicles that have the relation, `false` those that do not, and
+     * anything else (an empty select) leaves the query untouched.
+     */
+    protected function whereRelationPresence(string $relation, $value): void
+    {
+        $presence = filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);
+
+        if ($presence === true) {
+            $this->builder->whereHas($relation, fn ($query) => $query);
+        } elseif ($presence === false) {
+            $this->builder->whereDoesntHave($relation);
+        }
+    }
+
+    public function vendor($vendor)
     {
         if (!$vendor) {
             return;

package/server/src/Http/Requests/CreateDeviceRequest.php

@@ -41,7 +41,7 @@ class CreateDeviceRequest extends FleetbaseRequest
             'telematic'             => ['nullable', 'string'],
             'warranty'              => ['nullable', 'string'],
             'photo'                 => ['nullable', 'string'],
-            'attachable_type'       => ['nullable', 'string'],
+            'attachable_type'       => ['nullable', Rule::in(['fleet-ops:vehicle', 'fleet-ops:trailer', 'vehicle', 'trailer'])],
             'attachable'            => ['nullable', 'required_with:attachable_type', 'string'],
             'meta'                  => ['nullable', 'array'],
             'data'                  => ['nullable', 'array'],

package/server/src/Http/Requests/CreateEquipmentRequest.php

@@ -24,7 +24,7 @@ class CreateEquipmentRequest extends FleetbaseRequest
             'model'          => ['nullable', 'string'],
             'warranty'       => ['nullable', 'string'],
             'photo'          => ['nullable', 'string'],
-            'equipable_type' => ['nullable', 'string'],
+            'equipable_type' => ['nullable', Rule::in(['fleet-ops:vehicle', 'fleet-ops:trailer', 'fleet-ops:driver', 'vehicle', 'trailer', 'driver'])],
             'equipable'      => ['nullable', 'required_with:equipable_type', 'string'],
             'purchased_at'   => ['nullable', 'date'],
             'purchase_price' => ['nullable'],

package/server/src/Http/Requests/CreateTrailerRequest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Requests;
+
+use Fleetbase\FleetOps\Models\Trailer;
+use Fleetbase\FleetOps\Rules\ResolvablePoint;
+use Fleetbase\Http\Requests\FleetbaseRequest;
+use Illuminate\Validation\Rule;
+
+class CreateTrailerRequest extends FleetbaseRequest
+{
+    public function authorize(): bool
+    {
+        return request()->session()->has('api_credential') || request()->session()->has('is_sanctum_token');
+    }
+
+    public function rules(): array
+    {
+        return [
+            'name'                => [Rule::requiredIf($this->isMethod('POST')), 'string', 'max:255'],
+            'description'         => ['nullable', 'string'],
+            'code'                => ['nullable', 'string', 'max:255'],
+            'type'                => ['nullable', Rule::in(Trailer::TYPES)],
+            'body_type'           => ['nullable', 'string', 'max:255'],
+            'status'              => ['nullable', Rule::in(Trailer::STATUSES)],
+            'vin'                 => ['nullable', 'string', 'max:255'],
+            'plate_number'        => ['nullable', 'string', 'max:255'],
+            'serial_number'       => ['nullable', 'string', 'max:255'],
+            'make'                => ['nullable', 'string', 'max:255'],
+            'model'               => ['nullable', 'string', 'max:255'],
+            'year'                => ['nullable', 'integer', 'min:1880', 'max:' . (now()->year + 2)],
+            'color'               => ['nullable', 'string', 'max:255'],
+            'usage_type'          => ['nullable', 'string', 'max:255'],
+            'category'            => ['nullable', 'string'], 'vendor' => ['nullable', 'string'], 'warranty' => ['nullable', 'string'], 'photo' => ['nullable', 'string'],
+            'location'            => ['nullable', new ResolvablePoint()], 'latitude' => ['nullable', 'numeric', 'between:-90,90', 'required_with:longitude'],
+            'longitude'           => ['nullable', 'numeric', 'between:-180,180', 'required_with:latitude'],
+            'length'              => ['nullable', 'numeric', 'min:0'], 'width' => ['nullable', 'numeric', 'min:0'], 'height' => ['nullable', 'numeric', 'min:0'],
+            'tare_weight'         => ['nullable', 'numeric', 'min:0'], 'gvwr' => ['nullable', 'numeric', 'min:0'], 'payload_capacity' => ['nullable', 'numeric', 'min:0'],
+            'cargo_volume'        => ['nullable', 'numeric', 'min:0'], 'axle_count' => ['nullable', 'integer', 'min:0'], 'tire_count' => ['nullable', 'integer', 'min:0'],
+            'door_count'          => ['nullable', 'integer', 'min:0'], 'abs_equipped' => ['nullable', 'boolean'], 'ebs_equipped' => ['nullable', 'boolean'],
+            'refrigerated'        => ['nullable', 'boolean'], 'temperature_min' => ['nullable', 'numeric'], 'temperature_max' => ['nullable', 'numeric', 'gte:temperature_min'],
+            'reefer_engine_hours' => ['nullable', 'numeric', 'min:0'],
+            'measurement_system'  => ['nullable', Rule::in(['metric', 'imperial'])], 'odometer' => ['nullable', 'numeric', 'min:0'],
+            'odometer_unit'       => ['nullable', Rule::in(['km', 'mi', 'miles', 'kilometers'])],
+            'coupling_type'       => ['nullable', 'string', 'max:255'], 'brake_type' => ['nullable', 'string', 'max:255'],
+            'ownership_type'      => ['nullable', Rule::in(Trailer::OWNERSHIP_TYPES)],
+            'purchased_at'        => ['nullable', 'date'], 'lease_expires_at' => ['nullable', 'date'],
+            'financing_status'    => ['nullable', 'string', 'max:255'], 'currency' => ['nullable', 'string', 'size:3'],
+            'acquisition_cost'    => ['nullable', 'numeric', 'min:0'], 'current_value' => ['nullable', 'numeric', 'min:0'],
+            'insurance_value'     => ['nullable', 'numeric', 'min:0'], 'depreciation_rate' => ['nullable', 'numeric', 'min:0'],
+            'capacity'            => ['nullable', 'array'], 'specs' => ['nullable', 'array'], 'attributes' => ['nullable', 'array'], 'notes' => ['nullable', 'string'],
+        ];
+    }
+}

package/server/src/Http/Requests/UpdateTrailerRequest.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Requests;
+
+class UpdateTrailerRequest extends CreateTrailerRequest
+{
+}

package/server/src/Http/Resources/v1/AssetConnection.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\FleetOps\Http\Resources\v1\Concerns\ResolvesPublicRelationFields;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\Support\Http;
+use Fleetbase\Support\Resolve;
+
+/**
+ * An effective-dated towing connection between a Vehicle (connector) and a
+ * Trailer (connected asset).
+ */
+class AssetConnection extends FleetbaseResource
+{
+    use ResolvesPublicRelationFields;
+
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     */
+    public function toArray($request): array
+    {
+        $internal = Http::isInternalRequest();
+
+        return [
+            'id'                => $this->when($internal, $this->id, $this->public_id),
+            'uuid'              => $this->when($internal, $this->uuid),
+            'public_id'         => $this->when($internal, $this->public_id),
+            'company_uuid'      => $this->when($internal, $this->company_uuid),
+            'connector_type'    => $this->when($internal, Utils::toEmberResourceType($this->connector_type)),
+            'connector_uuid'    => $this->when($internal, $this->connector_uuid),
+            'connected_type'    => $this->when($internal, Utils::toEmberResourceType($this->connected_type)),
+            'connected_uuid'    => $this->when($internal, $this->connected_uuid),
+            'relationship_type' => $this->relationship_type,
+            'position'          => $this->position,
+            // Identifiers are always present so a connection can be followed back to both
+            // sides even when the related records were not eager loaded.
+            'vehicle_id'        => $this->publicIdForRelation('vehicle', 'connector_uuid'),
+            'trailer_id'        => $this->publicIdForRelation('trailer', 'connected_uuid'),
+            'vehicle'           => $this->whenLoaded('vehicle', fn () => $this->vehicleRepresentation($internal)),
+            'trailer'           => $this->whenLoaded('trailer', fn () => $this->trailerRepresentation($internal)),
+            'connected_at'      => $this->connected_at,
+            'disconnected_at'   => $this->disconnected_at,
+            'active'            => $this->disconnected_at === null,
+            'source'            => $this->source,
+            'confidence'        => $this->confidence,
+            'notes'             => $this->notes,
+            'meta'              => data_get($this, 'meta', Utils::createObject()),
+            'created_at'        => $this->created_at,
+            'updated_at'        => $this->updated_at,
+        ];
+    }
+
+    /**
+     * Only invoked through whenLoaded(), which already yields null for an absent record.
+     */
+    protected function vehicleRepresentation(bool $internal): mixed
+    {
+        $vehicle = $this->vehicle;
+
+        if ($internal) {
+            return Resolve::httpResourceForModel($vehicle);
+        }
+
+        return [
+            'id'           => $vehicle->public_id,
+            'name'         => $vehicle->display_name,
+            'plate_number' => $vehicle->plate_number,
+        ];
+    }
+
+    protected function trailerRepresentation(bool $internal): mixed
+    {
+        $trailer = $this->trailer;
+
+        if ($internal) {
+            return Resolve::httpResourceForModel($trailer);
+        }
+
+        return [
+            'id'           => $trailer->public_id,
+            'name'         => $trailer->display_name,
+            'type'         => $trailer->type,
+            'plate_number' => $trailer->plate_number,
+        ];
+    }
+}

package/server/src/Http/Resources/v1/Concerns/ResolvesPublicRelationFields.php

@@ -22,8 +22,13 @@ trait ResolvesPublicRelationFields
     /**
      * The relations the caller asked for, as real Eloquent relation names.
      *
-     * The controller has already normalised, mapped and allowlisted `with` /
-     * `expand` by the time a resource runs, so this is a plain read.
+     * The controller normalises, maps and allowlists `with` / `expand` for the
+     * resource it returns. That guarantee does not travel: this resource is also
+     * rendered nested inside Order and Driver responses, where the request's
+     * `with` names the parent's relations (`payload`, `driverAssigned.vehicle`).
+     * A nested resource re-reads the same request, so only relations the wrapped
+     * model actually defines are kept — a parent's expansion must never reach
+     * this model's loader, where it raises RelationNotFoundException.
      *
      * @return array<int, string>
      */
@@ -39,7 +44,28 @@ trait ResolvesPublicRelationFields
             return [];
         }
 
-        return array_values(array_filter(array_map('strval', $with), 'strlen'));
+        $with = array_values(array_filter(array_map('strval', $with), 'strlen'));
+
+        return array_values(array_filter($with, fn (string $relation): bool => $this->definesRelation($relation)));
+    }
+
+    /**
+     * Whether the wrapped model defines the root of a relation path.
+     *
+     * Only the first segment is checked: nested segments belong to the related
+     * model, and Eloquent validates those itself once the root exists.
+     */
+    private function definesRelation(string $relation): bool
+    {
+        $resource = $this->resource;
+
+        if (!is_object($resource) || !method_exists($resource, 'loadMissing')) {
+            return false;
+        }
+
+        $root = explode('.', $relation, 2)[0];
+
+        return $root !== '' && method_exists($resource, $root);
     }
 
     /**

package/server/src/Http/Resources/v1/Device.php

@@ -18,7 +18,9 @@ class Device extends FleetbaseResource
             'company_uuid'          => $this->when(Http::isInternalRequest(), $this->company_uuid),
             'telematic_uuid'        => $this->when(Http::isInternalRequest(), $this->telematic_uuid),
             'attachable_uuid'       => $this->when(Http::isInternalRequest(), $this->attachable_uuid),
-            'attachable_type'       => $this->when(Http::isInternalRequest(), $this->attachable_type ? Utils::toEmberResourceType($this->attachable_type) : null),
+            'attachable_type'       => $this->attachable_type ? Utils::toEmberResourceType($this->attachable_type) : null,
+            'attachable_id'         => $this->whenLoaded('attachable', fn () => $this->attachable?->public_id),
+            'attachable_name'       => $this->whenLoaded('attachable', fn () => $this->attachable?->display_name ?? $this->attachable?->name),
             'warranty_uuid'         => $this->when(Http::isInternalRequest(), $this->warranty_uuid),
             'photo_uuid'            => $this->when(Http::isInternalRequest(), $this->photo_uuid),
             'telematic'             => $this->whenLoaded('telematic', fn () => $this->resolveLoadedRelation($this->telematic)),

package/server/src/Http/Resources/v1/Equipment.php

@@ -19,7 +19,9 @@ class Equipment extends FleetbaseResource
             'warranty_uuid'      => $this->when(Http::isInternalRequest(), $this->warranty_uuid),
             'photo_uuid'         => $this->when(Http::isInternalRequest(), $this->photo_uuid),
             'equipable_uuid'     => $this->when(Http::isInternalRequest(), $this->equipable_uuid),
-            'equipable_type'     => $this->when(Http::isInternalRequest(), $this->equipable_type ? Utils::toEmberResourceType($this->equipable_type) : null),
+            'equipable_type'     => $this->equipable_type ? Utils::toEmberResourceType($this->equipable_type) : null,
+            'equipable_id'       => $this->whenLoaded('equipable', fn () => $this->equipable?->public_id),
+            'equipable_name'     => $this->whenLoaded('equipable', fn () => $this->equipable?->display_name ?? $this->equipable?->name),
             'warranty'           => $this->whenLoaded('warranty', fn () => $this->resolveLoadedRelation($this->warranty)),
             'photo'              => $this->whenLoaded('photo', fn () => $this->resolveLoadedRelation($this->photo)),
             'equipable'          => $this->whenLoaded('equipable', fn () => $this->resolveLoadedRelation($this->equipable)),

package/server/src/Http/Resources/v1/Fleet.php

@@ -24,7 +24,9 @@ class Fleet extends FleetbaseResource
         // dropped anything outside the public allowlist, so they are safe to
         // hand to the loader. `subfleets` used to arrive here spelled exactly
         // that and reach `load('subfleets')`, which is not the relation —
-        // the documented expansion raised instead of resolving.
+        // the documented expansion raised instead of resolving. Relations the
+        // fleet does not define are dropped as well: nested under another
+        // response the request's `with` describes the parent, not the fleet.
         $with = $this->requestedRelations($request);
 
         if ($with !== []) {

package/server/src/Http/Resources/v1/Index/Vehicle.php

@@ -3,6 +3,7 @@
 namespace Fleetbase\FleetOps\Http\Resources\v1\Index;
 
 use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Support\TrailerSummary;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Http\Resources\FleetbaseResource;
 use Fleetbase\Support\Http;
@@ -47,6 +48,7 @@ class Vehicle extends FleetbaseResource
             'speed'                 => (int) data_get($this, 'speed', 0),
             'online'                => (bool) data_get($this, 'online', false),
             'devices'               => $this->whenLoaded('devices', fn () => $this->compactDevices()),
+            'trailers'              => $this->whenLoaded('currentTrailers', fn () => $this->compactTrailers()),
             'assigned_orders_count' => $this->when($isInternal, $this->assignedOrdersCount()),
 
             // Meta flag to indicate this is an index resource
@@ -84,6 +86,14 @@ class Vehicle extends FleetbaseResource
         )->values()->all();
     }
 
+    /**
+     * Trailers currently coupled to the vehicle, compacted for map popovers.
+     */
+    protected function compactTrailers(): array
+    {
+        return TrailerSummary::collection($this->currentTrailers);
+    }
+
     protected function currentOrderReference(): ?string
     {
         $this->loadMissing('driver.currentOrder');