spree_core 5.4.0.beta8 → 5.4.0.beta10

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

@@ -0,0 +1,302 @@
+module Spree
+  module SearchProvider
+    class Meilisearch < Base
+      PREFIXED_ID_PATTERN = /\A[a-z]+_[A-Za-z0-9]+\z/
+      ALLOWED_STATUSES = %w[active draft archived paused].freeze
+
+      def self.indexing_required?
+        true
+      end
+
+      def initialize(store)
+        super
+        require 'meilisearch'
+      rescue LoadError
+        raise LoadError, "Add `gem 'meilisearch'` to your Gemfile to use the Meilisearch search provider"
+      end
+
+      def search_and_filter(scope:, query: nil, filters: {}, sort: nil, page: 1, limit: 25)
+        page = [page.to_i, 1].max
+        limit = limit.to_i.clamp(1, 100)
+
+        search_params = {
+          filter: build_filters(filters),
+          facets: facet_attributes,
+          sort: build_sort(sort),
+          offset: (page - 1) * limit,
+          limit: limit
+        }
+
+        Rails.logger.debug { "[Meilisearch] index=#{index_name} query=#{query.inspect} #{search_params.compact.inspect}" }
+
+        ms_result = client.index(index_name).search(query.to_s, search_params)
+
+        Rails.logger.debug { "[Meilisearch] #{ms_result['estimatedTotalHits']} hits in #{ms_result['processingTimeMs']}ms" }
+
+        # Hits have composite prefixed_id (prod_abc_en_USD), extract product_id (prod_abc)
+        product_prefixed_ids = ms_result['hits'].map { |h| h['product_id'] }.uniq
+        raw_ids = product_prefixed_ids.filter_map { |pid| Spree::Product.decode_prefixed_id(pid) }
+
+        # Intersect with AR scope for security/visibility.
+        # Since we filter by store/status/currency/discontinue_on in Meilisearch,
+        # the AR scope is a safety net — it should not filter anything out.
+        products = if raw_ids.any?
+                     scope.where(id: raw_ids).reorder(nil)
+                   else
+                     scope.none
+                   end
+
+        # Build Pagy object from Meilisearch response (passive mode)
+        pagy = build_pagy(ms_result, page, limit)
+
+        SearchResult.new(
+          products: products,
+          filters: build_facet_response(ms_result['facetDistribution'] || {}),
+          sort_options: available_sort_options.map { |id| { id: id } },
+          default_sort: 'manual',
+          total_count: ms_result['estimatedTotalHits'] || 0,
+          pagy: pagy
+        )
+      end
+
+      def index(product)
+        documents = ProductPresenter.new(product, store).call
+        client.index(index_name).add_documents(documents, 'prefixed_id')
+      end
+
+      def remove(product)
+        remove_by_id(product.prefixed_id)
+      end
+
+      def index_batch(documents)
+        client.index(index_name).add_documents(documents, 'prefixed_id')
+      end
+
+      # Remove all documents for a product by its prefixed_id (e.g. 'prod_abc')
+      def remove_by_id(prefixed_id)
+        filter = "product_id = '#{sanitize_prefixed_id(prefixed_id)}'"
+        client.index(index_name).delete_documents(filter: filter)
+      rescue ::Meilisearch::ApiError => e
+        raise unless e.http_code == 404
+      end
+
+      def reindex(scope = nil)
+        scope ||= store.products
+        ensure_index_settings!
+
+        scope.reorder(id: :asc)
+             .preload(*ProductPresenter::REQUIRED_PRELOADS)
+             .find_in_batches(batch_size: 500) do |batch|
+          documents = batch.flat_map { |product| ProductPresenter.new(product, store).call }
+          index_batch(documents)
+        end
+      end
+
+      # Configure index settings for filtering, sorting, and faceting.
+      # Called automatically by reindex, but can be called separately.
+      def ensure_index_settings!
+        index = client.index(index_name)
+        index.update_filterable_attributes(filterable_attributes)
+        index.update_sortable_attributes(sortable_attributes)
+        index.update_searchable_attributes(searchable_attributes)
+      end
+
+      private
+
+      def client
+        @client ||= ::Meilisearch::Client.new(
+          ENV.fetch('MEILISEARCH_URL', 'http://localhost:7700'),
+          ENV['MEILISEARCH_API_KEY']
+        )
+      end
+
+      def index_name
+        "#{store.code}_products"
+      end
+
+      def searchable_attributes
+        %w[name description sku option_values category_names tags]
+      end
+
+      def filterable_attributes
+        %w[product_id status in_stock store_ids locale currency discontinue_on price category_ids tags option_value_ids]
+      end
+
+      def sortable_attributes
+        %w[name price created_at available_on units_sold_count]
+      end
+
+      def facet_attributes
+        filterable_attributes
+      end
+
+      def available_sort_options
+        %w[price -price name -name -available_on available_on best_selling]
+      end
+
+      # Convert Ransack-style filters to Meilisearch filter syntax.
+      # Always applies store scoping, active status, and currency availability
+      # so that Meilisearch results match what the AR scope would return.
+      # All values are sanitized to prevent filter injection.
+      def build_filters(filters)
+        conditions = []
+
+        # Always scope to current store, locale, currency, active, not discontinued.
+        # This mirrors the AR scope: store.products.active(currency) with locale
+        conditions << "store_ids = '#{store.id}'"
+        conditions << "status = 'active'"
+        conditions << "locale = '#{locale.to_s.gsub(/[^a-zA-Z_-]/, '')}'"
+        conditions << "currency = '#{currency.to_s.gsub(/[^A-Z]/, '')}'"
+        conditions << "(discontinue_on = 0 OR discontinue_on > #{Time.current.to_i})"
+
+        filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
+        return conditions if filters.blank?
+
+        filters.each do |key, value|
+          next if value.blank?
+
+          key = key.to_s
+          case key
+          when 'price_gte'
+            conditions << "price >= #{value.to_f}"
+          when 'price_lte'
+            conditions << "price <= #{value.to_f}"
+          when 'in_stock'
+            conditions << 'in_stock = true' if value.to_s != '0'
+          when 'out_of_stock'
+            conditions << 'in_stock = false' if value.to_s != '0'
+          when 'categories_id_eq'
+            conditions << "category_ids = '#{sanitize_prefixed_id(value)}'" if valid_prefixed_id?(value)
+          when 'with_option_value_ids'
+            Array(value).each do |ov|
+              conditions << "option_value_ids = '#{sanitize_prefixed_id(ov)}'" if valid_prefixed_id?(ov)
+            end
+          end
+        end
+
+        conditions
+      end
+
+      def build_sort(sort)
+        return nil if sort.blank?
+
+        case sort
+        when 'price'
+          ['price:asc']
+        when '-price'
+          ['price:desc']
+        when 'name'
+          ['name:asc']
+        when '-name'
+          ['name:desc']
+        when '-available_on'
+          ['available_on:desc']
+        when 'available_on'
+          ['available_on:asc']
+        when 'best_selling'
+          ['units_sold_count:desc']
+        end
+      end
+
+      # Transform Meilisearch facetDistribution into our standard filter response format
+      def build_facet_response(facet_distribution)
+        filters = []
+
+        # Price range
+        if facet_distribution['price'].present?
+          amounts = facet_distribution['price'].keys.map(&:to_f)
+          filters << {
+            id: 'price',
+            type: 'price_range',
+            min: amounts.min,
+            max: amounts.max,
+            currency: currency
+          }
+        end
+
+        # Availability
+        if facet_distribution['in_stock'].present?
+          in_stock = facet_distribution['in_stock']['true'] || 0
+          out_of_stock = facet_distribution['in_stock']['false'] || 0
+          filters << {
+            id: 'availability',
+            type: 'availability',
+            options: [
+              { id: 'in_stock', count: in_stock },
+              { id: 'out_of_stock', count: out_of_stock }
+            ]
+          }
+        end
+
+        # Option values — group by option type for faceted display
+        if facet_distribution['option_value_ids'].present?
+          prefixed_ids = facet_distribution['option_value_ids'].keys
+          raw_ids = prefixed_ids.filter_map { |pid| Spree::OptionValue.decode_prefixed_id(pid) }
+          option_values = Spree::OptionValue.where(id: raw_ids).includes(:option_type).preload_associations_lazily.index_by(&:prefixed_id)
+
+          # Group by option type
+          by_option_type = {}
+          facet_distribution['option_value_ids'].each do |ov_prefixed_id, count|
+            ov = option_values[ov_prefixed_id]
+            next unless ov
+
+            ot = ov.option_type
+            by_option_type[ot] ||= []
+            by_option_type[ot] << { id: ov.prefixed_id, name: ov.name, label: ov.label, position: ov.position, count: count }
+          end
+
+          by_option_type.each do |option_type, values|
+            filters << {
+              id: option_type.prefixed_id,
+              type: 'option',
+              name: option_type.name,
+              label: option_type.label,
+              options: values.sort_by { |o| o[:position] }
+            }
+          end
+        end
+
+        # Categories
+        if facet_distribution['category_ids'].present?
+          prefixed_ids = facet_distribution['category_ids'].keys
+          raw_ids = prefixed_ids.filter_map { |pid| Spree::Taxon.decode_prefixed_id(pid) }
+          categories = Spree::Taxon.where(id: raw_ids).index_by(&:prefixed_id)
+
+          filters << {
+            id: 'categories',
+            type: 'category',
+            options: facet_distribution['category_ids'].filter_map do |prefixed_id, count|
+              cat = categories[prefixed_id]
+              next unless cat
+
+              { id: cat.prefixed_id, name: cat.name, permalink: cat.permalink, count: count }
+            end
+          }
+        end
+
+        filters
+      end
+
+      def build_pagy(ms_result, page, limit)
+        require 'pagy'
+        require 'pagy/toolbox/paginators/meilisearch'
+
+        fake_result = Struct.new(:raw_answer).new({
+          'totalHits' => ms_result['estimatedTotalHits'] || 0,
+          'hitsPerPage' => limit,
+          'page' => page
+        })
+
+        Pagy::MeilisearchPaginator.paginate(fake_result, {})
+      end
+
+      def valid_prefixed_id?(value)
+        value.to_s.match?(PREFIXED_ID_PATTERN)
+      end
+
+      def sanitize_prefixed_id(value)
+        value.to_s.gsub(/[^a-zA-Z0-9_]/, '')
+      end
+    end
+  end
+end

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

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

data/app/models/spree/shipment.rb

@@ -2,7 +2,7 @@ require 'ostruct'
 
 module Spree
   class Shipment < Spree.base_class
-    has_prefix_id :ship  # Spree-specific: shipment
+    has_prefix_id :ful
 
     include Spree::Core::NumberGenerator.new(prefix: 'H', length: 11)
     include Spree::NumberIdentifier

data/app/models/spree/shipping_method.rb

@@ -1,6 +1,6 @@
 module Spree
   class ShippingMethod < Spree.base_class
-    has_prefix_id :shpm  # Spree-specific: shipping method
+    has_prefix_id :dm
 
     acts_as_paranoid
     include Spree::CalculatedAdjustments

data/app/models/spree/shipping_rate.rb

@@ -1,6 +1,6 @@
 module Spree
   class ShippingRate < Spree.base_class
-    has_prefix_id :shpr  # Spree-specific: shipping rate
+    has_prefix_id :dr
 
     belongs_to :shipment, class_name: 'Spree::Shipment'
     belongs_to :tax_rate, -> { with_deleted }, class_name: 'Spree::TaxRate'

data/app/models/spree/taxon.rb

@@ -103,13 +103,8 @@ module Spree
     #
     # Search
     #
-    if defined?(PgSearch)
-      include PgSearch::Model
-      pg_search_scope :search_by_name, against: :name, using: { tsearch: { any_word: true, prefix: true } }
-    else
-      def self.search_by_name(query)
-        i18n { name.lower.matches("%#{query.downcase}%") }
-      end
+    def self.search_by_name(query)
+      i18n { name.lower.matches("%#{query.downcase}%") }
     end
 
     scope :with_matching_name, lambda { |name_to_match|

data/app/models/spree/variant.rb

@@ -129,33 +129,14 @@ module Spree
 
     scope :with_digital_assets, -> { joins(:digitals) }
 
-    if defined?(PgSearch)
-      include PgSearch::Model
+    scope :search, ->(query) {
+      next none if query.blank? || query.length < 3
 
-      pg_search_scope :search_by_sku, against: :sku, using: { tsearch: { prefix: true } }
-
-      pg_search_scope :search_by_sku_or_options,
-                      against: :sku,
-                      using: { tsearch: { prefix: true } },
-                      associated_against: { option_values: %i[presentation] }
-
-      pg_search_scope :search_by_name_sku_or_options, against: :sku, associated_against: {
-        product: %i[name],
-        option_values: %i[presentation]
-      }, using: { tsearch: { prefix: true } }
-
-      scope :multi_search, lambda { |query|
-        return none if query.blank? || query.length < 3
-
-        search_by_name_sku_or_options(query)
-      }
-    else
-      scope :multi_search, lambda { |query|
-        return none if query.blank? || query.length < 3
+      product_name_or_sku_cont(query)
+    }
 
-        product_name_or_sku_cont(query)
-      }
-    end
+    # Backward compatibility alias — remove in Spree 6.0
+    scope :multi_search, ->(*args) { search(*args) }
 
     # FIXME: cost price should be represented with DisplayMoney class
     LOCALIZED_NUMBERS = %w(cost_price weight depth width height)

data/app/models/spree/wishlist.rb

@@ -16,6 +16,7 @@ module Spree
     belongs_to :store, class_name: 'Spree::Store'
 
     has_many :wished_items, class_name: 'Spree::WishedItem', dependent: :destroy
+    alias wishlist_items wished_items
     has_many :variants, through: :wished_items, source: :variant, class_name: 'Spree::Variant'
     has_many :products, -> { distinct }, through: :variants, source: :product, class_name: 'Spree::Product'
 

data/app/presenters/spree/search_provider/product_presenter.rb

@@ -0,0 +1,131 @@
+module Spree
+  module SearchProvider
+    class ProductPresenter
+      # Associations needed by this presenter — used by reindex and rake task for preloading
+      REQUIRED_PRELOADS = [
+        :taxons, :option_types, :primary_media, :store_products,
+        { variants_including_master: [:prices, :option_values] }
+      ].freeze
+
+      attr_reader :product, :store
+
+      def initialize(product, store)
+        @product = product
+        @store = store
+      end
+
+      # Returns an array of documents — one per market × locale combination.
+      # Each document has flat name, description, price fields (no dynamic suffixes).
+      def call
+        documents = []
+
+        market_locale_pairs.each do |market, locale|
+          # Skip if product has no price in this currency
+          next unless lowest_price(market.currency)
+
+          Mobility.with_locale(locale) do
+            documents << build_document(locale, market.currency, default_locale)
+          end
+        end
+
+        # Fallback for stores without markets (legacy/test)
+        if documents.empty?
+          fallback_currency = store.default_market&.currency || store.supported_currencies_list.first&.iso_code
+          if fallback_currency && lowest_price(fallback_currency)
+            documents << build_document(default_locale, fallback_currency, default_locale)
+          end
+        end
+
+        documents
+      end
+
+      private
+
+      def build_document(locale, currency, fallback_locale)
+        {
+          # Composite ID: product + locale + currency
+          prefixed_id: "#{product.prefixed_id}_#{locale}_#{currency}",
+          product_id: product.prefixed_id,
+          locale: locale.to_s,
+          currency: currency,
+          # Translated fields — with fallback to default locale
+          name: translated(product, :name, fallback_locale),
+          description: translated(product, :description, fallback_locale),
+          slug: translated(product, :slug, fallback_locale),
+          # Price in this currency
+          price: lowest_price(currency)&.to_f,
+          compare_at_price: compare_at_price(currency)&.to_f,
+          # Non-locale/currency fields
+          status: product.status,
+          sku: product.sku,
+          in_stock: product.in_stock?,
+          store_ids: cached_store_ids,
+          discontinue_on: product.discontinue_on&.to_i || 0,
+          category_ids: product.taxons.map(&:prefixed_id),
+          category_names: product.taxons.map { |t| translated(t, :name, fallback_locale) },
+          option_type_ids: product.option_types.map(&:prefixed_id),
+          option_type_names: product.option_types.map { |ot| translated(ot, :presentation, fallback_locale) },
+          option_value_ids: variant_option_value_ids,
+          option_values: variant_option_values_data.map { |ov| translated(ov, :presentation, fallback_locale) }.uniq,
+          tags: product.tag_list || [],
+          thumbnail_url: product.primary_media&.url(:large),
+          units_sold_count: cached_units_sold_count,
+          available_on: product.available_on&.iso8601,
+          created_at: product.created_at&.iso8601,
+          updated_at: product.updated_at&.iso8601
+        }
+      end
+
+      # Returns all market × locale pairs for this store
+      def market_locale_pairs
+        @market_locale_pairs ||= store.markets.flat_map do |market|
+          market.supported_locales_list.map { |locale| [market, locale] }
+        end
+      end
+
+      def default_locale
+        @default_locale ||= store.default_market&.default_locale || I18n.default_locale.to_s
+      end
+
+      # Read a translated attribute with fallback to default locale.
+      def translated(record, attribute, fallback_locale)
+        value = record.send(attribute)
+        return value if value.present?
+
+        record.send(attribute, locale: fallback_locale.to_sym)
+      rescue ArgumentError
+        value
+      end
+
+      def lowest_price(currency)
+        @prices_cache ||= {}
+        @prices_cache[currency] = product.price_in(currency)&.amount unless @prices_cache.key?(currency)
+        @prices_cache[currency]
+      end
+
+      def compare_at_price(currency)
+        @compare_at_cache ||= {}
+        @compare_at_cache[currency] = product.compare_at_amount_in(currency) unless @compare_at_cache.key?(currency)
+        @compare_at_cache[currency]
+      end
+
+      # Memoized — avoids N+1 when called per document
+      def cached_store_ids
+        @cached_store_ids ||= product.store_ids.map(&:to_s)
+      end
+
+      def cached_units_sold_count
+        @cached_units_sold_count ||= product.store_products.detect { |sp| sp.store_id == store.id }&.units_sold_count || 0
+      end
+
+      def variant_option_value_ids
+        variant_option_values_data.map(&:prefixed_id).uniq
+      end
+
+      # Use variants_including_master (matches reindex preload) instead of variants.includes
+      def variant_option_values_data
+        @variant_option_values_data ||= product.variants_including_master.flat_map(&:option_values).uniq
+      end
+    end
+  end
+end

data/app/services/spree/carts/update.rb

@@ -9,8 +9,8 @@ module Spree
 
         ApplicationRecord.transaction do
           assign_cart_attributes
-          assign_address(:ship_address)
-          assign_address(:bill_address)
+          assign_address(:shipping_address)
+          assign_address(:billing_address)
 
           cart.save!
 
@@ -34,10 +34,11 @@ module Spree
 
       def assign_cart_attributes
         cart.email = params[:email] if params[:email].present?
-        cart.special_instructions = params[:special_instructions] if params.key?(:special_instructions)
+        cart.customer_note = params[:customer_note] if params.key?(:customer_note)
         cart.currency = params[:currency].upcase if params[:currency].present?
         cart.locale = params[:locale] if params[:locale].present?
         cart.metadata = cart.metadata.merge(params[:metadata].to_h) if params[:metadata].present?
+        cart.use_shipping = params[:use_shipping] if params.key?(:use_shipping)
       end
 
       def assign_address(address_type)
@@ -59,7 +60,7 @@ module Spree
           # Only revert to address state when shipping address changes.
           # Billing address updates (e.g. during payment) should not
           # destroy shipments and reset the checkout flow.
-          revert_to_address_state if address_type == :ship_address && cart.has_checkout_step?('address')
+          revert_to_address_state if address_type == :shipping_address && cart.has_checkout_step?('address')
           cart.public_send(:"#{address_type}_attributes=", address_params)
         end
       end

data/db/migrate/20260317000000_create_spree_refresh_tokens.rb

@@ -0,0 +1,16 @@
+class CreateSpreeRefreshTokens < ActiveRecord::Migration[7.2]
+  def change
+    create_table :spree_refresh_tokens do |t|
+      t.string :token, null: false
+      t.references :user, polymorphic: true, null: false
+      t.datetime :expires_at, null: false
+      t.string :ip_address
+      t.string :user_agent
+      t.timestamps
+    end
+
+    add_index :spree_refresh_tokens, :token, unique: true
+    add_index :spree_refresh_tokens, :expires_at
+    add_index :spree_refresh_tokens, [:user_type, :user_id], name: 'idx_refresh_tokens_user'
+  end
+end

data/db/sample_data/payment_methods.rb

@@ -4,6 +4,7 @@ cc_payment_method = Spree::Gateway::Bogus.where(
   active: true
 ).first_or_initialize
 
+cc_payment_method.display_on = 'back_end'
 cc_payment_method.stores = Spree::Store.all
 cc_payment_method.save!
 
@@ -13,5 +14,6 @@ check_payment_method = Spree::PaymentMethod::Check.where(
   active: true
 ).first_or_initialize
 
+check_payment_method.display_on = 'back_end'
 check_payment_method.stores = Spree::Store.all
 check_payment_method.save!

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '5.4.0.beta8'.freeze
+  VERSION = '5.4.0.beta10'.freeze
 
   def self.version
     VERSION

data/lib/spree/core.rb

@@ -110,13 +110,14 @@ module Spree
       gift_cards: :default,
       webhooks: :default,
       payment_webhooks: :default,
-      api_keys: :default
+      api_keys: :default,
+      search: :default
     )
   end
 
-  # @deprecated Spree.searcher_class is deprecated and will be removed in Spree 5.5.
+  # @deprecated Spree.searcher_class is deprecated and will be removed in Spree 5.5. Use Spree.search_provider instead.
   def self.searcher_class=(value)
-    Spree::Deprecation.warn('Spree.searcher_class is deprecated and will be removed in Spree 5.5. Please remove it from your initializer.')
+    Spree::Deprecation.warn('Spree.searcher_class is deprecated and will be removed in Spree 5.5. Use Spree.search_provider instead.')
     @@searcher_class = value
   end
 
@@ -124,6 +125,18 @@ module Spree
     @@searcher_class
   end
 
+  # Search provider class name. Controls product search, filtering, and faceted navigation.
+  #
+  #   Spree.search_provider = 'Spree::SearchProvider::Meilisearch'
+  #
+  def self.search_provider
+    @@search_provider ||= 'Spree::SearchProvider::Database'
+  end
+
+  def self.search_provider=(value)
+    @@search_provider = value.to_s
+  end
+
   # Returns the events adapter class used for publishing and subscribing to events.
   #
   # @example Using a custom adapter

data/lib/tasks/search.rake

@@ -0,0 +1,15 @@
+namespace :spree do
+  namespace :search do
+    desc 'Reindex all products in the search provider'
+    task reindex: :environment do
+      Spree::Store.all.find_each do |store|
+        provider = Spree.search_provider.constantize.new(store)
+        total = store.products.count
+
+        puts "Reindexing #{store.name} (#{total} products)..."
+        provider.reindex(store.products)
+        puts "Done."
+      end
+    end
+  end
+end