@fleetbase/fleetops-engine 0.6.70 → 0.6.72

package/server/tests/PublicOrderTrackingResourceTest.php

@@ -0,0 +1,221 @@
+<?php
+
+use Fleetbase\FleetOps\Http\Resources\v1\PublicOrderTracking;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+
+/**
+ * An order as the lookup loads it: tracking number, timeline, payload and
+ * tracker data, plus every field the public page must never see.
+ */
+function fleetopsPublicTrackingOrder(array $attributes = [], array $tracker = []): Order
+{
+    $order = new Order();
+    $order->setRawAttributes(array_merge([
+        'uuid'                 => 'order-internal-uuid',
+        'public_id'            => 'order_public',
+        'internal_id'          => 'INT-0042',
+        'company_uuid'         => 'company-uuid',
+        'customer_uuid'        => 'customer-uuid',
+        'facilitator_uuid'     => 'facilitator-uuid',
+        'driver_assigned_uuid' => 'driver-uuid',
+        'purchase_rate_uuid'   => 'rate-uuid',
+        'notes'                => 'Gate code 1234',
+        'meta'                 => '{"secret":"value"}',
+        'status'               => 'started',
+        'started'              => true,
+        'created_at'           => Carbon::parse('2026-10-01 09:00:00'),
+    ], $attributes), true);
+
+    $order->setRelation('trackingNumber', (object) [
+        'uuid'            => 'tracking-internal-uuid',
+        'public_id'       => 'track_public',
+        'tracking_number' => 'FLB1234567890SG',
+        'qr_code'         => 'qr-data',
+        'barcode'         => 'barcode-data',
+    ]);
+    $order->setRelation('trackingStatuses', collect([
+        (object) [
+            'uuid'       => 'status-internal-uuid',
+            'public_id'  => 'status_public',
+            'status'     => 'Order Created',
+            'details'    => 'New order created.',
+            'code'       => 'created',
+            'location'   => new Point(1.3, 103.8),
+            'created_at' => Carbon::parse('2026-10-01 09:00:00'),
+        ],
+    ]));
+    $order->setRelation('payload', (object) [
+        'uuid'      => 'payload-internal-uuid',
+        'public_id' => 'payload_public',
+        'meta'      => ['secret' => 'value'],
+        'cod_amount' => '100',
+        'pickup'    => (object) [
+            'uuid'      => 'pickup-internal-uuid',
+            'public_id' => 'place_pickup',
+            'name'      => 'Sender House',
+            'street1'   => '1 Sender Road',
+            'phone'     => '+6500000000',
+            'location'  => new Point(1.30, 103.80),
+        ],
+        'dropoff'   => (object) [
+            'uuid'      => 'dropoff-internal-uuid',
+            'public_id' => 'place_dropoff',
+            'name'      => 'Recipient House',
+            'street1'   => '2 Recipient Road',
+            'location'  => new Point(1.35, 103.85),
+        ],
+        'waypoints' => [],
+        'entities'  => collect([
+            (object) [
+                'uuid'          => 'entity-internal-uuid',
+                'public_id'     => 'entity_public',
+                'internal_id'   => 'ENT-INT',
+                'customer_uuid' => 'customer-uuid',
+                'name'          => 'Parcel',
+                'description'   => 'A box',
+                'tracking'      => 'FLB9999999999SG',
+                'price'         => '1500',
+                'currency'      => 'SGD',
+                'photo_url'     => 'https://example.test/parcel.png',
+                'meta'          => ['secret' => 'value'],
+            ],
+        ]),
+    ]);
+
+    $order->setAttribute('tracker_data', array_merge([
+        'provider'    => 'internal',
+        'driver'      => [
+            'location'             => ['type' => 'Point', 'coordinates' => [103.82, 1.32]],
+            'location_age_seconds' => 12,
+            'online'               => true,
+        ],
+        'progress'    => ['percentage' => 40, 'completed_stops' => 1, 'total_stops' => 2],
+        'stops'       => [['uuid' => 'stop-uuid', 'address' => '1 Sender Road']],
+        'active_stop' => ['uuid' => 'stop-uuid', 'address' => '2 Recipient Road', 'name' => 'Recipient House', 'latitude' => 1.35],
+        'next_stop'   => null,
+        'route'       => ['polyline' => 'abc'],
+        'eta'         => ['active_stop_seconds' => 600, 'completion_seconds' => 600, 'completion_at' => '2026-10-01T09:30:00.000Z'],
+        'insights'    => ['is_delayed' => false],
+    ], $tracker));
+
+    return $order;
+}
+
+test('public order tracking resource carries only what the track order page renders', function () {
+    $data = (new PublicOrderTracking(fleetopsPublicTrackingOrder()))->toArray(new Request());
+
+    expect(array_keys($data))->toBe([
+        'uuid', 'tracking', 'status', 'has_driver_assigned', 'tracking_number',
+        'tracking_statuses', 'payload', 'tracker_data', 'created_at',
+    ])
+        ->and($data['uuid'])->toBe('order_public')
+        ->and($data['tracking'])->toBe('FLB1234567890SG')
+        ->and($data['status'])->toBe('started')
+        ->and($data['has_driver_assigned'])->toBeTrue()
+        ->and($data['tracking_number'])->toBe(['uuid' => 'track_public', 'tracking_number' => 'FLB1234567890SG'])
+        ->and($data['created_at']->toDateTimeString())->toBe('2026-10-01 09:00:00');
+
+    expect($data['tracking_statuses'])->toHaveCount(1)
+        ->and(array_keys($data['tracking_statuses'][0]))->toBe(['uuid', 'status', 'details', 'created_at'])
+        ->and($data['tracking_statuses'][0]['uuid'])->toBe('status_public')
+        ->and($data['tracking_statuses'][0]['status'])->toBe('Order Created')
+        ->and($data['tracking_statuses'][0]['details'])->toBe('New order created.');
+
+    // Stops are coordinates only: the map routes between them, nothing names them.
+    $payload = $data['payload'];
+    expect(array_keys($payload))->toBe(['uuid', 'pickup', 'dropoff', 'waypoints', 'entities'])
+        ->and($payload['uuid'])->toBe('payload_public')
+        ->and(array_keys($payload['pickup']))->toBe(['uuid', 'location'])
+        ->and($payload['pickup']['uuid'])->toBe('place_pickup')
+        ->and($payload['pickup']['location']->getLat())->toBe(1.30)
+        ->and($payload['dropoff']['location']->getLng())->toBe(103.85)
+        ->and($payload['waypoints'])->toBe([])
+        ->and($payload['entities'])->toBe([[
+            'uuid'        => 'entity_public',
+            'name'        => 'Parcel',
+            'description' => 'A box',
+            'tracking'    => 'FLB9999999999SG',
+            'price'       => '1500',
+            'currency'    => 'SGD',
+            'photo_url'   => 'https://example.test/parcel.png',
+        ]]);
+
+    expect($data['tracker_data'])->toBe([
+        'driver'      => ['location' => ['type' => 'Point', 'coordinates' => [103.82, 1.32]]],
+        'progress'    => ['percentage' => 40, 'completed_stops' => 1],
+        'eta'         => ['active_stop_seconds' => 600, 'completion_at' => '2026-10-01T09:30:00.000Z'],
+        'active_stop' => ['address' => '2 Recipient Road'],
+        'next_stop'   => null,
+    ]);
+
+    // Nothing internal reaches the page, at any depth.
+    $json = json_encode($data);
+    foreach (['order-internal-uuid', 'INT-0042', 'company-uuid', 'customer-uuid', 'facilitator-uuid', 'driver-uuid', 'rate-uuid', 'Gate code', 'secret', 'qr-data', 'barcode-data', 'Sender House', '1 Sender Road', '+6500000000', 'ENT-INT', 'abc', 'internal'] as $leak) {
+        expect($json)->not->toContain($leak);
+    }
+});
+
+test('public order tracking resource drops the driver position unless the order is under way', function (array $attributes) {
+    $data = (new PublicOrderTracking(fleetopsPublicTrackingOrder($attributes)))->toArray(new Request());
+
+    expect($data['tracker_data']['driver'])->toBe(['location' => null])
+        ->and($data['tracker_data']['progress']['percentage'])->toBe(40);
+})->with([
+    'not started yet' => [['status' => 'dispatched', 'started' => false]],
+    'completed'       => [['status' => 'completed', 'started' => true]],
+    'canceled'        => [['status' => 'canceled', 'started' => true]],
+    'cancelled'       => [['status' => 'CANCELLED', 'started' => true]],
+]);
+
+test('public order tracking resource reports in progress only for started unfinished orders', function () {
+    expect(PublicOrderTracking::isInProgress(fleetopsPublicTrackingOrder()))->toBeTrue()
+        ->and(PublicOrderTracking::isInProgress(fleetopsPublicTrackingOrder(['started' => false])))->toBeFalse()
+        ->and(PublicOrderTracking::isInProgress(fleetopsPublicTrackingOrder(['status' => 'completed'])))->toBeFalse();
+});
+
+test('public order tracking resource tolerates missing relations and tracker data', function () {
+    $order = new Order();
+    $order->setRawAttributes(['public_id' => 'order_bare', 'status' => 'created'], true);
+    $order->setRelation('trackingNumber', null);
+    $order->setRelation('trackingStatuses', collect());
+    $order->setRelation('payload', null);
+
+    $data = (new PublicOrderTracking($order))->toArray(new Request());
+
+    expect($data['uuid'])->toBe('order_bare')
+        ->and($data['tracking'])->toBeNull()
+        ->and($data['has_driver_assigned'])->toBeFalse()
+        ->and($data['tracking_number'])->toBeNull()
+        ->and($data['tracking_statuses'])->toBe([])
+        ->and($data['payload'])->toBeNull()
+        ->and($data['tracker_data'])->toBe([
+            'driver'      => ['location' => null],
+            'progress'    => ['percentage' => null, 'completed_stops' => null],
+            'eta'         => ['active_stop_seconds' => null, 'completion_at' => null],
+            'active_stop' => null,
+            'next_stop'   => null,
+        ]);
+
+    // A payload with stops removed still serializes, leaving the gaps empty.
+    $order->setRelation('payload', (object) [
+        'public_id' => 'payload_bare',
+        'pickup'    => null,
+        'dropoff'   => null,
+        'waypoints' => collect([(object) ['public_id' => 'place_waypoint', 'location' => new Point(1.4, 103.9)]]),
+        'entities'  => [],
+    ]);
+    $payload = (new PublicOrderTracking($order))->toArray(new Request())['payload'];
+
+    expect($payload['pickup'])->toBeNull()
+        ->and($payload['dropoff'])->toBeNull()
+        ->and($payload['waypoints'][0]['uuid'])->toBe('place_waypoint')
+        ->and($payload['waypoints'][0]['location']->getLat())->toBe(1.4)
+        ->and($payload['entities'])->toBe([]);
+});
+
+test('public order tracking resource is never wrapped', function () {
+    expect(PublicOrderTracking::$wrap)->toBeNull();
+});

package/server/tests/QueueJobContractsTest.php

@@ -609,7 +609,8 @@ test('finalize api order creation job prepares optional dispatch and emits ready
     expect($missingOrderJob->events)->toBe([]);
 
     $order = new FleetOpsFinalizeOrderFake();
-    $order->setRawAttributes(['uuid' => 'order-uuid'], true);
+    $order->setRawAttributes(['uuid' => 'order-uuid', 'status' => 'created'], true);
+    $order->setRelation('trackingStatuses', collect());
 
     $serviceQuote = new ServiceQuote();
     $serviceQuote->setRawAttributes(['uuid' => 'service-quote-uuid'], true);

package/server/tests/RequestContractsTest.php

@@ -507,7 +507,7 @@ namespace {
                 'service_area' => 'service area',
                 'parent_fleet' => 'parent fleet',
             ])
-            ->and(requestRules(CancelOrderRequest::class))->toBe(['order' => 'required|exists:orders,uuid'])
+            ->and(requestRules(CancelOrderRequest::class))->toBe(['order' => 'required|exists:orders,uuid', 'reason' => 'nullable|string|max:1000'])
             ->and(requestRules(DecodeTrackingNumberQR::class))->toBe(['code' => 'required|string'])
             ->and(requestRules(CreateServiceQuoteRequest::class))->toBe([]);
     });

package/server/tests/RouteRegistrationExecutionTest.php

@@ -223,6 +223,32 @@ test('fleetops route file registers public internal analytics metrics and hub ro
     // Uploads through a link have a tighter limit of their own, on top of the group's.
     $upload = collect($recorder->routes)->firstWhere('uri', 'public/inspections/forms/{id}/files');
     expect($upload['middleware'] ?? [])->toBe(['throttle:20,1,inspection-upload']);
+
+    // The public tracking lookup has no session either, so it is rate limited
+    // per address, on a limiter of its own.
+    $lookup = collect($recorder->routes)->first(fn (array $route) => $route['action'] === 'OrderController@lookup');
+    expect($lookup)->not->toBeNull()
+        ->and($lookup['middleware'] ?? [])->toBe(['throttle:30,1,tracking-lookup']);
+
+    // The customer tracking page's public API answers in JSON and throttles inside the
+    // controller, so a throttled lookup looks exactly like an unknown number.
+    $tracking = collect($recorder->routes)->filter(fn (array $route) => str_starts_with($route['uri'], 'public/track/'));
+    expect($tracking->pluck('action', 'uri')->all())->toMatchArray([
+        'public/track/config'                    => 'TrackingController@config',
+        'public/track/account/orders'            => 'TrackingController@accountOrders',
+        'public/track/session'                   => 'TrackingController@signOut',
+        'public/track/{number}'                  => 'TrackingController@show',
+        'public/track/{number}/codes'            => 'TrackingController@sendCode',
+        'public/track/{number}/codes/verify'     => 'TrackingController@verifyCode',
+        'public/track/{number}/instructions'     => 'TrackingController@updateInstructions',
+        'public/track/{number}/proofs/{id}'      => 'TrackingController@proof',
+        'public/track/{number}/report'           => 'TrackingController@report',
+        'public/track/{number}/socket-token'     => 'TrackingController@socketToken',
+    ]);
+    foreach ($tracking as $route) {
+        expect($inGroup($route))->toBeTrue()
+            ->and($route['middleware'] ?? [])->toBe([]);
+    }
 });
 
 test('fleetops route file wires route groups with expected middleware and namespaces', function () {

package/server/tests/RouteSequencingEngineTest.php

@@ -128,6 +128,20 @@ test('route sequencing preserves vehicle assignment and orders stops by nearest
         'sequence'   => 1,
     ]);
     expect($assignments['order_far']['sequence'])->toBeGreaterThan($assignments['order_near']['sequence']);
+
+    // arrival, distance and duration are estimated along the sequenced stops
+    $near = $assignments['order_near'];
+    $far  = $assignments['order_far'];
+    expect($near['arrival'])->toBeGreaterThan(0)
+        ->and($far['arrival'])->toBeGreaterThan($near['arrival'])
+        ->and($far['distance'])->toBe($far['route_distance'])
+        ->and($near['distance'])->toBeLessThan($far['distance'])
+        ->and($near['route_duration'])->toBe($far['duration'])
+        ->and($result['summary'])->toMatchArray([
+            'distance' => $far['route_distance'],
+            'duration' => $far['route_duration'],
+            'metrics'  => 'estimated',
+        ]);
 });
 
 test('route sequencing handles multi drop waypoints and missing vehicle relations', function () {
@@ -150,7 +164,10 @@ test('route sequencing handles multi drop waypoints and missing vehicle relation
             'vehicle_id' => 'vehicle-missing-relation',
             'driver_id'  => null,
             'sequence'   => 1,
+            // with no vehicle position the route is measured from its first stop
+            'route_distance' => $result['assignments'][0]['distance'],
         ])
+        ->and($result['assignments'][0]['distance'])->toBeGreaterThan(0)
         ->and($result['summary']['assigned'])->toBe(1);
 });
 

package/server/tests/SettingControllerContractsTest.php

@@ -162,6 +162,116 @@ function fleetopsJsonPayload(mixed $response): array
     return $response->getData(true);
 }
 
+class FleetOpsMapCenterRedisFake
+{
+    public array $sets = [];
+
+    public function __construct(private array $cached = [], private bool $throws = false)
+    {
+    }
+
+    public function exists(string $key): bool
+    {
+        if ($this->throws) {
+            throw new RuntimeException('redis unavailable');
+        }
+
+        return array_key_exists($key, $this->cached);
+    }
+
+    public function get(string $key): mixed
+    {
+        return json_encode($this->cached[$key]);
+    }
+
+    public function set(string $key, string $value): bool
+    {
+        $this->sets[] = $key;
+
+        return true;
+    }
+}
+
+function fleetopsMapCenterFor(mixed $company, FleetOpsMapCenterRedisFake $redis): mixed
+{
+    Illuminate\Support\Facades\Redis::swap($redis);
+
+    $controller          = new FleetOpsSettingControllerProbe();
+    $controller->company = $company;
+
+    return fleetopsJsonPayload($controller->getMapSettings())['companyMapCenter'];
+}
+
+test('map settings persist a company default view and never persist the derived country centre', function () {
+    $controller = new FleetOpsSettingControllerProbe();
+
+    $saved = fleetopsJsonPayload($controller->saveMapSettings(new Request([
+        'settings' => [
+            'defaultMapLatitude'  => '-33.8688',
+            'defaultMapLongitude' => 151.2093,
+            'defaultMapZoom'      => '25',
+            'fitMapToVehicles'    => '1',
+            'companyMapCenter'    => ['latitude' => 1, 'longitude' => 2],
+        ],
+    ])));
+
+    expect($controller->configuredCompany['fleet-ops.map-settings'])->toMatchArray([
+        'defaultMapLatitude'  => -33.8688,
+        'defaultMapLongitude' => 151.2093,
+        'defaultMapZoom'      => 20,
+        'fitMapToVehicles'    => true,
+    ])
+        ->and(array_key_exists('companyMapCenter', $controller->configuredCompany['fleet-ops.map-settings']))->toBeFalse()
+        ->and($saved['defaultMapLatitude'])->toBe(-33.8688)
+        ->and($saved['companyMapCenter'])->toBeNull();
+
+    // A fresh company reads the defaults: no centre, no zoom, no fitting.
+    $fresh = fleetopsJsonPayload((new FleetOpsSettingControllerProbe())->getMapSettings());
+    expect($fresh)->toMatchArray([
+        'defaultMapLatitude'  => null,
+        'defaultMapLongitude' => null,
+        'defaultMapZoom'      => null,
+        'fitMapToVehicles'    => false,
+        'companyMapCenter'    => null,
+    ]);
+});
+
+test('map default view drops half or out of range centres and clamps the zoom', function (array $input, array $expected) {
+    $controller = new FleetOpsSettingControllerProbe();
+    $controller->saveMapSettings(new Request(['settings' => $input]));
+
+    expect($controller->configuredCompany['fleet-ops.map-settings'])->toMatchArray($expected);
+})->with([
+    'latitude only'          => [['defaultMapLatitude' => '10'], ['defaultMapLatitude' => null, 'defaultMapLongitude' => null]],
+    'latitude out of range'  => [['defaultMapLatitude' => 91, 'defaultMapLongitude' => 10], ['defaultMapLatitude' => null, 'defaultMapLongitude' => null]],
+    'longitude out of range' => [['defaultMapLatitude' => 10, 'defaultMapLongitude' => -180.5], ['defaultMapLatitude' => null, 'defaultMapLongitude' => null]],
+    'non numeric'            => [['defaultMapLatitude' => 'north', 'defaultMapLongitude' => ''], ['defaultMapLatitude' => null, 'defaultMapLongitude' => null]],
+    'zero is a real place'   => [['defaultMapLatitude' => 0, 'defaultMapLongitude' => '0'], ['defaultMapLatitude' => 0.0, 'defaultMapLongitude' => 0.0]],
+    'zoom below range'       => [['defaultMapZoom' => 0], ['defaultMapZoom' => 1]],
+    'zoom not an integer'    => [['defaultMapZoom' => '4.5'], ['defaultMapZoom' => null]],
+]);
+
+test('map settings centre a company on its country, falling back to the country of its timezone', function () {
+    $australia = ['countryData:AU' => ['coordinates' => ['latitude' => -25.58, 'longitude' => 134.5]]];
+
+    expect(fleetopsMapCenterFor(['country' => 'au'], new FleetOpsMapCenterRedisFake($australia)))
+        ->toBe(['country' => 'AU', 'latitude' => -25.58, 'longitude' => 134.5])
+        ->and(fleetopsMapCenterFor(['country' => 'Australia', 'timezone' => 'Australia/Sydney'], new FleetOpsMapCenterRedisFake($australia)))
+        ->toBe(['country' => 'AU', 'latitude' => -25.58, 'longitude' => 134.5]);
+});
+
+test('map settings omit the country centre when the company location cannot be resolved', function (mixed $company, array $cached, bool $throws) {
+    expect(fleetopsMapCenterFor($company, new FleetOpsMapCenterRedisFake($cached, $throws)))->toBeNull();
+})->with([
+    'no company'             => [null, [], false],
+    'no country or timezone' => [['country' => null, 'timezone' => ''], [], false],
+    'utc timezone'           => [['timezone' => 'UTC'], [], false],
+    'unknown timezone'       => [['timezone' => 'Not/AZone'], [], false],
+    'unknown country'        => [['country' => 'ZZ'], ['countryData:ZZ' => []], false],
+    'null island centroid'   => [['country' => 'XX'], ['countryData:XX' => ['coordinates' => ['latitude' => 0, 'longitude' => 0]]], false],
+    'country lookup fails'   => [['country' => 'AU'], [], true],
+]);
+
 test('setting controller persists and returns basic company settings through configured keys', function () {
     session(['company' => 'company-1']);
     $controller                  = new FleetOpsSettingControllerProbe();

package/server/tests/Support/TrackingPageDatabase.php

@@ -0,0 +1,200 @@
+<?php
+
+namespace Fleetbase\Tests\Support;
+
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * An in-memory database holding the tables the public tracking page reads and writes,
+ * so its queries run for real in tests.
+ */
+final class TrackingPageDatabase
+{
+    public static function boot(): SQLiteConnection
+    {
+        $connection = new SQLiteConnection(new \PDO('sqlite::memory:'));
+        $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection, 'testing' => $connection]);
+        $resolver->setDefaultConnection('mysql');
+        EloquentModel::setConnectionResolver($resolver);
+        EloquentModel::clearBootedModels();
+
+        $schema = $connection->getSchemaBuilder();
+        $common = function ($table) {
+            $table->increments('id');
+            $table->string('_key')->nullable();
+            $table->string('uuid')->nullable();
+            $table->string('public_id')->nullable();
+            $table->string('company_uuid')->nullable();
+            $table->text('meta')->nullable();
+            $table->timestamp('created_at')->nullable();
+            $table->timestamp('updated_at')->nullable();
+            $table->timestamp('deleted_at')->nullable();
+        };
+
+        $schema->create('settings', function ($table) {
+            $table->increments('id');
+            $table->string('key')->nullable();
+            $table->text('value')->nullable();
+            $table->timestamp('created_at')->nullable();
+            $table->timestamp('updated_at')->nullable();
+        });
+        $schema->create('tracking_numbers', function ($table) use ($common) {
+            $common($table);
+            $table->string('tracking_number')->nullable();
+            $table->string('owner_uuid')->nullable();
+            $table->string('owner_type')->nullable();
+            $table->string('region')->nullable();
+            $table->string('status_uuid')->nullable();
+            $table->text('qr_code')->nullable();
+            $table->text('barcode')->nullable();
+        });
+        $schema->create('orders', function ($table) use ($common) {
+            $common($table);
+            $table->string('payload_uuid')->nullable();
+            $table->string('customer_uuid')->nullable();
+            $table->string('customer_type')->nullable();
+            $table->string('tracking_number_uuid')->nullable();
+            $table->string('driver_assigned_uuid')->nullable();
+            $table->string('vehicle_assigned_uuid')->nullable();
+            $table->string('status')->nullable();
+            $table->boolean('dispatched')->nullable();
+            $table->boolean('started')->nullable();
+            $table->timestamp('scheduled_at')->nullable();
+            $table->timestamp('started_at')->nullable();
+        });
+        $schema->create('payloads', function ($table) use ($common) {
+            $common($table);
+            $table->string('pickup_uuid')->nullable();
+            $table->string('dropoff_uuid')->nullable();
+            $table->string('pickup_tracking_number_uuid')->nullable();
+            $table->string('dropoff_tracking_number_uuid')->nullable();
+        });
+        $schema->create('waypoints', function ($table) use ($common) {
+            $common($table);
+            $table->string('payload_uuid')->nullable();
+            $table->string('place_uuid')->nullable();
+            $table->string('customer_uuid')->nullable();
+            $table->string('customer_type')->nullable();
+            $table->string('tracking_number_uuid')->nullable();
+            $table->integer('order')->nullable();
+        });
+        $schema->create('entities', function ($table) use ($common) {
+            $common($table);
+            $table->string('payload_uuid')->nullable();
+            $table->string('destination_uuid')->nullable();
+            $table->string('tracking_number_uuid')->nullable();
+            $table->string('customer_uuid')->nullable();
+            $table->string('customer_type')->nullable();
+            $table->string('photo_uuid')->nullable();
+            $table->string('name')->nullable();
+            $table->string('description')->nullable();
+            $table->string('price')->nullable();
+            $table->string('currency')->nullable();
+        });
+        $schema->create('proofs', function ($table) use ($common) {
+            $common($table);
+            $table->string('order_uuid')->nullable();
+            $table->string('subject_uuid')->nullable();
+            $table->string('subject_type')->nullable();
+            $table->string('file_uuid')->nullable();
+            $table->text('raw_data')->nullable();
+            $table->string('remarks')->nullable();
+            $table->text('data')->nullable();
+        });
+        $schema->create('companies', function ($table) use ($common) {
+            $common($table);
+            $table->string('name')->nullable();
+            $table->string('logo_uuid')->nullable();
+            $table->string('phone')->nullable();
+            $table->string('website_url')->nullable();
+            $table->text('options')->nullable();
+        });
+        $schema->create('places', function ($table) use ($common) {
+            $common($table);
+            $table->string('name')->nullable();
+            $table->string('street1')->nullable();
+            $table->string('city')->nullable();
+            $table->string('phone')->nullable();
+            $table->text('location')->nullable();
+        });
+        $schema->create('files', function ($table) use ($common) {
+            $common($table);
+            $table->string('type')->nullable();
+            $table->string('path')->nullable();
+            $table->string('disk')->nullable();
+        });
+        $schema->create('contacts', function ($table) use ($common) {
+            $common($table);
+            $table->string('user_uuid')->nullable();
+            $table->string('name')->nullable();
+            $table->string('email')->nullable();
+            $table->string('phone')->nullable();
+            $table->string('type')->nullable();
+        });
+        $schema->create('vendors', function ($table) use ($common) {
+            $common($table);
+            $table->string('name')->nullable();
+            $table->string('email')->nullable();
+            $table->string('phone')->nullable();
+        });
+        $schema->create('tracking_statuses', function ($table) use ($common) {
+            $common($table);
+            $table->string('tracking_number_uuid')->nullable();
+            $table->string('status')->nullable();
+            $table->string('details')->nullable();
+            $table->string('code')->nullable();
+            $table->boolean('complete')->nullable();
+        });
+        $schema->create('verification_codes', function ($table) {
+            $table->increments('id');
+            $table->string('uuid')->nullable();
+            $table->string('subject_uuid')->nullable();
+            $table->string('subject_type')->nullable();
+            $table->string('code')->nullable();
+            $table->string('for')->nullable();
+            $table->text('meta')->nullable();
+            $table->string('status')->nullable();
+            $table->timestamp('expires_at')->nullable();
+            $table->timestamp('created_at')->nullable();
+            $table->timestamp('updated_at')->nullable();
+            $table->timestamp('deleted_at')->nullable();
+        });
+        $schema->create('tracking_sessions', function ($table) {
+            $table->increments('id');
+            $table->string('uuid')->nullable();
+            $table->string('token_hash')->nullable();
+            $table->string('ip')->nullable();
+            $table->string('user_agent')->nullable();
+            $table->timestamp('last_seen_at')->nullable();
+            $table->timestamp('expires_at')->nullable();
+            $table->timestamp('revoked_at')->nullable();
+            $table->timestamp('created_at')->nullable();
+            $table->timestamp('updated_at')->nullable();
+            // Fleetbase models soft delete (2026_10_12_000001_add_deleted_at_to_tracking_sessions_tables).
+            $table->timestamp('deleted_at')->nullable();
+        });
+        $schema->create('tracking_session_grants', function ($table) {
+            $table->increments('id');
+            $table->string('uuid')->nullable();
+            $table->string('tracking_session_uuid')->nullable();
+            $table->string('company_uuid')->nullable();
+            $table->string('order_uuid')->nullable();
+            $table->string('customer_type')->nullable();
+            $table->string('customer_uuid')->nullable();
+            $table->string('channel')->nullable();
+            $table->timestamp('expires_at')->nullable();
+            $table->timestamp('created_at')->nullable();
+            $table->timestamp('updated_at')->nullable();
+            $table->timestamp('deleted_at')->nullable();
+        });
+
+        return $connection;
+    }
+
+    public static function insert(SQLiteConnection $connection, string $table, array $row): void
+    {
+        $connection->table($table)->insert($row);
+    }
+}