@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/tests/Unit/Http/Requests/CreateFuelReportRequestTest.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Illuminate\Foundation\Http {
+    if (!class_exists(FormRequest::class)) {
+        class FormRequest extends \Illuminate\Http\Request
+        {
+        }
+    }
+}
+
+namespace {
+    use Fleetbase\FleetOps\Http\Requests\CreateFuelReportRequest;
+    use Fleetbase\FleetOps\Http\Requests\UpdateFuelReportRequest;
+
+    class FleetOpsCreateFuelReportSessionStore
+    {
+        public function __construct(private array $values)
+        {
+        }
+
+        public function has(string $key): bool
+        {
+            return array_key_exists($key, $this->values);
+        }
+    }
+
+    class FleetOpsCreateFuelReportRequestState
+    {
+        public static ?FleetOpsCreateFuelReportSessionStore $session = null;
+    }
+
+    if (!function_exists('Fleetbase\FleetOps\Http\Requests\request')) {
+        eval('namespace Fleetbase\FleetOps\Http\Requests; function request($key = null, $default = null) { return new class { public function session(): \FleetOpsCreateFuelReportSessionStore { return \FleetOpsCreateFuelReportRequestState::$session ?? new \FleetOpsCreateFuelReportSessionStore([]); } }; }');
+    }
+
+    function fleetopsCreateFuelReportRequestWithSession(array $sessionData): CreateFuelReportRequest
+    {
+        FleetOpsCreateFuelReportRequestState::$session = new FleetOpsCreateFuelReportSessionStore($sessionData);
+
+        return CreateFuelReportRequest::create('/fleet-ops/fuel-reports', 'POST');
+    }
+
+    test('fuel report create only fields are required on POST and optional on update', function () {
+        FleetOpsCreateFuelReportRequestState::$session = new FleetOpsCreateFuelReportSessionStore(['api_credential' => 'api-credential-uuid']);
+
+        // UpdateFuelReportRequest extends this class, so a flat `required` made every
+        // partial update fail — PUT with just {"status": "approved"} answered "The driver
+        // field is required." `driver` is the plainest case: the update action's
+        // $request->only() list does not include it, so the field was demanded and then
+        // discarded.
+        $create = CreateFuelReportRequest::create('/fleet-ops/fuel-reports', 'POST')->rules();
+        $update = UpdateFuelReportRequest::create('/fleet-ops/fuel-reports/report_1', 'PUT')->rules();
+
+        foreach (['driver', 'odometer', 'volume'] as $field) {
+            expect($create[$field])->toBe(['required'])
+                ->and($update[$field])->toBe(['sometimes']);
+        }
+
+        expect($create['metric_unit'])->toBe(['nullable'])
+            ->and($create['amount'])->toBe(['nullable']);
+    });
+
+    test('create fuel report authorization accepts api credentials or sanctum sessions', function () {
+        expect(fleetopsCreateFuelReportRequestWithSession([])->authorize())->toBeFalse()
+            ->and(fleetopsCreateFuelReportRequestWithSession(['api_credential' => 'api-credential-uuid'])->authorize())->toBeTrue()
+            ->and(fleetopsCreateFuelReportRequestWithSession(['is_sanctum_token' => true])->authorize())->toBeTrue();
+    });
+}

package/server/tests/Unit/Http/Requests/FleetActionRequestTest.php

@@ -0,0 +1,80 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Requests\Internal\FleetActionRequest;
+
+class FleetOpsFleetActionRequestProbe extends FleetActionRequest
+{
+    public string $action     = 'update';
+    public array $permissions = [];
+    public array $checks      = [];
+
+    protected function actionMethod(): string
+    {
+        return $this->action;
+    }
+
+    protected function can(string $permission): bool
+    {
+        $this->checks[] = $permission;
+
+        return $this->permissions[$permission] ?? false;
+    }
+}
+
+test('fleet action request maps controller actions to fleet permissions', function (string $action, string $permission) {
+    $request              = new FleetOpsFleetActionRequestProbe();
+    $request->action      = $action;
+    $request->permissions = [$permission => true];
+
+    expect($request->authorize())->toBeTrue()
+        ->and($request->checks)->toBe([$permission]);
+})->with([
+    'assign vehicle'  => ['assignVehicle', 'fleet-ops assign-vehicle-for fleet'],
+    'assign driver'   => ['assignDriver', 'fleet-ops assign-driver-for fleet'],
+    'remove vehicle'  => ['removeVehicle', 'fleet-ops remove-vehicle-for fleet'],
+    'remove driver'   => ['removeDriver', 'fleet-ops remove-driver-for fleet'],
+    'fallback update' => ['updateRecord', 'fleet-ops update fleet'],
+]);
+
+test('fleet action request denies actions when mapped permissions are unavailable', function (string $action, string $permission) {
+    $request         = new FleetOpsFleetActionRequestProbe();
+    $request->action = $action;
+
+    expect($request->authorize())->toBeFalse()
+        ->and($request->checks)->toBe([$permission]);
+})->with([
+    'assign vehicle denied'  => ['assignVehicle', 'fleet-ops assign-vehicle-for fleet'],
+    'assign driver denied'   => ['assignDriver', 'fleet-ops assign-driver-for fleet'],
+    'remove vehicle denied'  => ['removeVehicle', 'fleet-ops remove-vehicle-for fleet'],
+    'remove driver denied'   => ['removeDriver', 'fleet-ops remove-driver-for fleet'],
+    'fallback update denied' => ['archiveRecord', 'fleet-ops update fleet'],
+]);
+
+test('fleet action request exposes assignment validation rules', function () {
+    expect((new FleetActionRequest())->rules())->toBe([
+        'fleet'   => 'string|exists:fleets,uuid',
+        'driver'  => 'nullable|string|exists:drivers,uuid',
+        'vehicle' => 'nullable|string|exists:vehicles,uuid',
+    ]);
+});
+
+test('the real action method seam reads the resolved route action', function () {
+    // The probe above overrides actionMethod(); this exercises the real body
+    $request = FleetActionRequest::create('/int/v1/fleets/assign-vehicle', 'POST');
+    $request->setRouteResolver(fn () => new class {
+        public function getActionMethod()
+        {
+            return 'assignVehicle';
+        }
+
+        public function getAction($key = null)
+        {
+            return $key === null ? ['controller' => 'FleetController@assignVehicle'] : 'FleetController@assignVehicle';
+        }
+    });
+
+    $reflection = new ReflectionMethod(FleetActionRequest::class, 'actionMethod');
+    $reflection->setAccessible(true);
+
+    expect($reflection->invoke($request))->toBe('assignVehicle');
+});

package/server/tests/Unit/Http/Requests/RequestAuthorizationTest.php

@@ -0,0 +1,50 @@
+<?php
+
+use Illuminate\Http\Request;
+
+/**
+ * Covers the authorize() gate shared by the public API form requests: every
+ * one admits a request carrying an api credential, and the sanctum-aware
+ * variants also admit a sanctum token session.
+ */
+function fleetopsRequestWithSession(array $sessionKeys): Request
+{
+    $request = Request::create('/v1/resource', 'POST');
+    $store   = app('session.store');
+
+    foreach (['api_credential', 'is_sanctum_token'] as $key) {
+        $store->forget($key);
+    }
+    foreach ($sessionKeys as $key => $value) {
+        $store->put($key, $value);
+    }
+
+    $request->setLaravelSession($store);
+    app()->instance('request', $request);
+
+    return $request;
+}
+
+test('api form requests authorize credentialed sessions', function (string $requestClass, bool $acceptsSanctum) {
+    // An api credential always authorizes
+    fleetopsRequestWithSession(['api_credential' => 'credential-uuid']);
+    expect((new $requestClass())->authorize())->toBeTrue();
+
+    // A bare session never does
+    fleetopsRequestWithSession([]);
+    expect((new $requestClass())->authorize())->toBeFalse();
+
+    // Sanctum token sessions are accepted only by the sanctum-aware requests
+    fleetopsRequestWithSession(['is_sanctum_token' => true]);
+    expect((new $requestClass())->authorize())->toBe($acceptsSanctum);
+})->with([
+    'device'            => [Fleetbase\FleetOps\Http\Requests\CreateDeviceRequest::class, true],
+    'fuel transaction'  => [Fleetbase\FleetOps\Http\Requests\CreateFuelTransactionRequest::class, true],
+    'place'             => [Fleetbase\FleetOps\Http\Requests\CreatePlaceRequest::class, true],
+    'sensor'            => [Fleetbase\FleetOps\Http\Requests\CreateSensorRequest::class, true],
+    'vehicle'           => [Fleetbase\FleetOps\Http\Requests\CreateVehicleRequest::class, true],
+    'work order'        => [Fleetbase\FleetOps\Http\Requests\CreateWorkOrderRequest::class, true],
+    'order'             => [Fleetbase\FleetOps\Http\Requests\CreateOrderRequest::class, false],
+    'service rate'      => [Fleetbase\FleetOps\Http\Requests\CreateServiceRateRequest::class, false],
+    'driver simulation' => [Fleetbase\FleetOps\Http\Requests\DriverSimulationRequest::class, false],
+]);

package/server/tests/Unit/Http/Resources/CustomerResourceTest.php

@@ -0,0 +1,108 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\Customer as CustomerResource;
+use Fleetbase\FleetOps\Models\Customer;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the public Customer API resource: full array serialization with the
+ * customer_-prefixed public id, the orders count subquery, and the company
+ * payload projection with currency resolution and missing-company fallback.
+ */
+function fleetopsCustomerResourceBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'contacts'  => ['uuid', 'public_id', 'internal_id', 'company_uuid', 'user_uuid', 'place_uuid', 'photo_uuid', 'name', 'title', 'email', 'phone', 'type', 'slug', 'meta'],
+        'orders'    => ['uuid', 'public_id', 'company_uuid', 'customer_uuid', 'customer_type', 'status'],
+        'companies' => ['uuid', 'public_id', 'name', 'currency', 'country', 'phone'],
+        'places'    => ['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'name', 'street1', 'city', 'country', 'location'],
+        'settings'  => ['key', 'value'],
+    ];
+    foreach ($tables as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    session(['company' => 'company-1']);
+
+    return $connection;
+}
+
+function fleetopsCustomerResourceCustomer(array $attributes = []): Customer
+{
+    $customer = new Customer();
+    $customer->setRawAttributes(array_merge([
+        'uuid'         => 'contact-1',
+        'public_id'    => 'contact_abc',
+        'company_uuid' => 'company-1',
+        'name'         => 'Customer A',
+        'email'        => 'customer@example.test',
+        'type'         => 'customer',
+    ], $attributes), true);
+    $customer->exists = true;
+
+    return $customer;
+}
+
+test('customer resource serializes public payload with orders count', function () {
+    $connection = fleetopsCustomerResourceBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'public_id' => 'company_test', 'name' => 'Acme', 'currency' => 'sgd', 'country' => 'SG', 'phone' => '+65 1234']);
+    $connection->table('orders')->insert([
+        ['uuid' => 'order-1', 'customer_uuid' => 'contact-1', 'company_uuid' => 'company-1', 'status' => 'created'],
+        ['uuid' => 'order-2', 'customer_uuid' => 'contact-1', 'company_uuid' => 'company-1', 'status' => 'completed'],
+        ['uuid' => 'order-3', 'customer_uuid' => 'contact-other', 'company_uuid' => 'company-1', 'status' => 'created'],
+    ]);
+
+    $payload = (new CustomerResource(fleetopsCustomerResourceCustomer()))->toArray(new Request());
+
+    expect($payload['id'])->toBe('customer_abc')
+        ->and($payload['name'])->toBe('Customer A')
+        ->and($payload['orders_count'])->toBe(2)
+        ->and($payload['company']['id'])->toBe('company_test')
+        ->and($payload['company']['currency'])->toBe('SGD')
+        ->and($payload['company']['country'])->toBe('SG');
+});
+
+test('customer resource omits company payload when company is missing', function () {
+    fleetopsCustomerResourceBoot();
+
+    $payload = (new CustomerResource(fleetopsCustomerResourceCustomer([
+        'uuid'         => 'contact-2',
+        'public_id'    => 'contact_def',
+        'company_uuid' => 'company-missing',
+    ])))->toArray(new Request());
+
+    expect($payload['company'])->toBeNull()
+        ->and($payload['orders_count'])->toBe(0);
+});

package/server/tests/Unit/Http/Resources/EntityCustomerTypeTest.php

@@ -0,0 +1,35 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\Entity as EntityResource;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Entity;
+
+/**
+ * Covers Entity::setCustomerType(), which stamps the ember-facing customer type
+ * onto an already-resolved customer payload. An empty payload is passed straight
+ * back, since there is nothing to annotate.
+ */
+test('entity customer payloads are stamped with the ember resource type', function () {
+    $entity = new Entity();
+    $entity->setRawAttributes([
+        'uuid'          => 'entity-customer-type-1',
+        'public_id'     => 'entity_customertype1',
+        'customer_uuid' => 'contact-customer-type-1',
+        'customer_type' => Contact::class,
+    ], true);
+
+    $resource = new EntityResource($entity);
+
+    // A resolved customer payload gains the generic type plus the short
+    // ember-style class name derived from customer_type
+    $stamped = $resource->setCustomerType(['id' => 'contact_customertype1', 'name' => 'Stamped Customer']);
+
+    expect($stamped['type'])->toBe('customer')
+        ->and($stamped['name'])->toBe('Stamped Customer')
+        ->and($stamped['customer_type'])->not->toBeNull()
+        ->and($stamped['customer_type'])->not->toBe(Contact::class);
+
+    // Nothing resolved means nothing to stamp, and the input is returned as-is
+    expect($resource->setCustomerType([]))->toBe([])
+        ->and($resource->setCustomerType(null))->toBeNull();
+});

package/server/tests/Unit/Http/Resources/FleetResourceTest.php

@@ -0,0 +1,102 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\Fleet as FleetResource;
+use Fleetbase\FleetOps\Models\Fleet;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the Fleet resource relation preloading: requested with-relations
+ * are camelized and loaded, and subfleet driver/vehicle collections are
+ * eagerly attached when both are requested.
+ */
+if (!Request::hasMacro('isArray')) {
+    Request::macro('isArray', fn (string $key) => is_array($this->input($key)));
+}
+
+if (!Request::hasMacro('array')) {
+    Request::macro('array', fn (string $key, $default = []) => (array) $this->input($key, $default));
+}
+
+function fleetopsFleetResourceBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'fleets'              => ['uuid', 'public_id', 'company_uuid', 'parent_fleet_uuid', 'service_area_uuid', 'zone_uuid', 'name', 'task', 'status', 'meta', '_key'],
+        'fleet_drivers'       => ['uuid', 'fleet_uuid', 'driver_uuid', '_key'],
+        'fleet_vehicles'      => ['uuid', 'fleet_uuid', 'vehicle_uuid', '_key'],
+        'drivers'             => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'status', '_key'],
+        'vehicles'            => ['uuid', 'public_id', 'company_uuid', 'name', 'status', '_key'],
+        'users'               => ['uuid', 'public_id', 'company_uuid', 'name', '_key'],
+        'custom_fields'       => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'name', 'label', '_key'],
+        'custom_field_values' => ['uuid', 'public_id', 'company_uuid', 'custom_field_uuid', 'subject_uuid', 'subject_type', 'value', 'value_type', '_key'],
+    ];
+    foreach ($tables as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    session(['company' => 'company-1']);
+    app()->instance('request', Request::create('/v1/fleets', 'GET'));
+
+    $connection->table('fleets')->insert([
+        ['uuid' => 'fleet-parent-1', 'public_id' => 'fleet_parentone', 'company_uuid' => 'company-1', 'parent_fleet_uuid' => null, 'name' => 'Parent Fleet'],
+        ['uuid' => 'fleet-sub-1', 'public_id' => 'fleet_subone1', 'company_uuid' => 'company-1', 'parent_fleet_uuid' => 'fleet-parent-1', 'name' => 'Sub Fleet'],
+    ]);
+    $connection->table('users')->insert(['uuid' => 'user-fleet-1', 'company_uuid' => 'company-1', 'name' => 'Fleet Driver']);
+    $connection->table('drivers')->insert(['uuid' => 'driver-fleet-1', 'public_id' => 'driver_fleetone', 'company_uuid' => 'company-1', 'user_uuid' => 'user-fleet-1']);
+    $connection->table('vehicles')->insert(['uuid' => 'vehicle-fleet-1', 'public_id' => 'vehicle_fleetone', 'company_uuid' => 'company-1', 'name' => 'Fleet Truck']);
+    $connection->table('fleet_drivers')->insert(['uuid' => 'fd-1', 'fleet_uuid' => 'fleet-sub-1', 'driver_uuid' => 'driver-fleet-1']);
+    $connection->table('fleet_vehicles')->insert(['uuid' => 'fv-1', 'fleet_uuid' => 'fleet-sub-1', 'vehicle_uuid' => 'vehicle-fleet-1']);
+
+    return $connection;
+}
+
+test('fleet resource preloads requested subfleet driver and vehicle relations', function () {
+    fleetopsFleetResourceBoot();
+
+    $fleet   = Fleet::where('uuid', 'fleet-parent-1')->first();
+    $request = Request::create('/v1/fleets/fleet_parentone', 'GET', ['with' => ['subfleets', 'drivers', 'vehicles']]);
+
+    $resolved = (new FleetResource($fleet))->resolve($request);
+
+    expect($resolved['name'])->toBe('Parent Fleet')
+        ->and($fleet->relationLoaded('subfleets'))->toBeTrue()
+        ->and($fleet->relationLoaded('subFleets'))->toBeTrue();
+
+    $subFleet = $fleet->getRelation('subFleets')->first();
+    expect($subFleet)->not->toBeNull()
+        ->and($subFleet->relationLoaded('drivers'))->toBeTrue()
+        ->and($subFleet->relationLoaded('vehicles'))->toBeTrue()
+        ->and($subFleet->drivers)->toHaveCount(1)
+        ->and($subFleet->vehicles)->toHaveCount(1);
+});

package/server/tests/Unit/Http/Resources/IndexOrderResourceTest.php

@@ -0,0 +1,210 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\Index\Order as IndexOrderResource;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Payload;
+use Fleetbase\FleetOps\Models\TrackingNumber;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Vendor;
+use Illuminate\Http\Request;
+
+/**
+ * Covers the lightweight index Order resource relation closures: loaded
+ * customers and facilitators resolving into typed lightweight payloads,
+ * and payload/driver/vehicle/tracking-number pass-through resources.
+ */
+function fleetopsIndexOrderResourceOrder(): Order
+{
+    $order = new Order();
+    $order->setRawAttributes([
+        'uuid'                  => 'order-index-1',
+        'public_id'             => 'order_indexone1',
+        'company_uuid'          => 'company-1',
+        'customer_uuid'         => 'contact-1',
+        'customer_type'         => Contact::class,
+        'facilitator_uuid'      => 'vendor-1',
+        'facilitator_type'      => Vendor::class,
+        'driver_assigned_uuid'  => 'driver-1',
+        'vehicle_assigned_uuid' => 'vehicle-1',
+        'tracking_number_uuid'  => 'tn-1',
+        'status'                => 'created',
+        'type'                  => 'transport',
+    ], true);
+
+    $customer = new Contact();
+    $customer->setRawAttributes(['uuid' => 'contact-1', 'public_id' => 'contact_indexone', 'name' => 'Index Customer', 'type' => 'customer'], true);
+    $facilitator = new Vendor();
+    $facilitator->setRawAttributes(['uuid' => 'vendor-1', 'public_id' => 'vendor_indexone', 'name' => 'Index Facilitator'], true);
+    $payload = new Payload();
+    $payload->setRawAttributes(['uuid' => 'payload-1', 'public_id' => 'payload_indexone'], true);
+    $driver = new Driver();
+    $driver->setRawAttributes(['uuid' => 'driver-1', 'public_id' => 'driver_indexone'], true);
+    $vehicle = new Vehicle();
+    $vehicle->setRawAttributes(['uuid' => 'vehicle-1', 'public_id' => 'vehicle_indexone'], true);
+    $trackingNumber = new TrackingNumber();
+    $trackingNumber->setRawAttributes(['uuid' => 'tn-1', 'public_id' => 'tracking_number_indexone', 'tracking_number' => 'FLB-INDEX-1'], true);
+
+    $order->setRelation('customer', $customer);
+    $order->setRelation('facilitator', $facilitator);
+    $order->setRelation('payload', $payload);
+    $order->setRelation('driverAssigned', $driver);
+    $order->setRelation('vehicleAssigned', $vehicle);
+    $order->setRelation('trackingNumber', $trackingNumber);
+    $order->setRelation('trackingStatuses', collect([]));
+
+    return $order;
+}
+
+test('index order resource resolves loaded relations into lightweight payloads', function () {
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    app()->instance('request', Request::create('/v1/orders', 'GET'));
+    session(['company' => 'company-1']);
+
+    $order    = fleetopsIndexOrderResourceOrder();
+    $resource = new IndexOrderResource($order);
+    $resolved = $resource->resolve(Request::create('/v1/orders', 'GET'));
+
+    expect($resolved['tracking'])->toBe('FLB-INDEX-1')
+        ->and($resolved['customer']['type'])->toBe('customer')
+        ->and($resolved['customer']['customer_type'])->toContain('customer-')
+        ->and($resolved['facilitator']['type'])->toBe('facilitator')
+        ->and($resolved['facilitator']['facilitator_type'])->toContain('facilitator-')
+        ->and($resolved['payload'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Index\Payload::class)
+        ->and($resolved['driver_assigned'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Index\Driver::class)
+        ->and($resolved['vehicle_assigned'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Index\Vehicle::class)
+        ->and($resolved['tracking_number'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Index\TrackingNumber::class)
+        ->and($resolved['latest_status'])->toBe('created')
+        ->and($resolved['latest_status_code'])->toBeNull()
+        ->and($resolved['meta'])->toBe(['_index_resource' => true]);
+});
+
+/**
+ * The index Payload resource only emits pickup/dropoff when the payload can
+ * actually produce a place. Both accessors short-circuit on a directly related
+ * Place and otherwise fall back to the first/last waypoint marker — this covers
+ * the short-circuit, which is the arm the index listing hits in practice.
+ */
+test('index payload resource emits lightweight pickup and dropoff places', function () {
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    app()->instance('request', Request::create('/v1/orders', 'GET'));
+
+    // whenLoaded's default argument is evaluated eagerly, so the count queries
+    // run even though both relations are loaded.
+    $schema = $connection->getSchemaBuilder();
+    foreach (['entities', 'waypoints', 'places'] as $table) {
+        $schema->create($table, function ($blueprint) {
+            $blueprint->increments('id');
+            $blueprint->string('uuid')->nullable();
+            $blueprint->string('payload_uuid')->nullable();
+            $blueprint->string('place_uuid')->nullable();
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    $pickup = new Fleetbase\FleetOps\Models\Place();
+    $pickup->setRawAttributes([
+        'uuid'      => 'place-pickup-1',
+        'public_id' => 'place_indexpickup',
+        'name'      => 'Index Pickup',
+        'address'   => '1 Pickup Way',
+        'street1'   => '1 Pickup Way',
+        'city'      => 'Singapore',
+        'country'   => 'SG',
+    ], true);
+
+    $dropoff = new Fleetbase\FleetOps\Models\Place();
+    $dropoff->setRawAttributes([
+        'uuid'      => 'place-dropoff-1',
+        'public_id' => 'place_indexdropoff',
+        'name'      => 'Index Dropoff',
+        'address'   => '2 Dropoff Way',
+        'street1'   => '2 Dropoff Way',
+        'city'      => 'Singapore',
+        'country'   => 'SG',
+    ], true);
+
+    $payload = new Payload();
+    $payload->setRawAttributes(['uuid' => 'payload-index-1', 'public_id' => 'payload_indexone'], true);
+    $payload->setRelation('pickup', $pickup);
+    $payload->setRelation('dropoff', $dropoff);
+    $payload->setRelation('entities', collect([]));
+    $payload->setRelation('waypoints', collect([]));
+
+    $resolved = (new Fleetbase\FleetOps\Http\Resources\v1\Index\Payload($payload))->resolve(Request::create('/v1/orders', 'GET'));
+
+    expect($resolved['pickup'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Index\Place::class)
+        ->and($resolved['dropoff'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Index\Place::class)
+        ->and($resolved['entities_count'])->toBe(0)
+        ->and($resolved['waypoints_count'])->toBe(0);
+});
+
+test('v1 order resource resolves loaded relation closures and generic morphs', function () {
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    $schema = $connection->getSchemaBuilder();
+    $tables = [
+        'places'              => ['uuid', 'public_id', 'company_uuid', 'owner_uuid', 'owner_type', 'name', 'location', '_key'],
+        'users'               => ['uuid', 'public_id', 'company_uuid', 'name', 'type', '_key'],
+        'custom_fields'       => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'name', 'label', '_key'],
+        'custom_field_values' => ['uuid', 'public_id', 'company_uuid', 'custom_field_uuid', 'subject_uuid', 'subject_type', 'value', 'value_type', '_key'],
+        'vehicles'            => ['uuid', 'public_id', 'company_uuid', 'driver_uuid', 'name', '_key'],
+        'drivers'             => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'vehicle_uuid', 'current_job_uuid', 'status', '_key'],
+        'orders'              => ['uuid', 'public_id', 'company_uuid', 'driver_assigned_uuid', 'status', '_key'],
+        'contacts'            => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'name', 'type', '_key'],
+        'vendor_personnels'   => ['uuid', 'vendor_uuid', 'contact_uuid', '_key'],
+        'tracking_statuses'   => ['uuid', 'public_id', 'company_uuid', 'tracking_number_uuid', 'code', 'status', '_key'],
+        'comments'            => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'parent_comment_uuid', 'author_uuid', 'content', '_key'],
+        'proofs'              => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'order_uuid', 'file_uuid', '_key'],
+        'purchase_rates'      => ['uuid', 'public_id', 'company_uuid', 'service_quote_uuid', 'order_uuid', 'status', '_key'],
+        'companies'           => ['uuid', 'public_id', 'name', 'country', 'options'],
+        'company_users'       => ['uuid', 'company_uuid', 'user_uuid', 'status', '_key'],
+        'settings'            => ['uuid', 'key', 'value', '_key'],
+        'files'               => ['uuid', 'public_id', 'company_uuid', 'subject_uuid', 'subject_type', 'name', 'path', '_key'],
+        'payloads'            => ['uuid', 'public_id', 'company_uuid', 'pickup_uuid', 'dropoff_uuid', 'meta', '_key'],
+        'waypoints'           => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'place_uuid', 'order', 'type', '_key'],
+        'entities'            => ['uuid', 'public_id', 'company_uuid', 'payload_uuid', 'name', 'type', '_key'],
+        'tracking_numbers'    => ['uuid', 'public_id', 'company_uuid', 'tracking_number', 'barcode', 'qr_code', '_key'],
+    ];
+    foreach ($tables as $table => $columns) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+    app()->instance('request', Request::create('/v1/orders', 'GET'));
+    session(['company' => 'company-1']);
+
+    $order = fleetopsIndexOrderResourceOrder();
+
+    $resource = new Fleetbase\FleetOps\Http\Resources\v1\Order($order);
+    $resolved = $resource->resolve(Request::create('/v1/orders', 'GET'));
+
+    expect($resolved['customer'])->not->toBeNull()
+        ->and($resolved['facilitator'])->not->toBeNull()
+        ->and($resolved['driver_assigned'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Driver::class)
+        ->and($resolved['vehicle_assigned'])->toBeInstanceOf(Fleetbase\FleetOps\Http\Resources\v1\Vehicle::class)
+        ->and($resolved['tracking_statuses'])->not->toBeNull();
+
+    // Morphs without dedicated resources resolve through the generic wrapper
+    $company = new Fleetbase\Models\Company();
+    $company->setRawAttributes(['uuid' => 'company-morph-1', 'name' => 'Morph Co'], true);
+    $reflection = new ReflectionMethod(Fleetbase\FleetOps\Http\Resources\v1\Order::class, 'transformMorphResource');
+    $reflection->setAccessible(true);
+    $generic = $reflection->invoke($resource, $company);
+    expect($generic)->toBeArray()->toHaveKey('name');
+});