spree_core 5.4.0 → 5.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 063ec32e04e9cca4d9987ddc55b8bf72266d6f9aaf204f2e7da96ad57365495d
-  data.tar.gz: 9b13ad923ebcad513038a2bbe63d880c9b285e73e18e93a3f73983bec23cc6a1
+  metadata.gz: 23692bda70e0c85ecff286d989063498e74adc2e2422ae21719da5c6b6e97c98
+  data.tar.gz: 132486aca06d2912f82a54593d57eb9c400768b1a45b5412af77b61f2c822ac5
 SHA512:
-  metadata.gz: a4cbe7e4ea5cab60434be37aed988f0c1b5d2276a43f94b31bf4150dbd933e8ddb64f0a4ddffb316c9e5d10449b6de0563c2ccaa4baf31bd1fb7b511a2b55ab8
-  data.tar.gz: 52d17f39e82f7db6155af88252181cfe0fc60362cc29a46233f9748c09b6cd6b0a4cd03b6e9f544d12c1e7c2f895bd75b91c8d6142794b326e30f16d9738e08f
+  metadata.gz: 0dc0c862bb8c7313e53ac13b80fe2ce6dd697bfad36ed0841562220b12c5253e473ac5f2623e95ac038da6d8903b3a329a47a4dee813f47a37e498bde6a66bc4
+  data.tar.gz: facf65e2c8067fbd2cbba0c04ff49daadf53901b137a2a80ada8ae95e646f0ba2ae3df1a7def6651fc81c9aaf52d8d2268e9c86e42c982f4074b3560c7595d91

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

@@ -0,0 +1,45 @@
+module Spree
+  module Imports
+    class ProcessGroupJob < Spree::BaseJob
+      queue_as Spree.queues.imports
+
+      def perform(import_id, row_ids)
+        import = Spree::Import.find(import_id)
+        Spree::Current.store = import.store
+
+        mappings = import.mappings.mapped.to_a
+        schema_fields = import.schema_fields
+        large = import.large_import?
+        rows = import.rows.where(id: row_ids).order(:row_number)
+
+        if large
+          Spree::Events.disable do
+            rows.each { |row| row.bulk_process!(mappings: mappings, schema_fields: schema_fields) }
+          end
+        else
+          rows.each do |row|
+            row.process!(mappings: mappings, schema_fields: schema_fields)
+          end
+        end
+
+        check_import_completion(import, large)
+      end
+
+      private
+
+      def check_import_completion(import, large)
+        Spree::Import.where(id: import.id).update_all(
+          'completed_groups_count = COALESCE(completed_groups_count, 0) + 1'
+        )
+        import.reload
+
+        if import.completed_groups_count >= import.processing_groups_count
+          # Guard against concurrent workers both reaching this point
+          import.complete! if import.status == 'processing'
+        elsif large && (import.completed_groups_count % 10).zero?
+          import.publish_event('import.progress')
+        end
+      end
+    end
+  end
+end

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

@@ -3,16 +3,62 @@ module Spree
     class ProcessRowsJob < Spree::BaseJob
       queue_as Spree.queues.imports
 
+      BATCH_SIZE = 100
+
       def perform(import_id)
         import = Spree::Import.find(import_id)
+        dispatch_groups(import)
+      end
+
+      private
+
+      def dispatch_groups(import)
+        group_field = import.group_column
+        group_mapping = group_field && import.mappings.mapped.find_by(schema_field: group_field)
+        file_column = group_mapping&.file_column
 
-        # process all rows in sequential order
-        import.rows.pending_and_failed.find_each(batch_size: 100) do |row|
-          row.process!
+        if file_column
+          dispatch_grouped(import, file_column)
+        else
+          dispatch_batched(import)
         end
+      end
+
+      def dispatch_grouped(import, file_column)
+        groups = Hash.new { |h, k| h[k] = [] }
+
+        import.rows.pending_and_failed.order(:row_number).pluck(:id, :data).each do |id, data|
+          parsed = JSON.parse(data)
+          key = parsed[file_column].to_s.strip.downcase.presence || '__ungrouped__'
+          groups[key] << id
+        rescue JSON::ParserError
+          groups['__ungrouped__'] << id
+        end
+
+        # Set count before enqueuing so workers can't complete prematurely
+        import.update_columns(
+          processing_groups_count: groups.size,
+          completed_groups_count: 0,
+          updated_at: Time.current
+        )
+
+        groups.each_value { |row_ids| ProcessGroupJob.perform_later(import.id, row_ids) }
+      end
+
+      def dispatch_batched(import)
+        # Count first, then enqueue — prevents premature completion
+        row_id_batches = import.rows.pending_and_failed.order(:row_number)
+                              .pluck(:id)
+                              .each_slice(BATCH_SIZE)
+                              .to_a
+
+        import.update_columns(
+          processing_groups_count: row_id_batches.size,
+          completed_groups_count: 0,
+          updated_at: Time.current
+        )
 
-        # mark as complete
-        import.complete!
+        row_id_batches.each { |row_ids| ProcessGroupJob.perform_later(import.id, row_ids) }
       end
     end
   end

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

@@ -2,6 +2,10 @@ module Spree
   module PaymentSourceConcern
     extend ActiveSupport::Concern
 
+    included do
+      before_destroy :cleanup_payments_on_incomplete_orders
+    end
+
     # Available actions for the payment source.
     # @return [Array<String>]
     def actions
@@ -35,5 +39,22 @@ module Spree
     def has_payment_profile?
       gateway_customer_profile_id.present? || gateway_payment_profile_id.present?
     end
+
+    private
+
+    # Cleans up payments on incomplete orders before the source is destroyed.
+    # Invalidates checkout-state payments and voids non-checkout payments.
+    # Skips payments whose payment_method was already nullified (e.g. when
+    # the payment method itself is being destroyed).
+    def cleanup_payments_on_incomplete_orders
+      incomplete_payments = Spree::Payment.valid
+                                          .where(source: self)
+                                          .where.not(payment_method_id: nil)
+                                          .joins(:order)
+                                          .merge(Spree::Order.incomplete)
+
+      incomplete_payments.checkout.each(&:invalidate!)
+      incomplete_payments.where.not(state: :checkout).each(&:void!)
+    end
   end
 end

data/app/models/spree/address.rb

@@ -79,7 +79,7 @@ module Spree
       end
     end
 
-    delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true
+    delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true, allow_nil: true
     delegate :abbr, to: :state, prefix: true, allow_nil: true
 
     alias_attribute :postal_code, :zipcode

data/app/models/spree/gateway/bogus.rb

@@ -32,7 +32,7 @@ module Spree
     def authorize(_money, credit_card, _options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include?(credit_card.number) || (profile_id&.starts_with?('BGS-'))
-        Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'D' })
+        Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: generate_authorization, avs_result: { code: 'D' })
       else
         Spree::PaymentResponse.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
@@ -41,18 +41,18 @@ module Spree
     def purchase(_money, credit_card, _options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include?(credit_card.number) || (profile_id&.starts_with?('BGS-'))
-        Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'M' })
+        Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: generate_authorization, avs_result: { code: 'M' })
       else
         Spree::PaymentResponse.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 
     def credit(_money, _credit_card, _response_code, _options = {})
-      Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+      Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: generate_authorization)
     end
 
     def capture(_money, authorization, _gateway_options)
-      if authorization == '12345'
+      if authorization&.start_with?('BGS-')
         Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true)
       else
         Spree::PaymentResponse.new(false, 'Bogus Gateway: Forced failure', error: 'Bogus Gateway: Forced failure', test: true)
@@ -60,11 +60,11 @@ module Spree
     end
 
     def void(_response_code, _credit_card, _options = {})
-      Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: 'void-12345')
+      Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: "void-#{generate_authorization}")
     end
 
     def cancel(_response_code, _payment = nil)
-      Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+      Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: generate_authorization)
     end
 
     def test?
@@ -150,6 +150,10 @@ module Spree
 
     private
 
+    def generate_authorization
+      "BGS-#{SecureRandom.hex(6)}"
+    end
+
     def generate_profile_id(success)
       record = true
       prefix = success ? 'BGS' : 'FAIL'

data/app/models/spree/import.rb

@@ -76,6 +76,21 @@ module Spree
     #
     preference :delimiter, :string, default: ','
 
+    # Returns true if the import has more rows than the large import threshold.
+    # Large imports skip per-row UI broadcasts and use bulk processing.
+    # @return [Boolean]
+    def large_import?
+      rows_count >= Spree::Config[:large_import_threshold]
+    end
+
+    # Returns the schema field name used to group rows for parallel processing.
+    # Rows sharing the same value in this field are processed together in one job.
+    # Returns nil for imports where rows are independent (default — batched in chunks).
+    # @return [String, nil]
+    def group_column
+      nil
+    end
+
     # Returns true if the import is in mapping state
     # @return [Boolean]
     def mapping?

data/app/models/spree/import_row.rb

@@ -77,9 +77,9 @@ module Spree
       data_json[mapping.file_column]
     end
 
-    def process!
+    def process!(mappings: nil, schema_fields: nil)
       start_processing!
-      self.item = import.row_processor_class.new(self).process!
+      self.item = import.row_processor_class.new(self, mappings: mappings, schema_fields: schema_fields).process!
       complete!
     rescue StandardError => e
       Rails.error.report(e, handled: true, context: { import_row_id: id }, source: 'spree.core')
@@ -87,6 +87,18 @@ module Spree
       fail!
     end
 
+    # Bulk processing mode for large imports.
+    # Uses update_columns to skip callbacks, validations, and event publishing.
+    def bulk_process!(mappings:, schema_fields:)
+      update_columns(status: 'processing', updated_at: Time.current)
+      processor = import.row_processor_class.new(self, mappings: mappings, schema_fields: schema_fields)
+      self.item = processor.process!
+      update_columns(status: 'completed', item_type: item.class.name, item_id: item.id, updated_at: Time.current)
+    rescue StandardError => e
+      Rails.error.report(e, handled: true, context: { import_row_id: id }, source: 'spree.core')
+      update_columns(status: 'failed', validation_errors: e.message, updated_at: Time.current)
+    end
+
     def publish_import_row_completed_event
       publish_event('import_row.completed')
     end

data/app/models/spree/imports/product_translations.rb

@@ -5,6 +5,10 @@ module Spree
         Spree::Imports::RowProcessors::ProductTranslation
       end
 
+      def group_column
+        'slug'
+      end
+
       def model_class
         Spree::Product
       end

data/app/models/spree/imports/products.rb

@@ -4,6 +4,11 @@ module Spree
       def row_processor_class
         Spree::Imports::RowProcessors::ProductVariant
       end
+
+      # Group by slug: product row + its variant rows must be processed together
+      def group_column
+        'slug'
+      end
     end
   end
 end

data/app/models/spree/order.rb

@@ -102,7 +102,6 @@ module Spree
       go_to_state :payment, if: ->(order) { order.payment? || order.payment_required? }
       go_to_state :confirm, if: ->(order) { order.confirmation_required? }
       go_to_state :complete
-      remove_transition from: :delivery, to: :confirm, unless: ->(order) { order.confirmation_required? }
     end
 
     self.whitelisted_ransackable_associations = %w[shipments user created_by approver canceler promotions bill_address ship_address line_items store]
@@ -1013,7 +1012,6 @@ module Spree
 
       update_with_updater!
       send_order_canceled_webhook
-      publish_order_canceled_event
     end
 
     def after_resume
@@ -1094,10 +1092,6 @@ module Spree
       publish_event('order.completed')
     end
 
-    def publish_order_canceled_event
-      publish_event('order.canceled')
-    end
-
     def publish_order_resumed_event
       publish_event('order.resumed')
     end

data/app/models/spree/payment.rb

@@ -42,6 +42,7 @@ module Spree
 
     validates :payment_method, presence: true
     validates :source, presence: true, if: :source_required?
+    validates :response_code, uniqueness: { scope: [:order_id, :payment_method_id] }, allow_nil: true
     validate :payment_method_available_for_order, on: :create
 
     before_validation :validate_source

data/app/models/spree/payment_session.rb

@@ -92,6 +92,11 @@ module Spree
         p.amount = amount
         p.skip_source_requirement = true
       end
+    rescue ActiveRecord::RecordNotUnique
+      order.payments.find_by!(
+        payment_method: payment_method,
+        response_code: external_id
+      )
     end
 
     private

data/app/models/spree/product.rb

@@ -249,16 +249,11 @@ module Spree
 
       products_to_auto_match_ids = store.products.not_deleted.not_archived.where(id: product_ids).ids
 
-      # for ActiveJob 7.1+
-      if ActiveJob.respond_to?(:perform_all_later)
-        auto_match_taxons_jobs = products_to_auto_match_ids.map do |product_id|
-          Spree::Products::AutoMatchTaxonsJob.new(product_id)
-        end
-
-        ActiveJob.perform_all_later(auto_match_taxons_jobs)
-      else
-        products_to_auto_match_ids.each { |product_id| Spree::Products::AutoMatchTaxonsJob.perform_later(product_id) }
+      auto_match_taxons_jobs = products_to_auto_match_ids.map do |product_id|
+        Spree::Products::AutoMatchTaxonsJob.new(product_id).tap { |job| job.scheduled_at = 30.seconds.from_now }
       end
+
+      ActiveJob.perform_all_later(auto_match_taxons_jobs)
     end
 
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
@@ -582,7 +577,7 @@ module Spree
       store = stores.find_by(default: true) || stores.first
       return if store.nil? || store.taxons.automatic.none?
 
-      Spree::Products::AutoMatchTaxonsJob.perform_later(id)
+      Spree::Products::AutoMatchTaxonsJob.set(wait: 30.seconds).perform_later(id)
     end
 
     def to_csv(store = nil)

data/app/models/spree/promotion.rb

@@ -232,7 +232,7 @@ module Spree
 
     def adjusted_credits_count(promotable)
       adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
-      credits_count - adjustments.promotion.where(source_id: actions.pluck(:id)).size
+      credits_count - adjustments.eligible.promotion.where(source_id: actions.pluck(:id)).select(:order_id).distinct.count
     end
 
     def credits
@@ -240,7 +240,7 @@ module Spree
     end
 
     def credits_count
-      credits.count
+      credits.select(:order_id).distinct.count
     end
 
     def line_item_actionable?(order, line_item)

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

@@ -13,7 +13,7 @@ module Spree
         @store = store
       end
 
-      # Search, filter, and return facets in one call.
+      # Search and paginate products. Does NOT compute filter facets — use #filters for that.
       #
       # @param scope [ActiveRecord::Relation] base scope (store-scoped, visibility-filtered, authorized)
       # @param query [String, nil] text search query
@@ -26,6 +26,18 @@ module Spree
         raise NotImplementedError
       end
 
+      # Compute filter facets, sort options, and total count for the given scope.
+      # Called by the dedicated filters endpoint — kept separate from search_and_filter
+      # to avoid expensive facet queries on every product listing.
+      #
+      # @param scope [ActiveRecord::Relation] base scope
+      # @param query [String, nil] text search query
+      # @param filters [Hash] structured filters
+      # @return [FiltersResult]
+      def filters(scope:, query: nil, filters: {})
+        raise NotImplementedError
+      end
+
       # Index a product — called after product save. No-op for database provider.
       #
       # @param product [Spree::Product] the product to index

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

@@ -8,35 +8,16 @@ module Spree
       }.freeze
 
       def search_and_filter(scope:, query: nil, filters: {}, sort: nil, page: 1, limit: 25)
-        # 1. Text search
-        scope = scope.search(query) if query.present?
-
-        # 2. Extract internal params before passing to Ransack
-        category = filters.is_a?(Hash) ? filters.delete('_category') || filters.delete(:_category) : nil
-
-        # 2b. Extract option value IDs — handled by scope (OR within type, AND across)
-        option_value_ids = filters.is_a?(Hash) ? filters.delete('with_option_value_ids') || filters.delete(:with_option_value_ids) : nil
-
-        # 3. Structured filtering via Ransack
-        ransack_filters = sanitize_filters(filters)
-        if ransack_filters.present?
-          search = scope.ransack(ransack_filters)
-          scope = search.result(distinct: true)
-        end
-
-        # Save scope before option filters for disjunctive facet counts
-        scope_before_options = scope
-        if option_value_ids.present?
-          scope = scope.with_option_value_ids(Array(option_value_ids))
-        end
+        filters = filters.is_a?(Hash) ? filters.dup : {}
+        option_value_ids = filters.delete('with_option_value_ids') || filters.delete(:with_option_value_ids)
 
-        # 4. Facets (before sorting to avoid computed column conflicts with count)
-        filter_facets = build_facets(scope, category: category, option_value_ids: Array(option_value_ids), scope_before_options: scope_before_options)
+        scope = apply_search_and_filters(scope, query: query, filters: filters)
+        scope = scope.with_option_value_ids(Array(option_value_ids)) if option_value_ids.present?
 
-        # 5. Total count (before sorting to avoid computed column conflicts with count)
+        # Total count (before sorting to avoid computed column conflicts with count)
         total = scope.distinct.count
 
-        # 6. Sorting + pagination
+        # Sorting + pagination
         scope = apply_sort(scope, sort)
         page = [page.to_i, 1].max
         limit = limit.to_i.clamp(1, 100)
@@ -44,22 +25,56 @@ module Spree
 
         SearchResult.new(
           products: products,
+          total_count: total,
+          pagy: build_pagy(total, page, limit)
+        )
+      end
+
+      def filters(scope:, query: nil, filters: {})
+        filters = filters.is_a?(Hash) ? filters.dup : {}
+        category = filters.delete('_category') || filters.delete(:_category)
+        option_value_ids = Array(filters.delete('with_option_value_ids') || filters.delete(:with_option_value_ids))
+
+        # Apply text search + ransack filters (without option values)
+        scope_before_options = apply_search_and_filters(scope, query: query, filters: filters)
+
+        # Apply option value filters for the final scope
+        scope_with_options = if option_value_ids.present?
+                               scope_before_options.with_option_value_ids(option_value_ids)
+                             else
+                               scope_before_options
+                             end
+
+        filter_facets = build_facets(scope_with_options, category: category, option_value_ids: option_value_ids, scope_before_options: scope_before_options)
+
+        FiltersResult.new(
           filters: filter_facets[:filters],
           sort_options: filter_facets[:sort_options],
           default_sort: filter_facets[:default_sort],
-          total_count: total,
-          pagy: build_pagy(total, page, limit)
+          total_count: filter_facets[:total_count]
         )
       end
 
       private
 
+      def apply_search_and_filters(scope, query: nil, filters: {})
+        scope = scope.search(query) if query.present?
+
+        ransack_filters = sanitize_filters(filters)
+        if ransack_filters.present?
+          search = scope.ransack(ransack_filters)
+          scope = search.result(distinct: true)
+        end
+
+        scope
+      end
+
       def build_pagy(count, page, limit)
         Pagy::Offset.new(count: count, page: page, limit: limit)
       end
 
       def build_facets(scope, category: nil, option_value_ids: [], scope_before_options: nil)
-        return { filters: [], sort_options: available_sort_options, default_sort: 'manual' } unless defined?(Spree::Api::V3::FiltersAggregator)
+        return { filters: [], sort_options: available_sort_options, default_sort: 'manual', total_count: scope.distinct.count } unless defined?(Spree::Api::V3::FiltersAggregator)
 
         Spree::Api::V3::FiltersAggregator.new(
           scope: scope,
@@ -74,7 +89,7 @@ module Spree
         return {} if filters.blank?
 
         filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
-        filters.except('search', :search, '_category', :_category)
+        filters.except('search', :search, '_category', :_category, 'with_option_value_ids', :with_option_value_ids)
       end
 
       def apply_sort(scope, sort)

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

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