spree_core 5.5.3 → 5.6.0.rc1

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

@@ -158,6 +158,7 @@ module Spree
 
         Rails.logger.debug { "[Meilisearch] index=#{index_name} query=#{query.inspect} #{search_params.compact.inspect}" }
 
+        settings_refreshed = false
         begin
           if return_facets && grouped_options.any?
             queries = [{ indexUid: index_name, q: query.to_s, **search_params }]
@@ -175,6 +176,16 @@ module Spree
             facet_distribution = ms_result['facetDistribution'] || {}
           end
         rescue ::Meilisearch::ApiError => e
+          # Self-heal when a newly added filterable attribute (e.g. `preorder`)
+          # is referenced before the index settings were refreshed — otherwise
+          # every search on an upgraded store returns empty until a reindex or
+          # the next product write.
+          if e.code == 'invalid_search_filter' && !settings_refreshed
+            settings_refreshed = true
+            ensure_index_settings!
+            retry
+          end
+
           Rails.logger.warn { "[Meilisearch] Search failed: #{e.message}. Run `rake spree:search:reindex` to initialize the index." }
           Rails.error.report(e, handled: true, context: { index: index_name, query: query })
           return nil
@@ -233,7 +244,7 @@ module Spree
       end
 
       def filterable_attributes
-        %w[product_id status in_stock store_ids channel_ids locale currency available_on discontinue_on price category_ids tags option_value_ids]
+        %w[product_id status in_stock preorder store_ids channel_ids locale currency available_on discontinue_on price category_ids tags option_value_ids]
       end
 
       def sortable_attributes
@@ -266,14 +277,16 @@ module Spree
         conditions << "status = 'active'"
         conditions << "locale = '#{locale.to_s.gsub(/[^a-zA-Z_-]/, '')}'"
         conditions << "currency = '#{currency.to_s.gsub(/[^A-Z]/, '')}'"
-        # 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}')"
+        # Exclude future-dated products — mirrors
+        # +Product.available(Time.current, include_preorderable: true)+. ISO 8601
+        # strings sort lexicographically in chronological order, so the string
+        # compare is sound; +NOT EXISTS+/+IS NULL+ keep the available_on clause
+        # backward-compatible with legacy docs. The trailing +preorder = true+
+        # keeps scheduled "coming soon" pre-orders searchable before their
+        # publish date. It filters on the new +preorder+ attribute, so a
+        # +rake spree:search:reindex+ (or the next product write, which refreshes
+        # the index settings) is required after deploy before it takes effect.
+        conditions << "(available_on NOT EXISTS OR available_on IS NULL OR available_on <= '#{now.iso8601}' OR preorder = true)"
         conditions << "(discontinue_on = 0 OR discontinue_on > #{now.to_i})"
         conditions
       end

data/app/models/spree/setup_task.rb

@@ -0,0 +1,12 @@
+module Spree
+  # An evaluated onboarding task — the serializable result of running a
+  # {Spree::SetupTasks} registry entry against its subject (e.g. a store).
+  # See {Spree::Store#setup_tasks}.
+  class SetupTask
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :name, :string
+    attribute :done, :boolean
+  end
+end

data/app/models/spree/setup_tasks.rb

@@ -0,0 +1,86 @@
+module Spree
+  # Registry of onboarding tasks for a given subject type. `Spree.store_setup_tasks`
+  # holds the Getting Started checklist evaluated against a store; future
+  # registries (e.g. vendor onboarding) instantiate the same class against
+  # their own subject. Defaults are registered in
+  # `config/initializers/spree_store_setup_tasks.rb`; extensions and host apps
+  # can add or remove tasks at boot:
+  #
+  #   Rails.application.config.after_initialize do
+  #     Spree.store_setup_tasks.add :connect_stripe,
+  #       position: 25,
+  #       done: ->(store) { store.payment_methods.active.exists?(type: 'Spree::PaymentMethod::Stripe') }
+  #
+  #     Spree.store_setup_tasks.remove :setup_taxes_collection
+  #   end
+  #
+  # The registry holds domain data only — each frontend maps task keys to its
+  # own presentation: the legacy admin renders the
+  # `spree/admin/dashboard/setup_tasks/_<key>` partial titled by the
+  # `admin.store_setup_tasks.<key>` translation (both resolved across engine
+  # paths, so extensions ship theirs by convention), and the React dashboard
+  # consumes tasks as {Spree::SetupTask} records via the Admin API.
+  class SetupTasks
+    class Definition
+      attr_reader :key, :position
+
+      def initialize(key, position:, done:, **options)
+        raise ArgumentError, "done: must respond to #call" unless done.respond_to?(:call)
+
+        @key = key.to_sym
+        @position = position
+        @done = done
+        @if = options[:if]
+      end
+
+      # @param subject [Object] the record the checklist belongs to (e.g. a store)
+      # @return [Boolean] whether the task is complete
+      def done?(subject)
+        !!@done.call(subject)
+      end
+
+      # @param subject [Object] the record the checklist belongs to
+      # @return [Boolean] whether the task applies to this subject at all
+      def available?(subject)
+        @if.nil? || !!@if.call(subject)
+      end
+    end
+
+    def initialize
+      @tasks = {}
+    end
+
+    # Registers a task (replacing any existing task with the same key).
+    #
+    # @param key [Symbol] identifies the task; frontends derive presentation from it
+    # @param position [Integer] sort order in the checklist
+    # @param done [#call] receives the subject, returns whether the task is complete
+    # @param options [Hash] optional :if (per-subject visibility callable)
+    # @return [Definition]
+    def add(key, position:, done:, **options)
+      key = key.to_sym
+      @tasks[key] = Definition.new(key, position: position, done: done, **options)
+    end
+
+    # @param key [Symbol]
+    # @return [Definition, nil] the removed task
+    def remove(key)
+      @tasks.delete(key.to_sym)
+    end
+
+    def find(key)
+      @tasks[key.to_sym]
+    end
+
+    # @return [Array<Definition>] all tasks sorted by position
+    def tasks
+      @tasks.values.sort_by(&:position)
+    end
+
+    # @param subject [Object] the record the checklist belongs to (e.g. a store)
+    # @return [Array<Definition>] the tasks applicable to the given subject, sorted by position
+    def for(subject)
+      tasks.select { |task| task.available?(subject) }
+    end
+  end
+end

data/app/models/spree/shipment.rb

@@ -130,6 +130,17 @@ module Spree
       cost
     end
 
+    # Strict decimal bridge for string input — raises ArgumentError on
+    # malformed values instead of letting Rails' cast silently truncate
+    # ("12 boxes" would otherwise become 12.0). Blank strings cast to nil,
+    # matching the default Rails behavior.
+    #
+    # @param value [String, Numeric, nil]
+    def cost=(value)
+      value = value.blank? ? nil : BigDecimal(value.strip) if value.is_a?(String)
+      super
+    end
+
     def digital?
       shipping_method&.digital? || false
     end
@@ -347,6 +358,23 @@ module Spree
       shipping_rates
     end
 
+    # Public API v3 name for the selected rate (see docs/plans/6.0-fulfillment-and-delivery.md).
+    #
+    # @return [String, nil] the selected delivery rate's prefixed ID
+    def selected_delivery_rate_id
+      selected_shipping_rate&.prefixed_id
+    end
+
+    # Selects a delivery rate by its public prefixed ID (+dr_...+); raw IDs
+    # are accepted for internal callers. The model owns this naming bridge so
+    # API clients never deal with the legacy shipping-rate name.
+    #
+    # @param id [String, Integer] delivery rate prefixed or raw ID
+    def selected_delivery_rate_id=(id)
+      rate = Spree::PrefixedId.prefixed_id?(id) ? shipping_rates.find_by_prefix_id!(id) : shipping_rates.find(id)
+      self.selected_shipping_rate_id = rate.id
+    end
+
     def selected_shipping_rate_id
       selected_shipping_rate.try(:id)
     end
@@ -422,8 +450,17 @@ module Spree
       package
     end
 
+    # External systems (3PLs, courier APIs) often hand over a complete
+    # tracking link rather than a bare tracking code — returned as-is
+    # instead of being templated into the delivery method's tracking URL.
+    #
+    # @return [String, nil]
     def tracking_url
-      @tracking_url ||= shipping_method&.build_tracking_url(tracking)
+      @tracking_url ||= if tracking&.start_with?('https://')
+                          tracking
+                        else
+                          shipping_method&.build_tracking_url(tracking)
+                        end
     end
 
     def update_amounts

data/app/models/spree/shipment_handler.rb

@@ -7,7 +7,7 @@ module Spree
         # Do we have a specialized shipping-method-specific handler? e.g:
         # Given shipment.shipping_method = Spree::ShippingMethod::DigitalDownload
         # do we have Spree::ShipmentHandler::DigitalDownload?
-        if sm_handler = "Spree::ShipmentHandler::#{shipment.shipping_method.name.split('::').last}".safe_constantize
+        if sm_handler = "Spree::ShipmentHandler::#{shipment.shipping_method&.name&.split('::')&.last}".safe_constantize
           sm_handler.new(shipment)
         else
           new(shipment)

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

@@ -14,7 +14,7 @@ module Spree
         display_name = variant.name.to_s
         display_name += " (#{variant.options_text})" unless variant.options_text.blank?
 
-        if variant.available?
+        if variant.available? || variant.preorder?
           line_item.errors.add(:quantity,
                                :selected_quantity_not_available,
                                message: Spree.t(:selected_quantity_not_available, item: display_name.inspect))

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

@@ -88,8 +88,28 @@ module Spree
         @backorderable ||= stock_items.any?(&:backorderable)
       end
 
+      # Whether the requested quantity can be supplied. Beyond on-hand stock a
+      # variant may oversell two ways: +backorderable+ stock, or a pre-order
+      # (which also lifts the publish gate for a scheduled launch). Either way
+      # the variant's +backorder_limit+ caps how far below zero it may go; a nil
+      # (empty) limit means unlimited.
       def can_supply?(required = 1)
-        variant.available? && (backorderable? || total_on_hand >= required)
+        return false unless variant.available? || variant.preorder?
+        return true unless variant.should_track_inventory?
+
+        oversellable = backorderable? || variant.preorder?
+        limit = variant.backorder_limit
+        return true if oversellable && limit.nil?
+
+        # On-hand stock, plus — for a capped oversell — the room to sell below
+        # zero down to +-backorder_limit+ (a single clamp of signed on-hand plus
+        # the limit).
+        supplyable = if oversellable
+                       [available_stock - reserved_quantity + limit, 0].max
+                     else
+                       total_on_hand
+                     end
+        supplyable >= required
       end
 
       def stock_items

data/app/models/spree/stock_item.rb

@@ -107,7 +107,8 @@ module Spree
     private
 
     def verify_count_on_hand?
-      count_on_hand_changed? && !backorderable? && (count_on_hand < count_on_hand_was) && (count_on_hand < 0)
+      count_on_hand_changed? && !backorderable? && !variant.preorder? &&
+        (count_on_hand < count_on_hand_was) && (count_on_hand < 0)
     end
 
     # Process backorders based on amount of stock received

data/app/models/spree/stock_location.rb

@@ -157,7 +157,10 @@ module Spree
         else
           on_hand = item.count_on_hand
           on_hand = 0 if on_hand < 0
-          backordered = item.backorderable? ? (quantity - on_hand) : 0
+          # A pre-order oversells like a backorder: the shortfall becomes
+          # backordered inventory units (the backorder_limit cap is enforced
+          # upstream by Stock::Quantifier#can_supply?).
+          backordered = item.backorderable? || variant.preorder? ? (quantity - on_hand) : 0
         end
 
         [on_hand, backordered]

data/app/models/spree/store.rb

@@ -28,7 +28,7 @@ module Spree
     #
     TRANSLATABLE_FIELDS = %i[name meta_description meta_keywords seo_title customer_support_email
                              address contact_phone].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
+    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
     self::Translation.class_eval do
       acts_as_paranoid
       # deleted translation values still need to be accessible - remove deleted_at scope
@@ -46,7 +46,14 @@ module Spree
     # email preferences
     preference :send_consumer_transactional_emails, :boolean, default: true
     # Checkout preferences
+    # Store-level fallback for the channel-owned `guest_checkout` preference
+    # (see Spree::Channel::Gating). Retained so existing accessors keep working.
     preference :guest_checkout, :boolean, default: true
+    # Store-level fallback for the channel-owned `storefront_access` posture.
+    preference :storefront_access, :string, default: 'public'
+    # Canonical storefront origin used in customer-facing emails and links,
+    # e.g. "https://myshop.com" — see #storefront_url for the fallback chain.
+    preference :storefront_url, :string
     preference :special_instructions_enabled, :boolean, default: false
     preference :stock_reservation_ttl_minutes, :integer, default: 10
     # Address preferences
@@ -74,8 +81,9 @@ module Spree
     has_many :return_authorizations, through: :orders, class_name: 'Spree::ReturnAuthorization'
     # has_many :reimbursements, through: :orders, class_name: 'Spree::Reimbursement' FIXME: we should fetch this via Customer Return
 
-    has_many :store_payment_methods, class_name: 'Spree::StorePaymentMethod'
-    has_many :payment_methods, through: :store_payment_methods, class_name: 'Spree::PaymentMethod'
+    # :nullify (not :destroy) — clearing the collection must not cascade into
+    # Promotion#not_used? / payment records; orphaned rows are detached, not deleted.
+    has_many :payment_methods, class_name: 'Spree::PaymentMethod', dependent: :nullify
 
     has_many :products, class_name: 'Spree::Product', dependent: :nullify
     has_many :product_publications, through: :channels, source: :publications, class_name: 'Spree::ProductPublication'
@@ -91,11 +99,10 @@ module Spree
     has_many :store_credit_events, through: :store_credits, class_name: 'Spree::StoreCreditEvent'
 
     has_many :taxonomies, class_name: 'Spree::Taxonomy'
-    has_many :taxons, through: :taxonomies, class_name: 'Spree::Taxon'
-    has_many :categories, through: :taxonomies, class_name: 'Spree::Category', source: :taxons
+    has_many :taxons, class_name: 'Spree::Taxon'
+    has_many :categories, class_name: 'Spree::Category'
 
-    has_many :store_promotions, class_name: 'Spree::StorePromotion'
-    has_many :promotions, through: :store_promotions, class_name: 'Spree::Promotion'
+    has_many :promotions, class_name: 'Spree::Promotion', dependent: :nullify
 
     has_many :wishlists, class_name: 'Spree::Wishlist'
 
@@ -133,7 +140,10 @@ module Spree
     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 :preferred_storefront_access, inclusion: { in: Spree::Channel::Gating::STOREFRONT_ACCESS }
+    validate :preferred_storefront_url_is_an_origin
     validates :mail_from_address, email: { allow_blank: false }
+    validates :customer_support_email, email: { allow_blank: true }
     # FIXME: we should remove this condition in v5
     if !ENV['SPREE_DISABLE_DB_CONNECTION'] &&
        connected? &&
@@ -152,6 +162,7 @@ module Spree
     #
     # Callbacks
     before_validation :set_default_code, on: :create
+    before_validation :normalize_preferred_storefront_url
     before_save :ensure_default_exists_and_is_unique
     after_create :create_default_policies
 
@@ -276,11 +287,15 @@ module Spree
     end
 
     # Returns the storefront origin URL for use in customer-facing emails and links.
-    # Uses the first allowed origin if configured, otherwise falls back to formatted_url.
+    # Uses the `storefront_url` preference when set, then the oldest non-loopback
+    # allowed origin (the `http://localhost` origin seeded on install must never
+    # leak into customer emails), otherwise falls back to formatted_url.
     #
     # @return [String] e.g. "https://myshop.com"
     def storefront_url
-      allowed_origins.order(:created_at).pick(:origin) || formatted_url
+      preferred_storefront_url.presence ||
+        allowed_origins.order(:created_at).reject(&:loopback?).first&.origin ||
+        formatted_url
     end
 
     # Returns true if the given URL's origin matches one of the store's allowed origins.
@@ -412,5 +427,26 @@ module Spree
     def set_default_code
       self.code = 'default' if code.blank?
     end
+
+    # The storefront URL preference must always hold a canonical origin — it
+    # becomes the base for customer-email links and completes the storefront
+    # setup task, and the v3 Admin API writes it without any controller-side
+    # normalization. Parseable input is canonicalized here; garbage is left
+    # in place for the validation below to reject.
+    def normalize_preferred_storefront_url
+      raw = preferred_storefront_url
+      return if raw.blank?
+
+      normalized = Spree::AllowedOrigin.normalize_origin(raw)
+      self.preferred_storefront_url = normalized if normalized
+    end
+
+    def preferred_storefront_url_is_an_origin
+      raw = preferred_storefront_url
+      return if raw.blank?
+      return if Spree::AllowedOrigin.normalize_origin(raw)
+
+      errors.add(:preferred_storefront_url, :invalid)
+    end
   end
 end

data/app/models/spree/store_payment_method.rb

@@ -1,9 +1,13 @@
 module Spree
+  # Legacy join between Store and PaymentMethod. Superseded by the single-store
+  # +PaymentMethod#store+ FK in 5.6; retained only so the +spree_multi_store+
+  # extension can restore +has_many :stores+ and so the backfill task can read
+  # historic attachments. Dropped in 6.0.
   class StorePaymentMethod < Spree.base_class
     self.table_name = 'spree_payment_methods_stores'
 
     belongs_to :store, class_name: 'Spree::Store', touch: true
-    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', touch: true, inverse_of: :store_payment_methods
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', touch: true
 
     validates :store, :payment_method, presence: true
     validates :store_id, uniqueness: { scope: :payment_method_id }

data/app/models/spree/store_promotion.rb

@@ -1,4 +1,8 @@
 module Spree
+  # Legacy join between Store and Promotion. Superseded by the single-store
+  # +Promotion#store+ FK in 5.6; retained only so the +spree_multi_store+
+  # extension can restore +has_many :stores+ and so the backfill task can read
+  # historic attachments. Dropped in 6.0.
   class StorePromotion < Spree.base_class
     self.table_name = 'spree_promotions_stores'
 

data/app/models/spree/taxon.rb

@@ -4,6 +4,8 @@ require 'stringex'
 
 module Spree
   class Taxon < Spree.base_class
+    include Spree::SingleStoreResource
+
     has_prefix_id :ctg
 
     RULES_MATCH_POLICIES = %w[all any].freeze
@@ -37,7 +39,7 @@ module Spree
     # Associations
     #
     belongs_to :taxonomy, class_name: 'Spree::Taxonomy', inverse_of: :taxons
-    has_one :store, through: :taxonomy
+    belongs_to :store, class_name: 'Spree::Store', optional: true
     has_many :classifications, -> { order(:position) }, dependent: :destroy_async, inverse_of: :taxon
     has_many :products, through: :classifications
 
@@ -56,9 +58,16 @@ module Spree
     #
     # Validations
     #
-    validates :name, presence: true, uniqueness: { scope: %i[parent_id taxonomy_id], case_sensitive: false }
-    validates :taxonomy, presence: true
-    validates :permalink, uniqueness: { case_sensitive: false, scope: %i[parent_id taxonomy_id] }
+    validates :name, presence: true
+    validates :taxonomy, presence: true, if: :requires_taxonomy?
+    validates :store, presence: true
+    # Taxonomy-backed taxons are unique within their taxonomy; taxonomy-less
+    # categories (store-owned) are unique within their store, so two stores can
+    # each have a top-level "Shoes".
+    validates :name, uniqueness: { scope: %i[parent_id taxonomy_id], case_sensitive: false }, if: :requires_taxonomy?
+    validates :permalink, uniqueness: { scope: %i[parent_id taxonomy_id], case_sensitive: false }, if: :requires_taxonomy?
+    validates :name, uniqueness: { scope: %i[parent_id store_id], case_sensitive: false }, unless: :requires_taxonomy?
+    validates :permalink, uniqueness: { scope: %i[parent_id store_id], case_sensitive: false }, unless: :requires_taxonomy?
     validates :hide_from_nav, inclusion: { in: [true, false] }
     validate :check_for_root, on: :create
     validate :parent_belongs_to_same_taxonomy
@@ -81,13 +90,32 @@ module Spree
     after_commit :regenerate_pretty_name_and_permalink, on: :update, if: :should_regenerate_pretty_name_and_permalink?
     after_move :regenerate_pretty_name_and_permalink
     after_move :regenerate_translations_pretty_name_and_permalink
+    # Moving a subtree shifts its products under a new ancestor chain (and away
+    # from the old one), so recompute both branches' inclusive products_count.
+    # Capture the old parent before the move; recompute both chains after.
+    before_move :capture_parent_before_move
+    after_move :recalculate_products_count_after_move
+    # Destroying a taxon drops its subtree's products from every ancestor's
+    # inclusive count. Recompute the ancestors here (while the doomed subtree's
+    # rows still exist) excluding that subtree, since the Classification destroy
+    # callbacks can't help: classifications are removed via destroy_async, so
+    # they outlive this callback and their taxon may already be gone.
+    before_destroy :recalculate_ancestors_before_destroy, prepend: true
 
     #
     # Scopes
     #
-    scope :for_store, ->(store) { joins(:taxonomy).where(spree_taxonomies: { store_id: store.id }) }
-    scope :for_stores, ->(stores) { joins(:taxonomy).where(spree_taxonomies: { store_id: stores.ids }) }
+    # Prefer the direct store_id column; fall back to the taxonomy join for rows
+    # not yet backfilled (store_id IS NULL) so legacy behaviour is preserved.
+    scope :for_store, ->(store) { for_stores([store]) }
+    scope :for_stores, lambda { |stores|
+      store_ids = Array(stores).map(&:id)
+      taxonomy_ids = Spree::Taxonomy.where(store_id: store_ids).select(:id)
+      where(store_id: store_ids).or(where(store_id: nil, taxonomy_id: taxonomy_ids))
+    }
     scope :for_taxonomy, lambda { |taxonomy_name|
+      Spree::Deprecation.warn('Spree::Taxon.for_taxonomy is deprecated and will be removed in Spree 6. Please use for_store instead.')
+
       if Spree.use_translations?
         joins(:taxonomy)
           .join_translation_table(Taxonomy)
@@ -121,13 +149,14 @@ module Spree
     #
     self.whitelisted_ransackable_associations = %w[taxonomy parent]
     self.whitelisted_ransackable_attributes = %w[name permalink automatic depth is_root children_count
-                                                 classification_count hide_from_nav parent_id]
+                                                 classification_count products_count pretty_name hide_from_nav parent_id]
 
     #
     # Translations
     #
     TRANSLATABLE_FIELDS = %i[name pretty_name description permalink].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
+    RICH_TEXT_TRANSLATABLE_FIELDS = %i[description].freeze
+    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
 
     #
     # Action Text
@@ -154,6 +183,18 @@ module Spree
       !automatic?
     end
 
+    # The owning store. Prefers the direct +store_id+; falls back to the
+    # taxonomy's store for legacy rows not yet backfilled.
+    def store
+      super || taxonomy&.store
+    end
+
+    # Whether a taxonomy is mandatory. Legacy +Spree::Taxon+ requires one;
+    # +Spree::Category+ overrides this to false (it is owned via +store_id+).
+    def requires_taxonomy?
+      true
+    end
+
     def manual_sort_order?
       sort_order == 'manual'
     end
@@ -169,6 +210,26 @@ module Spree
                                                  )
     end
 
+    # Recomputes the stored, descendant-inclusive +products_count+ for the given
+    # taxons AND all of their ancestors — the nodes whose inclusive count can
+    # shift when a classification changes. Counts unique products classified
+    # under each node or its descendants (a product reachable through several
+    # nodes is counted once per ancestor). Call after any classification change.
+    #
+    # @param taxon_ids [Array<Integer>] taxons whose branch counts changed
+    def self.recalculate_products_count(taxon_ids)
+      changed = unscoped.where(id: Array(taxon_ids).compact.uniq)
+
+      # The affected nodes are each changed taxon plus its ancestors.
+      affected = changed.flat_map { |taxon| taxon.self_and_ancestors.to_a }.uniq(&:id)
+
+      affected.each do |taxon|
+        count = Spree::Classification.where(taxon_id: taxon.self_and_descendants.select(:id))
+                                     .distinct.count(:product_id)
+        taxon.update_column(:products_count, count) if taxon.products_count != count
+      end
+    end
+
     def products_matching_rules(opts = {})
       return Spree::Product.none if manual? || rules.empty?
 
@@ -379,6 +440,7 @@ module Spree
     end
 
     def sync_taxonomy_name
+      return unless taxonomy.present?
       return unless saved_changes.key?(:name) && root?
       return if taxonomy.name.to_s == name.to_s
 
@@ -389,7 +451,33 @@ module Spree
       # Touches all ancestors at once to avoid recursive taxonomy touch, and reduce queries.
       ancestors.update_all(updated_at: Time.current)
       # Have taxonomy touch happen in #touch_ancestors_and_taxonomy rather than association option in order for imports to override.
-      taxonomy.try!(:touch)
+      taxonomy.touch if taxonomy.present?
+    end
+
+    def capture_parent_before_move
+      @parent_id_before_move = parent_id_in_database
+    end
+
+    # Recompute the inclusive products_count for the moved node's new ancestor
+    # chain and the previous parent's chain too (whose subtree just lost this
+    # node's products).
+    def recalculate_products_count_after_move
+      affected = [id, @parent_id_before_move].compact
+      @parent_id_before_move = nil
+      self.class.recalculate_products_count(affected)
+    end
+
+    # Recomputes each ancestor's inclusive products_count as if this subtree were
+    # already gone (its classifications are destroyed asynchronously, so they're
+    # still present here). Excludes self_and_descendants from the count.
+    def recalculate_ancestors_before_destroy
+      doomed_ids = self_and_descendants.ids
+      ancestors.each do |ancestor|
+        remaining = Spree::Classification.
+                    where(taxon_id: ancestor.self_and_descendants.where.not(id: doomed_ids).select(:id)).
+                    distinct.count(:product_id)
+        ancestor.update_column(:products_count, remaining) if ancestor.products_count != remaining
+      end
     end
 
     def check_for_root
@@ -408,6 +496,21 @@ module Spree
       self.taxonomy = parent.taxonomy if parent.present? && taxonomy.blank?
     end
 
+    def set_store
+      Spree::Deprecation.warn('Spree::Taxon#set_store is deprecated and will be removed in Spree 6.0. ensure_store instead.')
+      ensure_store
+    end
+
+    # Every taxon is store-owned. Resolve the store from the taxonomy, then the
+    # parent, finally the current store — so the direct column is always
+    # populated for new records. Guards on the raw +store_id+ column rather than
+    # +#store+, whose reader masks an unset column with the taxonomy fallback.
+    def ensure_store
+      return if store_id.present?
+
+      self.store = taxonomy&.store || parent&.store || Spree::Store.current
+    end
+
     def regenerate_translations_pretty_name_and_permalink
       translations.each(&:regenerate_pretty_name_and_permalink)
     end

data/app/models/spree/taxonomy.rb

@@ -8,7 +8,7 @@ module Spree
     include Spree::SingleStoreResource
 
     TRANSLATABLE_FIELDS = %i[name].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
+    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
 
     acts_as_list