spree_core 6.0.0.beta4 → 6.0.0.rc1

data/app/models/spree/store_credit_event.rb

@@ -24,15 +24,15 @@ module Spree
     def display_action
       case action
       when Spree::StoreCredit::CAPTURE_ACTION
-        Spree.t('store_credit.captured')
+        I18n.t('spree.store_credit.captured')
       when Spree::StoreCredit::AUTHORIZE_ACTION
-        Spree.t('store_credit.authorized')
+        I18n.t('spree.store_credit.authorized')
       when Spree::StoreCredit::ALLOCATION_ACTION
-        Spree.t('store_credit.allocated')
+        I18n.t('spree.store_credit.allocated')
       when Spree::StoreCredit::ELIGIBLE_ACTION
-        Spree.t('store_credit.eligible')
+        I18n.t('spree.store_credit.eligible')
       when Spree::StoreCredit::VOID_ACTION, Spree::StoreCredit::CREDIT_ACTION
-        Spree.t('store_credit.credit')
+        I18n.t('spree.store_credit.credit')
       end
     end
 

data/app/models/spree/tax_exemption_certificate.rb

@@ -9,6 +9,8 @@ module Spree
   # valid in one state and not the next is the ordinary case, and the country
   # and state columns say exactly where it holds.
   class TaxExemptionCertificate < Spree.base_class
+    publishes_event :verified
+
     has_prefix_id :cert
 
     include Spree::HasStatus

data/app/models/spree/tax_identifier.rb

@@ -36,6 +36,8 @@ module Spree
   # directly. It is a habit of the gems that use it, not a rule this model
   # applies.
   class TaxIdentifier < Spree.base_class
+    publishes_event :number_changed
+
     has_prefix_id :txi
 
     # Statuses the platform records rather than the buyer chooses: nil means
@@ -150,7 +152,7 @@ module Spree
     # The kind as the dashboard shows it, falling back to the raw key so an
     # extension's kind reads as itself rather than blank.
     def kind_label
-      Spree.t("tax_identifier_kinds.#{kind}", default: kind.to_s.humanize)
+      I18n.t("spree.tax_identifier_kinds.#{kind}", default: kind.to_s.humanize)
     end
 
     # The class registered for this kind, or nil when nothing is registered and

data/app/models/spree/tax_line.rb

@@ -4,6 +4,11 @@ module Spree
   # per estimate. Snapshot columns (+rate+, +label+, +provider_id+) keep rows
   # self-describing after a TaxRate is deleted or when an external provider
   # computed them.
+  #
+  # Rows on a return, claim or exchange line are post-sale: the tax given back
+  # (+credit+), or the tax on an exchange's replacement. They are owned by the
+  # order like every other row but never count towards its totals — the order
+  # reads only {.sale} rows.
   class TaxLine < Spree.base_class
     include Spree::TypedAdjustmentLine
 
@@ -35,6 +40,13 @@ module Spree
     belongs_to :line_item, class_name: 'Spree::LineItem', optional: true
     belongs_to :fulfillment, class_name: 'Spree::Fulfillment', optional: true
     belongs_to :fee, class_name: 'Spree::Fee', optional: true
+    belongs_to :return_line_item, class_name: 'Spree::ReturnLineItem', optional: true
+    belongs_to :claim_line_item, class_name: 'Spree::ClaimLineItem', optional: true
+    belongs_to :exchange_line_item, class_name: 'Spree::ExchangeLineItem', optional: true
+
+    # The sale row a credit gives back — what caps repeated credits against one
+    # line, and the original a credit note refers to.
+    belongs_to :original_tax_line, class_name: 'Spree::TaxLine', optional: true
 
     # Tax included in price vs additional. Per-row (mixed regimes on one order).
     attribute :included, :boolean, default: false
@@ -46,20 +58,50 @@ module Spree
               inclusion: { in: ->(tax_line) { tax_line.class.taxability_reasons } },
               allow_nil: true
     validate :exactly_one_adjustable
+    validate :post_sale_owned_by_order
 
     # Tax reporting is the reason the treatment columns exist — "which country's
     # tax was this, and which sales were reverse-charged" has to be answerable.
     self.whitelisted_ransackable_attributes = %w[taxability_reason country_code state_code included provider_id]
 
+    POST_SALE_KEYS = %i[return_line_item_id claim_line_item_id exchange_line_item_id].freeze
+
+    ADJUSTABLE_KEYS = {
+      'Spree::LineItem' => :line_item_id,
+      'Spree::Fulfillment' => :fulfillment_id,
+      'Spree::Fee' => :fee_id,
+      'Spree::ReturnLineItem' => :return_line_item_id,
+      'Spree::ClaimLineItem' => :claim_line_item_id,
+      'Spree::ExchangeLineItem' => :exchange_line_item_id
+    }.freeze
+
     scope :included_in_price, -> { where(included: true) }
     scope :additional, -> { where(included: false) }
     scope :for_line_items, -> { where.not(line_item_id: nil) }
     scope :for_fulfillments, -> { where.not(fulfillment_id: nil) }
     scope :for_fees, -> { where.not(fee_id: nil) }
+    scope :sale, -> { where(POST_SALE_KEYS.index_with(nil)) }
+    scope :post_sale, -> { where.not(POST_SALE_KEYS.index_with(nil)) }
+    scope :credits, -> { where(credit: true) }
+    scope :charges, -> { where(credit: false) }
+
+    # The foreign key a row uses to point at an item of this class.
+    #
+    # @param klass [Class]
+    # @return [Symbol]
+    # @raise [ArgumentError] for a class that is not taxed
+    def self.adjustable_key_for(klass)
+      ADJUSTABLE_KEYS.fetch(klass.name) { raise ArgumentError, "#{klass} is not taxable" }
+    end
 
-    # @return [Spree::LineItem, Spree::Fulfillment, Spree::Fee, nil]
+    # @return [Spree::LineItem, Spree::Fulfillment, Spree::Fee, Spree::ReturnLineItem,
+    #   Spree::ClaimLineItem, Spree::ExchangeLineItem, nil]
     def adjustable
-      line_item || fulfillment || fee
+      line_item || fulfillment || fee || return_line_item || claim_line_item || exchange_line_item
+    end
+
+    def post_sale?
+      POST_SALE_KEYS.any? { |key| self[key].present? }
     end
 
     def included?
@@ -73,7 +115,15 @@ module Spree
     private
 
     def exactly_one_adjustable
-      errors.add(:base, :exactly_one_adjustable, message: Spree.t('errors.messages.exactly_one_adjustable')) unless [line_item, fulfillment, fee].compact.one?
+      adjustables = [line_item, fulfillment, fee, return_line_item, claim_line_item, exchange_line_item]
+      errors.add(:base, :exactly_one_adjustable, message: I18n.t('spree.errors.messages.exactly_one_adjustable')) unless adjustables.compact.one?
+    end
+
+    # Returns, claims and exchanges only exist on placed orders.
+    def post_sale_owned_by_order
+      return unless post_sale? && order.nil?
+
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order'))
     end
   end
 end

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

@@ -3,12 +3,16 @@ module Spree
     # Contract for tax providers — the only sanctioned writers of
     # {Spree::TaxLine} rows. +estimate+ must use replace-all set semantics per
     # target item (delete the item's stale lines, insert fresh ones); that is
-    # what keeps tax correct after address or item changes. Commit/void/refund
-    # are lifecycle no-ops for providers without a remote ledger.
+    # what keeps tax correct after address or item changes, and the post-sale
+    # +estimate_refund+ / +estimate_replacement+ follow the same rule.
+    # Commit/void/refund/commit_replacement are lifecycle no-ops for providers
+    # without a remote ledger.
     #
     # Providers are stateless and constructed without arguments, so anything
     # request-specific arrives as an argument rather than through the instance.
     class Base
+      extend Spree::ApiTyped
+
       # Domains this provider cannot handle, so a merchant is warned when
       # pairing it with a market instead of silently under-collecting. Declared
       # on the class because core reads it while presenting the choice, before
@@ -47,8 +51,8 @@ module Spree
         unsupported_capabilities.map do |capability|
           {
             key: capability.to_s,
-            label: Spree.t("tax_capabilities.#{capability}.label", default: capability.to_s.humanize),
-            description: Spree.t("tax_capabilities.#{capability}.description", default: nil)
+            label: I18n.t("spree.tax_capabilities.#{capability}.label", default: capability.to_s.humanize),
+            description: I18n.t("spree.tax_capabilities.#{capability}.description", default: nil)
           }.compact
         end
       end
@@ -61,7 +65,7 @@ module Spree
       # @return [Hash]
       def self.to_api_hash(store)
         {
-          id: name,
+          id: api_type,
           name: display_name,
           available: available_for_store?(store),
           unsupported_capabilities: unsupported_capability_details,
@@ -128,19 +132,72 @@ module Spree
         nil
       end
 
+      # Works out the tax given back on lines of a return, claim or exchange,
+      # and writes it as credit TaxLine rows on them. The customer is refunded
+      # exactly what these rows hold, so this — not +refund+ — decides the
+      # figure.
+      #
+      # Each item credits its +credited_quantity+, and zero means no rows.
+      # Replace-all per item, as +estimate+: the rows are rewritten when the
+      # warehouse counts what arrived and again when the money goes back.
+      #
+      # A provider may quote the credit, for example at the original
+      # +tax_date+, or give back the recorded share of what the sale charged —
+      # {Spree::TaxProvider::RecordedShare}, which Internal uses. Either way
+      # it answers in the same rows.
+      #
+      # @param order [Spree::Order] a placed order
+      # @param items [Array<Spree::ReturnLineItem, Spree::ClaimLineItem, Spree::ExchangeLineItem>]
+      # @param amounts [Hash{Object => BigDecimal}, nil] the money refunded per
+      #   item when it is less than the item's worth — a restocking fee, a
+      #   part refund. Tax is then credited in the same proportion. Nil
+      #   credits every item's full worth.
+      # @param tax_date [Time, nil] the date whose rates apply; nil = order.completed_at
+      # @return [void]
+      # @raise [Spree::Tax::ProviderError] when the credit could not be worked out
+      def estimate_refund(order, items, amounts: nil, tax_date: nil)
+        raise NotImplementedError, "Please implement 'estimate_refund' in your tax provider: #{self.class.name}"
+      end
+
+      # Taxes the replacement an exchange sends out, as a new sale, and writes
+      # it as charge TaxLine rows on the exchange lines. Never touches the
+      # order's own rows, which stay as the sale was placed. Replace-all per
+      # item; each item is taxed on its +taxable_basis+ under its
+      # +tax_category_id+, and one whose +credited_quantity+ is zero ships
+      # nothing and ends with no rows.
+      #
+      # @param order [Spree::Order] a placed order
+      # @param items [Array<Spree::ExchangeLineItem>]
+      # @param tax_date [Time, nil] date whose rates apply; nil = now
+      # @param tax_identifier [Spree::TaxIdentifier, nil] the order's frozen registration
+      # @param exemptions [Array] exemption evidence to apply
+      # @return [void]
+      # @raise [Spree::Tax::ProviderError] when the tax could not be worked out
+      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [])
+        raise NotImplementedError, "Please implement 'estimate_replacement' in your tax provider: #{self.class.name}"
+      end
+
+      # Files an exchange's replacement as a sale. Called once the exchange is
+      # fulfilled; must be idempotent, keyed on the exchange. No-op for a
+      # provider without a remote ledger.
+      #
+      # @param order [Spree::Order]
+      # @param items [Array<Spree::ExchangeLineItem>]
+      # @return [void]
+      def commit_replacement(order, items); end
+
       # Reports a partial credit against the committed document, keyed to the
-      # original transaction rather than voiding and re-committing it.
+      # original transaction rather than voiding and re-committing it. Called
+      # after the money has moved.
       #
-      # +amount+ is what the customer was actually refunded, which is not always
-      # the returned lines' worth: an admin may keep a restocking fee or refund
-      # a goodwill figure of their own. A provider must credit no more tax than
-      # that refund carries — crediting every returned line when only part of
-      # their value went back would reclaim tax the merchant never repaid, and a
-      # return is marked refunded once, so nothing later corrects it. Where the
-      # amount is short, allocate proportionally.
+      # By then each item's credit rows hold what went back (see
+      # +estimate_refund+), and a provider must credit no more than they do:
+      # the customer was repaid that tax and no more. +amount+ is the money
+      # refunded, which may be less than the items are worth when an admin kept
+      # a restocking fee or refunded a goodwill figure of their own.
       #
       # @param order [Spree::Order]
-      # @param return_items [Array<Spree::ReturnLineItem>] the returned lines
+      # @param return_items [Array<Spree::ReturnLineItem, Spree::ClaimLineItem, Spree::ExchangeLineItem>]
       # @param amount [BigDecimal, nil] the refund issued; nil = the lines' full worth
       # @param tax_date [Time, nil] the original supply date; nil = order.completed_at
       # @return [void]

data/app/models/spree/tax_provider/internal.rb

@@ -30,40 +30,43 @@ module Spree
         sweep_internal_duty_tax_lines(owner) if full_estimate
         return if items.empty?
 
-        rates = Spree::TaxRate.for_store(owner.store).for_jurisdiction(owner.tax_country&.iso, owner.tax_address&.state_code).to_a
+        rates = rates_for(owner)
 
         items.group_by(&:class).each do |klass, group|
           # Replace-all set semantics per estimate: stale lines die with the
           # address/items change that triggered the re-estimate.
-          Spree::TaxLine.where(tax_line_foreign_key(klass) => group.map(&:id)).delete_all
+          Spree::TaxLine.where(Spree::TaxLine.adjustable_key_for(klass) => group.map(&:id)).delete_all
         end
 
+        items.each { |item| tax_item(owner, item, rates, exemptions) }
+      end
+
+      # Gives back each credited unit's share of the TaxLines the sale actually
+      # charged (see Spree::TaxProvider::RecordedShare). TaxRate rows are not
+      # versioned, so this engine can never recompute at a past date —
+      # +tax_date+ is accepted and ignored, and the rows are the only record
+      # of what the customer paid.
+      def estimate_refund(order, items, amounts: nil, tax_date: nil)
+        Spree::TaxProvider::RecordedShare.new(order: order, items: items, amounts: amounts).call
+      end
+
+      # Taxed like any line of the order, under the replacement's own category
+      # and at the order's tax address. +tax_date+ is ignored for the reason
+      # given on #estimate.
+      #
+      # An exemption is read as it applied to the line being replaced: a
+      # certificate's per-line carve-out names that line, and the exchange line
+      # replacing it would otherwise match no carve-out and come out exempt.
+      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [])
+        return if items.empty?
+
+        Spree::TaxLine.charges.where(exchange_line_item_id: items.map(&:id)).delete_all
+
+        rates = rates_for(order)
         items.each do |item|
-          relevant_rates = rates.select { |rate| rate.tax_category_id == tax_category_id_for(item, owner) }
-
-          # A matched rate always produces a row, zero-amount ones included:
-          # a zero rate is a treatment ("this is zero-rated"), which reporting
-          # and e-invoicing both need to see. No matched rate means no opinion,
-          # and writes nothing.
-          taxed = relevant_rates.map do |rate|
-            jurisdiction = jurisdiction_for(rate, owner)
-            [rate, jurisdiction, exemption_for(item, exemptions, jurisdiction)]
-          end
+          next unless item.credited_quantity.to_i.positive?
 
-          # An exempt item has no tax to back out of its price, so its whole
-          # basis is pre-tax.
-          exempt_rates = taxed.select { |_rate, _jurisdiction, exemption| exemption }.map(&:first)
-          store_pre_tax_amount(item, relevant_rates - exempt_rates)
-
-          taxed.each do |rate, jurisdiction, exemption|
-            if exemption
-              write_tax_line(owner, item, rate, 0, 'customer_exempt', jurisdiction,
-                             data: exemption_data(exemption, item))
-            else
-              write_tax_line(owner, item, rate, compute_tax(rate, item, relevant_rates),
-                             reason_for(rate), jurisdiction)
-            end
-          end
+          tax_item(order, item, rates, exemptions, exemption_subject: item.line_item || item)
         end
       end
 
@@ -107,12 +110,35 @@ module Spree
         owner.tax_lines.where(fee_id: duty_fee_ids, provider_id: 'internal').delete_all
       end
 
-      def tax_line_foreign_key(klass)
-        case klass.name
-        when 'Spree::LineItem' then :line_item_id
-        when 'Spree::Fulfillment' then :fulfillment_id
-        when 'Spree::Fee' then :fee_id
-        else raise ArgumentError, "#{klass} is not taxable"
+      def rates_for(owner)
+        Spree::TaxRate.for_store(owner.store).for_jurisdiction(owner.tax_country&.iso, owner.tax_address&.state_code).to_a
+      end
+
+      def tax_item(owner, item, rates, exemptions, exemption_subject: item)
+        relevant_rates = rates.select { |rate| rate.tax_category_id == tax_category_id_for(item, owner) }
+
+        # A matched rate always produces a row, zero-amount ones included:
+        # a zero rate is a treatment ("this is zero-rated"), which reporting
+        # and e-invoicing both need to see. No matched rate means no opinion,
+        # and writes nothing.
+        taxed = relevant_rates.map do |rate|
+          jurisdiction = jurisdiction_for(rate, owner)
+          [rate, jurisdiction, exemption_for(exemption_subject, exemptions, jurisdiction)]
+        end
+
+        # An exempt item has no tax to back out of its price, so its whole
+        # basis is pre-tax.
+        exempt_rates = taxed.select { |_rate, _jurisdiction, exemption| exemption }.map(&:first)
+        store_pre_tax_amount(item, relevant_rates - exempt_rates)
+
+        taxed.each do |rate, jurisdiction, exemption|
+          if exemption
+            write_tax_line(owner, item, rate, 0, 'customer_exempt', jurisdiction,
+                           data: exemption_data(exemption, exemption_subject))
+          else
+            write_tax_line(owner, item, rate, compute_tax(rate, item, relevant_rates),
+                           reason_for(rate), jurisdiction)
+          end
         end
       end
 
@@ -209,7 +235,7 @@ module Spree
         owner_key = owner.is_a?(Spree::Order) ? :order : :cart
         Spree::TaxLine.create!(
           {
-            tax_line_foreign_key(item.class) => item.id,
+            Spree::TaxLine.adjustable_key_for(item.class) => item.id,
             owner_key => owner,
             tax_rate: rate,
             amount: amount,

data/app/models/spree/tax_provider/recorded_share.rb

@@ -0,0 +1,114 @@
+module Spree
+  module TaxProvider
+    # The tax a return, claim or exchange line gives back, read off what the
+    # sale actually charged: each credited unit's part of every TaxLine on the
+    # original line, row by row.
+    #
+    # Read from the rows rather than recomputed from TaxRate configuration,
+    # because the customer is owed back what they paid. Rates are not
+    # versioned, so a rate edited since the sale would otherwise refund a
+    # figure nobody was charged.
+    #
+    # Internal's answer to +estimate_refund+. Public so any other provider can
+    # answer with it too, rather than quoting the credit itself.
+    class RecordedShare
+      # @param order [Spree::Order]
+      # @param items [Array<Spree::ReturnLineItem, Spree::ClaimLineItem, Spree::ExchangeLineItem>]
+      # @param amounts [Hash{Object => BigDecimal}, nil] see Base#estimate_refund
+      def initialize(order:, items:, amounts: nil)
+        @order = order
+        @items = Array(items)
+        @amounts = amounts
+      end
+
+      # Replaces each item's credit rows.
+      #
+      # @return [void]
+      def call
+        items.each do |item|
+          key = Spree::TaxLine.adjustable_key_for(item.class)
+          Spree::TaxLine.credits.where(key => item.id).delete_all
+          credit(item, key)
+        end
+      end
+
+      private
+
+      attr_reader :order, :items, :amounts
+
+      def credit(item, key)
+        share = share_of_line(item)
+        return if share.zero?
+
+        sources = item.line_item.tax_lines.order(:id).to_a
+        sources.zip(shares_for(sources, share)).each do |source, cents|
+          write(item, key, source, cents)
+        end
+      end
+
+      # The part of the original line this item gives back: its credited units,
+      # and of those only the share of their worth the customer is refunded.
+      def share_of_line(item)
+        quantity = item.line_item&.quantity.to_i
+        units = item.credited_quantity.to_i
+        return 0 if quantity.zero? || units.zero?
+
+        Rational(units, quantity) * refunded_fraction(item)
+      end
+
+      def refunded_fraction(item)
+        return 1 if amounts.nil?
+
+        worth = item.credited_worth.to_d
+        return 0 unless worth.positive?
+
+        [Rational(amounts.fetch(item, 0).to_d) / Rational(worth), 1].min
+      end
+
+      # The rows' total share rounded once, then divided by largest remainder,
+      # so the credit lands on the cent and each rate keeps its part of it. A
+      # row is never credited past what earlier credits left of it, or three
+      # single-unit returns of one line could give back a cent more than it
+      # charged.
+      def shares_for(sources, share)
+        weights = sources.map { |source| to_minor_units(source.amount) }
+        return Array.new(sources.size, 0) if weights.sum.zero?
+
+        target = (Rational(weights.sum) * share).round(half: :up)
+        allotted = Spree::Adjusters::LargestRemainder.largest_remainder_shares(target, weights)
+
+        sources.zip(allotted).map { |source, cents| [cents, remaining_cents(source)].min }
+      end
+
+      def remaining_cents(source)
+        credited = Spree::TaxLine.credits.where(original_tax_line_id: source.id).sum(:amount)
+        [to_minor_units(source.amount) - to_minor_units(credited), 0].max
+      end
+
+      # Zero-amount rows are copied too: a zero-rated or exempt sale is a
+      # treatment the credit note has to repeat.
+      def write(item, key, source, cents)
+        Spree::TaxLine.create!(
+          key => item.id,
+          order: order,
+          credit: true,
+          original_tax_line: source,
+          tax_rate_id: source.tax_rate_id,
+          amount: Spree::Money::Rounding.from_minor_units(cents, order.currency),
+          rate: source.rate,
+          label: source.label,
+          included: source.included,
+          provider_id: source.provider_id,
+          taxability_reason: source.taxability_reason,
+          country_code: source.country_code,
+          state_code: source.state_code,
+          data: source.data
+        )
+      end
+
+      def to_minor_units(amount)
+        Spree::Money::Rounding.to_minor_units(amount, order.currency)
+      end
+    end
+  end
+end

data/app/models/spree/tax_rate.rb

@@ -100,8 +100,7 @@ module Spree
     #
     # @return [String]
     def adjustment_label
-      Spree.t included_in_price? ? :including_tax : :excluding_tax,
-              scope: 'adjustment_labels.tax_rates',
+      I18n.t "spree.adjustment_labels.tax_rates.#{included_in_price? ? :including_tax : :excluding_tax}",
               name: name.presence || tax_category.name,
               amount: amount_for_label
     end

data/app/models/spree/taxonomy.rb

@@ -12,7 +12,6 @@ module Spree
 
     has_many :taxons, class_name: 'Spree::Category', inverse_of: :taxonomy
     has_one :root, -> { where parent_id: nil }, class_name: 'Spree::Category', dependent: :destroy
-    belongs_to :store, class_name: 'Spree::Store'
 
     default_scope { order("#{table_name}.position, #{table_name}.created_at") }
   end

data/app/models/spree/variant.rb

@@ -231,6 +231,10 @@ module Spree
 
     scope :not_deleted, -> { where("#{Spree::Variant.quoted_table_name}.deleted_at IS NULL") }
 
+    # The variants of a product relation, as a subquery. Unordered, because a
+    # listing's sort would otherwise land inside the IN.
+    scope :for_products, ->(products) { where(product_id: products.reorder(nil).select(Spree::Product.arel_table[:id])) }
+
     # Variants the shop sells in this currency. Base prices only: a price
     # list's rows are what one audience pays under an agreement, and a ladder
     # holds several rows for one variant, so a contract-only variant is not
@@ -285,9 +289,6 @@ module Spree
       relation.where(conditions.reduce(:or)).distinct
     end
 
-    # Backward compatibility alias — remove in Spree 6.0
-    scope :multi_search, ->(*args) { search(*args) }
-
     # FIXME: cost price should be represented with DisplayMoney class
     LOCALIZED_NUMBERS = %w(cost_price weight depth width height)
 

data/app/models/spree/variant_media.rb

@@ -35,7 +35,7 @@ module Spree
       return if asset.product&.id == variant.product_id
 
       errors.add(:asset, :variant_product_mismatch,
-                 message: Spree.t('errors.messages.variant_product_mismatch'))
+                 message: I18n.t('spree.errors.messages.variant_product_mismatch'))
     end
 
     def refresh_variant_thumbnail

data/app/models/spree/webhook_endpoint.rb

@@ -13,7 +13,6 @@ module Spree
 
     encrypts :secret_key, deterministic: true if Rails.configuration.active_record.encryption.include?(:primary_key)
 
-    belongs_to :store, class_name: 'Spree::Store'
     has_many :webhook_deliveries, class_name: 'Spree::WebhookDelivery', dependent: :destroy_async
 
     validates :url, presence: true
@@ -50,18 +49,16 @@ module Spree
     # Number of consecutive failed deliveries before auto-disabling
     AUTO_DISABLE_THRESHOLD = 15
 
-    # Events whose payload carries a live customer credential (a password
-    # reset token). Receiving one is as good as holding the customer's account,
-    # so they reach only an endpoint that names them — never through `*` or a
-    # pattern — and the API asks for customer write access to point one at them.
-    CREDENTIAL_EVENTS = %w[customer.password_reset_requested].freeze
-
-    # Check if this endpoint is subscribed to a specific event
+    # Check if this endpoint is subscribed to a specific event.
+    #
+    # Events whose payload carries a live credential (a password reset token)
+    # reach only an endpoint that names them — never through `*` or a pattern —
+    # since receiving one is as good as holding the account.
     #
     # @param event_name [String] the event name to check
     # @return [Boolean]
     def subscribed_to?(event_name)
-      return subscriptions.to_a.include?(event_name) if CREDENTIAL_EVENTS.include?(event_name)
+      return subscriptions.to_a.include?(event_name) if Spree::Events.catalog.credential?(event_name)
       return true if subscriptions.blank? || subscriptions.include?('*')
 
       subscriptions.any? do |subscription|
@@ -74,11 +71,11 @@ module Spree
       end
     end
 
-    # Whether this endpoint receives customer credentials.
+    # The credential-carrying events this endpoint names.
     #
-    # @return [Boolean]
-    def receives_credentials?
-      (subscriptions.to_a & CREDENTIAL_EVENTS).any?
+    # @return [Array<Spree::Events::Catalog::Entry>]
+    def credential_subscriptions
+      Spree::Events.catalog.credential_events(subscriptions.to_a)
     end
 
     # Returns all events this endpoint is subscribed to

data/app/models/spree/wishlist.rb

@@ -6,15 +6,10 @@ module Spree
 
     publishes_lifecycle_events
 
-    if Rails::VERSION::STRING >= '7.1.0'
-      has_secure_token on: :save
-    else
-      has_secure_token
-    end
+    has_secure_token on: :save
 
     belongs_to :customer, class_name: "::#{Spree.customer_class}", touch: true
     include Spree::DeprecatedCustomerAlias
-    belongs_to :store, class_name: 'Spree::Store'
 
     has_many :wishlist_items, class_name: 'Spree::WishlistItem', dependent: :destroy
     has_many :wished_items, class_name: 'Spree::WishlistItem', inverse_of: :wishlist, deprecated: true

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

@@ -11,6 +11,12 @@ module Spree
       LEGACY_EVENT_PREFIX = 'wished_item'
       LEGACY_EVENT_SUFFIXES = %w[created updated deleted].freeze
 
+      def self.included(base)
+        LEGACY_EVENT_SUFFIXES.each do |suffix|
+          base.publishes_event("#{LEGACY_EVENT_PREFIX}.#{suffix}", deprecated_alias_of: "#{base.event_prefix}.#{suffix}")
+        end
+      end
+
       # 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

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

@@ -35,7 +35,7 @@ module Spree
           customer.first_name,
           customer.last_name,
           customer.email,
-          customer.accepts_email_marketing ? Spree.t(:say_yes) : Spree.t(:say_no),
+          customer.accepts_email_marketing ? I18n.t('spree.say_yes') : I18n.t('spree.say_no'),
           customer.address&.company,
           customer.address&.address1,
           customer.address&.address2,

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

@@ -25,7 +25,7 @@ module Spree
           newsletter_subscriber.email,
           newsletter_subscriber.customer&.full_name,
           newsletter_subscriber.customer_id,
-          newsletter_subscriber.verified? ? Spree.t(:say_yes) : Spree.t(:say_no),
+          newsletter_subscriber.verified? ? I18n.t('spree.say_yes') : I18n.t('spree.say_no'),
           newsletter_subscriber.verified_at,
           newsletter_subscriber.created_at,
           newsletter_subscriber.updated_at