spree_core 5.4.0 → 5.4.2

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

@@ -20,84 +20,9 @@ module Spree
       def search_and_filter(scope:, query: nil, filters: {}, sort: nil, page: 1, limit: 25)
         page = [page.to_i, 1].max
         limit = limit.to_i.clamp(1, 100)
-        filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
-        filters = (filters || {}).stringify_keys
-
-        # Extract and group option values by option type for proper OR/AND semantics
-        option_value_ids = extract_and_delete(filters, 'with_option_value_ids')
-        grouped_options = group_option_values_by_type(Array(option_value_ids))
-
-        base_conditions = build_filters(filters)
-        option_conditions = build_grouped_option_conditions(grouped_options)
-        all_conditions = base_conditions + option_conditions
-
-        search_params = {
-          filter: all_conditions,
-          facets: facet_attributes,
-          sort: build_sort(sort),
-          offset: (page - 1) * limit,
-          limit: limit
-        }
-
-        Rails.logger.debug { "[Meilisearch] index=#{index_name} query=#{query.inspect} #{search_params.compact.inspect}" }
-
-        begin
-          if grouped_options.any?
-            # N+1 multi-search: 1 hit query + 1 disjunctive facet query per active option type
-            queries = [{ indexUid: index_name, q: query.to_s, **search_params }]
-            option_type_ids_ordered = grouped_options.keys
-            option_type_ids_ordered.each do |option_type_id|
-              without_this = build_grouped_option_conditions(grouped_options.except(option_type_id))
-              queries << { indexUid: index_name, q: query.to_s, filter: base_conditions + without_this, facets: ['option_value_ids'], limit: 0 }
-            end
-
-            results = client.multi_search(queries)
-            ms_result = results['results'][0]
-
-            # Merge disjunctive counts per option type.
-            # Each disjunctive query excluded one option type's filter.
-            # Use that query's full option_value_ids distribution for that option type's values,
-            # and the main query's distribution for everything else.
-            main_ov_dist = ms_result.dig('facetDistribution', 'option_value_ids') || {}
-
-            # Build a set of prefixed IDs per option type (including unselected values)
-            # by looking up which option type each option value belongs to.
-            all_ov_prefixed_ids = Set.new
-            disjunctive_dists = {}
-            results['results'][1..].each_with_index do |r, idx|
-              dist = r.dig('facetDistribution', 'option_value_ids') || {}
-              disjunctive_dists[option_type_ids_ordered[idx]] = dist
-              all_ov_prefixed_ids.merge(dist.keys)
-            end
 
-            # Resolve which prefixed IDs belong to which option type
-            all_raw_ids = all_ov_prefixed_ids.filter_map { |pid| Spree::OptionValue.decode_prefixed_id(pid) }
-            ov_to_type = Spree::OptionValue.where(id: all_raw_ids).pluck(:id, :option_type_id).to_h
-            prefixed_to_type = all_ov_prefixed_ids.each_with_object({}) do |pid, h|
-              raw = Spree::OptionValue.decode_prefixed_id(pid)
-              h[pid] = ov_to_type[raw] if raw
-            end
-
-            # Start with main query's distribution, overlay disjunctive counts for active option types
-            merged_ov_dist = main_ov_dist.dup
-            disjunctive_dists.each do |option_type_id, dist|
-              dist.each do |pid, count|
-                merged_ov_dist[pid] = count if prefixed_to_type[pid] == option_type_id
-              end
-            end
-
-            facet_distribution = (ms_result['facetDistribution'] || {}).merge('option_value_ids' => merged_ov_dist)
-          else
-            ms_result = client.index(index_name).search(query.to_s, search_params)
-            facet_distribution = ms_result['facetDistribution'] || {}
-          end
-        rescue ::Meilisearch::ApiError => e
-          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 empty_result(scope, page, limit)
-        end
-
-        Rails.logger.debug { "[Meilisearch] #{ms_result['estimatedTotalHits']} hits in #{ms_result['processingTimeMs']}ms" }
+        ms_result, _ = execute_search(query: query, filters: filters, sort: sort, page: page, limit: limit)
+        return empty_result(scope, page, limit) unless ms_result
 
         # Hits have composite prefixed_id (prod_abc_en_USD), extract product_id (prod_abc)
         product_prefixed_ids = ms_result['hits'].map { |h| h['product_id'] }.uniq
@@ -115,11 +40,28 @@ module Spree
 
         SearchResult.new(
           products: products,
+          total_count: ms_result['estimatedTotalHits'] || 0,
+          pagy: pagy
+        )
+      end
+
+      def filters(scope:, query: nil, filters: {})
+        ms_result, facet_distribution = execute_search(query: query, filters: filters, sort: nil, page: 1, limit: 0, return_facets: true)
+
+        unless ms_result
+          return FiltersResult.new(
+            filters: [],
+            sort_options: available_sort_options.map { |id| { id: id } },
+            default_sort: 'manual',
+            total_count: 0
+          )
+        end
+
+        FiltersResult.new(
           filters: build_facet_response(facet_distribution),
           sort_options: available_sort_options.map { |id| { id: id } },
           default_sort: 'manual',
-          total_count: ms_result['estimatedTotalHits'] || 0,
-          pagy: pagy
+          total_count: ms_result['estimatedTotalHits'] || 0
         )
       end
 
@@ -193,6 +135,84 @@ module Spree
 
       private
 
+      # Execute a Meilisearch query. Returns [ms_result, facet_distribution].
+      # facet_distribution is empty when return_facets is false. Returns nil on API error.
+      def execute_search(query:, filters:, sort:, page:, limit:, return_facets: false)
+        filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
+        filters = (filters || {}).stringify_keys
+
+        option_value_ids = extract_and_delete(filters, 'with_option_value_ids')
+        grouped_options = group_option_values_by_type(Array(option_value_ids))
+
+        base_conditions = build_filters(filters)
+        option_conditions = build_grouped_option_conditions(grouped_options)
+        all_conditions = base_conditions + option_conditions
+
+        search_params = {
+          filter: all_conditions,
+          facets: return_facets ? facet_attributes : nil,
+          sort: build_sort(sort),
+          offset: (page - 1) * limit,
+          limit: limit
+        }.compact
+
+        Rails.logger.debug { "[Meilisearch] index=#{index_name} query=#{query.inspect} #{search_params.compact.inspect}" }
+
+        begin
+          if return_facets && grouped_options.any?
+            queries = [{ indexUid: index_name, q: query.to_s, **search_params }]
+            option_type_ids_ordered = grouped_options.keys
+            option_type_ids_ordered.each do |option_type_id|
+              without_this = build_grouped_option_conditions(grouped_options.except(option_type_id))
+              queries << { indexUid: index_name, q: query.to_s, filter: base_conditions + without_this, facets: ['option_value_ids'], limit: 0 }
+            end
+
+            results = client.multi_search(queries)
+            ms_result = results['results'][0]
+            facet_distribution = merge_disjunctive_facets(ms_result, results['results'][1..], option_type_ids_ordered)
+          else
+            ms_result = client.index(index_name).search(query.to_s, search_params)
+            facet_distribution = ms_result['facetDistribution'] || {}
+          end
+        rescue ::Meilisearch::ApiError => e
+          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
+        end
+
+        Rails.logger.debug { "[Meilisearch] #{ms_result['estimatedTotalHits']} hits in #{ms_result['processingTimeMs']}ms" }
+
+        [ms_result, facet_distribution]
+      end
+
+      def merge_disjunctive_facets(ms_result, disjunctive_results, option_type_ids_ordered)
+        main_ov_dist = ms_result.dig('facetDistribution', 'option_value_ids') || {}
+
+        all_ov_prefixed_ids = Set.new
+        disjunctive_dists = {}
+        disjunctive_results.each_with_index do |r, idx|
+          dist = r.dig('facetDistribution', 'option_value_ids') || {}
+          disjunctive_dists[option_type_ids_ordered[idx]] = dist
+          all_ov_prefixed_ids.merge(dist.keys)
+        end
+
+        all_raw_ids = all_ov_prefixed_ids.filter_map { |pid| Spree::OptionValue.decode_prefixed_id(pid) }
+        ov_to_type = Spree::OptionValue.where(id: all_raw_ids).pluck(:id, :option_type_id).to_h
+        prefixed_to_type = all_ov_prefixed_ids.each_with_object({}) do |pid, h|
+          raw = Spree::OptionValue.decode_prefixed_id(pid)
+          h[pid] = ov_to_type[raw] if raw
+        end
+
+        merged_ov_dist = main_ov_dist.dup
+        disjunctive_dists.each do |option_type_id, dist|
+          dist.each do |pid, count|
+            merged_ov_dist[pid] = count if prefixed_to_type[pid] == option_type_id
+          end
+        end
+
+        (ms_result['facetDistribution'] || {}).merge('option_value_ids' => merged_ov_dist)
+      end
+
       def presenter_class
         Spree::Dependencies.search_product_presenter_class
       end
@@ -436,9 +456,6 @@ module Spree
       def empty_result(scope, page, limit)
         SearchResult.new(
           products: scope.none,
-          filters: [],
-          sort_options: available_sort_options.map { |id| { id: id } },
-          default_sort: 'manual',
           total_count: 0,
           pagy: Pagy::Offset.new(count: 0, page: page, limit: limit)
         )

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

@@ -1,5 +1,5 @@
 module Spree
   module SearchProvider
-    SearchResult = Struct.new(:products, :filters, :sort_options, :default_sort, :total_count, :pagy, keyword_init: true)
+    SearchResult = Struct.new(:products, :total_count, :pagy, keyword_init: true)
   end
 end

data/app/models/spree/shipment.rb

@@ -112,8 +112,10 @@ module Spree
     self.whitelisted_ransackable_attributes = ['number']
 
     extend DisplayMoney
-    money_methods :cost, :discounted_cost, :final_price, :item_cost, :additional_tax_total, :included_tax_total, :tax_total
+    money_methods :cost, :discounted_cost, :final_price, :item_cost, :additional_tax_total, :included_tax_total, :tax_total, :promo_total
     alias display_amount display_cost
+    alias_attribute :discount_total, :promo_total
+    alias display_discount_total display_promo_total
 
     normalizes :tracking, with: ->(value) { value&.to_s&.squish&.presence }
 
@@ -197,6 +199,8 @@ module Spree
     def final_price
       cost + adjustment_total
     end
+    alias total final_price
+    alias display_total display_final_price
 
     def final_price_with_items
       item_cost + final_price

data/app/models/spree/shipping_rate.rb

@@ -7,7 +7,7 @@ module Spree
     belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
     extend Spree::DisplayMoney
 
-    money_methods :base_price, :final_price, :tax_amount
+    money_methods :base_price, :final_price, :tax_amount, :additional_tax_total, :included_tax_total, :tax_total
 
     delegate :order, :currency, :with_free_shipping_promotion?, to: :shipment
     delegate :name, to: :shipping_method
@@ -29,14 +29,37 @@ module Spree
     alias display_cost display_price
     alias_attribute :base_price, :cost
 
+    # Returns true if the shipping rate is free
+    #
+    # @return [Boolean]
     def free?
       final_price.zero?
     end
 
+    # Returns the tax amount for the shipping rate
+    #
+    # @return [BigDecimal]
     def tax_amount
       @tax_amount ||= tax_rate&.calculator&.compute_shipping_rate(self) || BigDecimal(0)
     end
 
+    # Returns the additional tax total for the shipping rate
+    #
+    # @return [BigDecimal]
+    def additional_tax_total
+      tax_rate&.included_in_price? ? BigDecimal(0) : tax_amount
+    end
+
+    # Returns the included tax total for the shipping rate
+    #
+    # @return [BigDecimal]
+    def included_tax_total
+      tax_rate&.included_in_price? ? tax_amount : BigDecimal(0)
+    end
+
+    alias tax_total tax_amount
+    alias display_tax_total display_tax_amount
+
     # returns base price - any available discounts for this Shipment
     # useful when you want to present a list of available shipping rates
     def final_price
@@ -46,6 +69,8 @@ module Spree
         cost + discount_amount
       end
     end
+    alias total final_price
+    alias display_total display_final_price
 
     # Returns the delivery range for the shipping method
     #

data/app/models/spree/taxon.rb

@@ -72,10 +72,9 @@ module Spree
     #
     # Callbacks
     #
-    before_validation :set_permalink, on: :create, if: :name
+    before_validation :set_permalink, if: :name
     before_validation :copy_taxonomy_from_parent
     before_save :set_pretty_name
-    before_save :set_permalink
     after_save :touch_ancestors_and_taxonomy
     after_update :sync_taxonomy_name
     after_touch :touch_ancestors_and_taxonomy

data/app/models/spree/variant.rb

@@ -470,14 +470,17 @@ module Spree
     # @param backorderable [Boolean] the backorderable flag
     # @param stock_location [Spree::StockLocation] the stock location to set the stock for
     # @return [void]
-    def set_stock(count_on_hand, backorderable = nil, stock_location = nil)
-      stock_location ||= Spree::Store.current.default_stock_location
-      stock_item = stock_items.find_or_initialize_by(stock_location: stock_location)
+    def set_stock(count_on_hand, backorderable = nil)
+      stock_item = stock_items.find_or_initialize_by(stock_location: default_stock_location)
       stock_item.count_on_hand = count_on_hand
       stock_item.backorderable = backorderable if backorderable.present?
       stock_item.save!
     end
 
+    def default_stock_location
+      Spree::Store.current.default_stock_location
+    end
+
     def price_modifier_amount_in(currency, options = {})
       return 0 unless options.present?
 

data/app/services/spree/credit_cards/destroy.rb

@@ -1,41 +1,25 @@
 module Spree
   module CreditCards
+    # @deprecated Use card.destroy directly instead. Payment cleanup is now
+    #   handled by the before_destroy callback in Spree::PaymentSourceConcern.
+    #   This service will be removed in Spree 6.0.
     class Destroy
       prepend Spree::ServiceModule::Base
 
       def call(card:)
-        ApplicationRecord.transaction do
-          run :invalidate_payments
-          run :void_payments
-          run :destroy
-        end
-      end
-
-      protected
-
-      def invalidate_payments(card:)
-        payment_scope(card).checkout.each(&:invalidate!)
-
-        success(card: card)
-      end
+        Spree::Deprecation.warn(
+          "#{self.class.name} is deprecated and will be removed in Spree 6.0. " \
+          'Use card.destroy directly instead. Payment cleanup is now handled ' \
+          'automatically by the before_destroy callback in PaymentSourceConcern.',
+          caller
+        )
 
-      def void_payments(card:)
-        payment_scope(card).where.not(state: :checkout).each(&:void!)
-
-        success(card: card)
-      end
-
-      def destroy(card:)
         if card.destroy
           success(card: card)
         else
-          failure(card.errors.full_messages.to_sentance)
+          failure(card.errors.full_messages.to_sentence)
         end
       end
-
-      def payment_scope(card)
-        card.payments.valid.joins(:order).merge(Spree::Order.incomplete)
-      end
     end
   end
 end

data/app/services/spree/gift_cards/apply.rb

@@ -68,7 +68,11 @@ module Spree
         )
         payment_method.name ||= Spree.t(:store_credit_name)
         payment_method.active = true
-        payment_method.save! if payment_method.new_record?
+
+        if payment_method.new_record?
+          payment_method.stores << store unless payment_method.stores.include?(store)
+          payment_method.save!
+        end
 
         payment_method
       end

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

@@ -2,10 +2,14 @@ module Spree
   module Imports
     module RowProcessors
       class Base
-        def initialize(row)
+        def initialize(row, mappings: nil, schema_fields: nil)
           @row = row
           @import = row.import
-          @attributes = row.to_schema_hash
+          @attributes = if mappings && schema_fields
+                          build_schema_hash(row, mappings, schema_fields)
+                        else
+                          row.to_schema_hash
+                        end
         end
 
         attr_reader :row, :import, :attributes
@@ -13,6 +17,19 @@ module Spree
         def process!
           raise NotImplementedError, 'Subclasses must implement the process! method'
         end
+
+        private
+
+        def build_schema_hash(row, mappings, schema_fields)
+          attributes = {}
+          schema_fields.each do |field|
+            mapping = mappings.find { |m| m.schema_field == field[:name] }
+            next unless mapping&.mapped?
+
+            attributes[field[:name]] = row.data_json[mapping.file_column]
+          end
+          attributes
+        end
       end
     end
   end

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

@@ -4,7 +4,7 @@ module Spree
       class ProductTranslation < Base
         TRANSLATABLE_FIELDS = %w[name description meta_title meta_description].freeze
 
-        def initialize(row)
+        def initialize(row, **)
           super
           @store = row.store
         end

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

@@ -4,7 +4,7 @@ module Spree
       class ProductVariant < Base
         OPTION_TYPES_COUNT = 3
 
-        def initialize(row)
+        def initialize(row, **)
           super
           @store = row.store
           @product = ensure_product_exists
@@ -47,7 +47,7 @@ module Spree
           end
 
           if attributes['inventory_count'].present?
-            variant.set_stock(attributes['inventory_count'].to_i, attributes['inventory_backorderable']&.to_b, store.default_stock_location)
+            variant.set_stock(attributes['inventory_count'].to_i, attributes['inventory_backorderable']&.to_b)
           end
 
           handle_images(variant)

data/app/services/spree/payments/handle_webhook.rb

@@ -30,6 +30,12 @@ module Spree
 
       def handle_success(payment_session, order, metadata)
         order.with_lock do
+          # Idempotency: if the session was already completed (by the API
+          # endpoint or a previous webhook), skip duplicate processing.
+          if payment_session.reload.completed?
+            return success(payment_session)
+          end
+
           # Ensure payment record exists
           payment = payment_session.find_or_create_payment!(metadata)
 

data/app/services/spree/seeds/zones.rb

@@ -7,17 +7,23 @@ module Spree
         eu_vat = Spree::Zone.where(name: 'EU_VAT', description: 'Countries that make up the EU VAT zone.', kind: 'country').first_or_create!
         uk_vat = Spree::Zone.where(name: 'UK_VAT', kind: 'country').first_or_create!
         north_america = Spree::Zone.where(name: 'North America', description: 'USA + Canada', kind: 'country').first_or_create!
-        Spree::Zone.where(name: 'South America', description: 'South America', kind: 'country').first_or_create!
+        central_america_and_caribbean = Spree::Zone.where(name: 'Central America and Caribbean', description: 'Central America and Caribbean', kind: 'country').first_or_create!
+        south_america = Spree::Zone.where(name: 'South America', description: 'South America', kind: 'country').first_or_create!
         middle_east = Spree::Zone.where(name: 'Middle East', description: 'Middle East', kind: 'country').first_or_create!
+        africa = Spree::Zone.where(name: 'Africa', description: 'Africa', kind: 'country').first_or_create!
         asia = Spree::Zone.where(name: 'Asia', description: 'Asia', kind: 'country').first_or_create!
         australia_and_oceania = Spree::Zone.where(name: 'Australia and Oceania', description: 'Australia and Oceania', kind: 'country').first_or_create!
 
         create_zone_members(eu_vat, %w(PL FI PT RO DE FR SK HU SI IE AT ES IT BE SE LV BG LT CY LU MT DK NL EE HR CZ GR))
         create_zone_members(north_america, %w(US CA))
+        create_zone_members(central_america_and_caribbean, %w(MX GT BZ SV HN NI CR PA CU DO HT JM BS BB TT PR AG DM GD KN LC VC AI AW BM KY CW GP MQ MS BL MF SX TC VG VI))
+        create_zone_members(south_america, %w(AR BO BR CL CO EC FK GF GY PY PE SR UY VE))
         create_zone_members(middle_east, %w(BH CY EG IR IQ IL JO KW LB OM QA SA SY TR AE YE))
+        create_zone_members(africa, %w(DZ AO BJ BW BF BI CV CM CF TD KM CG CD CI DJ EG GQ ER SZ ET GA GM GH GN GW KE LS LR LY
+                                       MG MW ML MR MU YT MA MZ NA NE NG RE RW SH ST SN SC SL SO ZA SS SD TZ TG TN UG ZM ZW))
         create_zone_members(asia, %w(AF AM AZ BH BD BT BN KH CN CX CC GE HK IN ID IR IQ IL JP JO KZ KW KG LA LB MO MY MV MN MM NP
                                      KP OM PK PS PH QA SA SG KR LK SY TW TJ TH TR TM AE UZ VN YE))
-        create_zone_members(australia_and_oceania, %w(AU NZ))
+        create_zone_members(australia_and_oceania, %w(AU NZ PG FJ SB VU NC PF WS AS GU KI MH FM NR NU NF MP PW PN TK TO TV WF CK))
         uk_vat.zone_members.where(zoneable: Spree::Country.find_by(iso: 'GB')).first_or_create!
       end
 

data/app/subscribers/spree/event_log_subscriber.rb

@@ -16,25 +16,27 @@ module Spree
 
     class << self
       def attach_to_notifications
-        # Always detach first to ensure clean state after code reload
+        # Always detach first to ensure clean state after code reload.
+        # The subscription reference is stored on Spree::Events (in lib/, not
+        # reloaded by Zeitwerk) so repeated reloads in development do not leak
+        # stale AS::N subscriptions when this class is reloaded.
         detach_from_notifications
 
-        @subscription = ActiveSupport::Notifications.subscribe(/\.#{NAMESPACE}$/) do |name, start, finish, _id, payload|
+        Spree::Events.log_subscription = ActiveSupport::Notifications.subscribe(/\.#{NAMESPACE}$/) do |name, start, finish, _id, payload|
           log_event(name, start, finish, payload)
         end
 
-        @attached = true
         Rails.logger.info "[Spree Events] Event logging enabled"
       end
 
       def detach_from_notifications
-        ActiveSupport::Notifications.unsubscribe(@subscription) if @subscription
-        @subscription = nil
-        @attached = false
+        subscription = Spree::Events.log_subscription
+        ActiveSupport::Notifications.unsubscribe(subscription) if subscription
+        Spree::Events.log_subscription = nil
       end
 
       def attached?
-        @attached || false
+        !Spree::Events.log_subscription.nil?
       end
 
       private

data/config/initializers/carmen.rb

@@ -0,0 +1,23 @@
+# Patches Carmen::Querying#normalise_name to avoid the deprecated
+# ActiveSupport::Multibyte::Chars API (mb_chars), which will be removed in
+# Rails 8.2.
+#
+# In Ruby 2.4+, String#downcase is already Unicode-aware, making the mb_chars
+# call redundant. Since Spree requires Ruby >= 3.2, we can drop it safely.
+#
+# This patch can be removed once the upstream gem is fixed.
+#
+# See: https://github.com/carmen-ruby/carmen/issues/304
+require 'carmen'
+
+module Spree
+  module CarmenQueryingPatch
+    private
+
+    def normalise_name(name)
+      name.downcase.unicode_normalize(:nfkc)
+    end
+  end
+end
+
+Carmen::Querying.prepend(Spree::CarmenQueryingPatch)

data/config/locales/en.yml

@@ -1342,7 +1342,6 @@ en:
     items_in_rmas: Items in Return Authorizations
     items_reimbursed: Items reimbursed
     items_to_be_reimbursed: Items to be reimbursed
-    join_slack: Join Slack
     key: Key
     kind: Kind
     label: Label

data/db/migrate/20260424000001_add_unique_index_to_spree_payments_response_code.rb

@@ -0,0 +1,51 @@
+class AddUniqueIndexToSpreePaymentsResponseCode < ActiveRecord::Migration[7.2]
+  def up
+    # Remove duplicate payments per (order, payment_method, response_code),
+    # preferring to keep completed payments over incomplete ones.
+    # Among same-state duplicates, keeps the most recent (highest id).
+    # Uses derived table for MySQL compatibility.
+    execute <<~SQL
+      DELETE FROM spree_payments
+      WHERE response_code IS NOT NULL
+        AND id NOT IN (
+          SELECT keeper_id FROM (
+            SELECT (
+              SELECT id FROM spree_payments p2
+              WHERE p2.order_id = p1.order_id
+                AND p2.payment_method_id = p1.payment_method_id
+                AND p2.response_code = p1.response_code
+              ORDER BY
+                CASE p2.state
+                  WHEN 'completed' THEN 0
+                  WHEN 'pending'   THEN 1
+                  WHEN 'processing' THEN 2
+                  ELSE 3
+                END,
+                p2.id DESC
+              LIMIT 1
+            ) AS keeper_id
+            FROM spree_payments p1
+            WHERE p1.response_code IS NOT NULL
+            GROUP BY p1.order_id, p1.payment_method_id, p1.response_code
+          ) AS keeper_ids
+        )
+    SQL
+
+    if ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+      # MySQL doesn't support partial indexes, but treats NULL as distinct
+      # in unique indexes so multiple payments with NULL response_code are allowed
+      add_index :spree_payments, [:order_id, :payment_method_id, :response_code],
+                unique: true,
+                name: 'idx_payments_order_method_response_code'
+    else
+      add_index :spree_payments, [:order_id, :payment_method_id, :response_code],
+                unique: true,
+                where: 'response_code IS NOT NULL',
+                name: 'idx_payments_order_method_response_code'
+    end
+  end
+
+  def down
+    remove_index :spree_payments, name: 'idx_payments_order_method_response_code'
+  end
+end

data/db/migrate/20260424100000_add_processing_groups_to_spree_imports.rb

@@ -0,0 +1,6 @@
+class AddProcessingGroupsToSpreeImports < ActiveRecord::Migration[7.2]
+  def change
+    add_column :spree_imports, :processing_groups_count, :integer, default: 0
+    add_column :spree_imports, :completed_groups_count, :integer, default: 0
+  end
+end