spree_core 5.4.0.beta9 → 5.4.0.beta10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47046110413017b3697dc5b8937c77dc5cb1577035ca12ed2e5c828c826457ba
-  data.tar.gz: c0318740d1a1eb2a71a4bd4a99c88d6ea7100f69d6746a3084a1c54b4e7a74d8
+  metadata.gz: 73ed6afd1feda3d20e24a8910273785420d08dfadebf8af34aa90c20b017a0b8
+  data.tar.gz: 323a92ea512ad2d37bac8be8b8f878f60dbbc4058ed020875c5740ef02a7481b
 SHA512:
-  metadata.gz: f306e9d832c4dcedb23306edd9a3d32b8459e04125c50139c7f77b6bc8726c2363facd9652d6b0132aef92a63b21228873349bb9a5ba812e5ab7e63f3b460240
-  data.tar.gz: 946536ad1ed9dccbb48ad8882811381449656391c3d0f05205a8bc0165380624400e9b5c58973daa71467f4e3b6384b74f4fb358bf9657bfff3de634b93cddfb
+  metadata.gz: 711d0f622de8f398bd3f0e8696c5e12e476d3671a6330781fd5a34a0ecb15cc32f17fcf9d8e1e3028584108a354465ba7721ca990e723077c89dddb9c428fcbb
+  data.tar.gz: 3634efec05dc63e7c44a27bcfe0265331224592ee8d88bc1b417446967af051ccd450723344bc287977de3793b95d17ca0fef1235e905aa25e7a787f65325a81

data/app/finders/spree/products/find.rb

@@ -112,7 +112,7 @@ module Spree
       def by_query(products)
         return products unless query?
 
-        products.multi_search(query)
+        products.search(query)
       end
 
       def by_ids(products)

data/app/jobs/spree/search_provider/index_job.rb

@@ -0,0 +1,22 @@
+module Spree
+  module SearchProvider
+    class IndexJob < Spree::BaseJob
+      queue_as Spree.queues.search
+
+      retry_on StandardError, wait: :polynomially_longer, attempts: 5
+      discard_on ActiveRecord::RecordNotFound
+
+      # @param resource_class [String] e.g. 'Spree::Product'
+      # @param resource_id [String] always pass as string for UUID support
+      # @param store_id [String] always pass as string for UUID support
+      def perform(resource_class, resource_id, store_id)
+        resource = resource_class.constantize.find_by(id: resource_id)
+        store = Spree::Store.find_by(id: store_id)
+        return unless resource && store
+
+        provider = Spree.search_provider.constantize.new(store)
+        provider.index(resource)
+      end
+    end
+  end
+end

data/app/jobs/spree/search_provider/remove_job.rb

@@ -0,0 +1,19 @@
+module Spree
+  module SearchProvider
+    class RemoveJob < Spree::BaseJob
+      queue_as Spree.queues.search
+
+      retry_on StandardError, wait: :polynomially_longer, attempts: 5
+
+      # @param prefixed_id [String] prefixed ID of the document to remove (e.g. 'prod_abc')
+      # @param store_id [String] always pass as string for UUID support
+      def perform(prefixed_id, store_id)
+        store = Spree::Store.find_by(id: store_id)
+        return unless store
+
+        provider = Spree.search_provider.constantize.new(store)
+        provider.remove_by_id(prefixed_id)
+      end
+    end
+  end
+end

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

@@ -3,41 +3,20 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      cattr_accessor :search_scopes do
-        []
-      end
-
-      def self.add_search_scope(name, &block)
-        singleton_class.send(:define_method, name.to_sym, &block)
-        search_scopes << name.to_sym
-      end
-
-      def self.simple_scopes
-        [
-          :ascend_by_updated_at,
-          :descend_by_updated_at,
-          :ascend_by_name,
-          :descend_by_name
-        ]
-      end
-
-      def self.add_simple_scopes(scopes)
-        scopes.each do |name|
-          # We should not define price scopes here, as they require something slightly different
-          next if name.to_s.include?('master_price')
-
-          parts = name.to_s.match(/(.*)_by_(.*)/)
-          scope(name.to_s, -> { order(Arel.sql(sanitize_sql("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ? 'ASC' : 'DESC'}"))) })
-        end
-      end
-
-      add_simple_scopes simple_scopes
-
-      add_search_scope :ascend_by_master_price do
+      scope :ascend_by_updated_at, -> { order("#{Product.quoted_table_name}.updated_at ASC") }
+      scope :descend_by_updated_at, -> { order("#{Product.quoted_table_name}.updated_at DESC") }
+      scope :ascend_by_name, -> { order("#{Product.quoted_table_name}.name ASC") }
+      scope :descend_by_name, -> { order("#{Product.quoted_table_name}.name DESC") }
+
+      # Deprecated — master variant being removed in 6.0. Use ascend_by_price / descend_by_price instead.
+      def self.ascend_by_master_price
+        Spree::Deprecation.warn('ascend_by_master_price is deprecated and will be removed in Spree 6.0. Use ascend_by_price instead.')
         order(price_table_name => { amount: :asc })
       end
 
-      add_search_scope :descend_by_master_price do
+      # Deprecated — master variant being removed in 6.0. Use ascend_by_price / descend_by_price instead.
+      def self.descend_by_master_price
+        Spree::Deprecation.warn('descend_by_master_price is deprecated and will be removed in Spree 6.0. Use descend_by_price instead.')
         order(price_table_name => { amount: :desc })
       end
 
@@ -47,7 +26,7 @@ module Spree
       # Uses Arel::Nodes::As for select expressions so that:
       # - PG allows ORDER BY with DISTINCT (expressions must appear in SELECT list)
       # - Mobility's select_for_count can safely call .right on all select_values
-      add_search_scope :ascend_by_price do
+      scope :ascend_by_price, -> {
         price_agg_sql = Price.non_zero.joins(:variant)
                             .select("#{Variant.table_name}.product_id AS product_id, MIN(#{Price.table_name}.amount) AS agg_price")
                             .group("#{Variant.table_name}.product_id")
@@ -59,9 +38,9 @@ module Spree
           select("#{Product.table_name}.*").
           select(Arel::Nodes::As.new(price_expr, Arel.sql('min_price'))).
           order(price_expr.asc)
-      end
+      }
 
-      add_search_scope :descend_by_price do
+      scope :descend_by_price, -> {
         price_agg_sql = Price.non_zero.joins(:variant)
                             .select("#{Variant.table_name}.product_id AS product_id, MAX(#{Price.table_name}.amount) AS agg_price")
                             .group("#{Variant.table_name}.product_id")
@@ -73,17 +52,21 @@ module Spree
           select("#{Product.table_name}.*").
           select(Arel::Nodes::As.new(price_expr, Arel.sql('max_price'))).
           order(price_expr.desc)
-      end
+      }
 
-      add_search_scope :price_between do |low, high|
+      scope :price_between, ->(low, high) {
         where(Price.table_name => { amount: low..high })
-      end
+      }
 
-      add_search_scope :master_price_lte do |price|
+      # Deprecated — master variant being removed in 6.0. Use price_lte / price_gte instead.
+      def self.master_price_lte(price)
+        Spree::Deprecation.warn('master_price_lte is deprecated and will be removed in Spree 6.0. Use price_lte instead.')
         where(Price.table_name => { amount: ..price })
       end
 
-      add_search_scope :master_price_gte do |price|
+      # Deprecated — master variant being removed in 6.0. Use price_lte / price_gte instead.
+      def self.master_price_gte(price)
+        Spree::Deprecation.warn('master_price_gte is deprecated and will be removed in Spree 6.0. Use price_gte instead.')
         where(Price.table_name => { amount: price.. })
       end
 
@@ -106,7 +89,6 @@ module Spree
         )
       }
 
-      # Can't use add_search_scope for this as it needs a default argument
       # Ransack calls with '1' to activate, '0' or nil to skip
       # In Ruby code: in_stock(true) for in-stock, in_stock(false) for out-of-stock
       def self.in_stock(in_stock = true)
@@ -117,14 +99,13 @@ module Spree
         end
       end
 
-      add_search_scope :price_lte do |price|
+      scope :price_lte, ->(price) {
         where(Price.table_name => { amount: ..price })
-      end
+      }
 
-      add_search_scope :price_gte do |price|
+      scope :price_gte, ->(price) {
         where(Price.table_name => { amount: price.. })
-      end
-      search_scopes << :in_stock
+      }
 
       def self.out_of_stock(out_of_stock = true)
         if out_of_stock == '0' || !out_of_stock
@@ -133,13 +114,12 @@ module Spree
           where.not(id: join_variants_and_stock_items.in_stock_or_backorderable_condition)
         end
       end
-      search_scopes << :out_of_stock
 
-      add_search_scope :backorderable do
+      def self.backorderable
         join_variants_and_stock_items.where(StockItem.table_name => { backorderable: true })
       end
 
-      add_search_scope :in_stock_or_backorderable do
+      def self.in_stock_or_backorderable
         join_variants_and_stock_items.in_stock_or_backorderable_condition
       end
 
@@ -152,34 +132,22 @@ module Spree
       # `:distinct` option as well:
       #
       #   Spree::Product.in_taxon(taxon).count(distinct: true)
-      #
-      # This is so that the count query is distinct'd:
-      #
-      #   SELECT COUNT(DISTINCT "spree_products"."id") ...
-      #
-      #   vs.
-      #
-      #   SELECT COUNT(*) ...
-      add_search_scope :in_taxon do |taxon|
+      scope :in_taxon, ->(taxon) {
         joins(:classifications).
           where("#{Classification.table_name}.taxon_id" => taxon.cached_self_and_descendants_ids).distinct
-      end
+      }
 
       # Alias for in_taxon — public API name
-      add_search_scope :in_category do |category|
-        in_taxon(category)
-      end
+      scope :in_category, ->(category) { in_taxon(category) }
 
-      # This scope selects products in all taxons AND all its descendants
-      # If you need products only within one taxon use
-      #
-      #   Spree::Product.taxons_id_eq([x,y])
-      add_search_scope :in_taxons do |*taxons|
+      # Deprecated — remove in 6.0. Use in_taxon instead.
+      def self.in_taxons(*taxons)
+        Spree::Deprecation.warn('in_taxons is deprecated and will be removed in Spree 6.0. Use in_taxon instead.')
         taxons = get_taxons(taxons)
         taxons.first ? prepare_taxon_conditions(taxons) : where(nil)
       end
 
-      add_search_scope :ascend_by_taxons_min_position do |taxon_ids|
+      scope :ascend_by_taxons_min_position, ->(taxon_ids) {
         min_position_sql = "MIN(#{Classification.table_name}.position)"
 
         joins(:classifications).
@@ -187,9 +155,11 @@ module Spree
           select("#{Product.table_name}.*", "#{min_position_sql} AS min_taxon_position").
           group("#{Product.table_name}.id").
           order(Arel.sql("#{min_position_sql} ASC"))
-      end
+      }
 
-      add_search_scope :with_option do |option|
+      # Deprecated — remove in 6.0. Not used internally.
+      def self.with_option(option)
+        Spree::Deprecation.warn('with_option is deprecated and will be removed in Spree 6.0.')
         if option.is_a?(OptionType)
           joins(:option_types).where(spree_option_types: { id: option.id })
         elsif option.is_a?(Integer)
@@ -201,7 +171,7 @@ module Spree
         end
       end
 
-      add_search_scope :with_option_value do |option, value|
+      scope :with_option_value, ->(option, value) {
         option_type_id = case option
                          when OptionType then option.id
                          when Integer then option
@@ -210,89 +180,66 @@ module Spree
                              OptionType.where(id: option).or(OptionType.where(name: option))&.first&.id
                            else
                              OptionType.where(name: option)&.first&.id
-                             OptionType.where(name: option)&.first&.id
                            end
                          end
 
-        return Product.group("#{Spree::Product.table_name}.id").none if option_type_id.blank?
+        next Product.group("#{Spree::Product.table_name}.id").none if option_type_id.blank?
 
         group("#{Spree::Product.table_name}.id").
           joins(variants: :option_values).
           where(Spree::OptionValue.table_name => { name: value, option_type_id: option_type_id })
-      end
+      }
 
       # Filters products by option value IDs (prefix IDs like 'optval_xxx')
       # Accepts an array of option value IDs
-      add_search_scope :with_option_value_ids do |*ids|
+      scope :with_option_value_ids, ->(*ids) {
         ids = ids.flatten.compact
-        return none if ids.empty?
+        next none if ids.empty?
 
         # Handle prefixed IDs (optval_xxx) by decoding to actual IDs
         actual_ids = ids.map do |id|
           id.to_s.include?('_') ? OptionValue.decode_prefixed_id(id) : id
         end.compact
 
-        return none if actual_ids.empty?
+        next none if actual_ids.empty?
 
         joins(variants: :option_values).where(Spree::OptionValue.table_name => { id: actual_ids })
-      end
+      }
 
-      # Finds all products which have an option value with the name matching the one given
-      add_search_scope :with do |value|
+      # Deprecated — remove in 6.0. Not used internally.
+      def self.with(value)
+        Spree::Deprecation.warn('Product.with is deprecated and will be removed in Spree 6.0.')
         includes(variants: :option_values).
           where("#{OptionValue.table_name}.name = ?", value)
       end
 
-      # Finds all products that have a name containing the given words.
-      add_search_scope :in_name do |words|
+      # Deprecated — remove in 6.0. Use .search scope instead.
+      def self.in_name(words)
+        Spree::Deprecation.warn('in_name is deprecated and will be removed in Spree 6.0. Use .search instead.')
         like_any([:name], prepare_words(words))
       end
 
-      # Finds all products that have a name or meta_keywords containing the given words.
-      add_search_scope :in_name_or_keywords do |words|
+      # Deprecated — remove in 6.0. Use .search scope instead.
+      def self.in_name_or_keywords(words)
+        Spree::Deprecation.warn('in_name_or_keywords is deprecated and will be removed in Spree 6.0. Use .search instead.')
         like_any([:name, :meta_keywords], prepare_words(words))
       end
 
-      # Finds all products that have a name, description, meta_description or meta_keywords containing the given keywords.
-      add_search_scope :in_name_or_description do |words|
+      # Deprecated — remove in 6.0. Use .search scope instead.
+      def self.in_name_or_description(words)
+        Spree::Deprecation.warn('in_name_or_description is deprecated and will be removed in Spree 6.0. Use .search instead.')
         like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
       end
 
-      # Finds all products that have the ids matching the given collection of ids.
-      # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
-      add_search_scope :with_ids do |*ids|
+      # Deprecated — remove in 6.0. Use where(id: ids) directly.
+      def self.with_ids(*ids)
+        Spree::Deprecation.warn('with_ids is deprecated and will be removed in Spree 6.0. Use where(id: ids) instead.')
         where(id: ids)
       end
 
-      # Sorts products from most popular (popularity is extracted from how many
-      # times use has put product in cart, not completed orders)
-      #
-      # there is alternative faster and more elegant solution, it has small drawback though,
-      # it doesn stack with other scopes :/
-      #
-      # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
-      # order: 'COALESCE(cnt, 0) DESC'
-      add_search_scope :descend_by_popularity do
-        joins(:master).
-          order(%Q{
-             COALESCE((
-               SELECT
-                 COUNT(#{LineItem.quoted_table_name}.id)
-               FROM
-                 #{LineItem.quoted_table_name}
-               JOIN
-                 #{Variant.quoted_table_name} AS popular_variants
-               ON
-                 popular_variants.id = #{LineItem.quoted_table_name}.variant_id
-               WHERE
-                 popular_variants.product_id = #{Product.quoted_table_name}.id
-             ), 0) DESC
-          })
-      end
-
-      add_search_scope :not_deleted do
+      scope :not_deleted, -> {
         where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.zone.now)
-      end
+      }
 
       def self.not_discontinued(only_not_discontinued = true)
         if only_not_discontinued != '0' && only_not_discontinued
@@ -301,7 +248,6 @@ module Spree
           all
         end
       end
-      search_scopes << :not_discontinued
 
       def self.with_currency(currency)
         joins(variants_including_master: :prices).
@@ -309,9 +255,7 @@ module Spree
           where.not(Price.table_name => { amount: nil }).
           distinct
       end
-      search_scopes << :with_currency
 
-      # Can't use add_search_scope for this as it needs a default argument
       def self.available(available_on = nil, currency = nil)
         scope = not_discontinued.where(status: 'active')
         if available_on
@@ -326,21 +270,22 @@ module Spree
 
         scope
       end
-      search_scopes << :available
 
       def self.active(currency = nil)
         available(nil, currency)
       end
-      search_scopes << :active
 
+      # Deprecated — remove in 6.0. Use active(currency).in_taxon(taxon) directly.
       def self.for_filters(currency, taxon: nil)
+        Spree::Deprecation.warn('for_filters is deprecated and will be removed in Spree 6.0. Use active(currency).in_taxon(taxon) instead.')
         scope = active(currency)
         scope = scope.in_taxon(taxon) if taxon.present?
         scope
       end
-      search_scopes << :for_filters
 
+      # Deprecated — remove in 6.0. Not used internally.
       def self.for_user(user = nil)
+        Spree::Deprecation.warn('for_user is deprecated and will be removed in Spree 6.0.')
         if user.try(:has_spree_role?, 'admin')
           with_deleted
         else
@@ -348,7 +293,9 @@ module Spree
         end
       end
 
-      add_search_scope :taxons_name_eq do |name|
+      # Deprecated — remove in 6.0. Not used internally.
+      def self.taxons_name_eq(name)
+        Spree::Deprecation.warn('taxons_name_eq is deprecated and will be removed in Spree 6.0.')
         group('spree_products.id').joins(:taxons).where(Taxon.arel_table[:name].eq(name))
       end
 
@@ -357,7 +304,7 @@ module Spree
       #
       # Uses Arel::Nodes::As so that ORDER BY expressions appear in SELECT
       # and work with DISTINCT (same pattern as the price sorting scopes).
-      add_search_scope :by_best_selling do |order_direction = :desc|
+      scope :by_best_selling, ->(order_direction = :desc) {
         sp_table = StoreProduct.table_name
         units_expr = Arel.sql("COALESCE(#{sp_table}.units_sold_count, 0)")
         revenue_expr = Arel.sql("COALESCE(#{sp_table}.revenue, 0)")
@@ -369,19 +316,32 @@ module Spree
           select(Arel::Nodes::As.new(revenue_expr, Arel.sql('best_selling_revenue'))).
           order(units_expr.send(order_dir)).
           order(revenue_expr.send(order_dir))
-      end
+      }
 
-      # .search_by_name
-      if defined?(PgSearch)
-        include PgSearch::Model
+      # Deprecated — remove in 6.0. Use by_best_selling instead.
+      def self.descend_by_popularity
+        Spree::Deprecation.warn('descend_by_popularity is deprecated and will be removed in Spree 6.0. Use by_best_selling instead.')
+        joins(:master).
+          order(%Q{
+             COALESCE((
+               SELECT
+                 COUNT(#{LineItem.quoted_table_name}.id)
+               FROM
+                 #{LineItem.quoted_table_name}
+               JOIN
+                 #{Variant.quoted_table_name} AS popular_variants
+               ON
+                 popular_variants.id = #{LineItem.quoted_table_name}.variant_id
+               WHERE
+                 popular_variants.product_id = #{Product.quoted_table_name}.id
+             ), 0) DESC
+          })
+      end
 
-        pg_search_scope :search_by_name, against: { name: 'A', meta_title: 'B' }, using: { trigram: { threshold: 0.3, word_similarity: true } }
-      else
-        def self.search_by_name(query)
-          i18n { name.lower.matches("%#{query.downcase}%") }
-        end
+      # .search_by_name — simple ILIKE on product name
+      def self.search_by_name(query)
+        i18n { name.lower.matches("%#{query.downcase}%") }
       end
-      search_scopes << :search_by_name
 
       def self.price_table_name
         Price.quoted_table_name

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

@@ -0,0 +1,83 @@
+module Spree
+  module SearchIndexable
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit :enqueue_search_index, on: [:create, :update]
+      after_commit :enqueue_search_removal, on: :destroy
+    end
+
+    # Index this record synchronously (inline, no job).
+    # Useful for bulk imports, rake tasks, or when you need immediate indexing.
+    def add_to_search_index
+      return unless search_indexing_enabled?
+
+      store_ids_for_indexing.each do |store_id|
+        store = Spree::Store.find_by(id: store_id)
+        next unless store
+
+        provider = Spree.search_provider.constantize.new(store)
+        provider.index(self)
+      end
+    end
+
+    # Returns the hash that would be sent to the search provider for indexing.
+    # Useful for debugging and previewing what gets indexed.
+    #
+    #   product.search_presentation         # uses Spree::Current.store
+    #   product.search_presentation(store)  # explicit store
+    #   => { id: 1, name: "Shirt", price_USD: 19.99, ... }
+    def search_presentation(store = nil)
+      store ||= Spree::Current.store
+      Spree::SearchProvider::ProductPresenter.new(self, store).call
+    end
+
+    # Remove this record from search index synchronously (inline, no job).
+    def remove_from_search_index
+      return unless search_indexing_enabled?
+
+      store_ids_for_indexing.each do |store_id|
+        store = Spree::Store.find_by(id: store_id)
+        next unless store
+
+        provider = Spree.search_provider.constantize.new(store)
+        provider.remove(self)
+      end
+    end
+
+    private
+
+    def enqueue_search_index
+      return unless search_indexing_enabled?
+
+      store_ids_for_indexing.each do |store_id|
+        Spree::SearchProvider::IndexJob.perform_later(self.class.name, id.to_s, store_id.to_s)
+      end
+    end
+
+    def enqueue_search_removal
+      return unless search_indexing_enabled?
+
+      pid = prefixed_id
+      store_ids_for_indexing.each do |store_id|
+        Spree::SearchProvider::RemoveJob.perform_later(pid, store_id.to_s)
+      end
+    end
+
+    def search_indexing_enabled?
+      Spree.search_provider.constantize.indexing_required?
+    rescue NameError
+      false
+    end
+
+    def store_ids_for_indexing
+      if respond_to?(:store_ids)
+        store_ids
+      elsif respond_to?(:store_id)
+        [store_id].compact
+      else
+        Spree::Store.pluck(:id)
+      end
+    end
+  end
+end

data/app/models/concerns/spree/{multi_searchable.rb → searchable.rb}

@@ -1,13 +1,13 @@
 module Spree
-  module MultiSearchable
+  module Searchable
     extend ActiveSupport::Concern
 
     included do
-      def self.sanitize_query_for_multi_search(query)
+      def self.sanitize_query_for_search(query)
         ActiveRecord::Base.sanitize_sql_like(query.to_s.downcase.strip)
       end
 
-      def self.multi_search_condition(model_class, attribute, query)
+      def self.search_condition(model_class, attribute, query)
         encrypted_attributes = model_class.encrypted_attributes.presence || []
 
         if encrypted_attributes.include?(attribute.to_sym)
@@ -16,6 +16,13 @@ module Spree
           model_class.arel_table[attribute.to_sym].lower.matches("%#{query}%")
         end
       end
+
+      # Backward compatibility aliases — remove in Spree 6.0
+      def self.sanitize_query_for_multi_search(query) = sanitize_query_for_search(query)
+      def self.multi_search_condition(model_class, attribute, query) = search_condition(model_class, attribute, query)
     end
   end
+
+  # Backward compatibility alias — remove in Spree 6.0
+  MultiSearchable = Searchable
 end

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

@@ -9,7 +9,7 @@ module Spree
     include Spree::UserReporting
     include Spree::UserRoles
     include Spree::RansackableAttributes
-    include Spree::MultiSearchable
+    include Spree::Searchable
     include Spree::Publishable
 
     included do
@@ -74,28 +74,31 @@ module Spree
         find_by_token_for!(:password_reset, token)
       end
 
-      def self.multi_search(query)
-        sanitized_query = sanitize_query_for_multi_search(query)
+      def self.search(query)
+        sanitized_query = sanitize_query_for_search(query)
         return none if query.blank?
 
         name_conditions = []
 
-        name_conditions << multi_search_condition(self, :first_name, sanitized_query)
-        name_conditions << multi_search_condition(self, :last_name, sanitized_query)
+        name_conditions << search_condition(self, :first_name, sanitized_query)
+        name_conditions << search_condition(self, :last_name, sanitized_query)
 
         full_name = NameOfPerson::PersonName.full(sanitized_query)
 
         if full_name.first.present? && full_name.last.present?
-          name_conditions << multi_search_condition(self, :first_name, full_name.first)
-          name_conditions << multi_search_condition(self, :last_name, full_name.last)
+          name_conditions << search_condition(self, :first_name, full_name.first)
+          name_conditions << search_condition(self, :last_name, full_name.last)
         end
 
         where(arel_table[:email].lower.eq(query.downcase)).or(where(name_conditions.reduce(:or)))
       end
 
+      # Backward compatibility alias — remove in Spree 6.0
+      def self.multi_search(query) = search(query)
+
       self.whitelisted_ransackable_associations = %w[bill_address ship_address addresses tags spree_roles]
       self.whitelisted_ransackable_attributes = %w[id email first_name last_name accepts_email_marketing]
-      self.whitelisted_ransackable_scopes = %w[multi_search]
+      self.whitelisted_ransackable_scopes = %w[search multi_search]
 
       def self.with_email(query)
         where("#{table_name}.email LIKE ?", "%#{query}%")