spree_core 5.3.4 → 5.4.0.beta

data/app/models/concerns/spree/stores/markets.rb

@@ -0,0 +1,124 @@
+module Spree
+  module Stores
+    module Markets
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :markets, class_name: 'Spree::Market', dependent: :destroy
+      end
+
+      # Returns the default market for this store
+      # @return [Spree::Market, nil]
+      def default_market
+        @default_market ||= Spree::Market.default_for_store(self)
+      end
+
+      # Returns the default country, derived from the default market
+      # @return [Spree::Country, nil]
+      def default_country
+        if has_markets?
+          default_market&.default_country
+        else
+          super
+        end
+      end
+
+      # Returns the default country ID, derived from the default market
+      # @return [Integer, nil]
+      def default_country_id
+        if has_markets?
+          default_country&.id
+        else
+          read_attribute(:default_country_id)
+        end
+      end
+
+      # Returns the default locale, delegating to the default market when markets exist
+      # Falls back to the store's own default_locale column
+      # @return [String, nil]
+      def default_locale
+        if has_markets?
+          default_market&.default_locale || read_attribute(:default_locale)
+        else
+          read_attribute(:default_locale)
+        end
+      end
+
+      # Returns the default currency, delegating to the default market when markets exist
+      # Falls back to the store's own default_currency column
+      # @return [String, nil]
+      def default_currency
+        if has_markets?
+          default_market&.currency || read_attribute(:default_currency)
+        else
+          read_attribute(:default_currency)
+        end
+      end
+
+      # Returns the market that contains the given country
+      # @param country [Spree::Country]
+      # @return [Spree::Market, nil]
+      def market_for_country(country)
+        Spree::Market.for_country(country, store: self)
+      end
+
+      # Returns countries from all markets as an ActiveRecord relation
+      # @return [ActiveRecord::Relation<Spree::Country>]
+      def countries_from_markets
+        Spree::Country
+          .where(id: Spree::Country.joins(market_countries: :market).where(Spree::Market.table_name => { store_id: id, deleted_at: nil }).select(:id))
+          .order(:name)
+      end
+
+      # Returns the countries available for checkout, derived from markets
+      # @return [Array<Spree::Country>]
+      def countries_available_for_checkout
+        @countries_available_for_checkout ||= Rails.cache.fetch(countries_available_for_checkout_cache_key) do
+          if markets.any?
+            markets.flat_map(&:countries).uniq.sort_by(&:name)
+          else
+            Spree::Country.all.to_a
+          end
+        end
+      end
+
+      # Returns supported currencies derived from markets, falling back to store attributes
+      # @return [Array<Money::Currency>]
+      def supported_currencies_list
+        @supported_currencies_list ||= if markets.any?
+                                         markets.pluck(:currency).uniq.map do |code|
+                                           ::Money::Currency.find(code)
+                                         end.compact.sort_by { |c| c.iso_code == default_currency ? 0 : 1 }
+                                       else
+                                         legacy_supported_currencies_list
+                                       end
+      end
+
+      # Returns supported locales derived from markets, falling back to store attributes
+      # @return [Array<String>]
+      def supported_locales_list
+        @supported_locales_list ||= if markets.any?
+                                      (markets.flat_map(&:supported_locales_list) << default_locale).compact.uniq.sort
+                                    else
+                                      legacy_supported_locales_list
+                                    end
+      end
+
+      private
+
+      def has_markets?
+        persisted? && (markets.loaded? ? markets.any? : markets.exists?)
+      end
+
+      def legacy_supported_currencies_list
+        ([default_currency] + read_attribute(:supported_currencies).to_s.split(',')).uniq.map(&:to_s).map do |code|
+          ::Money::Currency.find(code.strip)
+        end.compact.sort_by { |currency| currency.iso_code == default_currency ? 0 : 1 }
+      end
+
+      def legacy_supported_locales_list
+        (read_attribute(:supported_locales).to_s.split(',') << default_locale).compact.uniq.sort
+      end
+    end
+  end
+end

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

@@ -2,16 +2,18 @@ module Spree
   module UserMethods
     extend ActiveSupport::Concern
 
+    include Spree::PrefixedId
     include Spree::Metafields
     include Spree::UserPaymentSource
     include Spree::UserReporting
     include Spree::UserRoles
-    include Spree::AdminUserMethods
     include Spree::RansackableAttributes
     include Spree::MultiSearchable
     include Spree::Publishable
 
     included do
+      has_prefix_id :cus  # Stripe: cus_
+
       # Enable lifecycle events for user models
       publishes_lifecycle_events
 
@@ -40,6 +42,7 @@ module Spree
       has_many :gift_cards, class_name: 'Spree::GiftCard', foreign_key: :user_id, dependent: :destroy
       has_many :customer_group_users, class_name: 'Spree::CustomerGroupUser', foreign_key: :user_id, as: :user, dependent: :destroy
       has_many :customer_groups, through: :customer_group_users, class_name: 'Spree::CustomerGroup'
+      has_many :identities, class_name: 'Spree::UserIdentity', as: :user, dependent: :destroy
       belongs_to :ship_address, class_name: 'Spree::Address', optional: true
       belongs_to :bill_address, class_name: 'Spree::Address', optional: true
 
@@ -143,13 +146,10 @@ module Spree
     end
 
     # Returns true if the user can be deleted
+    # Customers can be deleted if they have no completed orders
     # @return [Boolean]
     def can_be_deleted?
-      if role_users.where(resource: Spree::Store.current).exists?
-        Spree::Store.current.users.where.not(id: id).exists?
-      else
-        orders.complete.none?
-      end
+      orders.complete.none?
     end
 
     # Returns the CSV row representation of the user
@@ -166,7 +166,7 @@ module Spree
     end
 
     def event_serializer_class
-      Spree::Events::UserSerializer
+      'Spree::Api::V3::CustomerSerializer'.safe_constantize
     end
 
     def event_prefix

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

@@ -4,6 +4,8 @@ module Spree
 
     included do
       has_many :credit_cards, class_name: 'Spree::CreditCard', foreign_key: :user_id, dependent: :destroy
+      has_many :payment_setup_sessions, class_name: 'Spree::PaymentSetupSession', foreign_key: :customer_id, dependent: :destroy
+
       def default_credit_card
         credit_cards.default.first
       end

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

@@ -48,6 +48,7 @@ module Spree
       end
 
       def self.spree_admin_created?
+        Spree::Deprecation.warn('Spree.admin_user_class.spree_admin_created? is deprecated and will be removed in Spree 5.5')
         spree_admin.exists?
       end
 

data/app/models/spree/ability.rb

@@ -30,11 +30,21 @@ module Spree
     # modify the default +Ability+ of an application.  The +ability+ argument must be a class that includes
     # the +CanCan::Ability+ module.  The registered ability should behave properly as a stand-alone class
     # and therefore should be easy to test in isolation.
+    # @deprecated Use Spree::PermissionSets instead. Will be removed in Spree 5.5.
     def self.register_ability(ability)
+      Spree::Deprecation.warn(
+        'Spree::Ability.register_ability is deprecated and will be removed in Spree 5.5. ' \
+        'Please use Spree::PermissionSets instead. See Spree::PermissionSets::Base for details.'
+      )
       abilities.add(ability)
     end
 
+    # @deprecated Use Spree::PermissionSets instead. Will be removed in Spree 5.5.
     def self.remove_ability(ability)
+      Spree::Deprecation.warn(
+        'Spree::Ability.remove_ability is deprecated and will be removed in Spree 5.5. ' \
+        'Please use Spree::PermissionSets instead. See Spree::PermissionSets::Base for details.'
+      )
       abilities.delete(ability)
     end
 
@@ -165,6 +175,9 @@ module Spree
         wished_item.wishlist.user == user
       end
       can :accept, Spree::Invitation, invitee_id: [user.id, nil], invitee_type: user.class.name, status: 'pending'
+      can :show, ::Spree::DigitalLink do |digital_link, token|
+        digital_link.token == token
+      end
       can :read, ::Spree::Policy
       can :read, ::Spree::Page if defined?(Spree::Page)
       can :read, ::Spree::Post if defined?(Spree::Post)

data/app/models/spree/address.rb

@@ -1,5 +1,7 @@
 module Spree
   class Address < Spree.base_class
+    has_prefix_id :addr  # Spree-specific: address
+
     require 'validates_zipcode'
 
     include Spree::Metafields
@@ -48,6 +50,8 @@ module Spree
 
     after_initialize :set_default_values, if: -> { new_record? && user.present? }
 
+    before_validation :normalize_country
+    before_validation :normalize_state
     before_validation :clear_invalid_state_entities, if: -> { country.present? }, on: :update
     before_validation :remove_emoji_and_normalize
 
@@ -83,6 +87,16 @@ module Spree
 
     alias_attribute :postal_code, :zipcode
 
+    # 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
+    def country_iso=(value)
+      @country_iso_input = value
+    end
+
+    def state_abbr=(value)
+      @state_abbr_input = value
+    end
+
     self.whitelisted_ransackable_attributes = ADDRESS_FIELDS
     self.whitelisted_ransackable_associations = %w[country state user]
 
@@ -247,6 +261,22 @@ module Spree
       self.phone ||= user.phone
     end
 
+    def normalize_country
+      iso = @country_iso_input
+      return if iso.blank?
+
+      self.country = Spree::Country.by_iso(iso)
+      @country_iso_input = nil
+    end
+
+    def normalize_state
+      abbr = @state_abbr_input
+      return if abbr.blank? || country.blank?
+
+      self.state = country.states.find_by(abbr: abbr)
+      @state_abbr_input = nil
+    end
+
     def clear_state
       self.state = nil
     end

data/app/models/spree/adjustment.rb

@@ -22,6 +22,8 @@
 # it might be reinstated.
 module Spree
   class Adjustment < Spree.base_class
+    has_prefix_id :adj  # Spree-specific: adjustment
+
     with_options polymorphic: true do
       belongs_to :adjustable, touch: true
       belongs_to :source

data/app/models/spree/api_key.rb

@@ -0,0 +1,47 @@
+module Spree
+  class ApiKey < Spree.base_class
+    has_prefix_id :key  # Spree-specific: api key
+
+    KEY_TYPES = %w[publishable secret].freeze
+    PREFIXES = { 'publishable' => 'pk_', 'secret' => 'sk_' }.freeze
+    TOKEN_LENGTH = 24
+
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :created_by, polymorphic: true, optional: true
+    belongs_to :revoked_by, polymorphic: true, optional: true
+
+    validates :name, presence: true
+    validates :key_type, presence: true, inclusion: { in: KEY_TYPES }
+    validates :token, presence: true, uniqueness: { scope: spree_base_uniqueness_scope }
+    validates :store, presence: true
+
+    before_validation :generate_token, on: :create
+
+    scope :active, -> { where(revoked_at: nil) }
+    scope :revoked, -> { where.not(revoked_at: nil) }
+    scope :publishable, -> { where(key_type: 'publishable') }
+    scope :secret, -> { where(key_type: 'secret') }
+
+    def publishable?
+      key_type == 'publishable'
+    end
+
+    def secret?
+      key_type == 'secret'
+    end
+
+    def active?
+      revoked_at.nil?
+    end
+
+    def revoke!(user = nil)
+      update!(revoked_at: Time.current, revoked_by: user)
+    end
+
+    private
+
+    def generate_token
+      self.token ||= "#{PREFIXES[key_type]}#{SecureRandom.base58(TOKEN_LENGTH)}"
+    end
+  end
+end

data/app/models/spree/asset.rb

@@ -1,5 +1,7 @@
 module Spree
   class Asset < Spree.base_class
+    has_prefix_id :asset  # Stripe: file_
+
     include Support::ActiveStorage
     include Spree::Metafields
     include Spree::Metadata

data/app/models/spree/authentication/strategies/base_strategy.rb

@@ -0,0 +1,55 @@
+module Spree
+  module Authentication
+    module Strategies
+      class BaseStrategy
+        attr_reader :params, :request_env, :user_class
+
+        def initialize(params:, request_env:, user_class: nil)
+          @params = params
+          @request_env = request_env
+          @user_class = user_class || Spree.user_class
+        end
+
+        # Returns Result object with user on success
+        # @return [Spree::ServiceModule::Result]
+        def authenticate
+          raise NotImplementedError, 'Subclass must implement #authenticate'
+        end
+
+        # Returns provider identifier (e.g., 'google', 'email')
+        # @return [String]
+        def provider
+          raise NotImplementedError, 'Subclass must implement #provider'
+        end
+
+        protected
+
+        # Success result with user
+        def success(user)
+          Spree::ServiceModule::Result.new(success: true, value: user)
+        end
+
+        # Failure result with error message
+        def failure(message)
+          Spree::ServiceModule::Result.new(success: false, error: message)
+        end
+
+        # Find user by email
+        def find_user_by_email(email)
+          user_class.find_by(email: email)
+        end
+
+        # Find or create user identity
+        def find_or_create_user_from_oauth(provider:, uid:, info:, tokens: {})
+          Spree::UserIdentity.find_or_create_from_oauth(
+            provider: provider,
+            uid: uid,
+            info: info,
+            tokens: tokens,
+            user_class: user_class
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/spree/authentication/strategies/email_password_strategy.rb

@@ -0,0 +1,47 @@
+module Spree
+  module Authentication
+    module Strategies
+      class EmailPasswordStrategy < BaseStrategy
+        def authenticate
+          email = params[:email]
+          password = params[:password]
+
+          return failure('Email is required') if email.blank?
+          return failure('Password is required') if password.blank?
+
+          user = find_user_by_email(email)
+          return failure('Invalid email or password') unless user
+
+          if validate_password(user, password)
+            success(user)
+          else
+            failure('Invalid email or password')
+          end
+        rescue => e
+          Rails.logger.error "EmailPasswordStrategy authentication failed: #{e.message}"
+          failure('Authentication failed')
+        end
+
+        def provider
+          'email'
+        end
+
+        private
+
+        def validate_password(user, password)
+          # Try Devise's valid_password? method first (most common)
+          if user.respond_to?(:valid_password?)
+            user.valid_password?(password)
+          # Fallback to authenticate method (for has_secure_password)
+          elsif user.respond_to?(:authenticate)
+            user.authenticate(password).present?
+          else
+            # No password authentication available
+            Rails.logger.warn "User class #{user.class} does not implement password authentication"
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/base.rb

@@ -4,6 +4,7 @@ class Spree::Base < ApplicationRecord
   include Spree::TranslatableResourceScopes
   include Spree::IntegrationsConcern
   include Spree::Publishable
+  include Spree::PrefixedId
 
   after_initialize do
     if has_attribute?(:preferences) && !preferences.nil?

data/app/models/spree/calculator.rb

@@ -1,5 +1,7 @@
 module Spree
   class Calculator < Spree.base_class
+    has_prefix_id :calc
+
     acts_as_paranoid
 
     belongs_to :calculable, polymorphic: true, optional: true, inverse_of: :calculator, touch: true

data/app/models/spree/country.rb

@@ -11,6 +11,8 @@ module Spree
              dependent: :destroy,
              foreign_key: :zoneable_id
     has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
+    has_many :market_countries, class_name: 'Spree::MarketCountry', dependent: :destroy
+    has_many :markets, through: :market_countries, class_name: 'Spree::Market'
 
     validates :name, :iso_name, :iso, :iso3, presence: true, uniqueness: { case_sensitive: false, scope: spree_base_uniqueness_scope }
 
@@ -23,6 +25,42 @@ module Spree
       self == store.default_country
     end
 
+    def self.to_tom_select_json
+      pluck(:name, :id, :iso).map do |name, id, iso|
+        {
+          id: id,
+          name: "#{iso_to_emoji_flag(iso)} #{name}"
+        }
+      end.as_json
+    end
+
+    def self.iso_to_emoji_flag(iso)
+      iso.upcase.chars.map { |c| (c.ord + 127397).chr(Encoding::UTF_8) }.join
+    end
+
+    # Returns the currency for this country from its market in the current store.
+    # Looks up which market contains this country and returns that market's currency.
+    #
+    # @return [String, nil] currency code (e.g., 'USD', 'EUR') or nil if no market found
+    def market_currency
+      Spree::Current.store&.market_for_country(self)&.currency
+    end
+
+    # Returns the default locale for this country from its market in the current store.
+    # Looks up which market contains this country and returns that market's default locale.
+    #
+    # @return [String, nil] locale code (e.g., 'en', 'de') or nil if no market found
+    def market_locale
+      Spree::Current.store&.market_for_country(self)&.default_locale
+    end
+
+    # Returns the supported locales for this country from its market in the current store.
+    #
+    # @return [Array<String>] locale codes (e.g., ['en', 'fr']) or empty array if no market found
+    def market_supported_locales
+      Spree::Current.store&.market_for_country(self)&.supported_locales_list || []
+    end
+
     def <=>(other)
       name <=> other.name
     end
@@ -30,5 +68,23 @@ module Spree
     def to_s
       name
     end
+
+    # Returns the default currency code for this country (e.g., 'USD', 'EUR')
+    # Uses the countries gem (ISO3166) for accurate currency data
+    def default_currency
+      iso3166_country&.currency_code
+    end
+
+    # Returns the default locale/language for this country (e.g., 'en', 'de')
+    # Uses the countries gem (ISO3166) for accurate language data
+    def default_locale
+      iso3166_country&.languages&.first
+    end
+
+    private
+
+    def iso3166_country
+      @iso3166_country ||= ISO3166::Country.new(iso)
+    end
   end
 end

data/app/models/spree/coupon_code.rb

@@ -1,5 +1,7 @@
 module Spree
   class CouponCode < Spree.base_class
+    has_prefix_id :coupon
+
     include Spree::Security::CouponCodes if defined?(Spree::Security::CouponCodes)
 
     enum :state, %i(unused used)

data/app/models/spree/credit_card.rb

@@ -1,5 +1,7 @@
 module Spree
   class CreditCard < Spree.base_class
+    has_prefix_id :card  # Stripe: card_
+
     include ActiveMerchant::Billing::CreditCardMethods
     include Spree::Metafields
     include Spree::Metadata

data/app/models/spree/current.rb

@@ -1,17 +1,21 @@
 module Spree
   class Current < ::ActiveSupport::CurrentAttributes
-    attribute :store, :currency, :zone, :price_lists, :global_pricing_context
+    attribute :store, :market, :currency, :zone, :price_lists, :global_pricing_context
 
     def store
       super || Spree::Store.default
     end
 
+    def market
+      super || store&.default_market
+    end
+
     def currency
-      super || store&.default_currency
+      super || market&.currency || store&.default_currency
     end
 
     def zone
-      super || Spree::Zone.default_tax || store&.checkout_zone
+      super || Spree::Zone.default_tax
     end
 
     def price_lists
@@ -26,7 +30,8 @@ module Spree
         self.global_pricing_context = Spree::Pricing::Context.new(
           currency: currency,
           store: store,
-          zone: zone
+          zone: zone,
+          market: market
         )
       end
     end

data/app/models/spree/customer_group.rb

@@ -1,5 +1,7 @@
 module Spree
   class CustomerGroup < Spree.base_class
+    has_prefix_id :cg
+
     acts_as_paranoid
 
     #

data/app/models/spree/customer_return.rb

@@ -1,5 +1,7 @@
 module Spree
   class CustomerReturn < Spree.base_class
+    has_prefix_id :cr
+
     include Spree::Core::NumberGenerator.new(prefix: 'CR', length: 9)
     include Spree::NumberIdentifier
     include Spree::Metafields

data/app/models/spree/data_feed.rb

@@ -1,5 +1,7 @@
 module Spree
   class DataFeed < Spree.base_class
+    has_prefix_id :df
+
     belongs_to :store, class_name: 'Spree::Store', foreign_key: 'store_id'
 
     scope :for_store, ->(store) { where(store: store) }

data/app/models/spree/digital.rb

@@ -1,5 +1,7 @@
 module Spree
   class Digital < Spree.base_class
+    has_prefix_id :dig
+
     publishes_lifecycle_events
 
     belongs_to :variant

data/app/models/spree/digital_link.rb

@@ -1,5 +1,7 @@
 module Spree
   class DigitalLink < Spree.base_class
+    has_prefix_id :dl  # Spree-specific: digital link
+
     publishes_lifecycle_events
 
     if Rails::VERSION::STRING >= '7.1.0'

data/app/models/spree/export.rb

@@ -2,11 +2,12 @@ require 'csv'
 
 module Spree
   class Export < Spree.base_class
+    has_prefix_id :exp
+
     SUPPORTED_FILE_FORMATS = %i[csv].freeze
 
     include Spree::SingleStoreResource
     include Spree::NumberIdentifier
-    include Spree::NumberAsParam
     include Spree::VendorConcern if defined?(Spree::VendorConcern)
 
     include Spree::Core::NumberGenerator.new(prefix: 'EF')
@@ -58,7 +59,7 @@ module Spree
     attribute :record_selection, :string, default: 'filtered'
 
     def event_serializer_class
-      Spree::Events::ExportSerializer
+      'Spree::Api::V3::ExportSerializer'.safe_constantize
     end
 
     def done?