spree_core 5.6.1 → 6.0.0.beta1

data/app/models/spree/variant_media.rb

@@ -1,14 +1,12 @@
 module Spree
-  # FK column is `media_id` (not `asset_id`) to match the 6.0 rename
-  # Spree::Asset → Spree::Media. The `:asset` association name follows the
-  # current parent class; in 6.0 it renames to `:media` without a column change.
+  # FK column is `media_id`, matching Spree::Media and its table. The `:asset`
+  # association name stays readable for one release alongside `:media`.
   class VariantMedia < Spree.base_class
     self.table_name = 'spree_variant_media'
 
     belongs_to :variant, class_name: 'Spree::Variant', touch: true
-    belongs_to :asset, class_name: 'Spree::Asset', foreign_key: :media_id, inverse_of: :variant_media
+    belongs_to :asset, class_name: 'Spree::Media', foreign_key: :media_id, inverse_of: :variant_media
 
-    validates :variant, :asset, presence: true
     validates :media_id, uniqueness: { scope: :variant_id }
     validate :asset_belongs_to_variant_product
 
@@ -17,7 +15,7 @@ module Spree
     # Resolves an array of variant identifiers (prefixed ids or raw ids) to the
     # numeric ids of variants that belong to `product`. Anything else — bad
     # prefix, foreign product, garbage — is dropped. This is the security
-    # boundary used by Spree::Asset#variant_ids=, so callers (forms, API params)
+    # boundary used by Spree::Media#variant_ids=, so callers (forms, API params)
     # can't link assets to variants from another product.
     def self.resolve_variant_ids(product, variant_ids)
       ids = Array(variant_ids).reject(&:blank?)
@@ -36,7 +34,8 @@ module Spree
       return if asset.blank? || variant.blank?
       return if asset.product&.id == variant.product_id
 
-      errors.add(:asset, 'must belong to the same product as the variant')
+      errors.add(:asset, :variant_product_mismatch,
+                 message: Spree.t('errors.messages.variant_product_mismatch'))
     end
 
     def refresh_variant_thumbnail

data/app/models/spree/webhook_endpoint.rb

@@ -16,7 +16,8 @@ module Spree
     belongs_to :store, class_name: 'Spree::Store'
     has_many :webhook_deliveries, class_name: 'Spree::WebhookDelivery', dependent: :destroy_async
 
-    validates :store, :url, presence: true
+    validates :url, presence: true
+    validates_store_uniqueness :url
     validates :url, format: { with: URI::DEFAULT_PARSER.make_regexp(%w[http https]), message: :invalid_url }
     validates :active, inclusion: { in: [true, false] }
     validate :url_must_not_resolve_to_private_ip, if: -> { !Rails.env.development? && url.present? && url_changed? }

data/app/models/spree/wished_item.rb

@@ -1,33 +1,5 @@
 module Spree
-  class WishedItem < Spree.base_class
-    has_prefix_id :wi  # Spree-specific: wished item
-
-    extend DisplayMoney
-    money_methods :total, :price
-
-    publishes_lifecycle_events
-
-    belongs_to :variant, class_name: 'Spree::Variant'
-    belongs_to :wishlist, class_name: 'Spree::Wishlist'
-
-    has_one :product, class_name: 'Spree::Product', through: :variant
-
-    validates :variant, :wishlist, presence: true
-    validates :variant, uniqueness: { scope: [:wishlist] }
-    validates :quantity, numericality: { only_integer: true, greater_than: 0 }
-
-    def price(currency)
-      variant.amount_in(currency[:currency])
-    end
-
-    def total(currency)
-      variant_price = variant.amount_in(currency[:currency])
-
-      if variant_price.nil?
-        variant_price
-      else
-        quantity * variant_price
-      end
-    end
-  end
+  # Constant alias for the legacy Spree::WishedItem, renamed to
+  # Spree::WishlistItem in 6.0. Remove in 6.1.
+  WishedItem = WishlistItem
 end

data/app/models/spree/wishlist.rb

@@ -12,40 +12,47 @@ module Spree
       has_secure_token
     end
 
-    belongs_to :user, class_name: "::#{Spree.user_class}", touch: true
+    belongs_to :customer, class_name: "::#{Spree.customer_class}", touch: true
+    include Spree::DeprecatedCustomerAlias
     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 :wishlist_items, class_name: 'Spree::WishlistItem', dependent: :destroy
+    has_many :wished_items, class_name: 'Spree::WishlistItem', inverse_of: :wishlist, deprecated: true
+    has_many :variants, through: :wishlist_items, source: :variant, class_name: 'Spree::Variant'
     has_many :products, -> { distinct }, through: :variants, source: :product, class_name: 'Spree::Product'
 
     after_commit :ensure_default_exists_and_is_unique
-    validates :name, :store, :user, presence: true
+    validates :name, presence: true
 
     def include?(variant_id)
-      wished_items.exists?(variant_id: variant_id)
+      wishlist_items.exists?(variant_id: variant_id)
     end
 
-    # returns the number of wished items in the wishlist
+    # returns the number of items in the wishlist
     #
     # @return [Integer]
+    def wishlist_items_count
+      @wishlist_items_count ||= variant_ids.count
+    end
+
+    # @deprecated Use {#wishlist_items_count}; removed in 6.1.
     def wished_items_count
-      @wished_items_count ||= variant_ids.count
+      Spree::Deprecation.warn('Spree::Wishlist#wished_items_count is deprecated and will be removed in Spree 6.1. Use #wishlist_items_count instead.')
+      wishlist_items_count
     end
 
     # returns the variant ids in the wishlist
     #
     # @return [Array<Integer>]
     def variant_ids
-      @variant_ids ||= wished_items.pluck(:variant_id)
+      @variant_ids ||= wishlist_items.pluck(:variant_id)
     end
 
     private
 
     def ensure_default_exists_and_is_unique
       if is_default?
-        Wishlist.where(is_default: true, user_id: user_id, store_id: store_id).where.not(id: id).update_all(is_default: false)
+        Wishlist.where(is_default: true, customer_id: customer_id, store_id: store_id).where.not(id: id).update_all(is_default: false)
       end
     end
   end

data/app/models/spree/wishlist_item/custom_events.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spree
+  class WishlistItem < Spree.base_class
+    # Dual-emits the pre-6.0 `wished_item.*` lifecycle events beside the
+    # `wishlist_item.*` ones, so a webhook endpoint a merchant configured
+    # against the old names keeps receiving deliveries for one release.
+    # Removed in 6.1, the same way {Spree::StockLevel::CustomEvents} carries
+    # `stock_item.*`.
+    module CustomEvents
+      LEGACY_EVENT_PREFIX = 'wished_item'
+      LEGACY_EVENT_SUFFIXES = %w[created updated deleted].freeze
+
+      # Wraps publishing rather than the three callbacks that call it, so the
+      # decisions Publishable makes — whether events are enabled at all,
+      # whether a touch-only update is worth announcing — are made once and the
+      # legacy twin simply follows whatever the new name did.
+      def publish_event(event_name, payload = nil, metadata = {})
+        published = super
+
+        legacy_name = legacy_event_name(event_name)
+        return published if legacy_name.nil?
+
+        super(legacy_name, payload, metadata)
+
+        published
+      end
+
+      private
+
+      # @return [String, nil] the pre-6.0 name for a lifecycle event, or nil
+      #   for anything else this model publishes
+      def legacy_event_name(event_name)
+        prefix, _, suffix = event_name.to_s.rpartition('.')
+        return unless prefix == event_prefix
+        return unless LEGACY_EVENT_SUFFIXES.include?(suffix)
+
+        "#{LEGACY_EVENT_PREFIX}.#{suffix}"
+      end
+    end
+  end
+end

data/app/models/spree/wishlist_item.rb

@@ -0,0 +1,37 @@
+module Spree
+  class WishlistItem < Spree.base_class
+    # The prefix stays wi_ through the rename: prefixed IDs are a Store API
+    # identifier clients hold, and decode_own_prefixed_id rejects a foreign
+    # prefix, so moving it would 404 every ID already issued.
+    has_prefix_id :wi  # Spree-specific: wishlist item
+
+    include Spree::WishlistItem::CustomEvents
+
+    extend DisplayMoney
+    money_methods :total, :price
+
+    publishes_lifecycle_events
+
+    belongs_to :variant, class_name: 'Spree::Variant'
+    belongs_to :wishlist, class_name: 'Spree::Wishlist'
+
+    has_one :product, class_name: 'Spree::Product', through: :variant
+
+    validates :variant, uniqueness: { scope: [:wishlist] }
+    validates :quantity, numericality: { only_integer: true, greater_than: 0 }
+
+    def price(currency)
+      variant.amount_in(currency[:currency])
+    end
+
+    def total(currency)
+      variant_price = variant.amount_in(currency[:currency])
+
+      if variant_price.nil?
+        variant_price
+      else
+        quantity * variant_price
+      end
+    end
+  end
+end

data/app/models/spree/zone.rb

@@ -1,93 +1,21 @@
 module Spree
+  # Migration-only shell, removed in Spree 6.1: rows survive solely as source
+  # data for the 5.6→6.0 zone, market and tax migrations. Countries and states
+  # are reference data in 6.0, so member ids resolve against the legacy tables
+  # rather than through associations.
   class Zone < Spree.base_class
     has_prefix_id :zone
 
-    include Spree::UniqueName
-
-    with_options dependent: :destroy, inverse_of: :zone do
-      has_many :zone_members, class_name: 'Spree::ZoneMember'
-      has_many :tax_rates
-    end
-    with_options through: :zone_members, source: :zoneable do
-      has_many :countries, source_type: 'Spree::Country'
-      has_many :states, source_type: 'Spree::State'
-    end
-
-    has_many :shipping_method_zones, class_name: 'Spree::ShippingMethodZone'
-    has_many :shipping_methods, through: :shipping_method_zones, class_name: 'Spree::ShippingMethod'
-
-    scope :with_default_tax, -> { where(default_tax: true) }
-
-    after_save :remove_defunct_members
-    after_save :remove_previous_default, if: %i[default_tax? saved_change_to_default_tax?]
-
+    has_many :zone_members, class_name: 'Spree::ZoneMember', dependent: :destroy, inverse_of: :zone
     alias members zone_members
-    accepts_nested_attributes_for :zone_members, allow_destroy: true, reject_if: proc { |a| a['zoneable_id'].blank? }
-
-    self.whitelisted_ransackable_attributes = ['description']
-
-    def self.default_tax
-      Spree::Current.default_tax_zone
-    end
-
-    def self.potential_matching_zones(zone)
-      if zone.country?
-        # Match zones of the same kind with similar countries
-        joins(countries: :zones).
-          where('zone_members_spree_countries_join.zone_id = ?', zone.id).
-          distinct
-      else
-        # Match zones of the same kind with similar states in AND match zones
-        # that have the states countries in
-        joins(:zone_members).where(
-          "(spree_zone_members.zoneable_type = 'Spree::State' AND
-            spree_zone_members.zoneable_id IN (?))
-           OR (spree_zone_members.zoneable_type = 'Spree::Country' AND
-            spree_zone_members.zoneable_id IN (?))",
-          zone.state_ids,
-          zone.states.pluck(:country_id)
-        ).distinct
-      end
-    end
-
-    # Returns the matching zone with the highest priority zone type (State, Country, Zone.)
-    # Returns nil in the case of no matches.
-    # Accepts either an address (with country_id/state_id) or a Spree::Country directly.
-    def self.match(address_or_country)
-      return unless address_or_country
-
-      if address_or_country.is_a?(Spree::Country)
-        country_id = address_or_country.id
-        state_id = nil
-      else
-        country_id = address_or_country.country_id
-        state_id = address_or_country.state_id
-      end
-
-      matches = includes(:zone_members).
-                  order('spree_zones.zone_members_count', 'spree_zones.created_at').
-                  where("(spree_zone_members.zoneable_type = 'Spree::Country' AND " \
-                        'spree_zone_members.zoneable_id = ?) OR ' \
-                        "(spree_zone_members.zoneable_type = 'Spree::State' AND " \
-                        'spree_zone_members.zoneable_id = ?)', country_id, state_id).
-                  references(:zones)
-
-      return if matches.empty?
-
-      %w[state country].each do |zone_kind|
-        if match = matches.detect { |zone| zone_kind == zone.kind }
-          return match
-        end
-      end
-      matches.first
-    end
 
+    # The stored kind, falling back to what the members point at — legacy rows
+    # predating the column carry the type only on their members.
     def kind
       if self[:kind].present?
         self[:kind]
       else
-        not_nil_scope = members.where.not(zoneable_type: nil)
-        zone_type = not_nil_scope.order('created_at ASC').pluck(:zoneable_type).last
+        zone_type = zone_members.where.not(zoneable_type: nil).order(created_at: :asc).pluck(:zoneable_type).last
         zone_type&.demodulize&.underscore
       end
     end
@@ -100,113 +28,27 @@ module Spree
       kind == 'state'
     end
 
-    def include?(address)
-      return false unless address
-
-      members.any? do |zone_member|
-        case zone_member.zoneable_type
-        when 'Spree::Country'
-          zone_member.zoneable_id == address.country_id
-        when 'Spree::State'
-          zone_member.zoneable_id == address.state_id
-        end
-      end
-    end
-
-    # convenience method for returning the countries contained within a zone
+    # The countries the zone covers, as value objects; a state member resolves
+    # through its state's country.
+    #
+    # @return [Array<Spree::Country>]
     def country_list
-      @countries ||= case kind
-                     when 'country' then
-                       Country.where(id: country_ids)
-                     when 'state' then
-                       Country.where(id: zoneables.collect(&:country_id))
-                     end
-    end
+      connection = self.class.connection
+      members_by_type = zone_members.where.not(zoneable_type: nil).group_by(&:zoneable_type)
 
-    def <=>(other)
-      name <=> other.name
-    end
-
-    # All zoneables belonging to the zone members.  Will be a collection of either
-    # countries or states depending on the zone type.
-    def zoneables
-      members.includes(:zoneable).collect(&:zoneable)
-    end
-
-    def country_ids
-      if country?
-        members.pluck(:zoneable_id)
-      else
-        []
-      end
-    end
-
-    def state_ids
-      if state?
-        members.pluck(:zoneable_id)
-      else
-        []
+      isos = Array(members_by_type['Spree::Country']).filter_map do |member|
+        connection.select_value("SELECT iso FROM spree_countries WHERE id = #{connection.quote(member.zoneable_id)}")
       end
-    end
-
-    def country_ids=(ids)
-      set_zone_members(ids, 'Spree::Country')
-    end
-
-    def state_ids=(ids)
-      set_zone_members(ids, 'Spree::State')
-    end
-
-    # Indicates whether the specified zone falls entirely within the zone performing
-    # the check.
-    def contains?(target)
-      return false if state? && target.country?
-      return false if zone_members.empty? || target.zone_members.empty?
-
-      if kind == target.kind
-        if state?
-          return false if (target.states.pluck(:id) - states.pluck(:id)).present?
-        elsif country?
-          return false if (target.countries.pluck(:id) - countries.pluck(:id)).present?
-        end
-      else
-        return false if (target.states.pluck(:country_id) - countries.pluck(:id)).present?
+      isos += Array(members_by_type['Spree::State']).filter_map do |member|
+        connection.select_value(<<~SQL.squish)
+          SELECT spree_countries.iso
+          FROM spree_states
+          INNER JOIN spree_countries ON spree_countries.id = spree_states.country_id
+          WHERE spree_states.id = #{connection.quote(member.zoneable_id)}
+        SQL
       end
-      true
-    end
-
-    def state_list
-      case kind
-      when 'country'
-        zoneables.map(&:states)
-      when 'state'
-        zoneables
-      end.flatten.compact.uniq
-    end
-
-    def state_list_for(country)
-      state_list.select { |state| state.country == country }
-    end
 
-    private
-
-    def remove_defunct_members
-      zone_members.defunct_without_kind(kind).destroy_all if zone_members.any?
-    end
-
-    def remove_previous_default
-      Spree::Zone.with_default_tax.where.not(id: id).update_all(default_tax: false)
+      isos.uniq.filter_map { |iso| Spree::Country.by_iso(iso) }
     end
-
-    def set_zone_members(ids, type)
-      zone_members.destroy_all
-      ids.reject(&:blank?).map do |id|
-        member = ZoneMember.new
-        member.zoneable_type = type
-        member.zoneable_id = id
-        members << member
-      end
-    end
-
   end
 end

data/app/models/spree/zone_member.rb

@@ -1,13 +1,10 @@
 module Spree
+  # Migration-only shell, removed in Spree 6.1 with {Spree::Zone}.
   class ZoneMember < Spree.base_class
-    belongs_to :zone, class_name: 'Spree::Zone', counter_cache: true, inverse_of: :zone_members
-    belongs_to :zoneable, polymorphic: true
+    # No zoneable association: countries and states are reference data in 6.0,
+    # so the type and id columns are plain values resolved against the legacy
+    # tables by the data-migration tasks.
+    belongs_to :zone, class_name: 'Spree::Zone', inverse_of: :zone_members
 
-    validates :zone, :zoneable, presence: true
-    validates :zoneable_id, uniqueness: { scope: spree_base_uniqueness_scope + [:zone_id, :zoneable_type] }
-
-    scope :defunct_without_kind, ->(kind) do
-      where('zoneable_id IS NULL OR zoneable_type != ?', "Spree::#{kind.classify}")
-    end
   end
 end

data/app/presenters/spree/csv/custom_fields_helper.rb

@@ -0,0 +1,25 @@
+module Spree
+  module CSV
+    module CustomFieldsHelper
+      private
+
+      # The store the export runs for decides the schema. Its header row comes
+      # from the same store's definitions, so reading any other store's here
+      # would shift every value column.
+      def custom_field_definitions_for_csv(resource, store)
+        # No store means no schema to read, so the row carries the base columns
+        # only — matching what the header row does in the same situation,
+        # rather than raising on nil halfway through a file.
+        return Spree::CustomFieldDefinition.none if store.nil?
+
+        store.custom_field_definitions.for_resource_type(resource.class.to_s).order(:namespace, :key)
+      end
+
+      def custom_fields_for_csv(resource, store)
+        custom_field_definitions_for_csv(resource, store).map do |definition|
+          resource.custom_fields.find { |custom_field| custom_field.custom_field_definition_id == definition.id }&.csv_value
+        end
+      end
+    end
+  end
+end

data/app/presenters/spree/csv/customer_presenter.rb

@@ -1,7 +1,7 @@
 module Spree
   module CSV
     class CustomerPresenter
-      include Spree::CSV::MetafieldsHelper
+      include Spree::CSV::CustomFieldsHelper
 
       HEADERS = [
         'First Name',
@@ -23,11 +23,12 @@ module Spree
         'Tags'
       ].freeze
 
-      def initialize(customer)
+      def initialize(customer, store)
         @customer = customer
+        @store = store
       end
 
-      attr_accessor :customer
+      attr_accessor :customer, :store
 
       def call
         csv = [
@@ -40,17 +41,17 @@ module Spree
           customer.address&.address2,
           customer.address&.city,
           customer.address&.state_text,
-          customer.address&.state_abbr,
+          customer.address&.state_code,
           customer.address&.country&.name,
           customer.address&.country&.iso,
-          customer.address&.zipcode,
+          customer.address&.postal_code,
           customer.phone,
           customer.amount_spent_in(Spree::Store.current.default_currency),
           customer.completed_orders.count,
           customer.tag_list
         ]
 
-        csv += metafields_for_csv(customer)
+        csv += custom_fields_for_csv(customer, store)
 
         csv
       end

data/app/presenters/spree/csv/gift_card_presenter.rb

@@ -1,7 +1,7 @@
 module Spree
   module CSV
     class GiftCardPresenter
-      include Spree::CSV::MetafieldsHelper
+      include Spree::CSV::CustomFieldsHelper
 
       HEADERS = [
         'Code',
@@ -18,11 +18,12 @@ module Spree
         'Updated At'
       ].freeze
 
-      def initialize(gift_card)
+      def initialize(gift_card, store)
         @gift_card = gift_card
+        @store = store
       end
 
-      attr_accessor :gift_card
+      attr_accessor :gift_card, :store
 
       def call
         csv = [
@@ -31,16 +32,16 @@ module Spree
           gift_card.display_amount_used,
           gift_card.display_amount_remaining,
           gift_card.currency,
-          gift_card.display_state,
+          gift_card.display_status,
           gift_card.expires_at&.strftime('%Y-%m-%d'),
-          gift_card.user&.email,
-          gift_card.user&.first_name,
-          gift_card.user&.last_name,
+          gift_card.customer&.email,
+          gift_card.customer&.first_name,
+          gift_card.customer&.last_name,
           gift_card.created_at&.strftime('%Y-%m-%d %H:%M:%S'),
           gift_card.updated_at&.strftime('%Y-%m-%d %H:%M:%S')
         ]
 
-        csv += metafields_for_csv(gift_card)
+        csv += custom_fields_for_csv(gift_card, store)
 
         csv
       end

data/app/presenters/spree/csv/newsletter_subscriber_presenter.rb

@@ -1,7 +1,7 @@
 module Spree
   module CSV
     class NewsletterSubscriberPresenter
-      include Spree::CSV::MetafieldsHelper
+      include Spree::CSV::CustomFieldsHelper
 
       HEADERS = [
         'Email',
@@ -13,24 +13,25 @@ module Spree
         'Updated At'
       ].freeze
 
-      def initialize(newsletter_subscriber)
+      def initialize(newsletter_subscriber, store)
         @newsletter_subscriber = newsletter_subscriber
+        @store = store
       end
 
-      attr_accessor :newsletter_subscriber
+      attr_accessor :newsletter_subscriber, :store
 
       def call
         csv = [
           newsletter_subscriber.email,
-          newsletter_subscriber.user&.full_name,
-          newsletter_subscriber.user_id,
+          newsletter_subscriber.customer&.full_name,
+          newsletter_subscriber.customer_id,
           newsletter_subscriber.verified? ? Spree.t(:say_yes) : Spree.t(:say_no),
           newsletter_subscriber.verified_at,
           newsletter_subscriber.created_at,
           newsletter_subscriber.updated_at
         ]
 
-        csv += metafields_for_csv(newsletter_subscriber)
+        csv += custom_fields_for_csv(newsletter_subscriber, store)
 
         csv
       end