spree_cm_commissioner 2.14.2 → 2.14.4

data/app/services/spree_cm_commissioner/api_caches/invalidate.rb

@@ -1,5 +1,6 @@
 module SpreeCmCommissioner
   module ApiCaches
+    # Clears one record's cached API responses. Every record of a model goes through InvalidateAll.
     class Invalidate
       prepend ::Spree::ServiceModule::Base
 
@@ -16,17 +17,39 @@ module SpreeCmCommissioner
         'SpreeCmCommissioner::VotingSession' => SpreeCmCommissioner::VotingSession
       }.freeze
 
-      # eg. 'Spree::Product', 123 or 'Spree::Product', nil
-      def call(model:, id: nil)
+      # CloudFront bills per path and only allows `*` at the end, so one prefix per namespace covers
+      # every segment's homepage_sections and homepage_background, plus homepage_data, instead of a
+      # path per BIT_SEGMENT key.
+      HOMEPAGE_SECTION_PATTERNS = [
+        '/api/v2/storefront/homepage*',
+        '/api/v2/tenant/homepage*'
+      ].freeze
+
+      HOMEPAGE_BACKGROUND_PATTERNS = ['/api/v2/storefront/homepage*'].freeze
+
+      # Deliberately broad, and identical for single-record and all-record
+      # invalidation: a payment method is either vendor-owned or store-level, and a
+      # store-level one is served for every vendor through the fallback in
+      # SpreeCmCommissioner::PaymentMethods::Find. From the record alone we cannot
+      # tell which vendors are affected.
+      #
+      # vendor_id is a query param, so the trailing `*` is what clears every
+      # vendor's cached variant of this path in one go.
+      #
+      # Payment methods change a handful of times a year, so a broad invalidation
+      # is cheap.
+      PAYMENT_METHOD_PATTERNS = [
+        '/api/v2/tenant/payment_methods*',
+        '/api/v2/storefront/payment_methods*'
+      ].freeze
+
+      # eg. 'Spree::Product', 123
+      def call(model:, id:)
         model_class = SUPPORTED_MODELS[model]
 
         return failure(nil, 'Model is not supported') if model_class.nil?
 
-        if id.present?
-          invalidate_single_record(model_class: model_class, id: id)
-        else
-          invalidate_all_records(model_class: model_class)
-        end
+        invalidate_single_record(model_class: model_class, id: id)
       end
 
       # eg. 'Spree::Product', 123 => ['/api/v2/tenant/products/123', '/api/v2/tenant/products/slug-of-product', ...]
@@ -38,7 +61,10 @@ module SpreeCmCommissioner
 
         refresh_record_cache_key(record)
 
-        api_patterns = single_api_pattern[record.class.name].map do |pattern|
+        # The record's own class first (a Show found as a Spree::Taxon keeps its show paths), then the
+        # model asked for, since STI subclasses such as Spree::Gateway::Payway have no entry of their own.
+        patterns = single_api_pattern[record.class.name] || single_api_pattern[model_class.name]
+        api_patterns = patterns.map do |pattern|
           pattern.gsub(/:(\w+)/) do
             key = Regexp.last_match(1)
             record.public_send(key).to_s
@@ -50,26 +76,13 @@ module SpreeCmCommissioner
         success(record: record, api_patterns: api_patterns)
       end
 
-      # eg. 'Spree::Product' => ['/api/v2/tenant/products/*', '/api/v2/storefront/products/*']
-      def invalidate_all_records(model_class:)
-        model_class.find_each do |record|
-          refresh_record_cache_key(record)
-        end
-
-        enqueue_invalidate(invalidate_uris[model_class.name])
-
-        success(api_patterns: invalidate_uris[model_class.name])
-      end
-
       def single_api_pattern
         {
-          'SpreeCmCommissioner::HomepageSection' => homepage_section_patterns,
-          'SpreeCmCommissioner::HomepageBackground' => homepage_background_patterns,
+          'SpreeCmCommissioner::HomepageSection' => HOMEPAGE_SECTION_PATTERNS,
+          'SpreeCmCommissioner::HomepageBackground' => HOMEPAGE_BACKGROUND_PATTERNS,
           'SpreeCmCommissioner::SeatLayout' => ['/api/v2/storefront/seat_layouts/:id*'],
-          'Spree::Menu' => [
-            '/api/v2/storefront/menus/:id*',
-            '/api/v2/storefront/homepage_data*'
-          ],
+          # The app reads menus from homepage_data; nothing calls /menus any more.
+          'Spree::Menu' => ['/api/v2/storefront/homepage_data*'],
           'Spree::Taxon' => [
             '/api/v2/tenant/taxons/:id*',
             '/api/v2/tenant/taxons/:permalink*',
@@ -92,50 +105,12 @@ module SpreeCmCommissioner
             '/api/v2/storefront/accommodations/:id*',
             '/api/v2/storefront/accommodations/:slug*'
           ],
-          'Spree::PaymentMethod' => payment_method_patterns
-        }
-      end
-
-      def invalidate_uris
-        {
-          'SpreeCmCommissioner::HomepageSection' => homepage_section_patterns,
-          'SpreeCmCommissioner::HomepageBackground' => homepage_background_patterns,
-          'SpreeCmCommissioner::SeatLayout' => ['/api/v2/storefront/seat_layouts/*'],
-          'Spree::Menu' => ['/api/v2/storefront/menus/*'],
-          'Spree::Taxon' => ['/api/v2/storefront/taxons/*'],
-          'Spree::Product' => [
-            '/api/v2/tenant/products/*',
-            '/api/v2/storefront/products/*'
-          ],
-          'Spree::Vendor' => [
-            '/api/v2/tenant/vendors/*',
-            '/api/v2/storefront/vendors/*',
-            '/api/v2/storefront/accommodations/*'
-          ],
-          'Spree::PaymentMethod' => payment_method_patterns
+          'Spree::PaymentMethod' => PAYMENT_METHOD_PATTERNS
         }
       end
 
       private
 
-      # Deliberately broad, and identical for single-record and all-record
-      # invalidation: a payment method is either vendor-owned or store-level, and a
-      # store-level one is served for every vendor through the fallback in
-      # SpreeCmCommissioner::PaymentMethods::Find. From the record alone we cannot
-      # tell which vendors are affected.
-      #
-      # vendor_id is a query param, so the trailing `*` is what clears every
-      # vendor's cached variant of this path in one go.
-      #
-      # Payment methods change a handful of times a year, so a broad invalidation
-      # is cheap.
-      def payment_method_patterns
-        [
-          '/api/v2/tenant/payment_methods*',
-          '/api/v2/storefront/payment_methods*'
-        ]
-      end
-
       # eg. updated_at: Fri, 26 Dec 2025 10:40:56.505450000 +07 +07:00
       def refresh_record_cache_key(record)
         # rubocop:disable Rails/SkipsModelValidations
@@ -147,29 +122,6 @@ module SpreeCmCommissioner
       def enqueue_invalidate(patterns)
         SpreeCmCommissioner::InvalidateCacheRequestJob.perform_later(patterns: patterns)
       end
-
-      # Every key of BIT_SEGMENT (general, ticket, ..., ferry).
-      def homepage_segment
-        SpreeCmCommissioner::HomepageSectionBitwise::BIT_SEGMENT.keys
-      end
-
-      def homepage_section_patterns
-        homepage_segment.flat_map do |segment|
-          [
-            "/api/v2/storefront/homepage/#{segment}/homepage_sections*",
-            "/api/v2/tenant/homepage/#{segment}/homepage_sections*"
-          ]
-        end
-      end
-
-      def homepage_background_patterns
-        patterns = homepage_segment.map do |segment|
-          "/api/v2/storefront/homepage/#{segment}/homepage_background*"
-        end
-
-        patterns << '/api/v2/storefront/homepage_data*'
-        patterns
-      end
     end
   end
 end

data/app/services/spree_cm_commissioner/api_caches/invalidate_all.rb

@@ -0,0 +1,61 @@
+module SpreeCmCommissioner
+  module ApiCaches
+    # Clears every record of a model for one storefront. `tenant` is required so a clear-all never
+    # pays for both namespaces by accident: nil is the BookMe+ storefront (/api/v2/storefront/
+    # paths), a SpreeCmCommissioner::Tenant is that tenant's API (/api/v2/tenant/ paths).
+    #
+    # Tenant APIs take the tenant from the OAuth token, not the URL, so every tenant shares one path
+    # today; taking the record keeps callers the same if tenant paths ever carry it.
+    #
+    # eg. InvalidateAll.call(model: 'SpreeCmCommissioner::HomepageSection', tenant: nil)
+    class InvalidateAll
+      prepend ::Spree::ServiceModule::Base
+
+      TENANT_PREFIX = '/api/v2/tenant/'.freeze
+
+      API_PATTERNS = {
+        'SpreeCmCommissioner::HomepageSection' => Invalidate::HOMEPAGE_SECTION_PATTERNS,
+        'SpreeCmCommissioner::HomepageBackground' => Invalidate::HOMEPAGE_BACKGROUND_PATTERNS,
+        'SpreeCmCommissioner::SeatLayout' => ['/api/v2/storefront/seat_layouts/*'],
+        'Spree::Menu' => ['/api/v2/storefront/homepage_data*'],
+        'Spree::Taxon' => ['/api/v2/storefront/taxons/*'],
+        'Spree::Product' => [
+          '/api/v2/tenant/products/*',
+          '/api/v2/storefront/products/*'
+        ],
+        'Spree::Vendor' => [
+          '/api/v2/tenant/vendors/*',
+          '/api/v2/storefront/vendors/*',
+          '/api/v2/storefront/accommodations/*'
+        ],
+        'Spree::PaymentMethod' => Invalidate::PAYMENT_METHOD_PATTERNS
+      }.freeze
+
+      def call(model:, tenant:)
+        model_class = Invalidate::SUPPORTED_MODELS[model] if API_PATTERNS.key?(model)
+        return failure(nil, 'Model is not supported') if model_class.nil?
+        return failure(nil, 'tenant must be a SpreeCmCommissioner::Tenant or nil') unless tenant.nil? || tenant.is_a?(SpreeCmCommissioner::Tenant)
+
+        refresh_records_cache_key(model_class, tenant)
+
+        api_patterns = API_PATTERNS[model].select { |pattern| pattern.start_with?(TENANT_PREFIX) == tenant.present? }
+
+        # Empty when the model has no API in this namespace, e.g. homepage backgrounds for a tenant,
+        # and CloudFront rejects an empty batch.
+        SpreeCmCommissioner::InvalidateCacheRequestJob.perform_later(patterns: api_patterns) if api_patterns.any?
+
+        success(api_patterns: api_patterns)
+      end
+
+      private
+
+      # updated_at keys Spree's serializer and collection caches, so only this storefront's records
+      # are touched when the model is tenant-scoped.
+      def refresh_records_cache_key(model_class, tenant)
+        scope = model_class.column_names.include?('tenant_id') ? model_class.where(tenant_id: tenant&.id) : model_class.all
+
+        scope.find_each(&:touch)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/audit_events/cleanup_expired.rb

@@ -0,0 +1,58 @@
+module SpreeCmCommissioner
+  module AuditEvents
+    class CleanupExpired
+      prepend ::Spree::ServiceModule::Base
+
+      BATCH_SIZE = 1_000
+      TIME_BUDGET = 30.seconds
+
+      # Deletes expired audit events chunk by chunk until none are left or the time budget is spent, so a large backlog
+      # never pins a Sidekiq thread past its shutdown window. CleanupExpiredJob schedules the next run while
+      # `more_remaining` is true.
+      #
+      # Safe to delete without callbacks: nothing references cm_audit_events (checked in cm-market-server/db/schema.rb).
+      # Errors are not rescued on purpose: a failed drain must surface to Sidekiq (retry + alert), not end quietly.
+      def call(batch_size: BATCH_SIZE, time_budget: TIME_BUDGET)
+        started_at = monotonic_now
+        deleted_count = 0
+        batches = 0
+        more_remaining = false
+
+        loop do
+          deleted = delete_expired_chunk(batch_size)
+          deleted_count += deleted
+          batches += 1 if deleted.positive?
+
+          break if deleted < batch_size
+
+          if monotonic_now - started_at >= time_budget.to_f
+            more_remaining = true
+            break
+          end
+        end
+
+        elapsed_ms = ((monotonic_now - started_at) * 1000).round
+        log_completion(deleted_count: deleted_count, batches: batches, elapsed_ms: elapsed_ms, more_remaining: more_remaining)
+
+        success(deleted_count: deleted_count, batches: batches, more_remaining: more_remaining)
+      end
+
+      private
+
+      # One `DELETE ... WHERE id IN (SELECT id ... LIMIT n)`: no rows are loaded into Ruby.
+      def delete_expired_chunk(batch_size)
+        SpreeCmCommissioner::AuditEvent
+          .where(id: SpreeCmCommissioner::AuditEvent.expired.limit(batch_size).select(:id))
+          .delete_all
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def log_completion(**data)
+        CmAppLogger.log(label: 'SpreeCmCommissioner::AuditEvents::CleanupExpired completed', data: data)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/audit_logger.rb

@@ -30,7 +30,7 @@ module SpreeCmCommissioner
         attempt: 0,
         retention_days: nil
       )
-        retention_until = (retention_days || 90).days.from_now.to_date
+        retention_until = (retention_days || SpreeCmCommissioner::AuditEvent::DEFAULT_RETENTION_DAYS).days.from_now.to_date
 
         SpreeCmCommissioner::AuditEventJob.perform_later(
           event_type: event_type,

data/app/services/spree_cm_commissioner/guests/build_dynamic_field_attributes.rb

@@ -0,0 +1,34 @@
+module SpreeCmCommissioner
+  module Guests
+    # Option-based fields (checkbox/radio/selection) become one GuestDynamicField row per selected
+    # option id; Guests::Update's own auto-cleanup destroys rows for deselected options. Fields not
+    # enabled on the guest's product are dropped.
+    class BuildDynamicFieldAttributes
+      def self.call(guest:, dynamic_fields:)
+        new(guest, dynamic_fields).call
+      end
+
+      def initialize(guest, dynamic_fields)
+        @guest = guest
+        @dynamic_fields = dynamic_fields
+      end
+
+      def call
+        return [] if @dynamic_fields.blank?
+
+        enabled_fields = @guest.line_item.product.dynamic_fields.index_by(&:id)
+
+        @dynamic_fields.flat_map do |dynamic_field_id, value|
+          dynamic_field = enabled_fields[dynamic_field_id.to_s.to_i]
+          next [] unless dynamic_field
+
+          if dynamic_field.requires_dynamic_field_options?
+            Array(value).compact_blank.map { |option_id| { dynamic_field_id: dynamic_field.id, dynamic_field_option_id: option_id } }
+          else
+            [{ dynamic_field_id: dynamic_field.id, value: value }]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -116,34 +116,31 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
       # vehicle_type is a shared BookMeBus category (many different physical buses/trips can
       # report the same vehicle_type_id), but the seat map we just fetched is specific to one
-      # trip's stop segment. Re-writing this shared template on every poll means whichever trip
-      # synced last silently overwrites (and, via cleanup_stale_blocks!, deletes seats from) the
-      # template every other trip of that vehicle_type duplicates from on creation. Only seed it
-      # once; each trip's own duplicated SeatLayout is what stays continuously in sync afterward
-      # (see duplicate_to_trip_if_needed!/sync_trip_seat_layout!).
+      # trip's stop segment. Adding or deleting seats on this shared template on every poll would let
+      # whichever trip synced last rewrite the template every other trip duplicates from, so its seats
+      # are only created once. Its geometry (sections, padding, spacing) is re-applied every time though,
+      # so templates synced before the builder standard heal on their next sync.
       if seat_layout.persisted?
+        apply_builder_layout!(seat_layout, external_seat_layout, create_missing: false)
         backfill_vehicle_type_seats!(vehicle_type, seat_layout)
         return seat_layout
       end
 
-      # Calculate dimensions based on layout
-      dimensions = calculate_layout_dimensions(external_seat_layout)
+      builder_layout = external_seat_layout.builder_layout
 
-      # Update seat layout attributes
       @sync_result.track(:seat_layout, seat_layout) do |tracker|
         seat_layout.assign_attributes(
           name: build_seat_layout_name(vehicle_type, external_seat_layout),
           status: :active,
-          width: dimensions[:width],
-          height: dimensions[:height],
+          width: builder_layout[:width],
+          height: builder_layout[:height],
           total_seats: external_seat_layout.seats.count,
           layoutable: vehicle_type
         )
         tracker.save_if_changed!(seat_layout)
       end
 
-      # Sync blocks (seats) for this layout - no variant for templates
-      sync_blocks!(seat_layout: seat_layout, external_seat_layout: external_seat_layout, variant: nil)
+      apply_builder_layout!(seat_layout, external_seat_layout, create_missing: true)
 
       backfill_vehicle_type_seats!(vehicle_type, seat_layout)
 
@@ -219,6 +216,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
       return if trip_seat_layout.blank?
 
+      apply_builder_layout!(trip_seat_layout, external_seat_layout, create_missing: false)
+
       # Assign variants to sellable blocks
       trip_seat_layout.blocks.each do |block|
         next unless block.sellable?
@@ -245,134 +244,52 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       "#{vehicle_type.name} Layout (#{seat_count} seats)"
     end
 
-    # Calculate layout dimensions based on external seat layout
+    # Lays the seats out exactly as the BookMe+ seat layout builder would (Resources::SeatLayout#builder_layout): one
+    # section per BookMeBus layer, named with the layer key (UnstockInventory sends it back as the reservation layer),
+    # seats matched by label so block ids, variants and reserved blocks survive. Idempotent: positions are a pure
+    # function of BookMeBus's grid, so a re-sync writes nothing once a layout matches.
     #
-    # @param external_seat_layout [Resources::SeatLayout]
-    # @return [Hash] Hash with :width and :height keys
-    def calculate_layout_dimensions(external_seat_layout)
-      block_width = 50
-      block_height = 50
-      gap = 10
-      padding = 200
-      layer_gap = 100
-
-      rows = external_seat_layout.row_count
-      columns = external_seat_layout.column_count
-      layer_count = external_seat_layout.primary_layout.keys.count
-
-      # Layers (e.g. lower/upper deck) sit side by side, not stacked - see
-      # Resources::SeatLayout#to_internal_blocks_attributes for the matching block placement.
-      width = (layer_count * columns * (block_width + gap)) + ((layer_count - 1) * layer_gap) + padding
-      height = (rows * (block_height + gap)) + padding
-
-      { width: width, height: height }
-    end
-
-    # Sync blocks for a seat layout
-    #
-    # This method creates or updates Block records from the external seat layout.
-    # It handles multi-layer layouts (e.g., double-decker buses) and assigns
-    # coordinates based on row/column positions.
-    #
-    # @param seat_layout [SpreeCmCommissioner::SeatLayout] The internal seat layout
-    # @param external_seat_layout [Resources::SeatLayout] External seat layout data
-    # @param variant [Spree::Variant] Optional variant to assign to blocks
-    def sync_blocks!(seat_layout:, external_seat_layout:, variant: nil)
-      # Get block attributes from external layout
-      blocks_attrs = external_seat_layout.to_internal_blocks_attributes(seat_layout)
-
-      # Track existing blocks by label for updates
-      existing_blocks = seat_layout.blocks.index_by(&:label)
-      seat_sections_by_layer = build_seat_sections_by_layer(seat_layout, blocks_attrs)
-
-      blocks_attrs.each do |block_attrs|
-        label = block_attrs[:label]
-        block = existing_blocks[label] || seat_layout.blocks.build
-        section = seat_sections_by_layer[block_attrs.dig(:metadata, :layer)]
-
-        @sync_result.track(:block, block) do |tracker|
-          # Only assign variant to sellable blocks (seat, sleeping_seat, standing)
-          block_variant = SpreeCmCommissioner::Block.sellable?(block_attrs[:block_type]) ? variant : nil
-
-          block.assign_attributes(
-            label: block_attrs[:label],
-            block_type: block_attrs[:block_type],
-            width: block_attrs[:width],
-            height: block_attrs[:height],
-            # cm-block renders position:absolute inside its parent cm-seat-section (also
-            # position:absolute), so a sectioned block's x/y must be relative to the section's
-            # own origin - not the canvas-absolute value every block starts with - or the section's
-            # offset gets applied twice and seats render far outside their section.
-            x: block_attrs[:x] - (section&.x || 0),
-            y: block_attrs[:y] - (section&.y || 0),
-            rotation: block_attrs[:rotation],
-            seat_layout: seat_layout,
-            seat_section: section,
-            variant: block_variant
-          )
-
-          tracker.save_if_changed!(block)
+    # create_missing: true builds a new template's seats; false only re-positions seats that already exist (a shared
+    # template or a trip copy must not gain or lose seats from one trip's segment).
+    def apply_builder_layout!(seat_layout, external_seat_layout, create_missing:)
+      builder_layout = external_seat_layout.builder_layout
+      blocks_by_label = seat_layout.blocks.index_by(&:label)
+
+      builder_layout[:sections].each do |section_attrs|
+        section = sync_seat_section!(seat_layout, section_attrs)
+
+        section_attrs[:blocks].each do |block_attrs|
+          block = blocks_by_label[block_attrs[:label]] || (seat_layout.blocks.build if create_missing)
+          next if block.nil?
+
+          @sync_result.track(:block, block) do |tracker|
+            block.assign_attributes(
+              block_attrs.slice(:label, :block_type, :width, :height, :x, :y, :rotation).merge(seat_layout: seat_layout, seat_section: section)
+            )
+            tracker.save_if_changed!(block)
+          end
         end
       end
 
-      # Remove blocks that no longer exist in the external layout
-      cleanup_stale_blocks!(seat_layout: seat_layout, synced_labels: blocks_attrs.pluck(:label))
-    end
+      remove_empty_stale_sections!(seat_layout, builder_layout[:sections].pluck(:name))
 
-    # A single-layer bus (the overwhelming common case - "BUS" only) keeps its blocks
-    # top-level (no seat_section), matching prior behavior exactly. Only a genuinely
-    # multi-layer layout (double-decker: "BUS" + "UPPER_DECK") gets one SeatSection per
-    # layer, so `block.seat_section&.name` reports the real deck instead of always
-    # falling back to the 'BUS' default UnstockInventory uses when it's nil. A single layer's real name is
-    # kept in the template mapping's `layers` payload instead - UnstockInventory#single_layer_name reads it.
-    #
-    # @return [Hash{String => SpreeCmCommissioner::SeatSection}] section per layer name
-    def build_seat_sections_by_layer(seat_layout, blocks_attrs)
-      attrs_by_layer = blocks_attrs.group_by { |attrs| attrs.dig(:metadata, :layer) }
-      return {} if attrs_by_layer.size <= 1
-
-      attrs_by_layer.each_with_object({}) do |(layer_name, attrs_for_layer), sections|
-        next if layer_name.blank?
-
-        sections[layer_name] = find_or_build_seat_section!(seat_layout, layer_name, attrs_for_layer)
+      @sync_result.track(:seat_layout, seat_layout) do |tracker|
+        seat_layout.assign_attributes(width: builder_layout[:width], height: builder_layout[:height])
+        tracker.save_if_changed!(seat_layout)
       end
     end
 
-    # Section geometry is a bounding box around its layer's blocks so it renders sanely,
-    # not just a placeholder - SeatSection requires positive width/height.
-    def find_or_build_seat_section!(seat_layout, layer_name, attrs_for_layer)
-      section = seat_layout.seat_sections.find_or_initialize_by(name: layer_name)
-
-      min_x = attrs_for_layer.pluck(:x).min
-      min_y = attrs_for_layer.pluck(:y).min
-      max_x = attrs_for_layer.map { |a| a[:x] + a[:width] }.max
-      max_y = attrs_for_layer.map { |a| a[:y] + a[:height] }.max
-
-      section.assign_attributes(x: min_x, y: min_y, width: max_x - min_x, height: max_y - min_y, rotation: 0)
+    def sync_seat_section!(seat_layout, section_attrs)
+      section = seat_layout.seat_sections.find_or_initialize_by(name: section_attrs[:name])
+      section.assign_attributes(section_attrs.slice(:x, :y, :width, :height).merge(rotation: 0))
       section.save! if section.new_record? || section.changed?
       section
     end
 
-    # Remove blocks that are no longer in the external layout
-    #
-    # @param seat_layout [SpreeCmCommissioner::SeatLayout] The seat layout
-    # @param synced_labels [Array<String>] Labels of blocks that were synced
-    def cleanup_stale_blocks!(seat_layout:, synced_labels:)
-      synced_labels_set = synced_labels.to_set
-
-      seat_layout.blocks.each do |block|
-        next if synced_labels_set.include?(block.label)
-
-        # Only delete blocks that don't have active reservations
-        if block.respond_to?(:all_reserved_blocks) && block.all_reserved_blocks.reserved_or_on_hold.exists?
-          Rails.logger.warn("[SyncSeatLayout] Skipping deletion of block #{block.label} - has active reservations")
-          next
-        end
-
-        @sync_result.track(:block, block) do |_tracker|
-          block.destroy!
-          @sync_result.increment_metric(:block, :deleted)
-        end
+    # A layer BookMeBus no longer reports. Kept while it still holds seats, so nothing with a reservation disappears.
+    def remove_empty_stale_sections!(seat_layout, layer_names)
+      seat_layout.seat_sections.where.not(name: layer_names).find_each do |section|
+        section.destroy! if section.blocks.empty?
       end
     end