spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/services/spree/imports/row_processors/purchase_order.rb

@@ -18,7 +18,7 @@ module Spree
 
         def process!
           reference = attributes['reference'].to_s.strip
-          raise ArgumentError, Spree.t(:purchase_order_import_reference_required) if reference.blank?
+          raise ArgumentError, I18n.t('spree.purchase_order_import_reference_required') if reference.blank?
 
           line = {
             variant: find_variant,
@@ -78,31 +78,31 @@ module Spree
 
         def find_supplier
           name = attributes['supplier'].to_s.strip
-          raise ArgumentError, Spree.t(:purchase_order_import_supplier_required) if name.blank?
+          raise ArgumentError, I18n.t('spree.purchase_order_import_supplier_required') if name.blank?
 
           cached_lookup(:purchase_order_import_supplier, name.downcase) do
             store.suppliers.find_by(Spree::Supplier.arel_table[:name].lower.eq(name.downcase))
-          end || raise(ArgumentError, Spree.t(:purchase_order_import_unknown_supplier, name: name))
+          end || raise(ArgumentError, I18n.t('spree.purchase_order_import_unknown_supplier', name: name))
         end
 
         def find_destination
           name = attributes['destination'].to_s.strip
-          raise ArgumentError, Spree.t(:purchase_order_import_destination_required) if name.blank?
+          raise ArgumentError, I18n.t('spree.purchase_order_import_destination_required') if name.blank?
 
           cached_lookup(:purchase_order_import_destination, name.downcase) do
             store.stock_locations.find_by(Spree::StockLocation.arel_table[:name].lower.eq(name.downcase))
-          end || raise(ArgumentError, Spree.t(:purchase_order_import_unknown_destination, name: name))
+          end || raise(ArgumentError, I18n.t('spree.purchase_order_import_unknown_destination', name: name))
         end
 
         def find_variant
           sku = attributes['sku'].to_s.strip
-          raise ArgumentError, Spree.t(:purchase_order_import_sku_required) if sku.blank?
+          raise ArgumentError, I18n.t('spree.purchase_order_import_sku_required') if sku.blank?
 
           variants = cached_lookup(:purchase_order_import_variant, sku.downcase) do
             store.variants.where(Spree::Variant.arel_table[:sku].lower.eq(sku.downcase)).limit(2).to_a
           end
-          raise ArgumentError, Spree.t(:purchase_order_import_unknown_sku, sku: sku) if variants.empty?
-          raise ArgumentError, Spree.t(:purchase_order_import_ambiguous_sku, sku: sku) if variants.many?
+          raise ArgumentError, I18n.t('spree.purchase_order_import_unknown_sku', sku: sku) if variants.empty?
+          raise ArgumentError, I18n.t('spree.purchase_order_import_ambiguous_sku', sku: sku) if variants.many?
 
           variants.first
         end
@@ -110,7 +110,7 @@ module Spree
         def quantity_for(value)
           text = value.to_s.strip
           unless text.match?(QUANTITY_FORMAT) && text.to_i.positive?
-            raise ArgumentError, Spree.t(:purchase_order_import_invalid_quantity, value: text)
+            raise ArgumentError, I18n.t('spree.purchase_order_import_invalid_quantity', value: text)
           end
 
           text.to_i
@@ -118,7 +118,7 @@ module Spree
 
         def amount_for(value)
           text = value.to_s.strip
-          raise ArgumentError, Spree.t(:purchase_order_import_invalid_cost, value: text) unless text.match?(AMOUNT_FORMAT)
+          raise ArgumentError, I18n.t('spree.purchase_order_import_invalid_cost', value: text) unless text.match?(AMOUNT_FORMAT)
 
           BigDecimal(text)
         end
@@ -127,7 +127,7 @@ module Spree
           currency = value.to_s.strip.upcase.presence || store.default_currency
           return currency if supported_currencies.include?(currency)
 
-          raise ArgumentError, Spree.t(:purchase_order_import_unsupported_currency, currency: currency)
+          raise ArgumentError, I18n.t('spree.purchase_order_import_unsupported_currency', currency: currency)
         end
 
         def supported_currencies
@@ -142,14 +142,14 @@ module Spree
 
           Date.iso8601(text)
         rescue Date::Error
-          raise ArgumentError, Spree.t(:purchase_order_import_invalid_date, column: column, value: text)
+          raise ArgumentError, I18n.t('spree.purchase_order_import_invalid_date', column: column, value: text)
         end
 
         def failure_message(result)
           error = result.error
           return error.full_messages.to_sentence if error.respond_to?(:full_messages)
 
-          error.to_s.presence || Spree.t(:purchase_order_import_failed)
+          error.to_s.presence || I18n.t('spree.purchase_order_import_failed')
         end
       end
     end

data/app/services/spree/locales.rb

@@ -4,11 +4,10 @@ module Spree
     # (Mobility-backed content such as product names, descriptions, taxons,
     # option values, etc.).
     #
-    # This is deliberately **independent of the admin/storefront UI translation
-    # set** (`Spree.available_locales`, which reflects which `spree_i18n` UI
-    # bundles happen to be installed). In a headless setup the storefront ships
-    # its own UI translations, so the languages a merchant can store content in
-    # must not be constrained by which admin chrome translations exist.
+    # This is deliberately **independent of the languages Spree ships
+    # translations for** (`Spree.available_locales`). In a headless setup the
+    # storefront ships its own UI translations, so the languages a merchant can
+    # store content in must not be constrained by Spree's own translations.
     #
     # Codes follow BCP-47 casing (lowercase language, uppercase region —
     # `pt-BR`, `zh-CN`) so the browser's `Intl.DisplayNames` resolves a clean
@@ -17,15 +16,15 @@ module Spree
     # English, Brazilian vs. European Portuguese, Simplified vs. Traditional
     # Chinese, etc.).
     #
-    # The underlying translation tables accept any locale string, so this list
-    # governs only what the locale pickers offer — it is not a hard storage
-    # constraint.
+    # Markets and stores only accept codes from this list when their locales
+    # change, so an order's or cart's locale (which must be one its store
+    # supports) is one too, unless the store kept a value saved before that.
     ALL = %w[
       aa ab ae af ak am an ar as av ay az
       ba be bg bh bi bm bn bo br bs
       ca ce ch co cr cs cu cv cy
       da de de-AT de-CH dv dz
-      ee el en en-AU en-CA en-GB en-IN en-NZ eo es es-419 es-MX et eu
+      ee el en en-AU en-CA en-GB en-IN en-NZ en-US eo es es-419 es-CL es-EC es-MX et eu
       fa ff fi fj fo fr fr-CA fy
       ga gd gl gn gu gv
       ha he hi ho hr ht hu hy hz
@@ -39,7 +38,7 @@ module Spree
       pa pi pl ps pt pt-BR pt-PT
       qu
       rm rn ro ru rw
-      sa sc sd se sg si sk sl sm sn so sq sr ss st su sv sw
+      sa sc sd se sg si sk sl sl-SI sm sn so sq sr ss st su sv sw
       ta te tg th ti tk tl tn to tr ts tt tw ty
       ug uk ur uz
       ve vi vo
@@ -48,5 +47,39 @@ module Spree
       yi yo
       za zh-CN zh-HK zh-TW zu
     ].freeze
+
+    # The codes in a comma-separated list that are not listed, for a
+    # validation to name.
+    #
+    # @param codes [String, nil] e.g. "en,pt-BR"
+    # @return [Array<String>]
+    def self.unlisted(codes)
+      codes.to_s.split(',').map(&:strip).reject(&:empty?) - ALL
+    end
+
+    # A listed locale for a code from elsewhere (a host app's I18n config, a
+    # country's official language, a legacy column): the listed spelling of
+    # the code itself (`en_US` and `pt-br` give `en-US` and `pt-BR`),
+    # otherwise the listed one for its language (`en-IE` gives `en`, `zh`
+    # gives `zh-CN`), or nil when Spree knows neither.
+    #
+    # @param code [String, Symbol, nil]
+    # @return [String, nil]
+    def self.listed(code)
+      code = code.to_s.strip.tr('_', '-')
+      return if code.empty?
+
+      ALL.find { |listed| listed.casecmp?(code) } || for_language(code.split('-').first)
+    end
+
+    # The listed locale for an ISO 639-1 language: the language itself, or
+    # its first regional variant when only those are listed (`zh` gives
+    # `zh-CN`).
+    #
+    # @param language [String]
+    # @return [String, nil]
+    def self.for_language(language)
+      Spree.locale_for_language(language.to_s.downcase, ALL)
+    end
   end
 end

data/app/services/spree/newsletter/subscribe.rb

@@ -26,7 +26,7 @@ module Spree
           end
         end
 
-        subscriber.publish_event('newsletter_subscriber.subscription_requested', subscription_requested_payload) unless subscriber.verified?
+        publish_subscription_requested unless subscriber.verified?
         subscriber
       end
 
@@ -34,17 +34,13 @@ module Spree
 
       attr_reader :email, :current_user, :current_store, :redirect_url
 
-      def subscription_requested_payload
-        payload = {
-          id: subscriber.prefixed_id,
-          email: subscriber.email,
-          verification_token: subscriber.verification_token,
-          unsubscribe_token: subscriber.generate_token_for(:unsubscribe),
-          store_id: current_store.prefixed_id,
-          customer_id: subscriber.customer&.prefixed_id
-        }
-        payload[:redirect_url] = redirect_url if redirect_url.present?
-        payload
+      def publish_subscription_requested
+        event_name = 'newsletter_subscriber.subscription_requested'
+        payload = subscriber.event_payload_for(
+          event_name,
+          include_verification_token: true, store: current_store, redirect_url: redirect_url.presence
+        )
+        subscriber.publish_event(event_name, payload)
       end
 
       def upsert_subscriber

data/app/services/spree/orders/build_fulfillments.rb

@@ -17,13 +17,14 @@ module Spree
     class BuildFulfillments
       prepend Spree::ServiceModule::Base
 
-      def call(order:)
+      # @param keep_selection [Boolean] false when the destination changed
+      def call(order:, keep_selection: true)
         return success(order) if order.completed?
         return success(order) unless order.ship_address_id.present?
         return success(order) unless order.line_items.any?
         return success(order) unless order.delivery_step_required?
 
-        order.rebuild_fulfillments!
+        order.rebuild_fulfillments!(keep_selection: keep_selection)
         order.create_shipment_tax_charge!
         order.set_fulfillments_cost
         order.apply_free_shipping_promotions

data/app/services/spree/orders/create.rb

@@ -45,11 +45,11 @@ module Spree
       rescue ActiveRecord::RecordInvalid => e
         failure(e.record, e.record.errors.full_messages.to_sentence)
       rescue ActiveStorage::FileNotFoundError
-        # An abandoned direct upload leaves the blob row without its bytes.
+        # An abandoned presigned upload leaves the blob row without its bytes.
         # ActiveStorage raises a message-less error for that, which would
         # otherwise be an unhandled 500 on the Admin API.
         order ||= @store.orders.new
-        order.errors.add(:po_document, :po_document_upload_incomplete, message: Spree.t(:po_document_upload_incomplete))
+        order.errors.add(:po_document, :po_document_upload_incomplete, message: I18n.t('spree.po_document_upload_incomplete'))
         failure(order, order.errors.full_messages.to_sentence)
       end
 
@@ -71,8 +71,8 @@ module Spree
         }
 
         # The buyer's purchase order, when it arrived with the paperwork. A
-        # signed blob id, so it assigns like any other attribute.
-        attrs[:po_document] = @params[:po_document] if @params[:po_document].present?
+        # signed id, so it assigns like any other attribute.
+        attrs[:po_document_signed_id] = @params[:po_document_signed_id] if @params[:po_document_signed_id].present?
 
         attrs[:market] = resolve_market if @params[:market_id].present?
         attrs[:channel] = resolve_channel if @params[:channel_id].present?
@@ -170,6 +170,7 @@ module Spree
             coupon_code: @params[:coupon_code]
           }
           order.coupon_code = nil
+          handler.release_stale_coupon_codes
         end
       end
     end

data/app/services/spree/orders/discounts/create.rb

@@ -17,17 +17,20 @@ module Spree
         # @param line_item [Spree::LineItem, nil] nil distributes order-level
         # @return [Spree::ServiceModule::Result] value is the created rows
         def call(order:, label:, value:, value_type: 'flat', line_item: nil)
-          value = BigDecimal(value.to_s)
-          return failure(nil, Spree.t('errors.messages.discount_value_must_be_positive')) unless value.positive?
-          return failure(nil, Spree.t('errors.messages.discount_value_type_invalid')) unless %w[flat percent].include?(value_type)
+          value = Spree::Money::Rounding.parse_decimal(value)
+          return failure(nil, I18n.t('spree.errors.messages.discount_value_must_be_positive')) unless value&.positive?
+          return failure(nil, I18n.t('spree.errors.messages.discount_value_type_invalid')) unless %w[flat percent].include?(value_type)
 
           rows = order.with_lock do
             created = line_item ? [line_item_row(order, line_item, label, value, value_type)].compact : distributed_rows(order, label, value, value_type)
-            Spree.order_recalculate_totals_workflow.call(order: order) if created.any?
+            if created.any?
+              Spree.order_recalculate_totals_workflow.call(order: order)
+              order.update_statuses!
+            end
             created
           end
 
-          return failure(nil, Spree.t('errors.messages.discount_has_no_effect')) if rows.empty?
+          return failure(nil, I18n.t('spree.errors.messages.discount_has_no_effect')) if rows.empty?
 
           success(rows)
         end
@@ -36,7 +39,7 @@ module Spree
 
         def line_item_row(order, line_item, label, value, value_type)
           base = discountable_base(line_item)
-          amount = -[amount_for(base, value, value_type), base].min
+          amount = -[amount_for(base, value, value_type, order.currency), base].min
           return if amount.zero?
 
           create_row(order, line_item, label, amount, value, value_type)
@@ -48,19 +51,19 @@ module Spree
           bases_sum = bases.sum
           return [] if bases_sum <= 0
 
-          total = [amount_for(bases_sum, value, value_type), bases_sum].min
-          shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares((total * 100).round, bases)
+          total = [amount_for(bases_sum, value, value_type, order.currency), bases_sum].min
+          shares = Spree::Adjusters::LargestRemainder.apportion(total, bases, order.currency)
 
           line_items.each_with_index.filter_map do |line_item, index|
-            amount = -BigDecimal(shares[index]) / 100
+            amount = -shares[index]
             next if amount.zero?
 
             create_row(order, line_item, label, amount, value, value_type)
           end
         end
 
-        def amount_for(base, value, value_type)
-          value_type == 'percent' ? (base * value / 100).round(2) : value
+        def amount_for(base, value, value_type, currency)
+          Spree::Money::Rounding.to_currency(value_type == 'percent' ? base * value / 100 : value, currency)
         end
 
         # Remaining discountable base: amount net of already-applied discounts.

data/app/services/spree/orders/discounts/destroy.rb

@@ -15,6 +15,7 @@ module Spree
           order.with_lock do
             discount.destroy!
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
           end
 
           success(discount)

data/app/services/spree/orders/discounts/update.rb

@@ -18,6 +18,7 @@ module Spree
             next false unless discount.update(attributes)
 
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
             true
           end
 

data/app/services/spree/orders/fees/create.rb

@@ -17,6 +17,7 @@ module Spree
             next false unless fee.save
 
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
             true
           end
 

data/app/services/spree/orders/fees/destroy.rb

@@ -12,6 +12,7 @@ module Spree
           order.with_lock do
             fee.destroy!
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
           end
 
           success(fee)

data/app/services/spree/orders/fees/update.rb

@@ -14,6 +14,7 @@ module Spree
             next false unless fee.update(attributes)
 
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
             true
           end
 

data/app/services/spree/orders/remove_line_item.rb

@@ -1,12 +1,22 @@
 module Spree
   module Orders
-    # Draft-order twin of the cart service — order: is the canonical keyword
-    # on this side, delegating onto the shared implementation.
+    # Draft-order twin of the cart service. Removing an item is an upsert with
+    # quantity zero, so the removal passes the same 'orders.upsert_items.validate'
+    # hook every other draft-order item edit does.
     class RemoveLineItem
       prepend Spree::ServiceModule::Base
 
+      # @param order [Spree::Order]
+      # @param line_item [Spree::LineItem]
+      # @param options [Hash] accepted for signature compatibility and ignored
+      # @return [Spree::ServiceModule::Result] value is the removed line item
       def call(order:, line_item:, options: {})
-        Spree::Carts::RemoveLineItem.call(cart: order, line_item: line_item, options: options)
+        result = Spree.order_upsert_items_workflow.call(
+          order: order,
+          items: [{ variant_id: line_item.variant_id, quantity: 0 }]
+        )
+
+        result.success? ? success(line_item) : failure(line_item, result.error)
       end
     end
   end

data/app/services/spree/orders/update.rb

@@ -15,7 +15,10 @@ module Spree
         items_param = @params.delete(:items)
         address_params = extract_address_params
 
-        ApplicationRecord.transaction do
+        # requires_new: the rescue below sits outside the block, so joining a
+        # caller's open transaction (the API's order lock) would let it commit
+        # the half-applied edit.
+        ApplicationRecord.transaction(requires_new: true) do
           ship_address_id_before = @order.ship_address_id
           assign_addresses(address_params)
 
@@ -25,11 +28,12 @@ module Spree
 
           process_items(items_param) if items_param
 
-          if items_param || @order.ship_address_id != ship_address_id_before
-            build_fulfillments
-          end
+          # An address row edited in place keeps its id, so an edit to the fields a quote reads counts too.
+          destination_changed = @order.ship_address_id != ship_address_id_before || @order.ship_address&.saved_change_to_destination?
+          build_fulfillments(keep_selection: !destination_changed) if items_param || destination_changed
 
           @order.recalculate_totals!
+          @order.update_statuses!
         end
 
         success(@order.reload)
@@ -70,8 +74,8 @@ module Spree
         propagate_step_failure!(result, fallback: 'Failed to update items on order') if result.failure?
       end
 
-      def build_fulfillments
-        result = Spree::Orders::BuildFulfillments.call(order: @order)
+      def build_fulfillments(keep_selection:)
+        result = Spree::Orders::BuildFulfillments.call(order: @order, keep_selection: keep_selection)
         propagate_step_failure!(result, fallback: 'Failed to build shipments') if result.failure?
       end
 

data/app/services/spree/orders/update_item.rb

@@ -21,7 +21,7 @@ module Spree
         price_provided = !price.equal?(PRICE_NOT_PROVIDED)
 
         if price_provided && order.completed?
-          return reject_price(line_item, :price_override_not_allowed, Spree.t('cart_line_item.price_override_not_allowed'))
+          return reject_price(line_item, :price_override_not_allowed, I18n.t('spree.cart_line_item.price_override_not_allowed'))
         end
 
         attributes = {}
@@ -30,7 +30,7 @@ module Spree
 
         if price_provided && !price.nil?
           manual_price = parse_manual_price(price)
-          return reject_price(line_item, :invalid_price, Spree.t('cart_line_item.invalid_price')) if manual_price.nil?
+          return reject_price(line_item, :invalid_price, I18n.t('spree.cart_line_item.invalid_price')) if manual_price.nil?
 
           attributes[:price] = manual_price
           attributes[:price_source] = Spree::LineItem::MANUAL_PRICE_SOURCE
@@ -47,7 +47,10 @@ module Spree
         ActiveRecord::Base.transaction do
           return failure(line_item) unless line_item.update(attributes)
 
-          Spree::Orders::Recalculate.call(order: order, line_item: line_item) if quantity_changing || price_provided
+          if quantity_changing || price_provided
+            Spree::Orders::Recalculate.call(order: order, line_item: line_item)
+            order.update_statuses!
+          end
         end
 
         success(line_item)

data/app/services/spree/orders/update_statuses.rb

@@ -4,7 +4,9 @@ module Spree
     # Derive-then-persist: statuses are recomputed from payment/refund/
     # fulfillment records and stored in indexed columns so admin filtering
     # keeps working. Triggered from payment/refund/fulfillment/return event
-    # subscribers — never inline from controllers.
+    # subscribers, and by each edit service that moves an order's total
+    # (fees, discounts, items) once it has re-summed — no event announces
+    # that change. Never inline from controllers.
     class UpdateStatuses
       prepend Spree::ServiceModule::Base
 

data/app/services/spree/prices/bulk_upsert.rb

@@ -44,9 +44,12 @@ module Spree
       #   (docs/plans/6.0-volume-pricing.md).
       def call(rows:)
         rows = Array(rows).map { |r| r.with_indifferent_access }
-        # Amounts are parsed once, here; everything below reads numbers.
         keyed = rows.select { |r| r[:variant_id].present? && r[:currency].present? }
-                    .map { |r| r.merge(amount: parse_amount(r[:amount]), compare_at_amount: parse_amount(r[:compare_at_amount])) }
+        unreadable = rows_with_malformed_amount(keyed)
+        return failure(nil, malformed_amounts: unreadable) if unreadable.any?
+
+        # Amounts are parsed once, here; everything below reads numbers.
+        keyed = keyed.map { |r| r.merge(amount: Spree::Money::Rounding.parse_decimal(r[:amount]), compare_at_amount: Spree::Money::Rounding.parse_decimal(r[:compare_at_amount])) }
         # Checked before anything is deduped: `row_key` coerces the quantity,
         # so two malformed rows would collapse into one and the batch would be
         # judged on a shape the caller never sent.
@@ -98,12 +101,13 @@ module Spree
             upsert_batch(base_rows, BASE_UNIQUE_BY)
           end
           upsert_batch(override_rows, OVERRIDE_UNIQUE_BY)
-          sweep(affected_keys, clear_rows)
+          cleared_variant_ids = sweep(affected_keys, clear_rows)
           # `upsert_all` and `delete_all` both skip AR callbacks, so the
           # `Price -> Variant -> Product` `touch:` chain never fires —
           # downstream caches (`cache_key_with_version`) would stay stale.
-          # Re-trigger the chain with one `.touch` per affected variant.
-          touch_variants(affected_keys.map { |k| k[0] }.uniq)
+          # A blank row clearing a rung that had no amount changes nothing,
+          # so only priced rows and cleared amounts touch their variant.
+          touch_variants((upsert_rows.map { |r| r[:variant_id].to_s } + cleared_variant_ids).uniq)
         end
 
         success(price_count: payload.length)
@@ -167,6 +171,18 @@ module Spree
         Integer(raw.to_s.strip, 10, exception: false)
       end
 
+      # Rows whose amount is not a number or plain decimal text ("1,599.99",
+      # `false`), refused before a malformed value can read as "clear".
+      def rows_with_malformed_amount(rows)
+        rows.each_with_index.filter_map do |row, index|
+          Spree::Money::Rounding.parse_decimal(row[:amount])
+          Spree::Money::Rounding.parse_decimal(row[:compare_at_amount])
+          nil
+        rescue Spree::Money::InvalidFormat
+          { index: index }
+        end
+      end
+
       # Rows pricing below zero. This path runs no model validations, so the
       # sign is checked here for every caller rather than in each of them.
       def rows_with_negative_amount(rows)
@@ -370,15 +386,6 @@ module Spree
         [row[:variant_id].to_s, row[:currency], row[:price_list_id].to_s]
       end
 
-      # Parses locale-aware decimal input ("1.234,56" in DE, "1,234.56"
-      # in en-US). Numeric values pass through; blank values become nil.
-      def parse_amount(value)
-        return nil if value.blank?
-        return value if value.is_a?(Numeric)
-
-        Spree::LocalizedNumber.parse(value)
-      end
-
       def sweep(affected_keys, clear_rows)
         cleared_keys = clear_rows.map { |r| row_key(r) }.to_set
         affected_set = affected_keys.to_set
@@ -392,16 +399,14 @@ module Spree
           )
           .pluck(:id, :variant_id, :currency, :price_list_id, :min_quantity, :amount)
 
-        doomed_ids = candidates.filter_map do |id, variant_id, currency, price_list_id, min_quantity, amount|
+        doomed = candidates.select do |_, variant_id, currency, price_list_id, min_quantity, amount|
           key = [variant_id.to_s, currency, price_list_id&.to_s, min_quantity]
-          next unless affected_set.include?(key)
-          next id if amount.nil?
-          next id if cleared_keys.include?(key)
-
-          nil
+          affected_set.include?(key) && (amount.nil? || cleared_keys.include?(key))
         end
 
-        Spree::Price.where(id: doomed_ids).delete_all if doomed_ids.any?
+        Spree::Price.where(id: doomed.map(&:first)).delete_all if doomed.any?
+
+        doomed.filter_map { |_, variant_id, *, amount| variant_id.to_s if amount }
       end
 
       # Bumps `updated_at` on the affected variants and their parent
@@ -410,15 +415,17 @@ module Spree
       # `Variant -> Product` `touch:` chains otherwise.
       #
       # We use `touch_all` rather than per-record `Variant#touch`: it bumps
-      # every affected row in a single UPDATE and skips AR callbacks, giving
-      # the cache bust without extra side effects.
+      # every affected row in a single UPDATE. It also skips the product's
+      # commit callbacks, so the search index, which stores prices, is
+      # refreshed here.
       def touch_variants(variant_ids)
         return if variant_ids.empty?
 
         variants = Spree::Variant.where(id: variant_ids)
-        product_ids = variants.pluck(:product_id).uniq
+        products = Spree::Product.where(id: variants.select(:product_id))
         variants.touch_all
-        Spree::Product.where(id: product_ids).touch_all if product_ids.any?
+        products.touch_all
+        products.find_each(&:enqueue_search_index)
       end
 
       # MySQL infers conflict targets from its own unique indexes and

data/app/services/spree/product_memberships.rb

@@ -0,0 +1,61 @@
+module Spree
+  # Bulk adding and removing products on categories or collections. The
+  # including service names the join model (`membership_class`), the grouping
+  # it belongs to (`group_class`, `group_key`) and refreshes the grouping's
+  # own counters in `refresh_group_counters`.
+  module ProductMemberships
+    private
+
+    def add_memberships(groups, products)
+      rows = groups.pluck(:id).flat_map do |group_id|
+        position = membership_class.where(group_key => group_id).count
+        products.pluck(:id).map do |product_id|
+          {
+            group_key => group_id, product_id: product_id, position: (position += 1),
+            created_at: Time.current, updated_at: Time.current
+          }
+        end
+      end
+      membership_class.insert_all(rows)
+
+      refresh_after_membership_change(groups.pluck(:id), products)
+    end
+
+    # Removes the products, then re-packs the remaining positions from 1.
+    def remove_memberships(groups, products)
+      group_ids = groups.pluck(:id)
+
+      ApplicationRecord.transaction do
+        membership_class.where(group_key => group_ids, product_id: products.pluck(:id)).delete_all
+
+        rows = group_ids.flat_map do |group_id|
+          membership_class.where(group_key => group_id).order(:position).pluck(:product_id).map.with_index(1) do |product_id, position|
+            {
+              group_key => group_id, product_id: product_id, position: position,
+              created_at: Time.current, updated_at: Time.current
+            }
+          end
+        end
+        membership_class.upsert_all(rows, unique_by: ([group_key, :product_id] unless Spree.mysql?)) if rows.any?
+      end
+
+      refresh_after_membership_change(group_ids, products)
+    end
+
+    # Bulk writes skip the join model's callbacks, so counters, caches and the
+    # search index are refreshed here.
+    def refresh_after_membership_change(group_ids, products)
+      product_ids = products.pluck(:id)
+      product_ids.each { |id| Spree::Product.reset_counters(id, membership_class.model_name.element.pluralize.to_sym) }
+      refresh_group_counters(group_ids)
+
+      Spree::Product.where(id: product_ids).touch_all
+      products.each(&:enqueue_search_index)
+      group_class.where(id: group_ids).touch_all
+    end
+
+    def group_key
+      group_class.model_name.element.foreign_key.to_sym
+    end
+  end
+end