spree_core 5.3.4 → 5.4.0.beta2

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'
@@ -75,7 +75,6 @@ module Spree
 
     has_many :store_products, class_name: 'Spree::StoreProduct'
     has_many :products, through: :store_products, class_name: 'Spree::Product'
-    has_many :product_properties, through: :products, class_name: 'Spree::ProductProperty'
     has_many :variants, through: :products, class_name: 'Spree::Variant', source: :variants_including_master
     has_many :stock_items, through: :variants, class_name: 'Spree::StockItem'
     has_many :inventory_units, through: :variants, class_name: 'Spree::InventoryUnit'
@@ -93,20 +92,12 @@ module Spree
 
     has_many :wishlists, class_name: 'Spree::Wishlist'
 
-    has_many :data_feeds, class_name: 'Spree::DataFeed'
-
     belongs_to :default_country, class_name: 'Spree::Country'
     belongs_to :checkout_zone, class_name: 'Spree::Zone'
 
     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
-
     has_many :integrations, class_name: 'Spree::Integration'
 
     has_many :gift_cards, class_name: 'Spree::GiftCard', dependent: :destroy
@@ -118,6 +109,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 +124,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 +154,60 @@ 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
-          new(default: true)
-        end
+      # 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
 
     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 +215,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 +228,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 +243,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 +274,61 @@ 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
-    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
+      formatted_url
     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
-      end
+      country.states.to_a
     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 +354,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 +366,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.")
@@ -406,66 +376,25 @@ module Spree
 
     private
 
-    def countries_available_for_checkout_cache_key
-      "#{cache_key_with_version}/#{checkout_zone&.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
-    end
+    def ensure_default_market
+      return if markets.exists?
 
-    def ensure_supported_locales
-      return unless attributes.keys.include?('supported_locales')
-      return if supported_locales.present?
-      return if default_locale.blank?
+      country = @default_country_for_market
+      return if country.blank?
 
-      self.supported_locales = default_locale
-    end
+      iso_country = ISO3166::Country[country.iso]
 
-    def ensure_supported_currencies
-      return unless attributes.keys.include?('supported_currencies')
-      return if supported_currencies.present?
-      return if default_currency.blank?
-
-      self.supported_currencies = default_currency
-    end
-
-    def validate_not_last
-      unless can_be_deleted?
-        errors.add(:base, :cannot_destroy_only_store)
-        throw(:abort)
-      end
-    end
-
-    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
         [
@@ -510,21 +439,6 @@ module Spree
       end
     end
 
-    def ensure_default_post_categories_are_created
-      Spree::Events.disable do
-        [
-          translate_with_store_locale_fallback('spree.default_post_categories.resources'),
-          translate_with_store_locale_fallback('spree.default_post_categories.articles'),
-          translate_with_store_locale_fallback('spree.default_post_categories.news')
-        ].each do |category_title|
-          # Use exists?/create pattern for safety
-          next if post_categories.where(title: category_title).exists?
-
-          post_categories.create(title: category_title)
-        end
-      end
-    end
-
     def create_default_policies
       Spree::Events.disable do
         [
@@ -547,42 +461,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,6 +54,10 @@ 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] }
 
@@ -8,15 +10,11 @@ module Spree
     has_many :variants, dependent: :nullify
 
     before_save :set_default_category
-    after_update :delete_cache
-    after_create :delete_cache
 
     self.whitelisted_ransackable_attributes = %w[name is_default tax_code]
 
     def self.default
-      Rails.cache.fetch('default_tax_category') do
-        find_by(is_default: true)
-      end
+      find_by(is_default: true)
     end
 
     def set_default_category
@@ -26,11 +24,5 @@ module Spree
         tax_category.update_columns(is_default: false, updated_at: Time.current)
       end
     end
-
-    private
-
-    def delete_cache
-      Rails.cache.delete('default_tax_category')
-    end
   end
 end

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,6 @@ 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
 
     has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
     has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
@@ -57,7 +58,6 @@ module Spree
     validates :taxonomy, presence: true
     validates :permalink, uniqueness: { case_sensitive: false, scope: [:parent_id, :taxonomy_id] }
     validates :hide_from_nav, inclusion: { in: [true, false] }
-    validates_associated :icon
     validate :check_for_root, on: :create
     validate :parent_belongs_to_same_taxonomy
     with_options length: { maximum: 255 }, allow_blank: true do
@@ -309,19 +309,6 @@ module Spree
       end
     end
 
-    # indicate which filters should be used for a taxon
-    # this method should be customized to your own site
-    def applicable_filters
-      Spree::Deprecation.warn('applicable_filters is deprecated and will be removed in Spree 5.5')
-      fs = []
-      # fs << ProductFilters.taxons_below(self)
-      ## unless it's a root taxon? left open for demo purposes
-
-      fs << Spree::Core::ProductFilters.price_filter if Spree::Core::ProductFilters.respond_to?(:price_filter)
-      fs << Spree::Core::ProductFilters.brand_filter if Spree::Core::ProductFilters.respond_to?(:brand_filter)
-      fs
-    end
-
     # Return meta_title if set otherwise generates from taxon name
     def seo_title
       meta_title.blank? ? name : meta_title

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