spree_core 6.0.0.rc5 → 6.0.0.rc7

data/app/models/spree/category.rb

@@ -81,7 +81,13 @@ module Spree
       validates :meta_description
       validates :meta_title
     end
-    validates :image, :square_image, content_type: Rails.application.config.active_storage.web_image_content_types
+    # Only a file assigned in this write is checked: a stored one passed when
+    # it was attached, and reading it back would cost a query per slot on
+    # every save — including each category a product write validates.
+    validates :image, content_type: Rails.application.config.active_storage.web_image_content_types,
+                      if: -> { attachment_changes.key?('image') }
+    validates :square_image, content_type: Rails.application.config.active_storage.web_image_content_types,
+                             if: -> { attachment_changes.key?('square_image') }
 
     #
     # Callbacks
@@ -183,16 +189,81 @@ module Spree
     def self.recalculate_products_count(category_ids)
       changed = unscoped.where(id: Array(category_ids).compact.uniq)
 
-      # The affected nodes are each changed category plus its ancestors.
-      affected = changed.flat_map { |category| category.self_and_ancestors.to_a }.uniq(&:id)
+      # The affected nodes are each changed category plus its ancestors,
+      # collected in one read: an ancestor chain per category is a query per
+      # node, which a bulk catalog move pays for every category it touched.
+      # A nested set makes an ancestor a node whose `lft`/`rgt` span the
+      # child's, so one range query answers for all of them.
+      changed = changed.to_a
+      return if changed.empty?
+
+      ancestor_conditions = changed.map do |category|
+        arel_table[:store_id].eq(category.store_id).
+          and(arel_table[:lft].lteq(category.lft)).
+          and(arel_table[:rgt].gteq(category.rgt))
+      end.reduce(:or)
+
+      affected = unscoped.where(ancestor_conditions).to_a
+
+      # One grouped query for the whole set rather than a count per node:
+      # this runs on every catalog move, and a deep tree would otherwise
+      # spend a query on each affected ancestor.
+      counts = distinct_product_counts_for(affected)
 
       affected.each do |category|
-        count = Spree::ProductCategory.where(category_id: category.self_and_descendants.select(:id))
-                                     .distinct.count(:product_id)
+        count = counts.fetch(category.id, 0)
         category.update_column(:products_count, count) if category.products_count != count
       end
     end
 
+    # Distinct product counts per category, each counting its whole subtree.
+    # A nested set stores the subtree as an `lft`/`rgt` range, so the tie
+    # between a node and its descendants is a range join rather than a
+    # separate descendant query for every node.
+    #
+    # @param categories [Array<Spree::Category>]
+    # @return [Hash{Integer => Integer}] category id => distinct product count
+    def self.distinct_product_counts_for(categories)
+      return {} if categories.empty?
+
+      nodes = arel_table.alias('counted_nodes')
+      descendants = arel_table
+      product_categories = Spree::ProductCategory.arel_table
+
+      relation = unscoped.
+                 from(nodes).
+                 joins(
+                   Arel::Nodes::InnerJoin.new(
+                     descendants,
+                     Arel::Nodes::On.new(
+                       descendants[:store_id].eq(nodes[:store_id]).
+                         and(descendants[:lft].gteq(nodes[:lft])).
+                         and(descendants[:rgt].lteq(nodes[:rgt]))
+                     )
+                   )
+                 ).
+                 joins(
+                   Arel::Nodes::InnerJoin.new(
+                     product_categories,
+                     Arel::Nodes::On.new(product_categories[:category_id].eq(descendants[:id]))
+                   )
+                 ).
+                 where(nodes[:id].in(categories.map(&:id))).
+                 group(nodes[:id])
+
+      relation.distinct.count(product_categories[:product_id])
+    end
+
+    # The breadcrumb trail, with the images a serializer renders alongside
+    # each crumb already loaded. `ancestors` comes from the nested set and
+    # preloads nothing, so drawing a trail would otherwise cost two
+    # attachment lookups per level.
+    #
+    # @return [ActiveRecord::Relation<Spree::Category>]
+    def ancestors
+      super.with_attached_image.with_attached_square_image
+    end
+
     def slug
       permalink
     end

data/app/models/spree/channel.rb

@@ -62,6 +62,47 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[name code active default store_id]
     search_by :name
 
+    # Publishes the given products on every channel in the current scope
+    # (`store.channels.where(id: ids).add_products(product_ids)`), touching
+    # and reindexing each product once rather than once per channel.
+    # @param product_ids [Array<Integer>, Integer]
+    # @return [Integer] the number of ProductPublications created or updated
+    def self.add_products(product_ids)
+      product_ids = Array(product_ids).map(&:to_s).uniq
+      channels = all.to_a
+      return 0 if product_ids.empty? || channels.empty?
+
+      count = channels.sum { |channel| channel.send(:upsert_publications, product_ids) }
+      refresh_products(product_ids)
+      channels.each(&:touch)
+      count
+    end
+
+    # Unpublishes the given products from every channel in the current scope.
+    # @param product_ids [Array<Integer>, Integer]
+    # @return [Integer] the number of ProductPublications destroyed
+    def self.remove_products(product_ids)
+      product_ids = Array(product_ids).map(&:to_s).uniq
+      channels = all.to_a
+      return 0 if product_ids.empty? || channels.empty?
+
+      removed = Spree::ProductPublication.includes(:product).where(channel_id: channels.map(&:id), product_id: product_ids).destroy_all
+      refresh_products(product_ids)
+      emptied_channel_ids = removed.map(&:channel_id).uniq
+      channels.select { |channel| emptied_channel_ids.include?(channel.id) }.each(&:touch)
+      removed.size
+    end
+
+    # @param product_ids [Array<String>]
+    # @return [void]
+    def self.refresh_products(product_ids)
+      products = Spree::Product.where(id: product_ids)
+      products.touch_all
+      # `to_a` once: `touch_all` does not load the relation, so iterating it
+      # afterwards would re-run the query.
+      products.to_a.each(&:enqueue_search_index)
+    end
+
     # Publishes the given products on this channel by creating/upserting ProductPublications.
     # Optionally sets the publication window; if not given, the products will be published immediately
     # with no end date.
@@ -73,42 +114,10 @@ module Spree
       product_ids = Array(product_ids).map(&:to_s).uniq
       return 0 if product_ids.empty?
 
-      now = Time.current
-      # Only include window columns in the upsert payload when the caller
-      # explicitly passed a value. Leaving them out keeps existing
-      # publication schedules intact on re-publish — otherwise +on_duplicate:
-      # :update+ + +update_only+ would rewrite scheduled +published_at+ /
-      # +unpublished_at+ to NULL whenever the bulk action re-runs without
-      # dates.
-      base = { channel_id: id, created_at: now, updated_at: now }
-      base[:published_at] = published_at unless published_at.nil?
-      base[:unpublished_at] = unpublished_at unless unpublished_at.nil?
-
-      records_to_upsert = product_ids.map { |product_id| base.merge(product_id: product_id) }
-
-      # Only update the window columns the caller passed. When neither was
-      # passed, treat re-publish as a no-op (+on_duplicate: :skip+ → MySQL
-      # +INSERT IGNORE+, PG/SQLite +ON CONFLICT DO NOTHING+).
-      update_columns = []
-      update_columns << :published_at unless published_at.nil?
-      update_columns << :unpublished_at unless unpublished_at.nil?
-      opts = if update_columns.empty?
-               { on_duplicate: :skip }
-             else
-               { record_timestamps: false, update_only: update_columns, on_duplicate: :update }
-             end
-      # MySQL infers the conflict target from the table's unique constraints
-      # and rejects an explicit +unique_by+; PostgreSQL/SQLite require it.
-      opts[:unique_by] = %i[product_id channel_id] unless mysql_adapter?
-
-      Spree::ProductPublication.upsert_all(records_to_upsert, **opts)
-
-      products = Spree::Product.where(id: product_ids)
-      products.touch_all
-      products.each(&:enqueue_search_index)
+      count = upsert_publications(product_ids, published_at: published_at, unpublished_at: unpublished_at)
+      self.class.refresh_products(product_ids)
       touch
-
-      records_to_upsert.size
+      count
     end
 
     # Unpublishes the given products from this channel.
@@ -118,12 +127,9 @@ module Spree
       product_ids = Array(product_ids).map(&:to_s).uniq
       return 0 if product_ids.empty?
 
-      count = publications.where(product_id: product_ids).destroy_all.size
-
-      products = Spree::Product.where(id: product_ids)
-      products.touch_all
-      products.each(&:enqueue_search_index)
+      count = publications.includes(:product).where(product_id: product_ids).destroy_all.size
 
+      self.class.refresh_products(product_ids)
       touch if count.positive?
       count
     end
@@ -161,6 +167,39 @@ module Spree
 
     private
 
+    def upsert_publications(product_ids, published_at: nil, unpublished_at: nil)
+      now = Time.current
+      # Only include window columns in the upsert payload when the caller
+      # explicitly passed a value. Leaving them out keeps existing
+      # publication schedules intact on re-publish — otherwise +on_duplicate:
+      # :update+ + +update_only+ would rewrite scheduled +published_at+ /
+      # +unpublished_at+ to NULL whenever the bulk action re-runs without
+      # dates.
+      base = { channel_id: id, created_at: now, updated_at: now }
+      base[:published_at] = published_at unless published_at.nil?
+      base[:unpublished_at] = unpublished_at unless unpublished_at.nil?
+
+      records_to_upsert = product_ids.map { |product_id| base.merge(product_id: product_id) }
+
+      # Only update the window columns the caller passed. When neither was
+      # passed, treat re-publish as a no-op (+on_duplicate: :skip+ → MySQL
+      # +INSERT IGNORE+, PG/SQLite +ON CONFLICT DO NOTHING+).
+      update_columns = []
+      update_columns << :published_at unless published_at.nil?
+      update_columns << :unpublished_at unless unpublished_at.nil?
+      opts = if update_columns.empty?
+               { on_duplicate: :skip }
+             else
+               { record_timestamps: false, update_only: update_columns, on_duplicate: :update }
+             end
+      # MySQL infers the conflict target from the table's unique constraints
+      # and rejects an explicit +unique_by+; PostgreSQL/SQLite require it.
+      opts[:unique_by] = %i[product_id channel_id] unless mysql_adapter?
+
+      Spree::ProductPublication.upsert_all(records_to_upsert, **opts)
+      records_to_upsert.size
+    end
+
     def ensure_not_default
       return unless default?
       return if destroyed_by_association.present?

data/app/models/spree/company.rb

@@ -177,10 +177,47 @@ module Spree
       self_and_descendants.where.not(id: id)
     end
 
+    # Distinct members across each node's whole subtree, for many nodes in
+    # one query.
+    #
+    # @param company_ids [Array] the subtree roots
+    # @return [Hash{Integer => Integer}] member count by root id; roots with none are absent
+    def self.members_counts_for(company_ids)
+      return {} if company_ids.empty?
+
+      membership_table = Spree::CompanyMembership.table_name
+      subtree_sql = sanitize_sql_array([<<~SQL.squish, company_ids])
+        WITH RECURSIVE subtree(root_id, id) AS (
+          SELECT id, id FROM #{table_name} WHERE id IN (?)
+          UNION
+          SELECT subtree.root_id, child.id FROM #{table_name} child
+          INNER JOIN subtree ON child.parent_id = subtree.id
+        )
+        SELECT root_id, id FROM subtree
+      SQL
+
+      Spree::CompanyMembership.
+        joins("INNER JOIN (#{subtree_sql}) company_subtree ON company_subtree.id = #{membership_table}.company_id").
+        group('company_subtree.root_id').
+        distinct.count(:customer_id)
+    end
+
+    # On a lazily preloaded list, the first call counts every node of the
+    # list at once.
+    #
     # @return [Integer]
     def members_count
-      Spree::CompanyMembership.where(company_id: self_and_descendants.select(:id)).
-        distinct.count(:customer_id)
+      return @members_count if defined?(@members_count)
+
+      siblings = lazy_preload_context&.records&.grep(self.class)
+      if siblings.blank?
+        return Spree::CompanyMembership.where(company_id: self_and_descendants.select(:id)).
+            distinct.count(:customer_id)
+      end
+
+      counts = self.class.members_counts_for(siblings.map(&:id))
+      siblings.each { |company| company.preloaded_members_count = counts.fetch(company.id, 0) }
+      @members_count
     end
 
     # The single tax anchor: the nearest self-or-ancestor +company+ node. Tax
@@ -248,6 +285,12 @@ module Spree
       Spree::Address.not_deleted.where(owner_type: 'Spree::Company', owner_id: self_and_ancestors.map(&:id))
     end
 
+    protected
+
+    def preloaded_members_count=(count)
+      @members_count = count
+    end
+
     private
 
     def ensure_can_be_deleted

data/app/models/spree/customer.rb

@@ -16,7 +16,7 @@ module Spree
     include Spree::AccountLockout
     include Spree::PasswordPolicy
 
-    validates :email, presence: true, uniqueness: { case_sensitive: false }
+    validates :email, presence: true, uniqueness: { case_sensitive: false, scope: spree_base_uniqueness_scope }
 
     attribute :accepts_email_marketing, :boolean, default: false
 

data/app/models/spree/customer_group.rb

@@ -21,7 +21,10 @@ module Spree
     # own association (rather than `alias_method`) is what lets `customer_ids=`
     # exist and what makes the `PrefixedId` auto-decoder in `assign_attributes`
     # recognise the key — that lookup keys off `reflect_on_association(:customers)`.
-    has_many :customers, through: :customer_group_users, source: :customer, source_type: Spree.customer_class.to_s
+    # Joining a group changes nothing on the customer, so saving the group
+    # does not re-validate every member it lists.
+    has_many :customers, through: :customer_group_users, source: :customer, source_type: Spree.customer_class.to_s,
+                         validate: false
 
     #
     # Validations
@@ -41,64 +44,79 @@ module Spree
     # @param user_ids [Array] array of user IDs to add
     # @return [Integer] number of customers added
     def add_customers(user_ids)
-      return 0 if user_ids.blank?
+      self.class.add_customers_to([self], user_ids)
+    end
 
-      user_ids = Array(user_ids).map(&:to_s).uniq
-      return 0 if user_ids.empty?
+    # Bulk remove customers from the group
+    # @param user_ids [Array] array of user IDs to remove
+    # @return [Integer] number of customers removed
+    def remove_customers(user_ids)
+      self.class.remove_customers_from([self], user_ids)
+    end
 
-      # Get existing user IDs to avoid duplicates
-      existing_user_ids = customer_group_users.where(customer_id: user_ids).pluck(:customer_id).map(&:to_s).to_set
+    # Adds customers to every given group, skipping memberships that already
+    # exist, with one lookup for all groups.
+    # @param groups [Array<Spree::CustomerGroup>]
+    # @param customer_ids [Array] customer IDs to add
+    # @return [Integer] number of memberships created
+    def self.add_customers_to(groups, customer_ids)
+      customer_ids = Array(customer_ids).compact_blank.map(&:to_s).uniq
+      groups = Array(groups)
+      return 0 if customer_ids.empty? || groups.empty?
+
+      existing_pairs = Spree::CustomerGroupUser.
+                       where(customer_group_id: groups.map(&:id), customer_id: customer_ids).
+                       pluck(:customer_group_id, :customer_id).
+                       to_set { |group_id, customer_id| [group_id, customer_id.to_s] }
 
       now = Time.current
-      user_type = Spree.customer_class.to_s
-
-      records_to_insert = user_ids.filter_map do |user_id|
-        next if existing_user_ids.include?(user_id)
-
-        {
-          customer_group_id: id,
-          user_id: user_id,
-          user_type: user_type,
-          created_at: now,
-          updated_at: now
-        }
+      customer_type = Spree.customer_class.to_s
+      records_to_insert = groups.flat_map do |group|
+        customer_ids.filter_map do |customer_id|
+          next if existing_pairs.include?([group.id, customer_id])
+
+          {
+            customer_group_id: group.id,
+            customer_id: customer_id,
+            customer_type: customer_type,
+            created_at: now,
+            updated_at: now
+          }
+        end
       end
-
       return 0 if records_to_insert.empty?
 
       Spree::CustomerGroupUser.upsert_all(records_to_insert, on_duplicate: :skip)
-      added_user_ids = records_to_insert.map { |r| r[:user_id] }
-      touch_users(added_user_ids)
-      touch
+      touch_customers(records_to_insert.map { |record| record[:customer_id] }.uniq)
+      changed_group_ids = records_to_insert.map { |record| record[:customer_group_id] }.to_set
+      groups.select { |group| changed_group_ids.include?(group.id) }.each(&:touch)
 
       records_to_insert.size
     end
 
-    # Bulk remove customers from the group
-    # @param user_ids [Array] array of user IDs to remove
-    # @return [Integer] number of customers removed
-    def remove_customers(user_ids)
-      return 0 if user_ids.blank?
+    # Removes customers from every given group.
+    # @param groups [Array<Spree::CustomerGroup>]
+    # @param customer_ids [Array] customer IDs to remove
+    # @return [Integer] number of memberships removed
+    def self.remove_customers_from(groups, customer_ids)
+      customer_ids = Array(customer_ids).compact_blank.map(&:to_s).uniq
+      groups = Array(groups)
+      return 0 if customer_ids.empty? || groups.empty?
 
-      user_ids = Array(user_ids).map(&:to_s).uniq
-      return 0 if user_ids.empty?
+      memberships = Spree::CustomerGroupUser.where(customer_group_id: groups.map(&:id), customer_id: customer_ids)
+      changed_group_ids = memberships.distinct.pluck(:customer_group_id).to_set
+      return 0 if changed_group_ids.empty?
 
-      deleted_count = customer_group_users.where(customer_id: user_ids).delete_all
-
-      if deleted_count > 0
-        touch_users(user_ids)
-        touch
-      end
+      deleted_count = memberships.delete_all
+      touch_customers(customer_ids)
+      groups.select { |group| changed_group_ids.include?(group.id) }.each(&:touch)
 
       deleted_count
     end
 
-    private
-
-    def touch_users(user_ids)
-      return if user_ids.blank?
-
-      Spree.customer_class.where(id: user_ids).touch_all
+    def self.touch_customers(customer_ids)
+      Spree.customer_class.where(id: customer_ids).touch_all
     end
+    private_class_method :touch_customers
   end
 end

data/app/models/spree/delivery_method.rb

@@ -451,10 +451,13 @@ module Spree
         calculator.description + ': ' +
 
         if calculator.is_a?(Spree::Calculator::Shipping::FlatRate)
-          if calculator.preferred_amount == 0
+          amount = calculator.amount_for(calculator.preferred_currency)
+          if amount.nil?
+            ''
+          elsif amount.zero?
             I18n.t('spree.free')
           else
-            Spree::Money.new(calculator.preferred_amount, { currency: calculator.preferred_currency }).to_s
+            Spree::Money.new(amount, { currency: calculator.preferred_currency }).to_s
           end
         elsif calculator.is_a?(Spree::Calculator::Shipping::FlexiRate)
           Spree::Money.new(calculator.preferred_first_item, { currency: calculator.preferred_currency }).to_s
@@ -497,14 +500,21 @@ module Spree
       reconcile_services(pending)
     end
 
+    # Matched against the method's rows loaded once, rather than a lookup per
+    # row. A row created here joins that list, so a later row naming the
+    # same (carrier, service) updates it as a lookup would.
     def reconcile_services(rows)
+      existing = services.reload.to_a
       kept_ids = rows.filter_map do |row|
-        record =
-          if row[:id].present?
-            id = Spree::PrefixedId.prefixed_id?(row[:id]) ? Spree::PrefixedId.decode_prefixed_id(row[:id]) : row[:id]
-            services.find_by(id: id)
-          end
-        record ||= services.find_or_initialize_by(carrier: row[:carrier], service: row[:service])
+        if row[:id].present?
+          id = Spree::PrefixedId.prefixed_id?(row[:id]) ? Spree::PrefixedId.decode_prefixed_id(row[:id]) : row[:id]
+          record = existing.find { |service| service.id.to_s == id.to_s }
+        end
+        record ||= existing.find { |service| service.carrier == row[:carrier] && service.service == row[:service] }
+        unless record
+          record = services.build(carrier: row[:carrier], service: row[:service])
+          existing << record
+        end
         record.assign_attributes(row.slice(:carrier, :service, :label, :markup_flat, :markup_percent, :position).to_h)
         record.save!
         record.id

data/app/models/spree/delivery_profile.rb

@@ -123,6 +123,24 @@ module Spree
       delivery_origin_groups.first
     end
 
+    # How many products use this profile. Counted for every profile of a
+    # lazily preloaded list in one grouped query, since loading the products
+    # themselves to count them would fetch the whole catalog.
+    #
+    # @return [Integer]
+    def products_count
+      return @products_count if defined?(@products_count)
+
+      profiles = lazy_preload_context&.records.presence || [self]
+      counts = Spree::Product.where(delivery_profile_id: profiles.map(&:id)).group(:delivery_profile_id).count
+      profiles.each { |profile| profile.products_count = counts.fetch(profile.id, 0) }
+      @products_count
+    end
+
+    protected
+
+    attr_writer :products_count
+
     private
 
     def create_default_origin_group

data/app/models/spree/digital_asset.rb

@@ -25,6 +25,20 @@ module Spree
     # and provider-backed assets (which carry no file) are exempt.
     DEFAULT_PROVIDER = 'Spree::DigitalAssetProvider::File'.freeze
 
+    # What a seller may upload unless the marketplace says otherwise: the
+    # formats digital goods usually come in. Executables, scripts and
+    # unrecognised binaries are left out on purpose, as is SVG, which can
+    # carry scripts. A marketplace selling a niche format adds it in settings.
+    # The text formats have no signature, so they are taken at the type the
+    # upload declared.
+    DEFAULT_SELLER_CONTENT_TYPES = %w[
+      application/pdf application/epub+zip application/zip application/x-7z-compressed application/gzip
+      application/json text/plain text/csv
+      audio/mpeg audio/mp4 audio/aac audio/flac audio/ogg audio/wav audio/x-wav audio/midi
+      video/mp4 video/webm video/quicktime
+      image/jpeg image/png image/gif image/webp image/tiff
+    ].freeze
+
     # The API names a provider by its shorthand (`file`); the column keeps the
     # class name.
     normalizes :provider_type, with: ->(value) { Spree::ApiTyped.class_name_for(Spree.digital_asset_providers, value) }

data/app/models/spree/event.rb

@@ -86,14 +86,29 @@ module Spree
     # @return [Boolean]
     def self.matches?(event_name, pattern)
       return true if pattern == '*'
+      return event_name == pattern unless pattern.include?('*')
 
-      if pattern.include?('*')
-        regex = Regexp.new("^#{Regexp.escape(pattern).gsub('\*', '.*')}$")
-        event_name.match?(regex)
-      else
-        event_name == pattern
+      wildcard_match?(event_name, pattern)
+    end
+
+    # `*` stands for any run of characters, as in a shell glob. The comparison
+    # is plain string searching so a pattern taken from a merchant never
+    # reaches the regexp engine, which has had memory bugs in pattern parsing.
+    def self.wildcard_match?(event_name, pattern)
+      head, *middle, tail = pattern.split('*', -1)
+      return false unless event_name.start_with?(head) && event_name.end_with?(tail)
+      return false if event_name.length < head.length + tail.length
+
+      position = head.length
+      limit = event_name.length - tail.length
+      middle.all? do |segment|
+        found = event_name.index(segment, position)
+        next false if found.nil? || found + segment.length > limit
+
+        position = found + segment.length
       end
     end
+    private_class_method :wildcard_match?
 
     alias_method :to_h, :attributes
 

data/app/models/spree/fulfillment.rb

@@ -653,7 +653,14 @@ module Spree
     #
     # @return [Spree::DeliveryMethod]
     def delivery_method
-      selected_delivery_rate&.delivery_method || delivery_rates.first&.delivery_method
+      selected = selected_delivery_rate
+      # The same row read through the rate list, when that list is to hand,
+      # so its method loads with every other rate's instead of on its own.
+      if selected && read_association_in_memory?(:delivery_rates)
+        selected = delivery_rates.detect { |rate| rate.id == selected.id } || selected
+      end
+
+      selected&.delivery_method || delivery_rates.first&.delivery_method
     end
 
     # The fulfillment provider strategy handling this fulfillment's

data/app/models/spree/fulfillment_changer.rb

@@ -138,7 +138,9 @@ module Spree
     end
 
     def reload_shipment_inventory_units
-      [current_shipment, desired_shipment].each { |shipment| shipment.fulfillment_items.reload }
+      shipments = [current_shipment, desired_shipment]
+      shipments.each { |shipment| shipment.association(:fulfillment_items).reset }
+      ActiveRecord::Associations::Preloader.new(records: shipments, associations: :fulfillment_items).call
     end
 
     def current_quantity

data/app/models/spree/fulfillment_item.rb

@@ -107,6 +107,17 @@ module Spree
       split
     end
 
+    # `dup` copies the foreign keys but not the loaded records, so every copy
+    # made while packing and splitting would look its line item and variant
+    # up again.
+    def initialize_dup(other)
+      super
+      %i[line_item variant].each do |name|
+        association = other.association(name)
+        self.association(name).target = association.target if association.loaded?
+      end
+    end
+
     # This will fail if extract >= available_quantity
     def split_inventory!(extract_quantity)
       split = self.class.split(self, extract_quantity)

data/app/models/spree/import.rb

@@ -215,10 +215,22 @@ module Spree
     end
 
     # Per-status row counts for API status payloads, memoized so one request
-    # issues a single grouped COUNT instead of one per status.
+    # issues a single grouped COUNT instead of one per status — and, on a
+    # lazily preloaded list, one for every import of the list.
     # @return [Hash{String => Integer}]
     def rows_status_counts
-      @rows_status_counts ||= rows.group(:status).count
+      return @rows_status_counts if @rows_status_counts
+
+      siblings = lazy_preload_context&.records&.grep(Spree::Import)
+      return @rows_status_counts = rows.group(:status).count if siblings.blank?
+
+      counts = Spree::ImportRow.where(import_id: siblings.map(&:id)).group(:import_id, :status).count
+      siblings.each do |import|
+        import.preloaded_rows_status_counts = counts.each_with_object({}) do |((import_id, status), count), by_status|
+          by_status[status] = count if import_id == import.id
+        end
+      end
+      @rows_status_counts
     end
 
     # Public API name for the +results_url+ preference (read/write symmetry).
@@ -474,6 +486,12 @@ module Spree
       end
     end
 
+    protected
+
+    def preloaded_rows_status_counts=(counts)
+      @rows_status_counts = counts
+    end
+
     private
 
     # Mirrors the machine's bang events: an illegal move raised.