spree_cm_commissioner 2.15.2 → 2.15.3

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/external_client/connection.rb

@@ -4,24 +4,24 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::ExternalClient
     REQUEST_TIMEOUT = 30
     OPEN_TIMEOUT = 10
 
-    def get(url, params = nil, headers = nil)
-      execute_request { connection.get(url, params, build_headers(headers)) }
+    def get(url, params = nil, headers = nil, lane: :background)
+      execute_request(lane: lane) { connection.get(url, params, build_headers(headers)) }
     end
 
-    def post(url, body = nil, headers = nil)
-      execute_request { connection.post(url, body, build_headers(headers)) }
+    def post(url, body = nil, headers = nil, lane: :background)
+      execute_request(lane: lane) { connection.post(url, body, build_headers(headers)) }
     end
 
-    def put(url, body = nil, headers = nil)
-      execute_request { connection.put(url, body, build_headers(headers)) }
+    def put(url, body = nil, headers = nil, lane: :background)
+      execute_request(lane: lane) { connection.put(url, body, build_headers(headers)) }
     end
 
-    def patch(url, body = nil, headers = nil)
-      execute_request { connection.patch(url, body, build_headers(headers)) }
+    def patch(url, body = nil, headers = nil, lane: :background)
+      execute_request(lane: lane) { connection.patch(url, body, build_headers(headers)) }
     end
 
-    def delete(url, params = nil, headers = nil)
-      execute_request { connection.delete(url, params, build_headers(headers)) }
+    def delete(url, params = nil, headers = nil, lane: :background)
+      execute_request(lane: lane) { connection.delete(url, params, build_headers(headers)) }
     end
 
     def connection
@@ -52,6 +52,10 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::ExternalClient
       @token_mutex ||= Mutex.new
     end
 
+    def call_limiter
+      @call_limiter ||= SpreeCmCommissioner::Integrations::CallLimiter.new(base_url: @integration.base_url)
+    end
+
     def token_expired?
       @access_token.blank? || @token_expires_at.blank? || Time.current >= @token_expires_at
     end
@@ -81,15 +85,17 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::ExternalClient
       reset_connection
     end
 
-    # Execute HTTP request with automatic token refresh on 401
-    def execute_request(retry_count: 0, &block)
+    # Runs the request, refreshing the token once on a 401. Counted against CallLimiter first, except checkout calls.
+    def execute_request(lane: :background, retry_count: 0, &block)
+      call_limiter.take!(lane: lane)
+
       response = block.call
 
       if response.status == 401 && retry_count.zero?
         invalidate_token
         access_token
         reset_connection
-        return execute_request(retry_count: 1, &block)
+        return execute_request(lane: lane, retry_count: 1, &block)
       end
 
       response

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_item_availability.rb

@@ -51,9 +51,11 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
       return unless should_sync_item?(inventory_item_mapping)
 
-      ActiveRecord::Base.transaction do
-        external_trip = fetch_external_trip(trip, on_date)
+      # Before the transaction: the call can take up to 30 s and would hold a database connection.
+      external_trip = fetch_external_trip(trip, on_date)
+      return if external_trip.nil? # no mapping data to look it up: leave the inventory untouched
 
+      ActiveRecord::Base.transaction do
         case external_trip
         when UNAVAILABLE
           # A confirmed response (not a failed/ambiguous lookup - see fetch_external_trip) shows
@@ -62,8 +64,6 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
           # Zero it out so BookMe+ stops selling a date BookMeBus has pulled, rather than only
           # discovering that at the very end of checkout, after payment has been taken.
           zero_out_inventory!(inventory_item)
-        when nil
-          return # rubocop:disable Rails/TransactionExitStatement -- couldn't determine (missing mapping data) - leave existing inventory untouched rather than guess
         else
           sync_price(inventory_item, external_trip)
 
@@ -79,6 +79,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
         update_last_sync_at(inventory_item_mapping)
       end
+    rescue SpreeCmCommissioner::Integrations::RateLimitedError
+      raise # #call records it and stops: the remaining items would only be refused too
     rescue StandardError => e
       @sync_result.record_error(e)
       CmAppLogger.error(label: '[BookMeBusV1::SyncItemAvailability] error', data: { inventory_item_id: inventory_item.id, error: e.message })
@@ -179,7 +181,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
         client.search_trips!(
           origin_id: origin_id,
           destination_id: destination_id,
-          on_date: on_date
+          on_date: on_date,
+          lane: :customer
         ) || []
       end
     end
@@ -295,9 +298,12 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
           trip_id: external_trip.id,
           from_stop_id: external_trip.from_stop_id,
           to_stop_id: external_trip.to_stop_id,
-          on_date: external_trip.on_date || Time.zone.today.to_s
+          on_date: external_trip.on_date || Time.zone.today.to_s,
+          lane: :customer
         )
       end
+    rescue SpreeCmCommissioner::Integrations::RateLimitedError
+      raise
     rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
       CmAppLogger.error(label: '[BookMeBusV1::SyncItemAvailability] get_seat_layout failed', data: { error: e.message })
       @sync_result.record_error(e)

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_locations.rb

@@ -3,6 +3,10 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
     # Initialize SyncLocations service
     # @param integration [SpreeCmCommissioner::Integrations::BookMeBusV1] The integration instance
     # @param sync_result [SpreeCmCommissioner::Integrations::Base::SyncResult] Optional sync result tracker
+    # The operator's trips with their cities, as fetched by the last call. SyncRoutes builds routes from the same
+    # answer, so the full sync asks BookMeBus once for it, not once per step.
+    attr_reader :trip_locations
+
     def initialize(integration:, sync_result: nil)
       @integration = integration
       @sync_result = sync_result || SpreeCmCommissioner::Integrations::Base::SyncResult.new
@@ -50,13 +54,15 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
     end
 
     def fetch_external_locations
-      trip_locations = begin
+      @trip_locations = begin
         @sync_result.track_api_call('get_trip_locations') { client.get_trip_locations! }
+      rescue SpreeCmCommissioner::Integrations::RateLimitedError
+        raise # the strategy stops the whole run on a 429, see FullSyncStrategy
       rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
         raise SpreeCmCommissioner::Integrations::SyncError, "Failed to sync locations: #{e.message}"
       end
 
-      trip_locations.flat_map(&:locations).uniq(&:id)
+      @trip_locations.flat_map(&:locations).uniq(&:id)
     end
 
     # Sync a single location and create it as a place with vendor place mapping
@@ -99,7 +105,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
         tracker.save_if_changed!(vendor_place)
       end
 
-      mapping.mark_as_active!(external_payload: external_location.to_h)
+      # Saved only when something changed (or an hour has passed): most runs find every location as it was.
+      mapping.confirm_active!(external_payload: external_location.to_h)
       mapping
     end
 

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_routes.rb

@@ -3,9 +3,11 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
     # Initialize SyncRoutes service
     # @param integration [SpreeCmCommissioner::Integrations::BookMeBusV1] The integration instance
     # @param sync_result [SpreeCmCommissioner::Integrations::Base::SyncResult] Optional sync result tracker
-    def initialize(integration:, sync_result: nil)
+    # @param trip_locations [Array, nil] the answer SyncLocations already got from BookMeBus. Fetched here when absent.
+    def initialize(integration:, sync_result: nil, trip_locations: nil)
       @integration = integration
       @sync_result = sync_result || SpreeCmCommissioner::Integrations::Base::SyncResult.new
+      @trip_locations = trip_locations
     end
 
     def call
@@ -70,7 +72,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
         tracker.save_if_changed!(route)
       end
 
-      mapping.mark_as_active!(
+      # Saved only when something changed (or an hour has passed): most runs find every route as it was.
+      mapping.confirm_active!(
         external_payload: {
           origin_place_id: origin_mapping.external_id,
           destination_place_id: destination_mapping.external_id,
@@ -109,7 +112,13 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
     # Raised before any route is written, so a failed call never reaches cleanup_stale_mappings!.
     def external_trip_locations
+      # The answer handed in by the full sync, if any. Not remembered after a fetch: a second call on this object must
+      # ask BookMeBus again.
+      return @trip_locations if @trip_locations
+
       @sync_result.track_api_call('get_trip_locations') { client.get_trip_locations! }
+    rescue SpreeCmCommissioner::Integrations::RateLimitedError
+      raise # the strategy stops the whole run on a 429, see FullSyncStrategy
     rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
       raise SpreeCmCommissioner::Integrations::SyncError, "Failed to sync routes: #{e.message}"
     end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_seat_layout.rb

@@ -34,13 +34,13 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
   #   sync_service = SyncSeatLayout.new(integration: integration, sync_result: sync_result)
   #   seat_layout = sync_service.call(vehicle_type: vehicle_type, external_trip: external_trip)
   #
-  class SyncSeatLayout # rubocop:disable Metrics/ClassLength
+  class SyncSeatLayout
     def initialize(integration:, sync_result: nil)
       @integration = integration
       @sync_result = sync_result || SpreeCmCommissioner::Integrations::Base::SyncResult.new
     end
 
-    def call(vehicle_type:, external_trip:, variant: nil, inventory_item: nil)
+    def call(vehicle_type:, external_trip:, variant: nil)
       return nil if vehicle_type.blank? || external_trip.blank?
 
       external_seat_layout = fetch_external_seat_layout(external_trip)
@@ -52,10 +52,12 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       # If variant provided, duplicate template to trip and sync trip-specific layout
       if variant.present?
         duplicate_to_trip_if_needed!(vehicle_seat_layout: vehicle_seat_layout, variant: variant)
-        sync_trip_seat_layout!(external_seat_layout: external_seat_layout, variant: variant, inventory_item: inventory_item)
+        sync_trip_seat_layout!(external_seat_layout: external_seat_layout, variant: variant)
       end
 
       vehicle_seat_layout
+    rescue SpreeCmCommissioner::Integrations::RateLimitedError
+      raise # the caller stops the whole run on a 429
     rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
       @sync_result.record_error(SpreeCmCommissioner::Integrations::SyncError.new("Failed to sync seat layout: #{e.message}"))
       nil
@@ -123,6 +125,7 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       if seat_layout.persisted?
         apply_builder_layout!(seat_layout, external_seat_layout, create_missing: false)
         backfill_vehicle_type_seats!(vehicle_type, seat_layout)
+        mapping.update!(last_synced_at: Time.current) # when SeatLayoutFreshness next asks again
         return seat_layout
       end
 
@@ -209,7 +212,7 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       @sync_result.record_error(StandardError.new("[SyncSeatLayout] Failed to duplicate seat layout to trip: #{e.message}"))
     end
 
-    def sync_trip_seat_layout!(external_seat_layout:, variant:, inventory_item:)
+    def sync_trip_seat_layout!(external_seat_layout:, variant:)
       return if variant.blank?
 
       trip_seat_layout = variant.trip&.seat_layout
@@ -228,10 +231,7 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
         end
       end
 
-      # Sync reserved blocks if inventory_item provided
-      return if inventory_item.blank?
-
-      sync_reserved_blocks!(seat_layout: trip_seat_layout, external_seat_layout: external_seat_layout, inventory_item: inventory_item)
+      trip_seat_layout.touch # rubocop:disable Rails/SkipsModelValidations -- synced: no older than its vehicle type's (SeatLayoutFreshness)
     end
 
     # Build name for seat layout
@@ -292,56 +292,5 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
         section.destroy! if section.blocks.empty?
       end
     end
-
-    # This method creates ReservedBlock records for seats that are marked as booked (status=1)
-    # in the BookMeBus API response, ensuring BookMe+ knows which seats are already reserved.
-    def sync_reserved_blocks!(seat_layout:, external_seat_layout:, inventory_item:) # rubocop:disable Metrics/PerceivedComplexity
-      return unless seat_layout.present? && inventory_item.present?
-
-      # Get all seats with their status from external API
-      external_seats_by_label = external_seat_layout.seats.index_by(&:label)
-
-      # Get all blocks for this seat layout
-      seat_layout.blocks.each do |block|
-        next unless block.sellable? # Only process sellable blocks (seat, sleeping_seat, standing)
-
-        external_seat = external_seats_by_label[block.label]
-        next unless external_seat # Skip if no matching external seat data
-
-        # Find or initialize reserved block
-        reserved_block = SpreeCmCommissioner::ReservedBlock.find_or_initialize_by(
-          inventory_item: inventory_item,
-          block: block
-        )
-
-        if external_seat.booked? # status == 1 in BookMeBus
-          # Seat is booked in BookMeBus - create/update reservation
-          next if reserved_block.reserved? # Already reserved, skip
-
-          @sync_result.track(:reserved_block, reserved_block) do |tracker|
-            reserved_block.assign_attributes(
-              status: :reserved,
-              expired_at: nil,
-              inventory_date: inventory_item.inventory_date,
-              guest: nil, # External reservation, no guest association
-              updated_by: nil # System sync, no user
-            )
-            tracker.save_if_changed!(reserved_block)
-          end
-        elsif reserved_block.persisted? # external_seat.available? - status == 0 in BookMeBus
-          # Seat is available in BookMeBus - remove external reservation if exists. Locked, and
-          # guest_id re-checked after acquiring the lock, so a real customer hold being created
-          # concurrently on this exact block can't be destroyed out from under them.
-          reserved_block.with_lock do
-            next unless reserved_block.guest_id.nil? # Only remove if it's an external reservation (no guest)
-
-            @sync_result.track(:reserved_block, reserved_block) do |_tracker|
-              reserved_block.destroy!
-              @sync_result.increment_metric(:reserved_block, :deleted)
-            end
-          end
-        end
-      end
-    end
   end
 end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_trips.rb

@@ -279,9 +279,7 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
   class SyncTrips # rubocop:disable Metrics/ClassLength
     attr_reader :integration, :sync_result, :route, :vendor
 
-    # Booked seats are only fetched for the dates the incremental sync keeps fresh (today and tomorrow); further out,
-    # SyncItemAvailability fetches them when a customer opens the trip.
-    SEAT_STATUS_DAYS_AHEAD = 1
+    VOLATILE_PAYLOAD_KEYS = SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::Trip::VOLATILE_PAYLOAD_KEYS
 
     def initialize(integration:, sync_result: nil, route: nil)
       @integration = integration
@@ -291,6 +289,7 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       @location_mappings = {}
       @location_id_cache = {}
       @seat_layout_synced_variant_ids = Set.new
+      @seat_layout_freshness = SpreeCmCommissioner::Integrations::BookMeBusV1::SeatLayoutFreshness.new(integration)
       @variant_ids_needing_items = Set.new
     end
 
@@ -378,9 +377,9 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       # Nothing came back for any date in the window - don't touch route stops/cleanup based
       # on an empty result (could be a transient outage rather than a genuinely dead route).
       if all_external_trips.empty?
-        # Incremental sync takes the route synced longest ago, so a route BookMeBus confirmed empty must still move to
-        # the back of the line, or every poll would pick it again and no other route would ever refresh.
-        touch_route_mapping if bookable_ids_by_date.any?
+        # An empty route, or one whose every date failed, still moves to the back of the line: otherwise every poll
+        # would pick it again. A 429 raises before this, so that route stays first in line.
+        touch_route_mapping(bookable_ids_by_date.keys)
         return
       end
 
@@ -399,7 +398,7 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       cleanup_stale_mappings!(synced_trip_ids) if @full_sync
 
       # Update route mapping timestamp
-      touch_route_mapping
+      touch_route_mapping(bookable_ids_by_date.keys)
     end
 
     # Isolated per date: a transient failure fetching one date shouldn't abort the whole
@@ -420,6 +419,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
           on_date: on_date
         ) || []
       end
+    rescue SpreeCmCommissioner::Integrations::RateLimitedError
+      raise # not a failed date: the whole run stops, see FullSyncStrategy and IncrementalSyncStrategy
     rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
       @sync_result.record_error(e)
       raise SpreeCmCommissioner::Integrations::SyncError, "Failed to fetch trips: #{e.message}"
@@ -428,6 +429,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
     def process_external_trips(external_trips)
       external_trips.filter_map do |external_trip|
         sync_trip!(external_trip)
+      rescue SpreeCmCommissioner::Integrations::RateLimitedError
+        raise # e.g. the seat layout call of this trip
       rescue SpreeCmCommissioner::Integrations::SyncError => e
         @sync_result.record_error(e)
         Rails.logger.warn("[SyncTrips] Sync error for trip #{external_trip.trip_id}: #{e.message}")
@@ -465,6 +468,9 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
         return external_trip.sync_identifier
       end
 
+      # The daily full sync still runs the whole pipeline for every trip.
+      return external_trip.sync_identifier if !@full_sync && sync_seats_only!(external_trip)
+
       # Prepare data outside transaction to avoid long-running transactions
       vehicle_type = sync_vehicle_type!(external_trip)
 
@@ -522,6 +528,26 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       external_trip.sync_identifier
     end
 
+    # A poll usually finds a trip as stored, with only another seat count. Then only the seats are updated, not the
+    # product, variant, trip, calendar, layout, stops and pricing. A changed price (compared on its own) or any other
+    # change takes the full pipeline. Returns true when it handled the trip.
+    def sync_seats_only!(external_trip)
+      mapping = SpreeCmCommissioner::IntegrationMapping.find_by(
+        integration_id: integration.id, internal_type: 'SpreeCmCommissioner::Trip', external_id: external_trip.sync_identifier, status: :active
+      )
+      return false unless mapping&.payload_unchanged?(external_trip.to_h, ignoring: VOLATILE_PAYLOAD_KEYS)
+
+      variant = Spree::Variant.find_by(sku: "variant-#{vendor.id}-#{external_trip.sync_identifier}")
+      return false unless variant && variant.price.to_d == calculate_price(external_trip).to_d
+      # A trip whose layout was never assigned (a failed first fetch) still needs the full pipeline to get one.
+      return false unless seat_layout_current?(variant)
+
+      SyncInventory.new(sync_result: sync_result, vendor: vendor).call(variant: variant, external_trip: external_trip)
+      @variant_ids_needing_items << variant.id if permanent_items_needed?(variant.product.service_calendar, variant, external_trip)
+      sync_result.increment_metric(:trip, :seats_only)
+      true
+    end
+
     # A calendar change can add dates anywhere in the window. A missing item for this date means its job never ran or
     # was lost, so the next poll repairs it. Stock isn't checked: it only seeds items. New variants get their items
     # from StockItem#create_inventory_items. service_available? stops a date the job would never create from
@@ -580,18 +606,17 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
       mapping.confirm_active!(
         external_payload: external_trip.to_h,
-        ignoring: SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::Trip::VOLATILE_PAYLOAD_KEYS
+        ignoring: VOLATILE_PAYLOAD_KEYS
       )
       mapping
     end
 
-    # A trip's seat layout is the same on every date, so it is synced once per run (on the first bookable date, which
-    # also refreshes it every run). Later dates only matter for which seats are booked, so they are synced again only
-    # when BookMeBus reports that for the trip and the date is close enough to matter. The trip is marked done only
-    # after a successful sync, so a failed first fetch is retried on the next date.
+    # A seat layout is the same on every date and for every trip of a vehicle type, so BookMeBus is asked for it only
+    # when it is missing or out of date. Which seats are booked is not synced here: SyncItemAvailability reads it when a
+    # customer opens the trip. A failed fetch is retried on the next date.
     def sync_seat_layout!(vehicle_type, external_trip, variant)
       return unless vehicle_type
-      return if seat_layout_current?(variant) && !booked_seats_needed?(external_trip)
+      return if seat_layout_current?(variant)
 
       layout = SyncSeatLayout.new(
         integration: integration,
@@ -599,25 +624,18 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       ).call(
         vehicle_type: vehicle_type,
         external_trip: external_trip,
-        variant: variant,
-        inventory_item: find_inventory_item_for_date(variant, external_trip)
+        variant: variant
       )
 
-      @seat_layout_synced_variant_ids << variant.id if layout
-    end
-
-    # Checks for assigned blocks, not just a layout: a trip copies its vehicle's layout on save, before any seat is
-    # assigned to it, and that first sync must still run.
-    def seat_layout_current?(variant)
-      return true if @seat_layout_synced_variant_ids.include?(variant.id)
+      return unless layout
 
-      !@full_sync && variant.trip&.seat_layout&.blocks&.exists?(variant_id: variant.id)
+      @seat_layout_synced_variant_ids << variant.id
+      @seat_layout_freshness.forget(vehicle_type)
     end
 
-    def booked_seats_needed?(external_trip)
-      trip_date = parse_trip_date(external_trip.on_date)
-
-      external_trip.per_seat_status? && trip_date.present? && trip_date <= Date.current + SEAT_STATUS_DAYS_AHEAD.days
+    # Synced in this run, or still matching its vehicle type's layout (see SeatLayoutFreshness).
+    def seat_layout_current?(variant)
+      @seat_layout_synced_variant_ids.include?(variant.id) || @seat_layout_freshness.current?(variant)
     end
 
     def sync_trip_stop!(trip_mapping)
@@ -732,16 +750,18 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       inventory_item.update_column(:max_capacity, original_max_capacity) # rubocop:disable Rails/SkipsModelValidations
     end
 
-    def touch_route_mapping
+    # `fresh_dates` are the dates BookMeBus answered for, recorded as refreshed (RouteFreshness).
+    def touch_route_mapping(fresh_dates = [])
       return unless route
 
-      route_mapping = SpreeCmCommissioner::IntegrationMapping.find_by(
-        integration_id: integration.id,
-        internal_type: 'SpreeCmCommissioner::Route',
-        internal_id: route.id,
-        status: :active
-      )
-      route_mapping&.update!(last_synced_at: Time.current)
+      route_mapping = SpreeCmCommissioner::IntegrationMapping.active_routes_of(integration).find_by(internal_id: route.id)
+      return unless route_mapping
+
+      # Locked because SyncRouteJob writes `private_metadata` too (see its record_outcome).
+      route_mapping.with_lock do
+        SpreeCmCommissioner::Integrations::BookMeBusV1::RouteFreshness.new(route_mapping).stamp(fresh_dates)
+        route_mapping.update!(last_synced_at: Time.current)
+      end
     end
 
     def find_external_location_id(place)

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/resources/trip.rb

@@ -91,10 +91,6 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Resources
       seats_remaining
     end
 
-    # Whether BookMeBus reports which seats are booked on a date: false for auto-assigned-seat trips, and a private
-    # taxi is booked as a whole vehicle, so seat status does not apply there either.
-    def per_seat_status? = is_selectable == true && route_type != 'private_taxi'
-
     # BookMe+ charges the non-local (foreigner) price by default, falling back to local_price
     # only when BookMeBus doesn't provide one. Single source of truth for both trip-creation
     # (SyncTrips) and per-date availability refresh (SyncItemAvailability) so they can't diverge.

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/route_freshness.rb

@@ -0,0 +1,48 @@
+# When the seats of each date of a route were last refreshed: `private_metadata['seats_synced_at']` on the route's
+# mapping, as date => time. Today and tomorrow are due again after 30 minutes, later dates after 6 hours, so the seat
+# refresh only asks BookMeBus about what is old.
+class SpreeCmCommissioner::Integrations::BookMeBusV1::RouteFreshness
+  KEY = 'seats_synced_at'.freeze
+  NEVER = Time.zone.at(0).freeze
+  NEAR_DAYS = 2 # today and tomorrow
+  NEAR_TTL = 30.minutes
+  FAR_TTL = 6.hours
+
+  def initialize(mapping)
+    @mapping = mapping
+  end
+
+  # The dates of the next `days` days that are due, nearest first. A date never refreshed is due.
+  def due_dates(days:, today: Date.current, now: Time.current)
+    (0...days).filter_map do |ahead|
+      date = today + ahead
+      date.iso8601 if due?(date, ahead, now)
+    end
+  end
+
+  # When the stalest of `dates` was refreshed (NEVER if one wasn't): routes are put in this order.
+  def oldest_stamp(dates)
+    dates.map { |date| stamps_by_date[date]&.then { |stamp| Time.zone.parse(stamp) } || NEVER }.min
+  end
+
+  # Records `dates` as refreshed now and drops dates already past. Assigns only; the caller saves.
+  def stamp(dates, at: Time.current, today: Date.current)
+    kept = stamps_by_date.reject { |date, _| Date.parse(date) < today }
+    refreshed = dates.to_h { |date| [date.to_s, at.iso8601] }
+
+    @mapping.private_metadata = (@mapping.private_metadata || {}).merge(KEY => kept.merge(refreshed))
+  end
+
+  private
+
+  def due?(date, ahead, now)
+    stamp = stamps_by_date[date.iso8601]
+    return true if stamp.nil?
+
+    Time.zone.parse(stamp) < now - (ahead < NEAR_DAYS ? NEAR_TTL : FAR_TTL)
+  end
+
+  def stamps_by_date
+    (@mapping.private_metadata || {})[KEY] || {}
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/seat_layout_freshness.rb

@@ -0,0 +1,46 @@
+# Whether a trip's seat layout still matches BookMeBus without asking again.
+#
+# A seat map belongs to the vehicle type: every trip of a type has the same one. So it is refreshed from BookMeBus
+# once a day per vehicle type (the SeatLayout mapping's `last_synced_at`), not once per trip. A trip needs BookMeBus's
+# answer again only when it has no layout assigned yet, or its layout is older than its vehicle type's.
+class SpreeCmCommissioner::Integrations::BookMeBusV1::SeatLayoutFreshness
+  TEMPLATE_TTL = 24.hours
+
+  def initialize(integration)
+    @integration = integration
+    @templates = {}
+  end
+
+  def current?(variant)
+    trip = variant.trip
+    layout = trip&.seat_layout
+    return false unless layout&.blocks&.exists?(variant_id: variant.id)
+
+    template = template_of(trip.vehicle_type)
+    template.present? && template.synced_at > TEMPLATE_TTL.ago && layout.updated_at >= template.updated_at
+  end
+
+  # Call after the vehicle type's layout was refreshed, so the next check reads the new times.
+  def forget(vehicle_type)
+    @templates.delete(vehicle_type.id)
+  end
+
+  private
+
+  Template = Struct.new(:synced_at, :updated_at)
+
+  # Read once per vehicle type and run: one trip's check must not cost two queries on every poll.
+  def template_of(vehicle_type)
+    return unless vehicle_type
+
+    @templates.fetch(vehicle_type.id) { @templates[vehicle_type.id] = load_template(vehicle_type) }
+  end
+
+  def load_template(vehicle_type)
+    mapping = SpreeCmCommissioner::IntegrationMapping.active.find_by(
+      integration_id: @integration.id, internal_type: 'SpreeCmCommissioner::SeatLayout', external_id: vehicle_type.id.to_s
+    )
+    layout = mapping&.internal
+    Template.new(mapping.last_synced_at, layout.updated_at) if layout && mapping.last_synced_at
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/sync_manager.rb

@@ -8,13 +8,12 @@ class SpreeCmCommissioner::Integrations::BookMeBusV1::SyncManager < SpreeCmCommi
     end
   end
 
-  # Override incremental sync
+  # Override incremental sync. A run with nothing due makes no calls, so it leaves no session row either.
   def sync_incremental!
-    run_execution(:incremental) do
-      SpreeCmCommissioner::Integrations::BookMeBusV1::SyncStrategies::IncrementalSyncStrategy.new(
-        integration: @integration
-      ).call
-    end
+    strategy = SpreeCmCommissioner::Integrations::BookMeBusV1::SyncStrategies::IncrementalSyncStrategy.new(integration: @integration)
+    return unless strategy.work_due?
+
+    run_execution(:incremental) { strategy.call }
   end
 
   # Override webhook sync (no-op)