spree_core 5.3.5 → 5.4.0.beta

data/app/models/spree/store.rb

@@ -2,9 +2,7 @@ require 'uri'
 
 module Spree
   class Store < Spree.base_class
-    RESERVED_CODES = %w(
-      admin default app api www cdn files assets checkout account auth login user
-    )
+    has_prefix_id :store  # Spree-specific: store
 
     include FriendlyId
     include Spree::TranslatableResource
@@ -12,6 +10,7 @@ module Spree
     include Spree::Metadata
     include Spree::Stores::Setup
     include Spree::Stores::Socials
+    include Spree::Stores::Markets
     include Spree::Security::Stores if defined?(Spree::Security::Stores)
     include Spree::UserManagement
 
@@ -19,7 +18,7 @@ module Spree
     # Magic methods
     #
     acts_as_paranoid
-    friendly_id :slug_candidates, use: [:slugged, :history], slug_column: :code, routes: :normal
+    friendly_id :code, use: [:slugged], slug_column: :code, routes: :normal
 
     #
     # Translations
@@ -38,6 +37,7 @@ module Spree
     # Preferences
     #
     # general preferences
+    preference :admin_locale, :string
     preference :timezone, :string, default: Time.zone.name
     preference :weight_unit, :string, default: 'lb'
     preference :unit_system, :string, default: 'imperial'
@@ -101,9 +101,6 @@ module Spree
     has_many :reports, class_name: 'Spree::Report'
     has_many :exports, class_name: 'Spree::Export'
 
-    has_many :custom_domains, class_name: 'Spree::CustomDomain', dependent: :destroy
-    has_one :default_custom_domain, -> { where(default: true) }, class_name: 'Spree::CustomDomain'
-
     has_many :posts, class_name: 'Spree::Post', dependent: :destroy, inverse_of: :store
     has_many :post_categories, class_name: 'Spree::PostCategory', dependent: :destroy, inverse_of: :store
 
@@ -118,6 +115,9 @@ module Spree
 
     has_many :customer_groups, class_name: 'Spree::CustomerGroup', dependent: :destroy, inverse_of: :store
 
+    has_many :api_keys, class_name: 'Spree::ApiKey', dependent: :destroy
+
+
     #
     # ActionText
     #
@@ -130,20 +130,16 @@ module Spree
     #
     # Virtual attributes
     #
-    attribute :import_products_from_store_id, :string, default: nil
-    attribute :import_payment_methods_from_store_id, :string, default: nil
-    attr_accessor :skip_validate_not_last
     store_accessor :private_metadata, :storefront_password
 
     #
     # Validations
     #
     with_options presence: true do
-      validates :name, :url, :mail_from_address, :default_currency, :default_country, :code
+      validates :name, :url, :mail_from_address, :code
     end
     validates :preferred_digital_asset_authorized_clicks, numericality: { only_integer: true, greater_than: 0 }
     validates :preferred_digital_asset_authorized_days, numericality: { only_integer: true, greater_than: 0 }
-    validates :code, uniqueness: { case_sensitive: false, conditions: -> { with_deleted } }, exclusion: RESERVED_CODES
     validates :mail_from_address, email: { allow_blank: false }
     # FIXME: we should remove this condition in v5
     if !ENV['SPREE_DISABLE_DB_CONNECTION'] &&
@@ -164,59 +160,64 @@ module Spree
 
     #
     # Callbacks
-    before_validation :ensure_default_country
-    before_validation :set_code, on: :create
-    before_validation :set_url
+    before_validation :set_default_code, on: :create
     before_save :ensure_default_exists_and_is_unique
-    before_save :ensure_supported_currencies, :ensure_supported_locales
+    after_create :ensure_default_market
     after_create :ensure_default_taxonomies_are_created
     after_create :ensure_default_automatic_taxons
     after_create :ensure_default_post_categories_are_created
-    after_create :import_products_from_store, if: -> { import_products_from_store_id.present? }
-    after_create :import_payment_methods_from_store, if: -> { import_payment_methods_from_store_id.present? }
     after_create :create_default_policies
-    before_destroy :validate_not_last, unless: :skip_validate_not_last
-    before_destroy :pass_default_flag_to_other_store
     after_commit :clear_cache
-    after_commit :handle_code_changes, on: :update, if: -> { code_previously_changed? }
 
     #
     # Scopes
     #
     default_scope { order(created_at: :asc) }
-    scope :by_custom_domain, ->(url) { left_joins(:custom_domains).where("#{Spree::CustomDomain.table_name}.url" => url) }
-    scope :by_url, ->(url) { where(url: url).or(where("#{table_name}.url like ?", "%#{url}%")) }
 
     #
     # Delegations
     #
-    delegate :iso, to: :default_country, prefix: true, allow_nil: true
 
-    def self.current(url = nil)
-      if url.present?
-        Spree.current_store_finder.new(url: url).execute
-      else
-        Spree::Current.store
-      end
+    def self.current(_url = nil)
+      Spree::Current.store
     end
 
-    # FIXME: we need to drop `or_initialize` in v5
-    # this behaviour is very buggy and unpredictable
+    # @deprecated The or_initialize behavior will be removed in Spree 5.5.
     def self.default
       Rails.cache.fetch('default_store') do
         # workaround for Mobility bug with first_or_initialize
         if where(default: true).any?
           where(default: true).first
         else
+          Spree::Deprecation.warn(
+            'Spree::Store.default returning a new unpersisted store when no default store exists is deprecated ' \
+            'and will be removed in Spree 5.5. Please ensure a default store is created before calling Store.default.'
+          )
           new(default: true)
         end
       end
     end
 
     def self.available_locales
-      Spree::Store.all.map(&:supported_locales_list).flatten.uniq
+      Spree::Store.default&.supported_locales_list || []
     end
 
+    # @deprecated Use Markets instead. Will be removed in Spree 5.5.
+    def checkout_zone
+      Spree::Deprecation.warn('Store#checkout_zone is deprecated and will be removed in Spree 5.5. Use Markets instead.')
+      super
+    end
+
+    # @deprecated Use Markets instead. Will be removed in Spree 5.5.
+    def checkout_zone=(zone)
+      Spree::Deprecation.warn('Store#checkout_zone= is deprecated and will be removed in Spree 5.5. Use Markets instead.')
+      super
+    end
+
+    # Virtual attribute — sets the country for the default market created on store creation.
+    # Not persisted on the store itself; only used by the after_create callback.
+    attr_reader :default_country_iso
+
     def default_country_iso=(iso)
       return if iso.blank?
 
@@ -224,10 +225,11 @@ module Spree
 
       country = Spree::Country.by_iso(iso)
 
-      if country.present?
-        self.default_country = country
-      elsif iso_country = ::Country[iso]
-        new_country = Spree::Country.create!(
+      unless country
+        iso_country = ::Country[iso]
+        return unless iso_country
+
+        country = Spree::Country.create!(
           iso_name: iso_country.local_name&.upcase,
           iso: iso_country.alpha2,
           iso3: iso_country.alpha3,
@@ -236,15 +238,9 @@ module Spree
           states_required: Spree::Address::STATES_REQUIRED.include?(iso),
           zipcode_required: !Spree::Address::NO_ZIPCODE_ISO_CODES.include?(iso)
         )
-
-        self.default_country = new_country
       end
-    end
 
-    def supported_currencies_list
-      @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 }
+      @default_country_for_market = country
     end
 
     def seo_meta_description
@@ -257,10 +253,6 @@ module Spree
       end
     end
 
-    def supported_locales_list
-      @supported_locales_list ||= (read_attribute(:supported_locales).to_s.split(',') << default_locale).compact.uniq.sort
-    end
-
     def unique_name
       @unique_name ||= "#{name} (#{code})"
     end
@@ -292,51 +284,63 @@ module Spree
       end
     end
 
-    def formatted_custom_domain
-      return unless default_custom_domain
-
-      @formatted_custom_domain ||= if Rails.env.development? || Rails.env.test?
-        URI::Generic.build(
-          scheme: Rails.application.routes.default_url_options[:protocol] || 'http',
-          host: default_custom_domain.url,
-          port: Rails.application.routes.default_url_options[:port]
-        ).to_s
-      else
-        URI::HTTPS.build(host: default_custom_domain.url).to_s
-      end
-    end
-
     def url_or_custom_domain
-      default_custom_domain&.url || url
+      url
     end
 
     def formatted_url_or_custom_domain
-      formatted_custom_domain || formatted_url
+      formatted_url
     end
 
-    # Returns the countries available for checkout for the store or creates a new one if it doesn't exist
-    # @return [Array<Spree::Country>]
-    def countries_available_for_checkout
-      @countries_available_for_checkout ||= Rails.cache.fetch(countries_available_for_checkout_cache_key) do
-        (checkout_zone.try(:country_list) || Spree::Country.all).to_a
-      end
-    end
-
-    # Returns the states available for checkout for the store or creates a new one if it doesn't exist
+    # Returns the states available for checkout for the store
     # @param country [Spree::Country] the country to get the states for
     # @return [Array<Spree::State>]
     def states_available_for_checkout(country)
       Rails.cache.fetch(states_available_for_checkout_cache_key(country)) do
-        (checkout_zone.try(:state_list_for, country) || country.states).to_a
+        country.states.to_a
       end
     end
 
+    # @deprecated Use {Spree::Zone.all} or {#countries_with_shipping_coverage} instead.
+    #   Will be removed in Spree 5.5.
     def supported_shipping_zones
-      @supported_shipping_zones ||= if checkout_zone.present?
-                                      [checkout_zone]
-                                    else
-                                      Spree::Zone.includes(zone_members: :zoneable).all
-                                    end
+      Spree::Deprecation.warn(
+        'Store#supported_shipping_zones is deprecated and will be removed in Spree 5.5. ' \
+        'Use Spree::Zone.all or Store#countries_with_shipping_coverage instead.'
+      )
+      zone = Spree::Zone.find_by(id: read_attribute(:checkout_zone_id))
+      if zone.present?
+        [zone]
+      else
+        Spree::Zone.includes(zone_members: :zoneable).all
+      end
+    end
+
+    # Returns countries covered by at least one shipping zone
+    # that has an active shipping method attached.
+    # Handles both country-type zones (direct membership) and
+    # state-type zones (country inferred from state).
+    #
+    # @return [ActiveRecord::Relation<Spree::Country>]
+    def countries_with_shipping_coverage
+      zone_ids = Spree::Zone
+        .joins(:shipping_methods)
+        .select(:id)
+
+      country_zone_country_ids = Spree::ZoneMember
+        .where(zone_id: zone_ids, zoneable_type: 'Spree::Country')
+        .select(:zoneable_id)
+
+      state_zone_country_ids = Spree::State
+        .where(id: Spree::ZoneMember
+          .where(zone_id: zone_ids, zoneable_type: 'Spree::State')
+          .select(:zoneable_id))
+        .select(:country_id)
+
+      Spree::Country
+        .where(id: country_zone_country_ids)
+        .or(Spree::Country.where(id: state_zone_country_ids))
+        .order(:name)
     end
 
     # Returns the default stock location for the store or creates a new one if it doesn't exist
@@ -362,10 +366,6 @@ module Spree
       favicon_image.variant(resize_to_limit: [32, 32])
     end
 
-    def can_be_deleted?
-      self.class.where.not(id: id).any?
-    end
-
     def metric_unit_system?
       preferred_unit_system == 'metric'
     end
@@ -378,24 +378,6 @@ module Spree
       @digital_shipping_category ||= ShippingCategory.find_or_create_by(name: 'Digital')
     end
 
-    def import_products_from_store
-      store = Store.find(import_products_from_store_id)
-      product_ids = store.products.pluck(:id)
-
-      return if product_ids.empty?
-
-      StoreProduct.insert_all(product_ids.map { |product_id| { store_id: id, product_id: product_id } })
-    end
-
-    def import_payment_methods_from_store
-      store = Store.find(import_payment_methods_from_store_id)
-      payment_method_ids = store.payment_method_ids
-
-      return if payment_method_ids.empty?
-
-      StorePaymentMethod.insert_all(payment_method_ids.map { |payment_method_id| { store_id: id, payment_method_id: payment_method_id } })
-    end
-
     %w[customer_terms_of_service customer_privacy_policy customer_returns_policy customer_shipping_policy].each do |policy_method|
       define_method policy_method do
         Spree::Deprecation.warn("Store##{policy_method} is deprecated and will be removed in Spree 5.5. Please use Store#policies instead.")
@@ -407,65 +389,36 @@ module Spree
     private
 
     def countries_available_for_checkout_cache_key
-      "#{cache_key_with_version}/#{checkout_zone&.cache_key_with_version}/countries_available_for_checkout"
+      "#{cache_key_with_version}/countries_available_for_checkout"
     end
 
     def states_available_for_checkout_cache_key(country)
-      "#{cache_key_with_version}/#{checkout_zone&.cache_key_with_version}/states_available_for_checkout/#{country&.cache_key_with_version}"
-    end
-
-    def ensure_default_exists_and_is_unique
-      if default
-        Store.where.not(id: id).update_all(default: false)
-      elsif Store.where(default: true).count.zero?
-        self.default = true
-      end
+      "#{cache_key_with_version}/states_available_for_checkout/#{country&.cache_key_with_version}"
     end
 
-    def ensure_supported_locales
-      return unless attributes.keys.include?('supported_locales')
-      return if supported_locales.present?
-      return if default_locale.blank?
-
-      self.supported_locales = default_locale
+    def clear_cache
+      Rails.cache.delete('default_store')
     end
 
-    def ensure_supported_currencies
-      return unless attributes.keys.include?('supported_currencies')
-      return if supported_currencies.present?
-      return if default_currency.blank?
+    def ensure_default_market
+      return if markets.exists?
 
-      self.supported_currencies = default_currency
-    end
+      country = @default_country_for_market
+      return if country.blank?
 
-    def validate_not_last
-      unless can_be_deleted?
-        errors.add(:base, :cannot_destroy_only_store)
-        throw(:abort)
-      end
-    end
+      iso_country = ISO3166::Country[country.iso]
 
-    def pass_default_flag_to_other_store
-      if default? && can_be_deleted?
-        self.class.where.not(id: id).first.update!(default: true)
-        self.default = false
+      Spree::Events.disable do
+        markets.create!(
+          name: country.name,
+          currency: iso_country&.currency_code || read_attribute(:default_currency) || 'USD',
+          default_locale: iso_country&.languages_official&.first || read_attribute(:default_locale) || 'en',
+          default: true,
+          countries: [country]
+        )
       end
     end
 
-    def clear_cache
-      Rails.cache.delete('default_store')
-    end
-
-    def ensure_default_country
-      return if default_country.present? && (checkout_zone.blank? || checkout_zone.country_list.blank? || checkout_zone.country_list.include?(default_country))
-
-      self.default_country = if checkout_zone.present? && checkout_zone.country_list.any?
-                               checkout_zone.country_list.first
-                             else
-                               Country.find_by(iso: 'US') || Country.first
-                             end
-    end
-
     def ensure_default_taxonomies_are_created
       Spree::Events.disable do
         [
@@ -547,42 +500,20 @@ module Spree
       I18n.t(key, locale: locale, default: I18n.t(key, locale: :en))
     end
 
-    # code is slug, so we don't want to generate new slug when code changes
-    # we use friendlyId only for history feature
-    def should_generate_new_friendly_id?
-      false
-    end
-
-    def slug_candidates
-      []
-    end
-
-    def handle_code_changes
-      # implement your custom logic here
+    def ensure_default_exists_and_is_unique
+      if default
+        Spree::Store.where.not(id: id).update_all(default: false)
+      elsif Spree::Store.where(default: true).count.zero?
+        self.default = true
+      end
     end
 
-    # This FriendlyId method is overwitten to keep our logic for generating code
-    # there is no option for own format
-    def set_code
-      self.code = if code.present?
-                    code.parameterize.strip
-                  elsif name.present?
-                    name.parameterize.strip
-                  end
-
-      return if self.code.blank?
-
-      # ensure code is unique
-      self.code = [name.parameterize, rand(9999)].join('-') while Spree::Store.with_deleted.where(code: self.code).exists?
+    def should_generate_new_friendly_id?
+      false
     end
 
-    # auto-assign internal URL for stores
-    def set_url
-      return if url_changed?
-      return unless code_changed?
-      return unless Spree.root_domain.present?
-
-      self.url = [code, Spree.root_domain].join('.')
+    def set_default_code
+      self.code = 'default' if code.blank?
     end
   end
 end

data/app/models/spree/store_credit.rb

@@ -1,5 +1,7 @@
 module Spree
   class StoreCredit < Spree.base_class
+    has_prefix_id :credit
+
     include Spree::SingleStoreResource
     include Spree::Metafields
     include Spree::Metadata
@@ -52,10 +54,6 @@ module Spree
     extend Spree::DisplayMoney
     money_methods :amount, :amount_used, :amount_remaining, :amount_authorized
 
-    def amount=(amount)
-      self[:amount] = Spree::LocalizedNumber.parse(amount)
-    end
-
     self.whitelisted_ransackable_attributes = %w[user_id created_by_id amount currency type_id]
     self.whitelisted_ransackable_associations = %w[type user created_by]
 

data/app/models/spree/store_credit_category.rb

@@ -1,5 +1,7 @@
 module Spree
   class StoreCreditCategory < Spree.base_class
+    has_prefix_id :sccat
+
     validates :name, presence: true
 
     before_destroy :validate_not_used

data/app/models/spree/store_credit_event.rb

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

data/app/models/spree/store_credit_type.rb

@@ -1,5 +1,7 @@
 module Spree
   class StoreCreditType < Spree.base_class
+    has_prefix_id :sctype
+
     DEFAULT_TYPE_NAME = 'Expiring'.freeze
     has_many :store_credits, class_name: 'Spree::StoreCredit', foreign_key: 'type_id'
 

data/app/models/spree/store_product.rb

@@ -1,5 +1,7 @@
 module Spree
   class StoreProduct < Spree.base_class
+    has_prefix_id :sp
+
     self.table_name = 'spree_products_stores'
 
     belongs_to :store, class_name: 'Spree::Store', touch: true

data/app/models/spree/tax_category.rb

@@ -1,5 +1,7 @@
 module Spree
   class TaxCategory < Spree.base_class
+    has_prefix_id :taxcat
+
     acts_as_paranoid
     validates :name, presence: true, uniqueness: { case_sensitive: false, scope: spree_base_uniqueness_scope + [:deleted_at] }
 

data/app/models/spree/tax_rate.rb

@@ -1,5 +1,7 @@
 module Spree
   class TaxRate < Spree.base_class
+    has_prefix_id :tax
+
     acts_as_paranoid
 
     include Spree::CalculatedAdjustments

data/app/models/spree/taxon.rb

@@ -2,6 +2,8 @@ require 'stringex'
 
 module Spree
   class Taxon < Spree.base_class
+    has_prefix_id :txn  # Spree-specific: taxon
+
     RULES_MATCH_POLICIES = %w[all any].freeze
     SORT_ORDERS = %w[
       manual
@@ -36,7 +38,8 @@ module Spree
     has_one :store, through: :taxonomy
     has_many :classifications, -> { order(:position) }, dependent: :destroy_async, inverse_of: :taxon
     has_many :products, through: :classifications
-    has_one :icon, as: :viewable, dependent: :destroy, class_name: 'Spree::TaxonImage' # TODO: remove this as this is deprecated
+    # @deprecated Use Spree::Taxon#image (Active Storage) instead. Will be removed in Spree 5.5.
+    has_one :icon, as: :viewable, dependent: :destroy, class_name: 'Spree::TaxonImage'
 
     has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
     has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'

data/app/models/spree/taxon_image.rb

@@ -1,9 +1,17 @@
 module Spree
+  # @deprecated Use Spree::Taxon#image (Active Storage) instead. Will be removed in Spree 5.5.
   class TaxonImage < Asset
     include Spree::TaxonImage::Configuration::ActiveStorage
     include Rails.application.routes.url_helpers
     include Spree::ImageMethods
 
+    after_initialize do
+      Spree::Deprecation.warn(
+        'Spree::TaxonImage is deprecated and will be removed in Spree 5.5. ' \
+        'Please use Spree::Taxon#image (Active Storage) instead.'
+      )
+    end
+
     def styles
       self.class.styles.map do |_, size|
         width, height = size[/(\d+)x(\d+)/].split('x').map(&:to_i)

data/app/models/spree/taxon_rule.rb

@@ -1,5 +1,7 @@
 module Spree
   class TaxonRule < Spree.base_class
+    has_prefix_id :txrule
+
     MATCH_POLICIES = %w[
       is_equal_to
       is_not_equal_to

data/app/models/spree/taxonomy.rb

@@ -1,5 +1,7 @@
 module Spree
   class Taxonomy < Spree.base_class
+    has_prefix_id :txnmy  # Spree-specific: taxonomy
+
     include Spree::TranslatableResource
     include Spree::Metafields
     include Spree::Metadata

data/app/models/spree/user_identity.rb

@@ -0,0 +1,81 @@
+module Spree
+  class UserIdentity < Spree::Base
+    has_prefix_id :uid
+
+    belongs_to :user, polymorphic: true, optional: false
+
+    validates :provider, presence: true
+    validates :uid, presence: true, uniqueness: { scope: [:provider, :user_type] }
+
+    validates :provider, inclusion: {
+      in: ->(_record) {
+        config = Rails.application.config.spree
+        (config.store_authentication_strategies.keys + config.admin_authentication_strategies.keys).uniq.map(&:to_s)
+      }
+    }
+
+    # Store provider-specific data
+    # info: JSON field with provider-specific data (name, avatar, etc)
+    # access_token: encrypted OAuth access token
+    # refresh_token: encrypted OAuth refresh token
+    # expires_at: token expiration timestamp
+
+    # Find or create user from OAuth data
+    def self.find_or_create_from_oauth(provider:, uid:, info:, tokens: {}, user_class: nil)
+      user_class ||= Spree.user_class
+      user_type = user_class.name
+
+      identity = find_by(provider: provider, uid: uid, user_type: user_type)
+
+      if identity
+        # Update existing identity with fresh tokens
+        identity.update(
+          info: info,
+          access_token: tokens[:access_token],
+          refresh_token: tokens[:refresh_token],
+          expires_at: tokens[:expires_at]
+        )
+        identity.user
+      else
+        # Create new user and identity
+        create_user_from_oauth(
+          provider: provider,
+          uid: uid,
+          info: info,
+          tokens: tokens,
+          user_class: user_class
+        )
+      end
+    end
+
+    def self.create_user_from_oauth(provider:, uid:, info:, tokens: {}, user_class: nil)
+      user_class ||= Spree.user_class
+
+      user = user_class.create!(
+        email: info[:email] || generate_temp_email(provider, uid),
+        password: SecureRandom.hex(32), # Random password for OAuth users
+        first_name: info[:first_name],
+        last_name: info[:last_name]
+      )
+
+      user.identities.create!(
+        provider: provider,
+        uid: uid,
+        info: info,
+        access_token: tokens[:access_token],
+        refresh_token: tokens[:refresh_token],
+        expires_at: tokens[:expires_at]
+      )
+
+      user
+    end
+
+    def self.generate_temp_email(provider, uid)
+      "#{provider}-#{uid}@temporary.example.com"
+    end
+
+    def expired?
+      expires_at && expires_at < Time.current
+    end
+  end
+end