spree_core 6.0.0.rc4 → 6.0.0.rc6

data/app/models/spree/ability.rb

@@ -167,6 +167,9 @@ module Spree
 
     # Reference data every staff member can read regardless of keys — address
     # forms need countries/states, and the dashboard shell reads the store.
+    # The back office also reads the store's markets and channels: its
+    # currencies and languages come from the markets, and list filters offer
+    # both.
     #
     # The store grant is unrestricted only for the store's own back office.
     # Another panel reads the one store it operates under and no other, so a
@@ -180,6 +183,11 @@ module Spree
       else
         can :read, Spree::Store, id: @store.id
       end
+
+      return unless store_resource?
+
+      can :read, Spree::Market, store_id: @resource.id
+      can :read, Spree::Channel, store_id: @resource.id
     end
 
   end

data/app/models/spree/address.rb

@@ -343,6 +343,12 @@ module Spree
     def snapshot
       dup.tap do |copy|
         copy.owner = nil
+
+        if business_owned?
+          copy.company = company.presence || owner&.name
+          copy.owner_type = owner_type
+        end
+
         copy.label = nil
         copy.deleted_at = nil
       end

data/app/models/spree/admin_user.rb

@@ -8,6 +8,7 @@ module Spree
 
     include Spree::AdminUserMethods
     include Spree::AccountLockout
+    include Spree::AccountDeactivation
     include Spree::PasswordPolicy
 
     validates :email, presence: true, uniqueness: { case_sensitive: false }

data/app/models/spree/base.rb

@@ -46,13 +46,21 @@ class Spree::Base < ApplicationRecord
     select("#{klass.table_name}.*").select(*(fields || klass::TRANSLATABLE_FIELDS))
   }
 
+  # The store's own rows of this model, through the association named after
+  # it. A model the store has no association for answers nothing: a tenant
+  # boundary that quietly widened to every store's rows is how a cross-store
+  # read ships unnoticed. Global reference data (countries, roles) and
+  # records reached through a parent are fetched as such, never through here.
+  #
+  # @param store [Spree::Store]
+  # @return [ActiveRecord::Relation]
   def self.for_store(store)
     plural_model_name = model_name.plural.gsub(/spree_/, '').to_sym
 
     if store.respond_to?(plural_model_name)
       store.send(plural_model_name)
     else
-      self
+      none
     end
   end
 
@@ -81,6 +89,30 @@ class Spree::Base < ApplicationRecord
     association(name).loaded? || lazy_preload_context.present?
   end
 
+  # Recomputes a counter cache for many records at once. Rails'
+  # +reset_counters+ spends two queries per record, which a bulk write pays
+  # for every row it touched; this is one grouped count plus one UPDATE per
+  # distinct value.
+  #
+  # @param ids [Array] the records whose counter is recomputed
+  # @param association [Symbol] the has_many whose rows are counted
+  # @return [void]
+  def self.reset_counters_in_bulk(ids, association)
+    ids = Array(ids).compact.uniq
+    return if ids.empty?
+
+    reflection = reflect_on_association(association)
+    counter = reflection.klass.reflect_on_all_associations(:belongs_to).find do |belongs_to|
+      belongs_to.foreign_key.to_s == reflection.foreign_key.to_s && belongs_to.options[:counter_cache]
+    end.counter_cache_column
+
+    counts = reflection.klass.where(reflection.foreign_key => ids).group(reflection.foreign_key).count
+
+    ids.group_by { |id| counts.fetch(id, 0) }.each do |count, grouped_ids|
+      unscoped.where(id: grouped_ids).where.not(counter => count).update_all(counter => count)
+    end
+  end
+
   # @see Spree.mysql? — the single definition; this reads it so a model can
   #   branch without reaching for the connection itself.
   def mysql_adapter?

data/app/models/spree/calculator/shipping/digital_delivery.rb

@@ -3,7 +3,9 @@ module Spree
     class DigitalDelivery < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :money, default: 0
+      # Blank once its figure has moved into `amounts`, so the method quotes
+      # nothing outside the hash.
+      preference :amount, :money, default: 0, nullable: true
       preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
       def self.description

data/app/models/spree/calculator/shipping/flat_rate.rb

@@ -3,7 +3,9 @@ module Spree
     class FlatRate < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :money, default: 0
+      # Blank once its figure has moved into `amounts`, so the method quotes
+      # nothing outside the hash.
+      preference :amount, :money, default: 0, nullable: true
       # @deprecated Together with the single `amount`, superseded by the
       #   per-currency `amounts` hash; kept as the fallback for its own
       #   currency so upgraded stores quote unchanged.

data/app/models/spree/calculator/shipping/per_item.rb

@@ -3,7 +3,9 @@ module Spree
     class PerItem < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :money, default: 0
+      # Blank once its figure has moved into `amounts`, so the method quotes
+      # nothing outside the hash.
+      preference :amount, :money, default: 0, nullable: true
       preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
       def self.description

data/app/models/spree/cart.rb

@@ -203,10 +203,13 @@ module Spree
     # delivery_unavailable warning per affected line item (parity with the
     # order-side ensure_available_delivery_rates).
     def prune_undeliverable_fulfillments!
-      undeliverable = fulfillments.reload.select { |fulfillment| fulfillment.delivery_rates.empty? }
+      candidates = fulfillments.reload.to_a
+      ActiveRecord::Associations::Preloader.new(records: candidates, associations: :delivery_rates).call
+      undeliverable = candidates.select { |fulfillment| fulfillment.delivery_rates.empty? }
       return if undeliverable.empty?
 
       affected_line_items = undeliverable.flat_map(&:line_items).uniq
+      ActiveRecord::Associations::Preloader.new(records: affected_line_items, associations: { variant: :product }).call
       undeliverable.each(&:destroy)
       self.warnings |= affected_line_items.map do |line_item|
         {
@@ -284,12 +287,9 @@ module Spree
     #
     # @return [ActiveRecord::Relation<Spree::Variant>]
     def orderable_variants
-      products = Spree.products_for_context_service.call(
-        store: store, channel: channel, customer: customer, company: resolved_company,
-        base: store.products.not_discontinued_on(channel)
-      ).value
-
-      Spree::Variant.for_products(products)
+      Spree::SalesContext.new(
+        store: store, channel: channel, customer: customer, company: resolved_company, resolve_company: false
+      ).orderable_variants
     end
 
     # Removes out-of-stock/discontinued items and populates warnings

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
@@ -245,7 +282,13 @@ module Spree
     #
     # @return [ActiveRecord::Relation]
     def address_book
-      Spree::Address.where(owner_type: 'Spree::Company', owner_id: self_and_ancestors.map(&:id))
+      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

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