spree_core 5.4.2 → 5.5.0.rc1

data/app/models/spree/promotion_action.rb

@@ -12,6 +12,15 @@ module Spree
 
     scope :of_type, ->(t) { where(type: t) }
 
+    # Per-subclass permitted attributes beyond `type` and `preferences`.
+    # Override in STI subclasses that accept nested attributes (e.g.
+    # CreateLineItems needs `promotion_action_line_items_attributes`,
+    # CreateAdjustment needs `calculator_type` + `calculator_attributes`).
+    # The Admin API merges these into its `params.permit(...)` allowlist.
+    def self.additional_permitted_attributes
+      []
+    end
+
     # This method should be overridden in subclass
     # Updates the state of the order or performs some other action depending on the subclass
     # options will contain the payload from the event that activated the promotion. This will include
@@ -27,25 +36,22 @@ module Spree
       type == 'Spree::Promotion::Actions::FreeShipping'
     end
 
-    # Returns the human name of the promotion action
-    #
-    # @return [String] eg. Free Shipping
-    def human_name
-      Spree.t("promotion_action_types.#{key}.name")
+    def self.human_name
+      Spree.t("promotion_action_types.#{api_type}.name", default: api_type.titleize)
     end
 
-    # Returns the human description of the promotion action
-    #
-    # @return [String]
-    def human_description
-      Spree.t("promotion_action_types.#{key}.description")
+    def self.human_description
+      Spree.t("promotion_action_types.#{api_type}.description", default: '')
     end
 
+    def human_name = self.class.human_name
+    def human_description = self.class.human_description
+
     # Returns the key of the promotion action
     #
     # @return [String] eg. free_shipping
     def key
-      type.demodulize.underscore
+      self.class.api_type
     end
 
     protected

data/app/models/spree/promotion_rule.rb

@@ -10,7 +10,15 @@ module Spree
     scope :of_type, ->(t) { where(type: t) }
 
     validates :promotion, presence: true
-    validate :unique_per_promotion, on: :create
+    validates :type, uniqueness: { scope: [:promotion_id, *spree_base_uniqueness_scope] }
+
+    # Per-subclass permitted attributes beyond `type` and `preferences`.
+    # Override in STI subclasses that accept association IDs (e.g.
+    # Rules::Product needs `product_ids`). The Admin API merges these
+    # into its `params.permit(...)` allowlist.
+    def self.additional_permitted_attributes
+      []
+    end
 
     def self.for(promotable)
       all.select { |rule| rule.applicable?(promotable) }
@@ -34,35 +42,26 @@ module Spree
       @eligibility_errors ||= ActiveModel::Errors.new(self)
     end
 
-    # Returns the human name of the promotion rule
-    #
-    # @return [String] eg. Currency
-    def human_name
-      Spree.t("promotion_rule_types.#{key}.name")
+    def self.human_name
+      Spree.t("promotion_rule_types.#{api_type}.name", default: api_type.titleize)
     end
 
-    # Returns the human description of the promotion rule
-    #
-    # @return [String]
-    def human_description
-      Spree.t("promotion_rule_types.#{key}.description")
+    def self.human_description
+      Spree.t("promotion_rule_types.#{api_type}.description", default: '')
     end
 
+    def human_name = self.class.human_name
+    def human_description = self.class.human_description
+
     # Returns the key of the promotion rule
     #
     # @return [String] eg. currency
     def key
-      type.demodulize.underscore
+      self.class.api_type
     end
 
     private
 
-    def unique_per_promotion
-      if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
-        errors.add(:base, 'Promotion already contains this rule type')
-      end
-    end
-
     def eligibility_error_message(key, options = {})
       Spree.t(key, Hash[scope: [:eligibility_errors, :messages]].merge(options))
     end

data/app/models/spree/search_provider/meilisearch.rb

@@ -233,7 +233,7 @@ module Spree
       end
 
       def filterable_attributes
-        %w[product_id status in_stock store_ids locale currency discontinue_on price category_ids tags option_value_ids]
+        %w[product_id status in_stock store_ids channel_ids locale currency available_on discontinue_on price category_ids tags option_value_ids]
       end
 
       def sortable_attributes
@@ -259,12 +259,22 @@ module Spree
       # System scoping — always applied. Rarely overridden.
       # Mirrors the AR scope: store.products.active(currency) with locale.
       def system_filter_conditions
+        now = Time.current
         conditions = []
         conditions << "store_ids = '#{store.id}'"
+        conditions << "channel_ids = '#{Spree::Current.channel.id}'" if Spree::Current.channel
         conditions << "status = 'active'"
         conditions << "locale = '#{locale.to_s.gsub(/[^a-zA-Z_-]/, '')}'"
         conditions << "currency = '#{currency.to_s.gsub(/[^A-Z]/, '')}'"
-        conditions << "(discontinue_on = 0 OR discontinue_on > #{Time.current.to_i})"
+        # Exclude future-dated products — mirrors +Product.available(Time.current)+.
+        # ISO 8601 strings sort lexicographically in chronological order, so the
+        # string compare is sound. +NOT EXISTS+ catches docs indexed before this
+        # attribute was emitted (legacy indexes), +IS NULL+ catches docs where
+        # the field was emitted as explicit null, and the +<=+ clause filters
+        # the remaining future-dated docs — so the upgrade is non-breaking and
+        # no reindex is required.
+        conditions << "(available_on NOT EXISTS OR available_on IS NULL OR available_on <= '#{now.iso8601}')"
+        conditions << "(discontinue_on = 0 OR discontinue_on > #{now.to_i})"
         conditions
       end
 

data/app/models/spree/shipment.rb

@@ -272,16 +272,22 @@ module Spree
     def manifest
       # Grouping by the ID means that we don't have to call out to the association accessor
       # This makes the grouping by faster because it results in less SQL cache hits.
-      inventory_units.group_by(&:variant_id).map do |_variant_id, units|
-        units.group_by(&:line_item_id).map do |_line_item_id, units|
+      inventory_units.group_by(&:variant_id).flat_map do |_variant_id, units|
+        units.group_by(&:line_item_id).filter_map do |_line_item_id, units|
+          line_item = units.first.line_item
+          # Defensively skip orphaned inventory units (line item destroyed
+          # without cascading) so a single bad row doesn't crash callers that
+          # rely on line_item being present (item_cost, item_weight, the admin
+          # shipment manifest view, etc.).
+          next if line_item.nil?
+
           states = {}
           units.group_by(&:state).each { |state, iu| states[state] = iu.sum(&:quantity) }
 
-          line_item = units.first.line_item
           variant = units.first.variant
           ManifestItem.new(line_item, variant, units.sum(&:quantity), states)
         end
-      end.flatten
+      end
     end
 
     def process_order_payments

data/app/models/spree/stock/availability_validator.rb

@@ -28,7 +28,7 @@ module Spree
       private
 
       def item_available?(line_item, quantity)
-        Spree::Stock::Quantifier.new(line_item.variant).can_supply?(quantity)
+        Spree::Stock::Quantifier.new(line_item.variant, excluded_order: line_item.order).can_supply?(quantity)
       end
     end
   end

data/app/models/spree/stock/quantifier.rb

@@ -1,25 +1,89 @@
 module Spree
   module Stock
     class Quantifier
-      attr_reader :variant, :stock_location
+      attr_reader :variant, :stock_location, :excluded_order
 
-      def initialize(variant, stock_location = nil)
-        @variant        = variant
-        @stock_location = stock_location
+      # @param excluded_order [Spree::Order, nil] when given, reservations
+      #   belonging to this order are not counted against availability. Used
+      #   when checking an order's own line items so the customer's own
+      #   checkout hold doesn't make their item look out of stock.
+      def initialize(variant, stock_location = nil, excluded_order: nil)
+        @variant         = variant
+        @stock_location  = stock_location
+        @excluded_order  = excluded_order
       end
 
+      # Units a customer can purchase right now: physical pool minus
+      # already-allocated units minus active checkout reservations. Clamped
+      # at zero so callers never see a negative count.
+      #
+      # Returns +BigDecimal::INFINITY+ when the variant does not track
+      # inventory (effectively unlimited supply).
+      #
+      # @return [Integer, BigDecimal] purchasable quantity, or +INFINITY+
       def total_on_hand
         @total_on_hand ||= if variant.should_track_inventory?
-                             if association_loaded?
-                               stock_items.sum(&:count_on_hand)
-                             else
-                               stock_items.sum(:count_on_hand)
-                             end
+                             [available_stock - reserved_quantity, 0].max
                            else
                              BigDecimal::INFINITY
                            end
       end
 
+      # Physical pool minus already-allocated units, summed across the
+      # variant's active stock items.
+      #
+      # In Spree 5.5 {Spree::StockItem#allocated_count} is a Ruby shim that
+      # always returns 0, so this equals +SUM(count_on_hand)+. In 6.0
+      # (Typed Stock Movements) +allocated_count+ becomes a real column and
+      # the SQL path subtracts it natively.
+      #
+      # @return [Integer] units available before checkout reservations
+      def available_stock
+        if association_loaded?
+          stock_items.sum(&:available_count)
+        elsif self.class.allocated_count_column?
+          stock_items.sum('count_on_hand - allocated_count')
+        else
+          stock_items.sum(:count_on_hand)
+        end
+      end
+
+      # Units currently held by active checkout reservations on the
+      # location-filtered stock items. Returns 0 when stock reservations
+      # are globally disabled.
+      #
+      # Reads through the same {#stock_items} collection as {#available_stock}
+      # so a per-location query (filtered by `stock_location`) only counts
+      # reservations that belong to those same stock items — otherwise a
+      # multi-location variant would subtract reservations from other
+      # warehouses.
+      #
+      # When +excluded_order+ is set, that order's own reservations are left
+      # out of the count so an order's own checkout hold doesn't count
+      # against the availability of its own line items.
+      #
+      # @return [Integer]
+      def reserved_quantity
+        return @reserved_quantity if defined?(@reserved_quantity)
+        return @reserved_quantity = 0 unless Spree::Config[:stock_reservations_enabled]
+        return @reserved_quantity = 0 if stock_items.blank?
+
+        excluded_order_id = excluded_order&.id
+
+        @reserved_quantity = if reservations_preloaded?
+                               stock_items.sum do |si|
+                                 reservations = si.active_stock_reservations
+                                 reservations = reservations.reject { |r| r.order_id == excluded_order_id } if excluded_order_id
+                                 reservations.sum(&:quantity)
+                               end
+                             else
+                               reservations = Spree::StockReservation.active.where(stock_item_id: stock_items.map(&:id))
+                               reservations = reservations.where.not(order_id: excluded_order_id) if excluded_order_id
+                               reservations.sum(:quantity)
+                             end
+      end
+
+      # Check if any of variant stock items is backorderable
       def backorderable?
         @backorderable ||= stock_items.any?(&:backorderable)
       end
@@ -32,12 +96,28 @@ module Spree
         @stock_items ||= scope_to_location(variant.stock_items)
       end
 
+      # Memoized schema check so {#available_stock} doesn't introspect the
+      # column list on every call. Flips from false → true when 6.0 Typed
+      # Stock Movements adds the `allocated_count` column.
+      #
+      # @return [Boolean]
+      def self.allocated_count_column?
+        return @allocated_count_column if defined?(@allocated_count_column)
+
+        @allocated_count_column = Spree::StockItem.connection.column_exists?(:spree_stock_items, :allocated_count)
+      end
+
       private
 
       def association_loaded?
         variant.association(:stock_items).loaded?
       end
 
+      def reservations_preloaded?
+        association_loaded? &&
+          stock_items.all? { |si| si.association(:active_stock_reservations).loaded? }
+      end
+
       def scope_to_location(collection)
         if stock_location.blank?
           if association_loaded?

data/app/models/spree/stock_item.rb

@@ -15,6 +15,8 @@ module Spree
       belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant'
     end
     has_many :stock_movements, inverse_of: :stock_item
+    has_many :stock_reservations, class_name: 'Spree::StockReservation', inverse_of: :stock_item, dependent: :destroy
+    has_many :active_stock_reservations, -> { active }, class_name: 'Spree::StockReservation', inverse_of: :stock_item
 
     validates :stock_location, :variant, presence: true
     validates :variant_id, uniqueness: { scope: :stock_location_id }, unless: :deleted_at
@@ -38,6 +40,18 @@ module Spree
 
     scope :with_active_stock_location, -> { joins(:stock_location).merge(Spree::StockLocation.active) }
 
+    # Stock items for products assigned to `store`. Walks
+    # `variant → product → stores`, dedups via `distinct` so a product
+    # in multiple stores doesn't double-count its stock items.
+    #
+    # Used by the admin API as the base scope (`StockItem.for_store`)
+    # so the controller can filter directly by stock_location/variant
+    # without inheriting `Spree::Store#stock_items`'s extra joins or
+    # the variant default ordering.
+    scope :for_store, ->(store) {
+      joins(variant: :product).where(spree_products: { store_id: store.id })
+    }
+
     def backordered_inventory_units
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end
@@ -64,6 +78,28 @@ module Spree
       in_stock? || backorderable?
     end
 
+    # Units already allocated to pending shipments at this stock item.
+    #
+    # Always returns 0 in Spree 5.5. The 6.0 Typed Stock Movements plan
+    # (see docs/plans/6.0-typed-stock-movements.md) adds an indexed
+    # `allocated_count` column updated by typed movements (`allocated`,
+    # `released`, `shipped`); the Rails column accessor then takes
+    # precedence over this method automatically.
+    #
+    # @return [Integer]
+    def allocated_count
+      0
+    end
+
+    # Physical stock minus allocated units at this stock item. Distinct from
+    # {Spree::Stock::Quantifier#available_stock}, which sums this across all
+    # stock items belonging to a variant.
+    #
+    # @return [Integer]
+    def available_count
+      count_on_hand - allocated_count
+    end
+
     def reduce_count_on_hand_to_zero
       set_count_on_hand(0) if count_on_hand > 0
     end

data/app/models/spree/stock_location.rb

@@ -2,6 +2,15 @@ module Spree
   class StockLocation < Spree.base_class
     has_prefix_id :sloc  # Spree-specific: stock location
 
+    # Categorizes the location. Open string — extensible by setting any value;
+    # KINDS lists the built-in options used by the admin UI dropdown.
+    KINDS = %w[warehouse store fulfillment_center].freeze
+
+    # Pickup stock policy: 'local' = only items physically at this location are
+    # collectable; 'any' = items can be transferred from other locations
+    # (ship-to-store). See docs/plans/6.0-fulfillment-and-delivery.md.
+    PICKUP_STOCK_POLICIES = %w[local any].freeze
+
     include Spree::UniqueName
     if defined?(Spree::Security::StockLocations)
       include Spree::Security::StockLocations
@@ -20,14 +29,41 @@ module Spree
     belongs_to :state, class_name: 'Spree::State', optional: true
     belongs_to :country, class_name: 'Spree::Country'
 
+    validates :kind, presence: true
+    validates :pickup_stock_policy, inclusion: { in: PICKUP_STOCK_POLICIES }
+    validates :pickup_ready_in_minutes,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 },
+              allow_nil: true
+
+    self.whitelisted_ransackable_attributes = %w[
+      name active default kind pickup_enabled
+      country_id state_id created_at updated_at
+    ]
+
     scope :active, -> { where(active: true) }
+    scope :pickup_enabled, -> { where(pickup_enabled: true) }
     scope :order_default, -> { order(default: :desc, name: :asc) }
 
+    before_validation :normalize_country
+    before_validation :normalize_state
+
     after_create :create_stock_items, if: :propagate_all_variants?
     after_save :ensure_one_default
     after_update :conditional_touch_records
 
     delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true, allow_nil: true
+    delegate :abbr, to: :state, prefix: true, allow_nil: true
+
+    # Writer methods for API convenience — accept ISO/abbr codes instead of FK IDs.
+    # Mirrors Spree::Address: SDK clients use country_iso/state_abbr because
+    # Country/State don't expose prefixed IDs (their `iso` is the public handle).
+    def country_iso=(value)
+      @country_iso_input = value
+    end
+
+    def state_abbr=(value)
+      @state_abbr_input = value
+    end
 
     def state_text
       state.try(:abbr) || state.try(:name) || state_name
@@ -168,6 +204,22 @@ module Spree
 
     private
 
+    def normalize_country
+      iso = @country_iso_input
+      return if iso.blank?
+
+      self.country = Spree::Country.by_iso(iso)
+      @country_iso_input = nil
+    end
+
+    def normalize_state
+      abbr = @state_abbr_input
+      return if abbr.blank? || country.blank?
+
+      self.state = country.states.find_by(abbr: abbr)
+      @state_abbr_input = nil
+    end
+
     def create_stock_items
       Spree::StockLocations::StockItems::CreateJob.perform_later(self)
     end

data/app/models/spree/stock_reservation.rb

@@ -0,0 +1,38 @@
+module Spree
+  class StockReservation < Spree.base_class
+    has_prefix_id :res
+
+    publishes_lifecycle_events
+
+    belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_reservations
+    belongs_to :line_item, class_name: 'Spree::LineItem', inverse_of: :stock_reservations
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :stock_reservations
+
+    validates :stock_item, :line_item, :order, :quantity, :expires_at, presence: true
+    validates :quantity, numericality: { greater_than: 0, only_integer: true }, presence: true
+    validates :line_item_id, uniqueness: { scope: :stock_item_id }, presence: true
+
+    scope :active, -> { where('spree_stock_reservations.expires_at > ?', Time.current) }
+    scope :expired, -> { where('spree_stock_reservations.expires_at <= ?', Time.current) }
+    scope :for_order, ->(order) { where(order_id: order.id) }
+    scope :for_store, ->(store) {
+      joins(:order).where(spree_orders: { store_id: store.id })
+    }
+
+    self.whitelisted_ransackable_attributes = %w[stock_item_id line_item_id order_id quantity expires_at]
+    self.whitelisted_ransackable_associations = %w[stock_item line_item order]
+
+    def active?
+      expires_at > Time.current
+    end
+
+    # Resolves the reservation TTL: per-Store preference if set, otherwise
+    # the global Spree::Config[:default_stock_reservation_ttl_minutes]. Falls
+    # back to 10 minutes if both are unset (e.g. early-boot / fixture state).
+    def self.ttl_for(order)
+      minutes = order&.store&.preferred_stock_reservation_ttl_minutes
+      minutes = Spree::Config[:default_stock_reservation_ttl_minutes] if minutes.blank?
+      minutes.to_i.then { |m| m > 0 ? m : 10 }.minutes
+    end
+  end
+end

data/app/models/spree/stock_reservations/insufficient_stock_error.rb

@@ -0,0 +1,12 @@
+module Spree
+  module StockReservations
+    class InsufficientStockError < StandardError
+      attr_reader :line_item
+
+      def initialize(line_item, message)
+        @line_item = line_item
+        super(message)
+      end
+    end
+  end
+end

data/app/models/spree/store.rb

@@ -12,8 +12,10 @@ module Spree
     include Spree::Metadata
     include Spree::Stores::Setup
     include Spree::Stores::Markets
+    include Spree::Stores::Channels
     include Spree::Security::Stores if defined?(Spree::Security::Stores)
     include Spree::UserManagement
+    include Spree::OrderRouting::HasStrategyPreference
 
     #
     # Magic methods
@@ -46,6 +48,7 @@ module Spree
     # Checkout preferences
     preference :guest_checkout, :boolean, default: true
     preference :special_instructions_enabled, :boolean, default: false
+    preference :stock_reservation_ttl_minutes, :integer, default: 10
     # Address preferences
     preference :company_field_enabled, :boolean, default: false
     # digital assets preferences
@@ -54,6 +57,9 @@ module Spree
     preference :digital_asset_authorized_clicks, :integer, default: 5
     preference :digital_asset_authorized_days, :integer, default: 7
     preference :digital_asset_link_expire_time, :integer, default: 300
+    # Class name of the Spree::OrderRouting::Strategy::Base subclass that
+    # decides which StockLocation fulfills which items.
+    preference :order_routing_strategy, :string, default: 'Spree::OrderRouting::Strategy::Rules'
 
     #
     # Associations
@@ -71,10 +77,11 @@ module Spree
     has_many :store_payment_methods, class_name: 'Spree::StorePaymentMethod'
     has_many :payment_methods, through: :store_payment_methods, class_name: 'Spree::PaymentMethod'
 
-    has_many :store_products, class_name: 'Spree::StoreProduct'
-    has_many :products, through: :store_products, class_name: 'Spree::Product'
+    has_many :products, class_name: 'Spree::Product', dependent: :nullify
+    has_many :product_publications, through: :channels, source: :publications, class_name: 'Spree::ProductPublication'
     has_many :variants, through: :products, class_name: 'Spree::Variant', source: :variants_including_master
     has_many :stock_items, through: :variants, class_name: 'Spree::StockItem'
+    has_many :prices, through: :variants, class_name: 'Spree::Price'
     has_many :inventory_units, through: :variants, class_name: 'Spree::InventoryUnit'
     has_many :option_value_variants, through: :variants, class_name: 'Spree::OptionValueVariant'
     has_many :customer_returns, class_name: 'Spree::CustomerReturn', inverse_of: :store
@@ -108,6 +115,9 @@ module Spree
     has_many :webhook_endpoints, class_name: 'Spree::WebhookEndpoint', dependent: :destroy, inverse_of: :store
     has_many :webhook_deliveries, through: :webhook_endpoints, class_name: 'Spree::WebhookDelivery'
 
+    has_many :channels, class_name: 'Spree::Channel', dependent: :destroy
+    has_many :order_routing_rules, through: :channels, class_name: 'Spree::OrderRoutingRule'
+
     has_many :customer_groups, class_name: 'Spree::CustomerGroup', dependent: :destroy, inverse_of: :store
 
     has_many :api_keys, class_name: 'Spree::ApiKey', dependent: :destroy
@@ -121,6 +131,7 @@ module Spree
     end
     validates :preferred_digital_asset_authorized_clicks, numericality: { only_integer: true, greater_than: 0 }
     validates :preferred_digital_asset_authorized_days, numericality: { only_integer: true, greater_than: 0 }
+    validates :preferred_stock_reservation_ttl_minutes, numericality: { only_integer: true, greater_than: 0 }
     validates :mail_from_address, email: { allow_blank: false }
     # FIXME: we should remove this condition in v5
     if !ENV['SPREE_DISABLE_DB_CONNECTION'] &&
@@ -141,7 +152,6 @@ module Spree
     # Callbacks
     before_validation :set_default_code, on: :create
     before_save :ensure_default_exists_and_is_unique
-    after_create :ensure_default_market
     after_create :create_default_policies
 
     #
@@ -165,7 +175,7 @@ module Spree
       else
         Spree::Deprecation.warn(
           'Spree::Store.default returning a new unpersisted store when no default store exists is deprecated ' \
-          'and will be removed in Spree 5.5. Please ensure a default store is created before calling Store.default.'
+          'and will be removed in Spree 6.0. Please ensure a default store is created before calling Store.default.'
         )
         new(default: true)
       end
@@ -175,6 +185,10 @@ module Spree
       Spree::Store.default&.supported_locales_list || []
     end
 
+    def default_channel
+      channels.find_by(code: Spree::Channel::DEFAULT_CODE) || channels.active.first
+    end
+
     # @deprecated Use Markets instead. Will be removed in Spree 5.5.
     def checkout_zone
       Spree::Deprecation.warn('Store#checkout_zone is deprecated and will be removed in Spree 5.5. Use Markets instead.')
@@ -366,25 +380,6 @@ module Spree
 
     private
 
-    def ensure_default_market
-      return if markets.exists?
-
-      country = @default_country_for_market
-      return if country.blank?
-
-      iso_country = ISO3166::Country[country.iso]
-
-      Spree::Events.disable do
-        markets.create!(
-          name: country.name,
-          currency: iso_country&.currency_code || read_attribute(:default_currency) || 'USD',
-          default_locale: iso_country&.languages_official&.first || read_attribute(:default_locale) || 'en',
-          default: true,
-          countries: [country]
-        )
-      end
-    end
-
     def create_default_policies
       Spree::Events.disable do
         [
@@ -401,55 +396,6 @@ module Spree
       end
     end
 
-    def ensure_default_taxonomies_are_created
-      Spree::Deprecation.warn('Store#ensure_default_taxonomies_are_created is deprecated and will be removed in Spree 5.5. Please remove it from your codebase')
-
-      Spree::Events.disable do
-        [
-          translate_with_store_locale_fallback('spree.taxonomy_categories_name'),
-          translate_with_store_locale_fallback('spree.taxonomy_brands_name'),
-          translate_with_store_locale_fallback('spree.taxonomy_collections_name')
-        ].each do |taxonomy_name|
-          # Manual exists?/create to work around Mobility bug with find_or_create_by
-          next if taxonomies.with_matching_name(taxonomy_name).exists?
-
-          taxonomies.create(name: taxonomy_name)
-        end
-      end
-    end
-
-    def ensure_default_automatic_taxons
-      Spree::Deprecation.warn('Store#ensure_default_automatic_taxons is deprecated and will be removed in Spree 5.5. Please remove it from your codebase')
-
-      Spree::Events.disable do
-        # Use Mobility-safe lookup for taxonomy
-        collections_taxonomy = taxonomies.with_matching_name(translate_with_store_locale_fallback('spree.taxonomy_collections_name')).first
-        return unless collections_taxonomy.present?
-
-        automatic_taxons_config = [
-          { name: translate_with_store_locale_fallback('spree.automatic_taxon_names.on_sale'),
-            rule_type: 'Spree::TaxonRules::Sale', rule_value: 'true' },
-          { name: translate_with_store_locale_fallback('spree.automatic_taxon_names.new_arrivals'), rule_type: 'Spree::TaxonRules::AvailableOn', rule_value: 30 }
-        ]
-
-        automatic_taxons_config.map do |config|
-          # Manual exists?/create to work around Mobility bug with first_or_create
-          taxon_scope = collections_taxonomy.taxons.automatic.with_matching_name(config[:name])
-
-          if taxon_scope.exists?
-            taxon_scope.first
-          else
-            collections_taxonomy.taxons.create!(
-              name: config[:name],
-              automatic: true,
-              parent: collections_taxonomy.root,
-              taxon_rules: [TaxonRule.new(type: config[:rule_type], value: config[:rule_value])]
-            )
-          end
-        end
-      end
-    end
-
     # Translates a key using the store's default locale with fallback to :en
     def translate_with_store_locale_fallback(key)
       locale = default_locale.presence&.to_sym || :en