spree_core 5.4.0.beta8 → 5.4.0.beta10

data/app/models/spree/address.rb

@@ -83,6 +83,8 @@ module Spree
     delegate :abbr, to: :state, prefix: true, allow_nil: true
 
     alias_attribute :postal_code, :zipcode
+    alias_attribute :first_name, :firstname
+    alias_attribute :last_name, :lastname
 
     # Writer methods for API convenience - these set country/state from ISO/abbr codes
     # The reader methods (country_iso, state_abbr) are delegates to country.iso and state.abbr
@@ -111,21 +113,7 @@ module Spree
       user.present? && id == user.ship_address_id
     end
 
-    def first_name
-      firstname
-    end
-
-    def first_name=(value)
-      self.firstname = value
-    end
-
-    def last_name
-      lastname
-    end
-
-    def last_name=(value)
-      self.lastname = value
-    end
+    # first_name / last_name aliases are defined via alias_attribute above
 
     def full_name
       "#{firstname} #{lastname}".strip

data/app/models/spree/credit_card.rb

@@ -48,6 +48,7 @@ module Spree
     scope :not_removed, -> { where(deleted_at: nil) }
 
     alias_attribute :brand, :cc_type
+    alias_attribute :last4, :last_digits
 
     store_accessor :private_metadata, :wallet
 

data/app/models/spree/inventory_unit.rb

@@ -1,6 +1,6 @@
 module Spree
   class InventoryUnit < Spree.base_class
-    has_prefix_id :iu
+    has_prefix_id :fi
 
     extend Spree::DisplayMoney
 

data/app/models/spree/line_item.rb

@@ -102,6 +102,10 @@ module Spree
     alias single_money display_price
     alias single_display_amount display_price
 
+    # 5.5 API naming bridges (DB column rename in 6.0)
+    alias_attribute :discount_total, :promo_total
+    alias display_discount_total display_promo_total
+
     def discounted_price
       return price if quantity.zero?
 

data/app/models/spree/metafield_definition.rb

@@ -23,10 +23,10 @@ module Spree
     # Scopes
     #
     scope :for_resource_type, ->(resource_type) { where(resource_type: resource_type) }
-    scope :multi_search, ->(search) do
-      return all if search.blank?
+    scope :search, ->(query) do
+      return all if query.blank?
 
-      search_term = "%#{search.downcase}%"
+      search_term = "%#{query.downcase}%"
       namespace_condition = arel_table[:namespace].lower.matches(search_term)
       key_condition = arel_table[:key].lower.matches(search_term)
       name_condition = arel_table[:name].lower.matches(search_term)
@@ -34,6 +34,9 @@ module Spree
       where(namespace_condition.or(key_condition).or(name_condition))
     end
 
+    # Backward compatibility alias — remove in Spree 6.0
+    scope :multi_search, ->(*args) { search(*args) }
+
     #
     # Callbacks
     #
@@ -46,7 +49,7 @@ module Spree
     # Ransack
     #
     self.whitelisted_ransackable_attributes = %w[key namespace name resource_type display_on]
-    self.whitelisted_ransackable_scopes = %w[multi_search]
+    self.whitelisted_ransackable_scopes = %w[search multi_search]
 
     # Returns the full key with namespace
     # @return [String] eg. custom.id

data/app/models/spree/option_type.rb

@@ -33,6 +33,9 @@ module Spree
     has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
     has_many :prototypes, through: :option_type_prototypes, class_name: 'Spree::Prototype'
 
+    # 5.5 API naming bridge (DB column rename in 6.0)
+    alias_attribute :label, :presentation
+
     #
     # Validations
     #

data/app/models/spree/option_value.rb

@@ -28,6 +28,9 @@ module Spree
     has_many :variants, through: :option_value_variants, class_name: 'Spree::Variant'
     has_many :products, through: :variants, class_name: 'Spree::Product'
 
+    # 5.5 API naming bridge (DB column rename in 6.0)
+    alias_attribute :label, :presentation
+
     #
     # Validations
     #

data/app/models/spree/order.rb

@@ -32,7 +32,7 @@ module Spree
     include Spree::MemoizedData
     include Spree::Metafields
     include Spree::Metadata
-    include Spree::MultiSearchable
+    include Spree::Searchable
     if defined?(Spree::Security::Orders)
       include Spree::Security::Orders
     end
@@ -54,6 +54,12 @@ module Spree
     alias display_ship_total display_shipment_total
     alias_attribute :ship_total, :shipment_total
 
+    # 5.5 API naming bridges (DB columns rename in 6.0)
+    alias_attribute :discount_total, :promo_total
+    alias display_discount_total display_promo_total
+    alias_attribute :customer_note, :special_instructions
+    alias_attribute :total_quantity, :item_count
+
     MONEY_THRESHOLD  = 100_000_000
     MONEY_VALIDATION = {
       presence: true,
@@ -87,7 +93,7 @@ module Spree
       completed_at email number state payment_state shipment_state
       total item_total item_count considered_risky channel
     ]
-    self.whitelisted_ransackable_scopes = %w[refunded partially_refunded multi_search]
+    self.whitelisted_ransackable_scopes = %w[refunded partially_refunded search multi_search]
 
     attr_reader :coupon_code
     attr_accessor :temporary_address
@@ -108,11 +114,13 @@ module Spree
                               optional: true, dependent: :destroy
     alias_method :billing_address, :bill_address
     alias_method :billing_address=, :bill_address=
+    alias_attribute :billing_address_id, :bill_address_id
 
     belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address',
                               optional: true, dependent: :destroy
     alias_method :shipping_address, :ship_address
     alias_method :shipping_address=, :ship_address=
+    alias_attribute :shipping_address_id, :ship_address_id
 
     belongs_to :store, class_name: 'Spree::Store'
 
@@ -139,7 +147,6 @@ module Spree
              inverse_of: :order
 
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
-    has_many :cart_promotions, class_name: 'Spree::CartPromotion', foreign_key: :order_id
     has_many :promotions, through: :order_promotions, class_name: 'Spree::Promotion'
 
     has_many :shipments, class_name: 'Spree::Shipment', dependent: :destroy, inverse_of: :order do
@@ -150,10 +157,18 @@ module Spree
     has_many :shipment_adjustments, through: :shipments, source: :adjustments
 
     alias items line_items
+    alias discounts order_promotions
+    alias fulfillments shipments
+    alias_attribute :delivery_total, :shipment_total
+    alias display_delivery_total display_shipment_total
+    alias_attribute :fulfillment_status, :shipment_state
+    alias_attribute :payment_status, :payment_state
 
     accepts_nested_attributes_for :line_items
     accepts_nested_attributes_for :bill_address
     accepts_nested_attributes_for :ship_address
+    alias shipping_address_attributes= ship_address_attributes=
+    alias billing_address_attributes= bill_address_attributes=
     accepts_nested_attributes_for :payments, reject_if: :credit_card_nil_payment?
     accepts_nested_attributes_for :shipments
 
@@ -220,8 +235,8 @@ module Spree
     # shows completed orders first, by their completed_at date, then uncompleted orders by their created_at
     scope :reverse_chronological, -> { order(Arel.sql('spree_orders.completed_at IS NULL'), completed_at: :desc, created_at: :desc) }
 
-    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?
 
       query_pattern = "%#{sanitized_query}%"
@@ -229,19 +244,22 @@ module Spree
       conditions = []
       conditions << arel_table[:number].lower.matches(query_pattern)
 
-      conditions << multi_search_condition(Spree::Address, :firstname, sanitized_query)
-      conditions << multi_search_condition(Spree::Address, :lastname, sanitized_query)
+      conditions << search_condition(Spree::Address, :firstname, sanitized_query)
+      conditions << search_condition(Spree::Address, :lastname, sanitized_query)
 
       full_name = NameOfPerson::PersonName.full(sanitized_query)
 
       if full_name.first.present? && full_name.last.present?
-        conditions << multi_search_condition(Spree::Address, :firstname, full_name.first)
-        conditions << multi_search_condition(Spree::Address, :lastname, full_name.last)
+        conditions << search_condition(Spree::Address, :firstname, full_name.first)
+        conditions << search_condition(Spree::Address, :lastname, full_name.last)
       end
 
       left_joins(:bill_address).where(arel_table[:email].lower.eq(query.downcase)).or(where(conditions.reduce(:or)))
     end
 
+    # Backward compatibility alias — remove in Spree 6.0
+    def self.multi_search(query) = search(query)
+
     # Find an order by prefixed ID first, falling back to number, then integer id for backwards compatibility
     # @param param [String] the prefixed ID, number, or integer id to search for
     # @return [Spree::Order, nil] the found order or nil

data/app/models/spree/order_promotion.rb

@@ -1,6 +1,6 @@
 module Spree
   class OrderPromotion < Spree.base_class
-    has_prefix_id :oprom
+    has_prefix_id :discount
 
     belongs_to :order, class_name: 'Spree::Order'
     belongs_to :promotion, class_name: 'Spree::Promotion'

data/app/models/spree/product.rb

@@ -34,6 +34,7 @@ module Spree
     include Spree::Metadata
     include Spree::Product::Webhooks
     include Spree::Product::Slugs
+    include Spree::SearchIndexable
     if defined?(Spree::VendorConcern)
       include Spree::VendorConcern
     end
@@ -58,12 +59,6 @@ module Spree
 
     self::Translation.class_eval do
       normalizes :name, :meta_title, with: ->(value) { value&.to_s&.squish&.presence }
-
-      if defined?(PgSearch)
-        include PgSearch::Model
-
-        pg_search_scope :search_by_name, against: { name: 'A', meta_title: 'B' }, using: { trigram: { threshold: 0.3, word_similarity: true } }
-      end
     end
 
     # we need to have this callback before any dependent: :destroy associations
@@ -169,32 +164,15 @@ module Spree
                         where("#{Spree::Price.table_name}.compare_at_amount > #{Spree::Price.table_name}.amount")
                     }
 
-    if defined?(PgSearch)
-      scope :multi_search, lambda { |query, include_options = false|
-        return none if query.blank?
+    scope :search, ->(query) {
+      next none if query.blank?
 
-        product_ids = if Spree.use_translations?
-                        Spree::Product::Translation.search_by_name(query).pluck(:spree_product_id)
-                      else
-                        Spree::Product.search_by_name(query).ids
-                      end
+      product_ids = Spree::Variant.search_by_product_name_or_sku(query).pluck(:product_id)
+      where(id: product_ids.uniq.compact)
+    }
 
-        variant_product_ids = if include_options.present?
-                                Spree::Variant.search_by_sku_or_options(query).pluck(:product_id)
-                              else
-                                Spree::Variant.search_by_sku(query).pluck(:product_id)
-                              end
-
-        where(id: (product_ids + variant_product_ids).uniq.compact)
-      }
-    else
-      scope :multi_search, lambda { |query|
-        return none if query.blank?
-
-        product_ids = Spree::Variant.search_by_product_name_or_sku(query).pluck(:product_id)
-        where(id: product_ids.uniq.compact)
-      }
-    end
+    # Backward compatibility alias — remove in Spree 6.0
+    scope :multi_search, ->(*args) { search(*args) }
 
     scope :archivable, -> { where(status: %w[active draft]) }
     scope :by_source, ->(source) { send(source) }
@@ -224,7 +202,7 @@ module Spree
                                                    shipping_category classifications option_types]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon price_between
                                              price_lte price_gte
-                                             multi_search in_stock out_of_stock with_option_value_ids
+                                             search multi_search in_stock out_of_stock with_option_value_ids
 
                                              ascend_by_price descend_by_price]
 

data/app/models/spree/refresh_token.rb

@@ -0,0 +1,60 @@
+module Spree
+  class RefreshToken < Spree.base_class
+    has_prefix_id :rt
+
+    belongs_to :user, polymorphic: true
+
+    has_secure_token :token
+
+    validates :user, :expires_at, presence: true
+
+    scope :active, -> { where('expires_at > ?', Time.current) }
+    scope :expired, -> { where('expires_at <= ?', Time.current) }
+
+    def expired?
+      expires_at <= Time.current
+    end
+
+    # Rotate: destroy this token and create a new one.
+    # Returns the new token.
+    def rotate!(request_env: {})
+      new_token = nil
+      transaction do
+        new_token = self.class.create!(
+          user: user,
+          expires_at: self.class.default_expiry.from_now,
+          ip_address: request_env[:ip_address] || ip_address,
+          user_agent: request_env[:user_agent] || user_agent
+        )
+        destroy!
+      end
+      new_token
+    end
+
+    # Create a refresh token for a user
+    def self.create_for(user, request_env: {})
+      create!(
+        user: user,
+        expires_at: default_expiry.from_now,
+        ip_address: request_env[:ip_address],
+        user_agent: request_env[:user_agent]
+      )
+    end
+
+    # Revoke all refresh tokens for a user (e.g., on password change)
+    def self.revoke_all_for(user)
+      where(user: user).delete_all
+    end
+
+    # Clean up expired tokens
+    def self.cleanup_expired!
+      expired.delete_all
+    end
+
+    def self.default_expiry
+      Spree::Api::Config[:refresh_token_expiry].seconds
+    rescue StandardError
+      30.days
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Spree
+  module SearchProvider
+    class Base
+      attr_reader :store
+
+      # Whether this provider requires background indexing jobs.
+      # Override in subclasses. Database provider returns false.
+      def self.indexing_required?
+        false
+      end
+
+      def initialize(store)
+        @store = store
+      end
+
+      # Search, filter, and return facets in one call.
+      #
+      # @param scope [ActiveRecord::Relation] base scope (store-scoped, visibility-filtered, authorized)
+      # @param query [String, nil] text search query
+      # @param filters [Hash] structured filters (price_gte, with_option_value_ids, categories_id_eq, etc.)
+      # @param sort [String, nil] sort param (e.g. 'price', '-price', 'best_selling')
+      # @param page [Integer] page number
+      # @param limit [Integer] results per page
+      # @return [SearchResult]
+      def search_and_filter(scope:, query: nil, filters: {}, sort: nil, page: 1, limit: 25)
+        raise NotImplementedError
+      end
+
+      # Index a product — called after product save. No-op for database provider.
+      #
+      # @param product [Spree::Product] the product to index
+      def index(product)
+        # no-op by default
+      end
+
+      # Remove a product from the index.
+      #
+      # @param product [Spree::Product] the product to remove
+      def remove(product)
+        # no-op by default
+      end
+
+      # Remove a document from the index by prefixed ID (used when record is already deleted).
+      #
+      # @param prefixed_id [String] the prefixed ID (e.g. 'prod_abc')
+      def remove_by_id(prefixed_id)
+        # no-op by default
+      end
+
+      # Index a batch of documents. Called by rake task with pre-serialized documents.
+      #
+      # @param documents [Array<Hash>] serialized product documents
+      def index_batch(documents)
+        # no-op by default
+      end
+
+      # Configure index settings (filterable, sortable, searchable attributes).
+      # Called by rake task before indexing. No-op for database provider.
+      def ensure_index_settings!
+        # no-op by default
+      end
+
+      # Bulk reindex — full catalog sync. Called manually or via rake task.
+      #
+      # @param scope [ActiveRecord::Relation] products to reindex (default: all in store)
+      def reindex(scope = nil)
+        # no-op by default
+      end
+
+      private
+
+      def locale
+        Spree::Current.locale || store.default_market&.default_locale || I18n.locale.to_s
+      end
+
+      def currency
+        Spree::Current.currency || store.default_market&.currency
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Spree
+  module SearchProvider
+    class Database < Base
+      CUSTOM_SORT_SCOPES = {
+        'price' => :ascend_by_price,
+        '-price' => :descend_by_price,
+        'best_selling' => :by_best_selling
+      }.freeze
+
+      def search_and_filter(scope:, query: nil, filters: {}, sort: nil, page: 1, limit: 25)
+        # 1. Text search
+        scope = scope.search(query) if query.present?
+
+        # 2. Extract internal params before passing to Ransack
+        category = filters.is_a?(Hash) ? filters.delete('_category') || filters.delete(:_category) : nil
+
+        # 3. Structured filtering via Ransack
+        ransack_filters = sanitize_filters(filters)
+        if ransack_filters.present?
+          search = scope.ransack(ransack_filters)
+          scope = search.result(distinct: true)
+        end
+
+        # 4. Facets (before sorting to avoid computed column conflicts with count)
+        filter_facets = build_facets(scope, category: category)
+
+        # 5. Total count (before sorting to avoid computed column conflicts with count)
+        total = scope.distinct.count
+
+        # 6. Sorting + pagination
+        scope = apply_sort(scope, sort)
+        page = [page.to_i, 1].max
+        limit = limit.to_i.clamp(1, 100)
+        products = scope.offset((page - 1) * limit).limit(limit)
+
+        SearchResult.new(
+          products: products,
+          filters: filter_facets[:filters],
+          sort_options: filter_facets[:sort_options],
+          default_sort: filter_facets[:default_sort],
+          total_count: total,
+          pagy: build_pagy(total, page, limit)
+        )
+      end
+
+      private
+
+      def build_pagy(count, page, limit)
+        require 'pagy'
+        Pagy::Offset.new(count: count, page: page, limit: limit)
+      end
+
+      def build_facets(scope, category: nil)
+        return { filters: [], sort_options: available_sort_options, default_sort: 'manual' } unless defined?(Spree::Api::V3::FiltersAggregator)
+
+        Spree::Api::V3::FiltersAggregator.new(
+          scope: scope,
+          currency: currency,
+          category: category
+        ).call
+      end
+
+      def sanitize_filters(filters)
+        return {} if filters.blank?
+
+        filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
+        filters.except('search', :search, '_category', :_category)
+      end
+
+      def apply_sort(scope, sort)
+        return scope if sort.blank?
+
+        scope_method = CUSTOM_SORT_SCOPES[sort]
+        if scope_method
+          scope.reorder(nil).send(scope_method)
+        else
+          # Standard Ransack sort: 'name' → 'name asc', '-name' → 'name desc'
+          ransack_sort = sort.split(',').map { |field|
+            if field.start_with?('-')
+              "#{field[1..]} desc"
+            else
+              "#{field} asc"
+            end
+          }.join(',')
+
+          scope.ransack(s: ransack_sort).result
+        end
+      end
+
+      def available_sort_options
+        %w[price -price best_selling name -name -available_on available_on].map { |id| { id: id } }
+      end
+    end
+  end
+end