@fleetbase/fleetops-engine 0.6.61 → 0.6.63

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

@@ -0,0 +1,110 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1\Concerns;
+
+use Fleetbase\Support\Http;
+use Illuminate\Http\Resources\MissingValue;
+
+/**
+ * Renders a relationship twice: as an additive `<name>_id` public identifier, and
+ * as the nested object under the name the endpoint has always used.
+ *
+ * The two are deliberately separate keys. The SDK stores whatever the API returns
+ * verbatim — `Resource::$attributes = $attributes`, no normalisation — so a
+ * property that is an object on one call and a string on another silently breaks
+ * every consumer that dereferences it. Navigator interpolates `driver.user`
+ * straight into a socket channel name; an object there would subscribe it to
+ * `user.[object Object]` and simply stop delivering messages. So an existing
+ * object key stays an object key, always, and the identifier arrives beside it.
+ */
+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.
+     *
+     * @return array<int, string>
+     */
+    protected function requestedRelations($request): array
+    {
+        $with = $request->input('with');
+
+        if (is_string($with)) {
+            $with = explode(',', $with);
+        }
+
+        if (!is_array($with)) {
+            return [];
+        }
+
+        return array_values(array_filter(array_map('strval', $with), 'strlen'));
+    }
+
+    /**
+     * The nested object for a relationship.
+     *
+     * Internal console requests keep the exact `whenLoaded` behaviour they have
+     * always had. Public requests get the object only when they asked for it,
+     * which is also what they got before: these relations were never eager
+     * loaded on the public endpoints, so the key was absent unless `with` named
+     * it. Absent stays absent; it never becomes a string.
+     *
+     * @param array<int, string> $with camelCased relations the caller asked for
+     */
+    protected function publicRelationObject(string $relation, array $with, \Closure $resource): mixed
+    {
+        if (Http::isInternalRequest()) {
+            return $this->whenLoaded($relation, $resource);
+        }
+
+        if (!in_array($relation, $with, true)) {
+            return new MissingValue();
+        }
+
+        $this->loadRelationIfPossible($relation);
+
+        return $this->{$relation} ? $resource() : null;
+    }
+
+    /**
+     * The public id behind a relationship, or null when nothing is assigned.
+     *
+     * Additive and unconditional: it is present whether or not the object is,
+     * and it does not change when the object is expanded.
+     *
+     * @param string|null $foreignKey the column holding the relation for a belongsTo;
+     *                                null for the inverse side, which has no local column
+     */
+    protected function publicIdForRelation(string $relation, ?string $foreignKey): ?string
+    {
+        if ($foreignKey !== null && empty($this->{$foreignKey})) {
+            return null;
+        }
+
+        $resource = $this->resource;
+
+        if (is_object($resource) && method_exists($resource, 'relationLoaded') && $resource->relationLoaded($relation)) {
+            return data_get($this, $relation . '.public_id');
+        }
+
+        // Not every resource wraps an Eloquent model — webhook payload fixtures and
+        // compact serializers pass plain objects — so read the already-materialised
+        // value rather than calling a relation method that is not there.
+        if (!is_object($resource) || !method_exists($resource, $relation)) {
+            return data_get($this, $relation . '.public_id');
+        }
+
+        return $this->{$relation}()->value('public_id');
+    }
+
+    private function loadRelationIfPossible(string $relation): void
+    {
+        $resource = $this->resource;
+
+        if (is_object($resource) && method_exists($resource, 'loadMissing') && method_exists($resource, $relation)) {
+            $this->loadMissing($relation);
+        }
+    }
+}

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

@@ -37,6 +37,7 @@ class Driver extends FleetbaseResource
             'name'                          => $this->name,
             'email'                         => $this->email,
             'phone'                         => $this->phone,
+            'timezone'                      => data_get($this, 'user.timezone'),
             'drivers_license_number'        => $this->drivers_license_number,
             'license_expiry'                => $this->formatDateOnly($this->license_expiry),
             'photo_url'                     => $this->photo_url,
@@ -45,25 +46,38 @@ class Driver extends FleetbaseResource
             'vehicle_name'                  => $this->when(Http::isInternalRequest(), $this->vehicle_name),
             'vehicle_avatar'                => $this->vehicle_avatar,
             'vendor_name'                   => $this->when(Http::isInternalRequest(), $this->vendor_name),
-            'assigned_orders_count'         => $this->when(Http::isInternalRequest(), $this->assignedOrdersCount()),
-            'current_order_reference'       => $this->when(Http::isInternalRequest(), $this->currentOrderReference()),
+            'assigned_orders_count'         => $this->when(Http::isInternalRequest(), fn () => $this->assignedOrdersCount()),
+            'current_order_reference'       => $this->when(Http::isInternalRequest(), fn () => $this->currentOrderReference()),
             'vehicle'                       => $this->whenLoaded('vehicle', fn () => new VehicleWithoutDriver($this->vehicle)),
             'current_job'                   => $this->whenLoaded('currentJob', fn () => new Order($this->currentJob)),
             'current_job_id'                => $this->when(Http::isInternalRequest(), data_get($this, 'currentJob.tracking')),
             'jobs'                          => $this->whenLoaded('jobs', fn () => $this->getJobs()),
             'vendor'                        => $this->whenLoaded('vendor', fn () => new Vendor($this->vendor)),
+            // Public callers receive each assignment as a public id so a write
+            // can be read back; the nested objects above are unchanged.
+            'vehicle_id'                    => $this->when(Http::isPublicRequest(), fn () => $this->vehicle_id),
+            'vendor_id'                     => $this->when(Http::isPublicRequest(), fn () => $this->vendor_id),
+            'job_id'                        => $this->when(Http::isPublicRequest(), fn () => data_get($this, 'currentJob.public_id')),
             'fleets'                        => $this->whenLoaded('fleets', fn () => Fleet::collection($this->fleets()->without('drivers')->get())),
             'current_shift'                 => $this->whenLoaded('currentShift', fn () => $this->currentShift),
             'location'                      => $this->wasRecentlyCreated ? new Point(0, 0) : Utils::castPoint($this->location),
             'heading'                       => (int) data_get($this, 'heading', 0),
+            'bearing'                       => data_get($this, 'bearing'),
             'altitude'                      => (int) data_get($this, 'altitude', 0),
             'speed'                         => (int) data_get($this, 'speed', 0),
             'country'                       => data_get($this, 'country'),
             'currency'                      => data_get($this, 'currency', Utils::getCurrenyFromCountryCode($this->country)),
             'city'                          => data_get($this, 'city', Utils::getCapitalCityFromCountryCode($this->country)),
             'online'                        => data_get($this, 'online', false),
+            'current_status'                => data_get($this, 'current_status'),
             'status'                        => $this->status,
             'token'                         => $this->token,
+            // Orchestrator constraints
+            'skills'                        => data_get($this, 'skills'),
+            'max_travel_time'               => $this->max_travel_time,
+            'max_distance'                  => $this->max_distance,
+            'time_window_start'             => $this->time_window_start,
+            'time_window_end'               => $this->time_window_end,
             'meta'                          => data_get($this, 'meta', Utils::createObject()),
             'updated_at'                    => $this->updated_at,
             'created_at'                    => $this->created_at,
@@ -131,7 +145,13 @@ class Driver extends FleetbaseResource
             'currency'               => data_get($this, 'currency', Utils::getCurrenyFromCountryCode($this->country)),
             'city'                   => data_get($this, 'city', Utils::getCapitalCityFromCountryCode($this->country)),
             'online'                 => data_get($this, 'online', false),
+            'current_status'         => data_get($this, 'current_status'),
             'status'                 => $this->status,
+            'skills'                 => data_get($this, 'skills'),
+            'max_travel_time'        => $this->max_travel_time,
+            'max_distance'           => $this->max_distance,
+            'time_window_start'      => $this->time_window_start,
+            'time_window_end'        => $this->time_window_end,
             'meta'                   => data_get($this, 'meta', Utils::createObject()),
             'updated_at'             => $this->updated_at,
             'created_at'             => $this->created_at,

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

@@ -2,12 +2,15 @@
 
 namespace Fleetbase\FleetOps\Http\Resources\v1;
 
+use Fleetbase\FleetOps\Http\Resources\v1\Concerns\ResolvesPublicRelationFields;
 use Fleetbase\Http\Resources\FleetbaseResource;
 use Fleetbase\Support\Http;
-use Illuminate\Support\Str;
+use Fleetbase\Support\Resolve;
 
 class Fleet extends FleetbaseResource
 {
+    use ResolvesPublicRelationFields;
+
     /**
      * Transform the resource into an array.
      *
@@ -17,22 +20,15 @@ class Fleet extends FleetbaseResource
      */
     public function toArray($request)
     {
-        if ($request->isArray('with')) {
-            $with = array_map(function ($relation) {
-                return Str::camel($relation);
-            }, $request->array('with'));
-
-            $this->load($with);
-
-            if (in_array('subfleets', $with, true)) {
-                if (in_array('drivers', $with, true)) {
-                    $this->loadMissing('subFleets.drivers');
-                }
+        // The controller has already mapped these onto real relation names and
+        // 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.
+        $with = $this->requestedRelations($request);
 
-                if (in_array('vehicles', $with, true)) {
-                    $this->loadMissing('subFleets.vehicles');
-                }
-            }
+        if ($with !== []) {
+            $this->loadMissing($with);
         }
 
         return $this->withCustomFields([
@@ -40,16 +36,31 @@ class Fleet extends FleetbaseResource
             'uuid'                  => $this->when(Http::isInternalRequest(), $this->uuid),
             'public_id'             => $this->when(Http::isInternalRequest(), $this->public_id),
             'name'                  => $this->name,
+            'color'                 => $this->color ?? null,
             'task'                  => $this->task ?? null,
             'status'                => $this->status ?? null,
-            'drivers_count'         => $this->when(Http::isInternalRequest(), $this->drivers_count),
-            'drivers_online_count'  => $this->when(Http::isInternalRequest(), $this->drivers_online_count),
-            'vehicles_count'        => $this->when(Http::isInternalRequest(), $this->vehicles_count),
-            'vehicles_online_count' => $this->when(Http::isInternalRequest(), $this->vehicles_online_count),
-            'service_area'          => $this->whenLoaded('serviceArea', fn () => new ServiceArea($this->serviceArea)),
-            'zone'                  => $this->whenLoaded('zone', fn () => new Zone($this->zone)),
-            'vendor'                => $this->whenLoaded('vendor', fn () => new Vendor($this->vendor)),
-            'parent_fleet'          => $this->whenLoaded('parentFleet', fn () => new ParentFleet($this->parentFleet)),
+            'photo_url'             => $this->photo_url,
+            // Closures, not values: `when()` evaluates a plain second argument
+            // eagerly, so each of these counts ran a query on every public
+            // request that then discarded the result.
+            'drivers_count'         => $this->when(Http::isInternalRequest(), fn () => $this->drivers_count),
+            'drivers_online_count'  => $this->when(Http::isInternalRequest(), fn () => $this->drivers_online_count),
+            'vehicles_count'        => $this->when(Http::isInternalRequest(), fn () => $this->vehicles_count),
+            'vehicles_online_count' => $this->when(Http::isInternalRequest(), fn () => $this->vehicles_online_count),
+            // Additive public identifiers. Always present, unchanged when the
+            // object beside them is expanded, and never a substitute for it.
+            'service_area_id'       => $this->publicIdForRelation('serviceArea', 'service_area_uuid'),
+            'zone_id'               => $this->publicIdForRelation('zone', 'zone_uuid'),
+            'vendor_id'             => $this->publicIdForRelation('vendor', 'vendor_uuid'),
+            'parent_fleet_id'       => $this->publicIdForRelation('parentFleet', 'parent_fleet_uuid'),
+            'photo_id'              => $this->publicIdForRelation('photo', 'image_uuid'),
+            // The objects keep the shape they have always had: absent unless the
+            // relation was loaded, an object when it was, never a string.
+            'service_area'          => $this->publicRelationObject('serviceArea', $with, fn () => new ServiceArea($this->serviceArea)),
+            'zone'                  => $this->publicRelationObject('zone', $with, fn () => new Zone($this->zone)),
+            'vendor'                => $this->publicRelationObject('vendor', $with, fn () => new Vendor($this->vendor)),
+            'parent_fleet'          => $this->publicRelationObject('parentFleet', $with, fn () => new ParentFleet($this->parentFleet)),
+            'photo'                 => $this->publicRelationObject('photo', $with, fn () => Resolve::httpResourceForModel($this->photo)),
             'subfleets'             => $this->whenLoaded('subFleets', fn () => SubFleet::collection($this->subFleets)),
             'drivers'               => $this->whenLoaded('drivers', fn () => Driver::collection($this->drivers()->with(Http::isInternalRequest() || $request->has('with.jobs') ? ['jobs'] : [])->get())),
             'vehicles'              => $this->whenLoaded('vehicles', fn () => Vehicle::collection($this->vehicles)),
@@ -68,11 +79,13 @@ class Fleet extends FleetbaseResource
         return [
             'id'           => $this->public_id,
             'name'         => $this->name,
+            'color'        => $this->color ?? null,
             'task'         => $this->task ?? null,
             'status'       => $this->status ?? null,
-            'parent_fleet' => $this->when($this->serviceArea, data_get($this, 'parentFleet.public_id')),
+            'parent_fleet' => $this->when($this->parentFleet, data_get($this, 'parentFleet.public_id')),
             'service_area' => $this->when($this->serviceArea, data_get($this, 'serviceArea.public_id')),
             'zone'         => $this->when($this->zone, data_get($this, 'zone.public_id')),
+            'vendor'       => $this->when($this->vendor, data_get($this, 'vendor.public_id')),
             'updated_at'   => $this->updated_at,
             'created_at'   => $this->created_at,
         ];

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

@@ -2,12 +2,16 @@
 
 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;
 
 class Vehicle extends FleetbaseResource
 {
+    use ResolvesPublicRelationFields;
+
     /**
      * Transform the resource into an array.
      *
@@ -17,6 +21,12 @@ class Vehicle extends FleetbaseResource
      */
     public function toArray($request)
     {
+        $with = $this->requestedRelations($request);
+
+        if ($with !== []) {
+            $this->loadMissing($with);
+        }
+
         return $this->withCustomFields([
             // Identity
             'id'                     => $this->when(Http::isInternalRequest(), $this->id, $this->public_id),
@@ -39,10 +49,24 @@ class Vehicle extends FleetbaseResource
             'description'            => $this->description,
             'driver_name'            => $this->when(Http::isInternalRequest(), $this->driver_name),
             'vendor_name'            => $this->when(Http::isInternalRequest(), $this->vendor_name),
-            'assigned_orders_count'  => $this->when(Http::isInternalRequest(), $this->assignedOrdersCount()),
-            'current_order_reference'=> $this->when(Http::isInternalRequest(), $this->currentOrderReference()),
-            // Relationships
-            'driver'                 => $this->whenLoaded('driver', fn () => new Driver($this->driver)),
+            'assigned_orders_count'  => $this->when(Http::isInternalRequest(), fn () => $this->assignedOrdersCount()),
+            'current_order_reference'=> $this->when(Http::isInternalRequest(), fn () => $this->currentOrderReference()),
+            // Relationships. The identifier is additive and always present so a
+            // write can be read back; the object beside it keeps the shape it
+            // has always had — absent unless loaded, an object when it is.
+            'driver_id'              => $this->publicIdForRelation('driver', null),
+            'vendor_id'              => $this->publicIdForRelation('vendor', 'vendor_uuid'),
+            'category_id'            => $this->publicIdForRelation('category', 'category_uuid'),
+            'warranty_id'            => $this->publicIdForRelation('warranty', 'warranty_uuid'),
+            'photo_id'               => $this->publicIdForRelation('photo', 'photo_uuid'),
+            'driver'                 => $this->publicRelationObject('driver', $with, fn () => new Driver($this->driver)),
+            'vendor'                 => $this->publicRelationObject('vendor', $with, fn () => new Vendor($this->vendor)),
+            // Resolved through the repository's own resource resolver rather than
+            // a hardcoded class: Category and File live in core, and Warranty has
+            // no v1 resource of its own.
+            'category'               => $this->publicRelationObject('category', $with, fn () => Resolve::httpResourceForModel($this->category)),
+            'warranty'               => $this->publicRelationObject('warranty', $with, fn () => Resolve::httpResourceForModel($this->warranty)),
+            'photo'                  => $this->publicRelationObject('photo', $with, fn () => Resolve::httpResourceForModel($this->photo)),
             'devices'                => $this->whenLoaded('devices', fn () => $this->devices),
             // Vehicle identification
             'make'                   => $this->make,
@@ -139,6 +163,15 @@ class Vehicle extends FleetbaseResource
             'altitude'               => (int) data_get($this, 'altitude', 0),
             'speed'                  => (int) data_get($this, 'speed', 0),
             'telematics'             => data_get($this, 'telematics'),
+            // Orchestrator constraints
+            'skills'                   => data_get($this, 'skills'),
+            'payload_capacity_volume'  => $this->payload_capacity_volume,
+            'payload_capacity_pallets' => $this->payload_capacity_pallets,
+            'payload_capacity_parcels' => $this->payload_capacity_parcels,
+            'max_tasks'                => $this->max_tasks,
+            'time_window_start'        => $this->time_window_start,
+            'time_window_end'          => $this->time_window_end,
+            'return_to_depot'          => $this->return_to_depot,
             // Notes & meta
             'notes'                  => $this->notes,
             'meta'                   => data_get($this, 'meta', Utils::createObject()),
@@ -273,6 +306,15 @@ class Vehicle extends FleetbaseResource
             'vin_data'                    => data_get($this, 'vin_data', Utils::createObject()),
             'specs'                       => data_get($this, 'specs', Utils::createObject()),
             'details'                     => data_get($this, 'details', Utils::createObject()),
+            // Orchestrator constraints
+            'skills'                     => data_get($this, 'skills'),
+            'payload_capacity_volume'    => $this->payload_capacity_volume,
+            'payload_capacity_pallets'   => $this->payload_capacity_pallets,
+            'payload_capacity_parcels'   => $this->payload_capacity_parcels,
+            'max_tasks'                  => $this->max_tasks,
+            'time_window_start'          => $this->time_window_start,
+            'time_window_end'            => $this->time_window_end,
+            'return_to_depot'            => $this->return_to_depot,
             // Notes & meta
             'notes'                      => $this->notes,
             'meta'                       => data_get($this, 'meta', Utils::createObject()),

package/server/src/Models/Driver.php

@@ -110,7 +110,7 @@ class Driver extends Model
         'current_status',
         'slug',
         'status',
-        'meta,',
+        'meta',
         // Orchestrator
         'skills',
         'max_travel_time',
@@ -255,7 +255,7 @@ class Driver extends Model
      */
     public function user()
     {
-        return $this->belongsTo(User::class)->select(['uuid', 'company_uuid', 'public_id', 'avatar_uuid', 'name', 'phone', 'email', 'type', 'status', 'last_login'])->without(['driver'])->withTrashed();
+        return $this->belongsTo(User::class)->select(['uuid', 'company_uuid', 'public_id', 'avatar_uuid', 'name', 'phone', 'email', 'timezone', 'type', 'status', 'last_login'])->without(['driver'])->withTrashed();
     }
 
     /**

package/server/src/routes.php

@@ -302,6 +302,14 @@ Route::prefix(config('fleetops.api.routing.prefix'))->namespace('Fleetbase\Fleet
             $router->group(['prefix' => 'fleets'], function () use ($router) {
                 $router->post('/', 'FleetController@create');
                 $router->get('/', 'FleetController@query');
+                // Membership routes are declared ahead of the `{id}` routes so a
+                // literal `vehicles`/`drivers` segment can never be swallowed by
+                // the single-parameter patterns below. Both parameters are public
+                // ids; no internal uuid is ever accepted or returned here.
+                $router->post('{id}/vehicles/{vehicle}', 'FleetController@assignVehicle');
+                $router->delete('{id}/vehicles/{vehicle}', 'FleetController@removeVehicle');
+                $router->post('{id}/drivers/{driver}', 'FleetController@assignDriver');
+                $router->delete('{id}/drivers/{driver}', 'FleetController@removeDriver');
                 $router->get('{id}', 'FleetController@find');
                 $router->put('{id}', 'FleetController@update');
                 $router->delete('{id}', 'FleetController@delete');