@fleetbase/fleetops-engine 0.6.60 → 0.6.62

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

@@ -2,11 +2,14 @@
 
 namespace Fleetbase\FleetOps\Http\Requests;
 
+use Fleetbase\FleetOps\Http\Requests\Concerns\ScopesPublicRelationRules;
 use Fleetbase\Http\Requests\FleetbaseRequest;
 use Illuminate\Validation\Rule;
 
 class CreateFleetRequest extends FleetbaseRequest
 {
+    use ScopesPublicRelationRules;
+
     /**
      * Determine if the user is authorized to make this request.
      */
@@ -21,8 +24,33 @@ class CreateFleetRequest extends FleetbaseRequest
     public function rules(): array
     {
         return [
-            'name'         => [Rule::requiredIf($this->isMethod('POST'))],
-            'service_area' => 'exists:service_areas,public_id',
+            'name'   => [Rule::requiredIf($this->isMethod('POST')), 'nullable', 'string', 'max:191'],
+            'color'  => 'nullable|string|max:64',
+            'task'   => 'nullable|string|max:191',
+            /*
+             * Fleet status is not a closed set on this model: the console, the
+             * spreadsheet importer and existing integrations all write free-form
+             * values, and `active`/`disabled`/`decommissioned` are the console's
+             * options rather than a schema constraint. Restricting the public API
+             * to a subset would leave it unable to express a state the console can.
+             */
+            'status'       => 'nullable|string|max:64',
+            'service_area' => $this->publicRelationRules('service_areas'),
+            'zone'         => $this->publicRelationRules('zones'),
+            'vendor'       => $this->publicRelationRules('vendors'),
+            'parent_fleet' => $this->publicRelationRules('fleets'),
+            'photo'        => 'nullable|string',
+        ];
+    }
+
+    /**
+     * Get custom attributes for validator errors.
+     */
+    public function attributes(): array
+    {
+        return [
+            'service_area' => 'service area',
+            'parent_fleet' => 'parent fleet',
         ];
     }
 }

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

@@ -25,8 +25,13 @@ class CreateServiceRateRequest extends FleetbaseRequest
         return [
             'service_name'                  => [Rule::requiredIf($this->isMethod('POST')), 'string'],
             'service_type'                  => [Rule::requiredIf($this->isMethod('POST')), 'string'],
-            'service_area'                  => [Rule::exists('service_areas', 'public_id')->whereNull('deleted_at')],
-            'zone'                          => [Rule::exists('zones', 'public_id')->whereNull('deleted_at')],
+            // `nullable` so an empty relationship is treated as absent rather than
+            // as an invalid one. Both are optional, but without it `exists` runs
+            // against the null that ConvertEmptyStringsToNull produced and answers
+            // "The selected service area is invalid" for a field the caller simply
+            // did not fill in.
+            'service_area'                  => ['nullable', Rule::exists('service_areas', 'public_id')->whereNull('deleted_at')],
+            'zone'                          => ['nullable', Rule::exists('zones', 'public_id')->whereNull('deleted_at')],
             'rate_calculation_method'       => [Rule::requiredIf($this->isMethod('POST')), 'string', 'in:fixed_meter,fixed_rate,per_meter,per_drop,algo,parcel'],
             'currency'                      => ['required', 'size:3'],
             'base_fee'                      => ['numeric'],

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

@@ -2,12 +2,45 @@
 
 namespace Fleetbase\FleetOps\Http\Requests;
 
+use Fleetbase\FleetOps\Http\Requests\Concerns\ScopesPublicRelationRules;
 use Fleetbase\FleetOps\Rules\ResolvablePoint;
 use Fleetbase\Http\Requests\FleetbaseRequest;
 use Illuminate\Validation\Rule;
 
 class CreateVehicleRequest extends FleetbaseRequest
 {
+    use ScopesPublicRelationRules;
+
+    /**
+     * The statuses the public API accepts for a vehicle.
+     *
+     * `active` is retained even though the model rewrites it to `available`, so
+     * clients written against the original contract keep working.
+     *
+     * @var array<int, string>
+     */
+    public const STATUSES = [
+        'active',
+        'available',
+        'in_use',
+        'maintenance',
+        'out_of_service',
+        'reserved',
+        'retired',
+        'staging',
+        'on_route',
+        'idle',
+        'cleaning',
+        'awaiting_parts',
+        'inspection_due',
+        'inspection_failed',
+        'accident',
+        'compliance_hold',
+        'stolen',
+        'operational',
+        'decommissioned',
+    ];
+
     /**
      * Determine if the user is authorized to make this request.
      */
@@ -22,35 +55,126 @@ class CreateVehicleRequest extends FleetbaseRequest
     public function rules(): array
     {
         return [
-            'status'    => [
-                'nullable',
-                Rule::in([
-                    'active',
-                    'available',
-                    'in_use',
-                    'maintenance',
-                    'out_of_service',
-                    'reserved',
-                    'retired',
-                    'staging',
-                    'on_route',
-                    'idle',
-                    'cleaning',
-                    'awaiting_parts',
-                    'inspection_due',
-                    'inspection_failed',
-                    'accident',
-                    'compliance_hold',
-                    'stolen',
-                    'operational',
-                    'decommissioned',
-                ]),
-            ],
-            'vendor'    => 'nullable|exists:vendors,public_id',
-            'driver'    => 'nullable|exists:drivers,public_id',
+            'status' => ['nullable', Rule::in(static::STATUSES)],
+
+            // Identity and description
+            'internal_id'      => 'nullable|string|max:191',
+            'name'             => 'nullable|string|max:191',
+            'description'      => 'nullable|string',
+            'make'             => 'nullable|string|max:191',
+            'model'            => 'nullable|string|max:191',
+            'model_type'       => 'nullable|string|max:191',
+            'year'             => 'nullable|integer|min:1900|max:2100',
+            'trim'             => 'nullable|string|max:191',
+            'color'            => 'nullable|string|max:64',
+            'type'             => 'nullable|string|max:191',
+            'class'            => 'nullable|string|max:191',
+            'plate_number'     => 'nullable|string|max:191',
+            'vin'              => 'nullable|string|max:64',
+            'serial_number'    => 'nullable|string|max:191',
+            'call_sign'        => 'nullable|string|max:191',
+            'fuel_card_number' => 'nullable|string|max:191',
+
+            // Measurement and operation.
+            //
+            // Validated rather than merely accepted: the model casts odometer
+            // to an integer, so an unchecked string would be stored as 0 — a
+            // vehicle reporting zero miles rather than an error.
+            'odometer'             => 'nullable|numeric|min:0',
+            'odometer_unit'        => 'nullable|string|max:12',
+            'odometer_at_purchase' => 'nullable|numeric|min:0',
+            'measurement_system'   => 'nullable|string|max:32',
+            'fuel_type'            => 'nullable|string|max:64',
+            'fuel_volume_unit'     => 'nullable|string|max:12',
+            'online'               => 'nullable|boolean',
+
+            // Body, capacity and dimensions
+            'transmission'      => 'nullable|string|max:64',
+            'body_type'         => 'nullable|string|max:191',
+            'body_sub_type'     => 'nullable|string|max:191',
+            'usage_type'        => 'nullable|string|max:64',
+            'ownership_type'    => 'nullable|string|max:64',
+            'cargo_volume'      => 'nullable|numeric|min:0',
+            'passenger_volume'  => 'nullable|numeric|min:0',
+            'interior_volume'   => 'nullable|numeric|min:0',
+            'weight'            => 'nullable|numeric|min:0',
+            'width'             => 'nullable|numeric|min:0',
+            'length'            => 'nullable|numeric|min:0',
+            'height'            => 'nullable|numeric|min:0',
+            'towing_capacity'   => 'nullable|numeric|min:0',
+            'payload_capacity'  => 'nullable|numeric|min:0',
+            'seating_capacity'  => 'nullable|integer|min:0',
+            'ground_clearance'  => 'nullable|numeric|min:0',
+            'bed_length'        => 'nullable|numeric|min:0',
+            'fuel_capacity'     => 'nullable|numeric|min:0',
+
+            // Lifecycle and financing
+            'financing_status'                     => 'nullable|string|max:64',
+            'loan_number_of_payments'              => 'nullable|integer|min:0',
+            'loan_first_payment'                   => 'nullable|date',
+            'loan_amount'                          => 'nullable|numeric|min:0',
+            'estimated_service_life_distance_unit' => 'nullable|string|max:12',
+            'estimated_service_life_distance'      => 'nullable|integer|min:0',
+            'estimated_service_life_months'        => 'nullable|integer|min:0',
+            'insurance_value'                      => 'nullable|numeric|min:0',
+            'depreciation_rate'                    => 'nullable|numeric',
+            'current_value'                        => 'nullable|numeric|min:0',
+            'acquisition_cost'                     => 'nullable|numeric|min:0',
+            'currency'                             => 'nullable|string|size:3',
+            'purchased_at'                         => 'nullable|date',
+            'lease_expires_at'                     => 'nullable|date',
+
+            // Regulatory and engine specifications
+            'emission_standard'    => 'nullable|string|max:64',
+            'dpf_equipped'         => 'nullable|boolean',
+            'scr_equipped'         => 'nullable|boolean',
+            'gvwr'                 => 'nullable|numeric|min:0',
+            'gcwr'                 => 'nullable|numeric|min:0',
+            'engine_number'        => 'nullable|string|max:191',
+            'engine_model'         => 'nullable|string|max:191',
+            'engine_make'          => 'nullable|string|max:191',
+            'engine_family'        => 'nullable|string|max:191',
+            'engine_configuration' => 'nullable|string|max:191',
+            'engine_displacement'  => 'nullable|numeric|min:0',
+            'engine_size'          => 'nullable|numeric|min:0',
+            'horsepower'           => 'nullable|numeric|min:0',
+            'horsepower_rpm'       => 'nullable|integer|min:0',
+            'torque'               => 'nullable|numeric|min:0',
+            'torque_rpm'           => 'nullable|integer|min:0',
+            'number_of_cylinders'  => 'nullable|integer|min:0',
+            'cylinder_arrangement' => 'nullable|string|max:64',
+
+            // Structured and descriptive fields
+            'specs'   => 'nullable|array',
+            'details' => 'nullable|array',
+            'notes'   => 'nullable|string',
+            'meta'    => 'nullable|array',
+
+            // Orchestrator
+            'skills'                   => 'nullable|array',
+            'skills.*'                 => 'string',
+            'payload_capacity_volume'  => 'nullable|numeric|min:0',
+            'payload_capacity_pallets' => 'nullable|integer|min:0',
+            'payload_capacity_parcels' => 'nullable|integer|min:0',
+            'max_tasks'                => 'nullable|integer|min:0',
+            'time_window_start'        => 'nullable|date_format:H:i,H:i:s',
+            'time_window_end'          => 'nullable|date_format:H:i,H:i:s',
+            'return_to_depot'          => 'nullable|boolean',
+
+            // Relationships, resolved from public ids inside the caller's company
+            'vendor'   => $this->publicRelationRules('vendors'),
+            'driver'   => $this->publicRelationRules('drivers'),
+            'category' => $this->publicRelationRules('categories'),
+            'warranty' => $this->publicRelationRules('warranties'),
+            'photo'    => 'nullable|string',
+
+            // Location
             'location'  => ['nullable', new ResolvablePoint()],
             'latitude'  => ['nullable', 'required_with:longitude'],
             'longitude' => ['nullable', 'required_with:latitude'],
+            'altitude'  => 'nullable|numeric',
+            'heading'   => 'nullable|numeric',
+            'speed'     => 'nullable|numeric',
         ];
     }
 }

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/Manifest.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\Support\Http;
+
+/**
+ * Public projection of a Manifest — a driver's route for a day.
+ *
+ * A manifest is order-agnostic: it is a sequence of stops, which may belong to
+ * several orders or to none the driver has ever seen as an order. That is why
+ * this exposes the stops directly rather than making a consumer assemble them
+ * from orders.
+ *
+ * Totals ride along because a driver wants to know what the day looks like
+ * before starting it, and computing them client-side from the stop list gives a
+ * different answer than the server's own.
+ */
+class Manifest extends FleetbaseResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     */
+    public function toArray($request): array
+    {
+        return [
+            'id'               => $this->when(Http::isInternalRequest(), $this->id, $this->public_id),
+            'uuid'             => $this->when(Http::isInternalRequest(), $this->uuid),
+            'public_id'        => $this->when(Http::isInternalRequest(), $this->public_id),
+            'status'           => $this->status,
+            'scheduled_date'   => $this->scheduled_date,
+            'started_at'       => $this->started_at,
+            'completed_at'     => $this->completed_at,
+            'total_distance_m' => $this->total_distance_m,
+            'total_duration_s' => $this->total_duration_s,
+            'stop_count'       => $this->stop_count,
+            'completed_stops'  => $this->completed_stops,
+            'pending_stops'    => $this->pending_stops,
+            'driver_name'      => $this->driver_name,
+            'vehicle_name'     => $this->vehicle_name,
+            'notes'            => $this->notes,
+            // Present only when the manifest was loaded with them, so a list
+            // endpoint stays a list.
+            'stops'            => ManifestStop::collection($this->whenLoaded('stops')),
+            'updated_at'       => $this->updated_at,
+            'created_at'       => $this->created_at,
+        ];
+    }
+}

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

@@ -0,0 +1,47 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\Support\Http;
+
+/**
+ * Public projection of a ManifestStop.
+ *
+ * Carries the place inline rather than as an id. A driver app rendering a route
+ * needs a name and a coordinate for every stop, and making it resolve each one
+ * separately turns a route of twenty stops into twenty-one requests.
+ *
+ * `sequence` is the order to drive them in, and is the field a re-sequence
+ * rewrites.
+ */
+class ManifestStop extends FleetbaseResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     */
+    public function toArray($request): array
+    {
+        return [
+            'id'                   => $this->when(Http::isInternalRequest(), $this->id, $this->public_id),
+            'uuid'                 => $this->when(Http::isInternalRequest(), $this->uuid),
+            'public_id'            => $this->when(Http::isInternalRequest(), $this->public_id),
+            'status'               => $this->status,
+            'sequence'             => $this->sequence,
+            'estimated_arrival'    => $this->estimated_arrival,
+            'actual_arrival'       => $this->actual_arrival,
+            'distance_from_prev_m' => $this->distance_from_prev_m,
+            'duration_from_prev_s' => $this->duration_from_prev_s,
+            'place'                => new Place($this->whenLoaded('place')),
+            'order'                => $this->when($this->relationLoaded('order') && $this->order, fn () => [
+                'id'              => data_get($this->order, 'public_id'),
+                'tracking_number' => data_get($this->order, 'trackingNumber.tracking_number'),
+                'status'          => data_get($this->order, 'status'),
+            ]),
+            'updated_at'           => $this->updated_at,
+            'created_at'           => $this->created_at,
+        ];
+    }
+}