spree_core 5.4.3 → 5.5.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8ff8a33cfaa4b9554bb3658995a2ed99d1715cb2365d3da012fce5dd2bbd518
-  data.tar.gz: fd19b449aa211be4cbec760db28e573064f9112d8c0922bf78517e51c0fc5002
+  metadata.gz: '017291169758b3fc4f9791b940c3264c91df65cd9197621ca0cafd8e3ade2ba1'
+  data.tar.gz: a4f6cfd15c25ce054ce792d545eaf6db7e815b023d66348b4c44d5a226abb3c2
 SHA512:
-  metadata.gz: 5a392b8f08c1732f3b661a8758d37d63ac70e2aa7cf39d01dff5521c0e3267b1ee87ed190ea2cdddf914c7bf83462ebb6c7809736b5243610ab6d5e55c411300
-  data.tar.gz: 841e2707d2535a628a1cc2c743d594276a1cda0a969dd243ed8d82329f53f5d96bda3433517e40d0e261ef79159a7faae9cb57ebb1c5975b6bd2ea00f17d7641
+  metadata.gz: 83d3c2a6c3b13d4c508ab4f4c5c15deb544eb3ba7da48ddd966d872d76ec301f7b87093bc0eb42bd12fe1507575ca09b82919796b079a4aa4e66d71d76dd6332
+  data.tar.gz: 4453580426836b0b3333309c1eaadabf4bca2fa1fbd8cea51ab1fc1b59c9e02409d098f63e7c77e5dcce222746263d53e021ec3f1b724fd2daa71c623ca573d0

data/app/helpers/spree/base_helper.rb

@@ -22,82 +22,10 @@ module Spree
       end.sort_by { |c| c.name.parameterize }
     end
 
-    def spree_resource_path(resource)
-      Spree::Deprecation.warn('BaseHelper#spree_resource_path is deprecated and will be removed in Spree 5.5')
-
-      last_word = resource.class.name.split('::', 10).last
-
-      spree_class_name_as_path(last_word)
-    end
-
-    def spree_class_name_as_path(class_name)
-      Spree::Deprecation.warn('BaseHelper#spree_class_name_as_path is deprecated and will be removed in Spree 5.5')
-
-      class_name.underscore.humanize.parameterize(separator: '_')
-    end
-
-    def display_price(product_or_variant)
-      Spree::Deprecation.warn('display_price is deprecated and will be removed in Spree 5.5. Use variant.price_for(context).display_amount instead.')
-
-      product_or_variant.
-        price_in(current_currency).
-        display_price_including_vat_for(current_price_options).
-        to_html
-    end
-
-    def display_compare_at_price(product_or_variant)
-      Spree::Deprecation.warn('display_compare_at_price is deprecated and will be removed in Spree 5.5. Use variant.price_for(context).display_compare_at_amount instead.')
-
-      product_or_variant.
-        price_in(current_currency).
-        display_compare_at_price_including_vat_for(current_price_options).
-        to_html
-    end
-
-    def link_to_tracking(shipment, options = {})
-      Spree::Deprecation.warn('BaseHelper#link_to_tracking is deprecated and will be removed in Spree 5.5. Please use shipment.tracking_url instead.')
-
-      return unless shipment.tracking && shipment.shipping_method
-
-      options[:target] ||= :blank
-
-      if shipment.tracking_url
-        link_to(shipment.tracking, shipment.tracking_url, options)
-      else
-        content_tag(:span, shipment.tracking)
-      end
-    end
-
     def object
       instance_variable_get('@' + controller_name.singularize)
     end
 
-    def pretty_time(time)
-      return '' if time.blank?
-
-      Spree::Deprecation.warn('BaseHelper#pretty_time is deprecated and will be removed in Spree 5.5. Please add `local_time` gem to your Gemfile and use `local_time(time)` instead')
-
-      [I18n.l(time.to_date, format: :long), time.strftime('%l:%M %p %Z')].join(' ')
-    end
-
-    def pretty_date(date)
-      return '' if date.blank?
-
-      Spree::Deprecation.warn('BaseHelper#pretty_date is deprecated and will be removed in Spree 5.5. Please add `local_time` gem to your Gemfile and use `local_date(date)` instead')
-
-      [I18n.l(date.to_date, format: :long)].join(' ')
-    end
-
-    def seo_url(taxon, options = {})
-      Spree::Deprecation.warn('BaseHelper#seo_url is deprecated and will be removed in Spree 5.5. Please use spree_storefront_resource_url')
-      spree.nested_taxons_path(taxon.permalink, options.merge(locale: locale_param))
-    end
-
-    def frontend_available?
-      Spree::Deprecation.warn('BaseHelper#frontend_available? is deprecated and will be removed in Spree 5.5')
-      Spree::Core::Engine.frontend_available?
-    end
-
     # returns the URL of an object on the storefront
     # @param resource [Spree::Product, Spree::Taxon, Spree::Page] the resource to get the URL for
     # @param options [Hash] the options for the URL
@@ -160,11 +88,6 @@ module Spree
       product_or_variant.primary_media
     end
 
-    def base_cache_key
-      Spree::Deprecation.warn('`base_cache_key` is deprecated and will be removed in Spree 5.5. Please use `spree_base_cache_key` instead')
-      spree_base_cache_key
-    end
-
     def spree_base_cache_key
       @spree_base_cache_key ||= [
         I18n.locale,
@@ -178,11 +101,6 @@ module Spree
       ->(record = nil) { [*spree_base_cache_key, record].compact_blank }
     end
 
-    def maximum_quantity
-      Spree::Deprecation.warn('BaseHelper#maximum_quantity is deprecated and will be removed in Spree 5.5')
-      Spree::DatabaseTypeUtilities::INTEGER_MAX
-    end
-
     def payment_method_icon_tag(payment_method, opts = {})
       return '' unless defined?(inline_svg)
 

data/app/helpers/spree/currency_helper.rb

@@ -42,18 +42,6 @@ module Spree
       [label, currency]
     end
 
-    # Returns the list of supported currencies for the current store.
-    # @return [Array<Money::Currency>] the list of supported currencies
-    def preferred_currencies
-      Spree::Deprecation.warn('preferred_currencies is deprecated and will be removed in Spree 5.5. Use current_store.supported_currencies_list instead.')
-      @preferred_currencies ||= current_store.supported_currencies_list
-    end
-
-    def preferred_currencies_select_options
-      Spree::Deprecation.warn('preferred_currencies_select_options is deprecated and will be removed in Spree 5.5. Use supported_currency_options instead.')
-      preferred_currencies.map { |currency| currency_presentation(currency) }
-    end
-
     def currency_money(currency = current_currency)
       ::Money::Currency.find(currency)
     end

data/app/helpers/spree/products_helper.rb

@@ -120,14 +120,6 @@ module Spree
         limit(Spree::Config[:products_per_page])
     end
 
-    def related_products
-      Spree::Deprecation.warn('ProductsHelper#related_products is deprecated and will be removed in Spree 5.5. Please use ProductsHelper#relations from now on.')
-
-      return [] unless @product.respond_to?(:has_related_products?)
-
-      @related_products ||= relations_by_type('related_products')
-    end
-
     def product_available_in_currency?
       !(@product_price.nil? || @product_price.zero?)
     end

data/app/jobs/spree/base_job.rb

@@ -1,5 +1,23 @@
 module Spree
+  # Shared base for every Spree job.
+  #
+  # Retries only transient infrastructure errors. Broad replay is unsafe here because
+  # most jobs have non-idempotent post-work side effects (counters, state transitions,
+  # lifecycle events, external calls); jobs whose work is retry-safe opt in to
+  # `retry_on StandardError` themselves (see `Spree::WebhookDeliveryJob`,
+  # `Spree::Events::SubscriberJob`). RecordNotFound gets its own tighter policy
+  # to absorb the Sidekiq enqueue-vs-DB-commit race (sub-second window) without
+  # holding the queue for genuine deletes.
   class BaseJob < ApplicationJob
     queue_as Spree.queues.default
+
+    retry_on ActiveRecord::Deadlocked,
+             ActiveRecord::LockWaitTimeout,
+             ActiveRecord::ConnectionNotEstablished,
+             ActiveRecord::ConnectionFailed,
+             wait: :polynomially_longer, attempts: 5
+    retry_on ActiveRecord::RecordNotFound, wait: 2.seconds, attempts: 3
+
+    discard_on ActiveJob::DeserializationError
   end
 end

data/app/jobs/spree/events/subscriber_job.rb

@@ -16,7 +16,8 @@ module Spree
     class SubscriberJob < Spree::BaseJob
       queue_as Spree.queues.events
 
-      # Retry configuration
+      # Subscribers run user-defined code that can hit external services; broad retry
+      # is intentional.
       retry_on StandardError, wait: :polynomially_longer, attempts: 3
 
       discard_on ActiveJob::DeserializationError do |job, error|

data/app/jobs/spree/exports/generate_job.rb

@@ -3,6 +3,17 @@ module Spree
     class GenerateJob < Spree::BaseJob
       queue_as Spree.queues.exports
 
+      # `Export#generate` is not retry-safe: each call re-attaches a new ActiveStorage
+      # blob (leaving the prior one orphaned) and re-enqueues the completion email.
+      # Opt out of the parent's retry policy so transient errors fail fast into the
+      # dead queue for operator review rather than producing duplicate side effects.
+      retry_on ActiveRecord::Deadlocked,
+               ActiveRecord::LockWaitTimeout,
+               ActiveRecord::ConnectionNotEstablished,
+               ActiveRecord::ConnectionFailed,
+               ActiveRecord::RecordNotFound,
+               attempts: 1
+
       def perform(export_id)
         export = Spree::Export.find_by_prefix_id!(export_id)
         export.generate

data/app/jobs/spree/images/save_from_url_job.rb

@@ -11,7 +11,7 @@ module Spree
       discard_on URI::InvalidURIError
       discard_on SsrfFilter::Error
 
-      def perform(viewable_id, viewable_type, external_url, external_id = nil, position = nil)
+      def perform(viewable_id, viewable_type, external_url, external_id = nil, position = nil, link_variant_id = nil)
         viewable = viewable_type.safe_constantize.find(viewable_id)
 
         Spree::Image.ensure_metafield_definition_exists!(Spree::Image::EXTERNAL_URL_METAFIELD_KEY)
@@ -30,9 +30,14 @@ module Spree
 
         # don't re-download the image if it's already been downloaded
         # still trigger save! if position has changed
-        image.save! and return if image_already_saved?(image, external_url)
+        if image_already_saved?(image, external_url)
+          image.save!
+          link_to_variant(image, link_variant_id)
+          return
+        end
 
         download_and_attach_image(external_url, image, external_id)
+        link_to_variant(image, link_variant_id)
       rescue ActiveStorage::IntegrityError => e
         raise e unless Rails.env.test?
       end
@@ -85,21 +90,31 @@ module Spree
         image.persisted? && image.attachment.attached? && image.external_url.present? && external_url == image.external_url
       end
 
+      # `Product#images` delegates to the master variant (legacy alias) — use
+      # `Product#media` so 5.5 product-level uploads don't get re-pinned to master.
+      def viewable_assets(viewable)
+        viewable.is_a?(Spree::Product) ? viewable.media : viewable.images
+      end
+
       def image_scope(viewable)
-        if Spree::Image.respond_to?(:with_deleted)
-          viewable.images.with_deleted
-        else
-          viewable.images
-        end
+        scope = viewable_assets(viewable)
+        scope.respond_to?(:with_deleted) ? scope.with_deleted : scope
       end
 
       def find_or_initialize_image(viewable, external_url, external_id = nil)
         if external_id.present? && viewable.respond_to?(:external_id)
           image_scope(viewable).find_or_initialize_by(external_id: external_id)
         else
-          image_scope(viewable).with_external_url(external_url).first || viewable.images.new
+          image_scope(viewable).with_external_url(external_url).first || viewable_assets(viewable).new
         end
       end
+
+      def link_to_variant(image, variant_id)
+        return if variant_id.blank?
+        return unless image.persisted? && image.viewable_type == 'Spree::Product'
+
+        Spree::VariantMedia.find_or_create_by(variant_id: variant_id, media_id: image.id)
+      end
     end
   end
 end

data/app/jobs/spree/imports/assign_tags_job.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Imports
+    class AssignTagsJob < Spree::Imports::BaseJob
+      def perform(product_id, tags)
+        product = Spree::Product.find(product_id)
+        product.tag_list = tags
+        product.save!
+      end
+    end
+  end
+end

data/app/jobs/spree/imports/base_job.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Imports
+    # Shared base for every job in the imports pipeline.
+    #
+    # The narrow transient-error retry policy is inherited from `Spree::BaseJob`;
+    # we only override the queue here. Per-row business errors are caught inside
+    # `Spree::ImportRow#process!` and converted to `row.fail!`, so they never
+    # bubble up to the job layer. Subclasses may extend the retry list (e.g.
+    # `CreateCategoriesJob` adds `RecordNotUnique` to recover from concurrent
+    # taxon creation races).
+    class BaseJob < Spree::BaseJob
+      queue_as Spree.queues.imports
+    end
+  end
+end

data/app/jobs/spree/imports/create_categories_job.rb

@@ -0,0 +1,37 @@
+module Spree
+  module Imports
+    class CreateCategoriesJob < Spree::Imports::BaseJob
+      # Concurrent imports can race on `with_matching_name(...).first || create!(...)`
+      # for the same taxonomy/taxon name and hit the unique index; a retry then finds
+      # the peer's committed row.
+      retry_on ActiveRecord::RecordNotUnique, wait: :polynomially_longer, attempts: 5
+
+      def perform(product_id, store_id, taxon_pretty_names)
+        product = Spree::Product.find(product_id)
+        store = Spree::Store.find(store_id)
+        taxons = taxon_pretty_names.filter_map { |taxon_pretty_name| find_or_create_taxon(store, taxon_pretty_name) }
+
+        product.taxons = taxons
+      end
+
+      private
+
+      def find_or_create_taxon(store, taxon_pretty_name)
+        taxon_names = taxon_pretty_name.strip.split('->').map(&:strip).map(&:presence).compact
+        return if taxon_names.empty?
+
+        taxonomy_name = taxon_names.shift
+        taxonomy = store.taxonomies.with_matching_name(taxonomy_name).first || store.taxonomies.create!(name: taxonomy_name)
+
+        last_taxon = taxonomy.root
+
+        taxon_names.each do |taxon_name|
+          last_taxon = taxonomy.taxons.with_matching_name(taxon_name).where(parent: last_taxon).first ||
+                       taxonomy.taxons.create!(name: taxon_name, parent: last_taxon)
+        end
+
+        last_taxon
+      end
+    end
+  end
+end

data/app/jobs/spree/imports/create_rows_job.rb

@@ -1,8 +1,6 @@
 module Spree
   module Imports
-    class CreateRowsJob < Spree::BaseJob
-      queue_as Spree.queues.imports
-
+    class CreateRowsJob < Spree::Imports::BaseJob
       discard_on ::CSV::MalformedCSVError, EncodingError do |job, error|
         import = Spree::Import.find(job.arguments.first)
         import.update_columns(processing_errors: error.message, status: :failed, updated_at: Time.current)

data/app/jobs/spree/imports/process_group_job.rb

@@ -1,8 +1,6 @@
 module Spree
   module Imports
-    class ProcessGroupJob < Spree::BaseJob
-      queue_as Spree.queues.imports
-
+    class ProcessGroupJob < Spree::Imports::BaseJob
       def perform(import_id, row_ids)
         import = Spree::Import.find(import_id)
         Spree::Current.store = import.store
@@ -10,7 +8,8 @@ module Spree
         mappings = import.mappings.mapped.to_a
         schema_fields = import.schema_fields
         large = import.large_import?
-        rows = import.rows.where(id: row_ids).order(:row_number)
+        # Skip rows already completed on a prior attempt so retries don't double-process them.
+        rows = import.rows.where(id: row_ids).pending_and_failed.order(:row_number)
 
         if large
           Spree::Events.disable do
@@ -27,14 +26,17 @@ module Spree
 
       private
 
+      # Completion is row-state-derived so retry-induced over-increments of the counter
+      # stay harmless. The counter pre-check just shortcuts the row scan for workers
+      # that obviously can't be the last group to finish. `in_flight` excludes orphaned
+      # `processing` rows past the stall window so a dead worker can't block completion.
       def check_import_completion(import, large)
         Spree::Import.where(id: import.id).update_all(
           'completed_groups_count = COALESCE(completed_groups_count, 0) + 1'
         )
         import.reload
 
-        if import.completed_groups_count >= import.processing_groups_count
-          # Guard against concurrent workers both reaching this point
+        if import.completed_groups_count >= import.processing_groups_count && import.rows.in_flight.none?
           import.complete! if import.status == 'processing'
         elsif large && (import.completed_groups_count % 10).zero?
           import.publish_event('import.progress')

data/app/jobs/spree/imports/process_rows_job.rb

@@ -1,8 +1,6 @@
 module Spree
   module Imports
-    class ProcessRowsJob < Spree::BaseJob
-      queue_as Spree.queues.imports
-
+    class ProcessRowsJob < Spree::Imports::BaseJob
       BATCH_SIZE = 100
 
       def perform(import_id)

data/app/jobs/spree/media/migrate_product_assets_job.rb

@@ -0,0 +1,83 @@
+module Spree
+  module Media
+    # Per-product worker for the 5.4 → 5.5 media migration. Idempotent.
+    class MigrateProductAssetsJob < Spree::BaseJob
+      queue_as Spree.queues.images
+
+      def perform(product_id)
+        product = Spree::Product.includes(:master, :variants).find_by(id: product_id)
+        return unless product
+
+        # One query for all variant-pinned assets on the product (master +
+        # non-master). Grouping by viewable_id avoids N queries per variant.
+        viewable_ids = product.variants.map(&:id)
+        viewable_ids << product.master.id if product.master
+        return if viewable_ids.empty?
+
+        assets_by_variant = Spree::Asset
+                              .where(viewable_type: 'Spree::Variant', viewable_id: viewable_ids)
+                              .pluck(:id, :viewable_id)
+                              .group_by(&:last)
+                              .transform_values { |rows| rows.map(&:first) }
+        return if assets_by_variant.empty?
+
+        master_id = product.master&.id
+        touched_variants = []
+
+        product.variants.each do |variant|
+          asset_ids = assets_by_variant[variant.id]
+          next if asset_ids.blank?
+
+          move_assets_to_product(asset_ids, product)
+          link_assets_to_variant(asset_ids, variant.id)
+          touched_variants << variant
+        end
+
+        if master_id && (master_asset_ids = assets_by_variant[master_id]).present?
+          move_assets_to_product(master_asset_ids, product)
+          touched_variants << product.master
+        end
+
+        # update_all + upsert_all skip callbacks, so refresh thumbnails by hand.
+        touched_variants.each(&:update_thumbnail!)
+        recalculate_counters(product)
+      end
+
+      private
+
+      def move_assets_to_product(asset_ids, product)
+        Spree::Asset.where(id: asset_ids).update_all(
+          viewable_type: 'Spree::Product',
+          viewable_id: product.id,
+          updated_at: Time.current
+        )
+      end
+
+      def link_assets_to_variant(asset_ids, variant_id)
+        rows = asset_ids.map { |asset_id| { variant_id: variant_id, media_id: asset_id } }
+
+        # MySQL infers the conflict target from the unique index; only PG/SQLite
+        # need the explicit `unique_by:`.
+        opts = { on_duplicate: :skip }
+        if %w[PostgreSQL SQLite].include?(ActiveRecord::Base.connection.adapter_name)
+          opts[:unique_by] = :idx_variant_media_unique
+        end
+
+        Spree::VariantMedia.upsert_all(rows, **opts)
+      end
+
+      def recalculate_counters(product)
+        new_count = product.media.count
+        new_primary_id = product.media.order(:position).pick(:id)
+
+        return if product.media_count == new_count && product.primary_media_id == new_primary_id
+
+        product.update_columns(
+          media_count: new_count,
+          primary_media_id: new_primary_id,
+          updated_at: Time.current
+        )
+      end
+    end
+  end
+end

data/app/jobs/spree/products/refresh_metrics_job.rb

@@ -3,11 +3,22 @@ module Spree
     class RefreshMetricsJob < Spree::BaseJob
       queue_as Spree.queues.products
 
-      def perform(product_id, store_id)
-        store_product = Spree::StoreProduct.find_by(product_id: product_id, store_id: store_id)
-        return unless store_product
+      def perform(product_id)
+        product = Spree::Product.find_by(id: product_id)
+        return unless product
 
-        store_product.refresh_metrics!
+        completed_order_ids = product.completed_orders.select(:id)
+        variant_ids = product.variants_including_master.ids
+
+        line_items = Spree::LineItem.joins(:order)
+          .where(spree_orders: { id: completed_order_ids })
+          .where(variant_id: variant_ids)
+
+        # update columns to skip callbacks
+        product.update_columns(
+          units_sold_count: line_items.sum(:quantity),
+          revenue: line_items.sum(:pre_tax_amount)
+        )
       end
     end
   end

data/app/jobs/spree/reports/generate_job.rb

@@ -3,6 +3,17 @@ module Spree
     class GenerateJob < Spree::BaseJob
       queue_as Spree.queues.reports
 
+      # `Report#generate` is not retry-safe: each call re-attaches a new ActiveStorage
+      # blob (leaving the prior one orphaned) and re-enqueues the completion email.
+      # Opt out of the parent's retry policy so transient errors fail fast into the
+      # dead queue for operator review rather than producing duplicate side effects.
+      retry_on ActiveRecord::Deadlocked,
+               ActiveRecord::LockWaitTimeout,
+               ActiveRecord::ConnectionNotEstablished,
+               ActiveRecord::ConnectionFailed,
+               ActiveRecord::RecordNotFound,
+               attempts: 1
+
       def perform(report_id)
         report = Spree::Report.find_by_prefix_id!(report_id)
         report.generate

data/app/jobs/spree/search_provider/index_job.rb

@@ -3,8 +3,12 @@ module Spree
     class IndexJob < Spree::BaseJob
       queue_as Spree.queues.search
 
+      # Search providers are external services (Meilisearch, etc.); a transient 5xx or
+      # network blip should not drop the index update.
       retry_on StandardError, wait: :polynomially_longer, attempts: 5
-      discard_on ActiveRecord::RecordNotFound
+      # Must come after `retry_on StandardError` so DeserializationError lands in discard
+      # (ActiveJob handler lookup is reverse-declaration-order).
+      discard_on ActiveJob::DeserializationError
 
       # @param resource_class [String] e.g. 'Spree::Product'
       # @param resource_id [String] always pass as string for UUID support

data/app/jobs/spree/search_provider/remove_job.rb

@@ -3,7 +3,11 @@ module Spree
     class RemoveJob < Spree::BaseJob
       queue_as Spree.queues.search
 
+      # Search providers are external services; broad retry covers network blips and 5xx.
       retry_on StandardError, wait: :polynomially_longer, attempts: 5
+      # Must come after `retry_on StandardError` so DeserializationError lands in discard
+      # (ActiveJob handler lookup is reverse-declaration-order).
+      discard_on ActiveJob::DeserializationError
 
       # @param prefixed_id [String] prefixed ID of the document to remove (e.g. 'prod_abc')
       # @param store_id [String] always pass as string for UUID support

data/app/jobs/spree/stock_reservations/expire_job.rb

@@ -0,0 +1,11 @@
+module Spree
+  module StockReservations
+    class ExpireJob < Spree::BaseJob
+      queue_as Spree.queues.stock_reservations
+
+      def perform
+        Spree::StockReservation.expired.in_batches(of: 1_000).delete_all
+      end
+    end
+  end
+end

data/app/models/concerns/spree/calculated_adjustments.rb

@@ -18,11 +18,44 @@ module Spree
         calculator.class.to_s if calculator
       end
 
+      # Accepts a fully-qualified class name (`'Spree::Calculator::FlatRate'`)
+      # or the public API shorthand (`'flat_rate'`). Shorthand is resolved
+      # against this parent's registered calculators so a CreateAdjustment
+      # can't be assigned a shipping-only calculator just by knowing its
+      # name.
       def calculator_type=(calculator_type)
-        klass = calculator_type.constantize if calculator_type
+        return if calculator_type.blank?
+
+        str = calculator_type.to_s
+        klass =
+          if str.include?('::')
+            str.safe_constantize
+          else
+            registry = self.class.respond_to?(:calculators) ? self.class.calculators : []
+            registry.find { |k| k.api_type == str }
+          end
         self.calculator = klass.new if klass && !calculator.instance_of?(klass)
       end
 
+      # API v3 writer for the flat `calculator: { type:, preferences: {} }`
+      # payload. Routes preferences through `set_preference` so values are
+      # coerced by the typed `preferred_<name>=` setters — direct
+      # assignment to the serialized hash would skip coercion.
+      def assign_calculator_attributes(attrs)
+        return if attrs.nil?
+
+        attrs = attrs.to_h.with_indifferent_access
+        self.calculator_type = attrs[:type] if attrs[:type].present?
+
+        return if calculator.nil? || attrs[:preferences].blank?
+
+        attrs[:preferences].to_h.each do |key, value|
+          next unless calculator.has_preference?(key.to_sym)
+
+          calculator.set_preference(key.to_sym, value)
+        end
+      end
+
       private
 
       def self.model_name_without_spree_namespace

data/app/models/concerns/spree/display_on.rb

@@ -9,11 +9,42 @@ module Spree
       scope :available_on_front_end, -> { where(display_on: [:front_end, :both]) }
       scope :available_on_back_end,  -> { where(display_on: [:back_end, :both]) }
 
+      # 5.5 → 6.0 bridge: see docs/plans/5.5-6.0-display-on-to-boolean.md.
+      # The tri-state `display_on` enum collapses to a single
+      # `storefront_visible` boolean in 6.0 — `back_end` becomes `false`,
+      # everything else becomes `true`. The legacy `front_end`-only value
+      # (visible to customers but hidden from staff) has no real use case
+      # and folds into `storefront_visible: true` on migration.
+      scope :storefront_visible, -> { where.not(display_on: 'back_end') }
+      scope :admin_only,         -> { where(display_on: 'back_end') }
+
+      # Expose `storefront_visible` to Ransack so admin clients can filter
+      # by it (e.g. `q[storefront_visible_eq]=true`) without knowing about
+      # the underlying tri-state `display_on` column.
+      ransacker :storefront_visible, type: :boolean do |parent|
+        # Wrap in `Grouping` so Postgres sees `(display_on != 'back_end') = TRUE`
+        # instead of the ambiguous `display_on != 'back_end' = TRUE`.
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::NotEqual.new(parent.table[:display_on], Arel::Nodes::Quoted.new('back_end'))
+        )
+      end
+
+      self.whitelisted_ransackable_attributes =
+        (whitelisted_ransackable_attributes || []) | %w[storefront_visible]
+
       validates :display_on, presence: true, inclusion: { in: DISPLAY.map(&:to_s) }
 
       def available_on_front_end?
         display_on == 'front_end' || display_on == 'both'
       end
+
+      def storefront_visible
+        display_on != 'back_end'
+      end
+
+      def storefront_visible=(value)
+        self.display_on = ActiveModel::Type::Boolean.new.cast(value) ? 'both' : 'back_end'
+      end
     end
   end
 end