spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/models/spree/delivery_method_rules/channel_rule.rb

@@ -13,11 +13,8 @@ module Spree
       # decodes them on write, so eligibility compares against raw
       # `channel_id` rows. The scope confines the existence check to the
       # method's store, so cross-store channel IDs can't sneak in.
-      preference :channel_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Channel,
-                   scope: ->(rule) { rule.store.channels }
-                 )
+      preference :channel_ids, :array, of: :id, model: 'Spree::Channel', default: [],
+                 scope: ->(rule) { rule.store.channels }
 
       def channels
         return [] if preferred_channel_ids.blank?

data/app/models/spree/delivery_method_rules/item_total_rule.rb

@@ -4,8 +4,8 @@ module Spree
     # owner's currency). Empty preferences pass — half-configured rules fail
     # open per-rule, matching the PromotionRule/PriceRule convention.
     class ItemTotalRule < Spree::DeliveryMethodRule
-      preference :minimum_amount, :decimal, default: nil, nullable: true
-      preference :maximum_amount, :decimal, default: nil, nullable: true
+      preference :minimum_amount, :money, default: nil, nullable: true
+      preference :maximum_amount, :money, default: nil, nullable: true
 
       def eligible?(package)
         total = package.item_total

data/app/models/spree/delivery_profile.rb

@@ -13,6 +13,7 @@ module Spree
     include Spree::HasListPosition
 
     has_prefix_id :fp
+    search_by :name
 
     acts_as_list scope: :store
 

data/app/models/spree/delivery_rate.rb

@@ -40,9 +40,8 @@ module Spree
 
       return price if tax_rate.nil? || tax_amount.zero? || !tax_rate.show_rate_in_label
 
-      Spree.t(
-        tax_rate.included_in_price? ? :including_tax : :excluding_tax,
-        scope: 'shipping_rates.display_price',
+      I18n.t(
+        "spree.shipping_rates.display_price.#{tax_rate.included_in_price? ? :including_tax : :excluding_tax}",
         price: price,
         tax_amount: display_tax_amount,
         tax_rate_name: tax_rate.name
@@ -81,9 +80,9 @@ module Spree
       @tax_amount ||= if tax_rate.nil?
                         BigDecimal(0)
                       elsif tax_rate.included_in_price?
-                        (cost / (1 + tax_rate.amount) * tax_rate.amount).round(2)
+                        Spree::Money::Rounding.to_currency(cost / (1 + tax_rate.amount) * tax_rate.amount, currency)
                       else
-                        (cost * tax_rate.amount).round(2)
+                        Spree::Money::Rounding.to_currency(cost * tax_rate.amount, currency)
                       end
     end
 
@@ -147,18 +146,18 @@ module Spree
     def display_delivery_range
       return unless delivery_range
 
-      Spree.t(:display_delivery_range, delivery_range: delivery_range)
+      I18n.t('spree.display_delivery_range', delivery_range: delivery_range)
     end
 
     private
 
     # What every money display on this rate reads instead of an amount.
     def quoted_after_review
-      Spree.t('delivery_rates.quoted_after_review')
+      I18n.t('spree.delivery_rates.quoted_after_review')
     end
 
     def discount_amount
-      fulfillment.discounts.promotion.sum(:amount)
+      fulfillment.promotion_discount_total
     end
   end
 end

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

@@ -13,6 +13,7 @@ module Spree
     # store integration — they never store credentials themselves.
     class Base
       include Spree::IntegrationBackedProvider
+      extend Spree::ApiTyped
 
       attr_reader :delivery_method
 

data/app/models/spree/delivery_zone.rb

@@ -8,7 +8,6 @@ module Spree
     # 2026-03-16 "Consolidate metadata") — write-only developer escape hatch.
     attribute :metadata, default: -> { {} }
 
-    belongs_to :store, class_name: 'Spree::Store'
     # Zones are destination sets owned by a delivery profile; within it they
     # hang off an origin group, so the same profile can quote different
     # tables per warehouse. The profile's methods bind to at most one zone.
@@ -34,7 +33,7 @@ module Spree
     validate :origin_group_must_belong_to_profile,
              if: -> { delivery_origin_group_id_changed? || delivery_profile_id_changed? }
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.whitelisted_ransackable_attributes = %w[name delivery_profile_id]
 
     # @param address [Spree::Address, nil]
     # @return [Boolean] whether any member of this zone matches the address

data/app/models/spree/delivery_zone_member.rb

@@ -78,21 +78,21 @@ module Spree
 
     def postal_definition
       if postal_code_prefix.present?
-        errors.add(:postal_code_prefix, :delivery_zone_prefix_and_range_exclusive, message: Spree.t('errors.messages.delivery_zone_prefix_and_range_exclusive')) if postal_range?
+        errors.add(:postal_code_prefix, :delivery_zone_prefix_and_range_exclusive, message: I18n.t('spree.errors.messages.delivery_zone_prefix_and_range_exclusive')) if postal_range?
         return
       end
 
       if postal_code_from.blank? || postal_code_to.blank?
-        errors.add(:base, :delivery_zone_postal_definition_required, message: Spree.t('errors.messages.delivery_zone_postal_definition_required'))
+        errors.add(:base, :delivery_zone_postal_definition_required, message: I18n.t('spree.errors.messages.delivery_zone_postal_definition_required'))
         return
       end
 
       unless country_code.present? && range_capable_country_codes.include?(country_code)
-        errors.add(:base, :delivery_zone_range_not_supported, message: Spree.t('errors.messages.delivery_zone_range_not_supported'))
+        errors.add(:base, :delivery_zone_range_not_supported, message: I18n.t('spree.errors.messages.delivery_zone_range_not_supported'))
         return
       end
 
-      errors.add(:postal_code_to, :delivery_zone_range_inverted, message: Spree.t('errors.messages.delivery_zone_range_inverted')) if postal_code_to < postal_code_from
+      errors.add(:postal_code_to, :delivery_zone_range_inverted, message: I18n.t('spree.errors.messages.delivery_zone_range_inverted')) if postal_code_to < postal_code_from
     end
   end
 end

data/app/models/spree/digital_asset.rb

@@ -5,6 +5,9 @@ module Spree
     has_prefix_id :dig
 
     publishes_lifecycle_events
+    publishes_event 'digital.created', deprecated_alias_of: 'digital_asset.created'
+    publishes_event 'digital.updated', deprecated_alias_of: 'digital_asset.updated'
+    publishes_event 'digital.deleted', deprecated_alias_of: 'digital_asset.deleted'
 
     # Provider config lives under one key in `metadata` so a provider owns its
     # own namespace without colliding with other developer metadata. The values
@@ -22,6 +25,10 @@ module Spree
     # and provider-backed assets (which carry no file) are exempt.
     DEFAULT_PROVIDER = 'Spree::DigitalAssetProvider::File'.freeze
 
+    # The API names a provider by its shorthand (`file`); the column keeps the
+    # class name.
+    normalizes :provider_type, with: ->(value) { Spree::ApiTyped.class_name_for(Spree.digital_asset_providers, value) }
+
     validate :provider_type_is_registered, if: -> { provider_type.present? }
     # Only ask a valid provider whether it needs a file — an unregistered
     # provider_type is already rejected above, and calling requires_attachment?

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

@@ -12,6 +12,8 @@ module Spree
     # into internal software and owns its own configuration. The base gives it
     # only the asset.
     class Base
+      extend Spree::ApiTyped
+
       attr_reader :digital_asset
 
       SETTING_TYPES = %i[string number boolean select].freeze

data/app/models/spree/digital_link.rb

@@ -3,12 +3,9 @@ module Spree
     has_prefix_id :dl  # Spree-specific: digital link
 
     publishes_lifecycle_events
+    publishes_event :downloaded
 
-    if Rails::VERSION::STRING >= '7.1.0'
-      has_secure_token on: :save
-    else
-      has_secure_token
-    end
+    has_secure_token on: :save
 
     if defined?(Spree::Security::DigitalLinks)
       include Spree::Security::DigitalLinks

data/app/models/spree/discount.rb

@@ -45,7 +45,7 @@ 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].compact.one?
+      errors.add(:base, :exactly_one_adjustable, message: I18n.t('spree.errors.messages.exactly_one_adjustable')) unless [line_item, fulfillment].compact.one?
     end
   end
 end

data/app/models/spree/email_template.rb

@@ -0,0 +1,25 @@
+module Spree
+  # A store's published version of an editable email template (an email, the
+  # layout or a shared partial). Found before the template file whenever a
+  # customer email renders, so it is what customers receive. Reverting marks it
+  # reverted rather than deleting it, so its revisions stay reachable.
+  class EmailTemplate < Spree.base_class
+    has_prefix_id :etpl
+
+    include Spree::EmailTemplateIdentity
+    include Spree::HasStatus
+    include Spree::ActedBy
+
+    has_status :published, :reverted, default: :published
+
+    publishes_events :published, :reverted
+
+    acted_by :published_by
+    acted_by :reverted_by
+
+    has_many :revisions, -> { order(created_at: :desc) }, class_name: 'Spree::EmailTemplateRevision',
+                                                           dependent: :destroy, inverse_of: :email_template
+
+    validates :published_at, presence: true
+  end
+end

data/app/models/spree/email_template_draft.rb

@@ -0,0 +1,13 @@
+module Spree
+  # Work in progress on an editable email template, one per store, template
+  # and language. Shared by every admin of the store: `lock_version` refuses a
+  # save made from a stale copy, and `updated_by` says who saved it last.
+  class EmailTemplateDraft < Spree.base_class
+    has_prefix_id :etdr
+
+    include Spree::EmailTemplateIdentity
+    include Spree::ActedBy
+
+    acted_by :updated_by
+  end
+end

data/app/models/spree/email_template_revision.rb

@@ -0,0 +1,17 @@
+module Spree
+  # One published version of a store's email template, kept so it can be
+  # restored. Append-only.
+  class EmailTemplateRevision < Spree.base_class
+    has_prefix_id :etrv
+
+    include Spree::ActedBy
+
+    belongs_to :email_template, class_name: 'Spree::EmailTemplate', inverse_of: :revisions
+
+    acted_by :published_by
+
+    validates :body, presence: true
+
+    delegate :store, :key, :locale, to: :email_template
+  end
+end

data/app/models/spree/email_templates/entry.rb

@@ -0,0 +1,118 @@
+module Spree
+  module EmailTemplates
+    # One editable email template for one store and language, as the editor
+    # shows it: what customers receive now, the draft in progress and
+    # Spree's default. For one language, Spree's translation keys are written
+    # out as text in it, so the merchant reads and edits plain words.
+    class Entry
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :definition
+      attribute :locale, :string, default: Spree::EmailTemplate::ANY_LOCALE
+      attribute :published
+      attribute :draft
+      attribute :customized_locales, default: -> { [] }
+
+      delegate :key, :kind, to: :definition
+
+      # @param store [Spree::Store]
+      # @param locale [String] a language code, or "any"
+      # @return [Array<Spree::EmailTemplates::Entry>] every editable template
+      def self.all(store, locale: Spree::EmailTemplate::ANY_LOCALE)
+        published = store.email_templates.published.where(locale: [locale, Spree::EmailTemplate::ANY_LOCALE]).
+                    sort_by { |template| template.locale == locale ? 0 : 1 }.uniq(&:key).index_by(&:key)
+        drafts = store.email_template_drafts.where(locale: locale).includes(:updated_by).index_by(&:key)
+        customized = store.email_templates.published.pluck(:key, :locale).group_by(&:first)
+
+        Spree.editable_email_templates.map do |definition|
+          new(definition: definition, locale: locale, published: published[definition.key], draft: drafts[definition.key],
+              customized_locales: customized.fetch(definition.key, []).map(&:last).sort)
+        end
+      end
+
+      # @param store [Spree::Store]
+      # @param id [String] the template's key with dots, e.g. "spree.order_mailer.confirm_email"
+      # @param locale [String]
+      # @return [Spree::EmailTemplates::Entry]
+      # @raise [ActiveRecord::RecordNotFound] when no editable template has that id
+      def self.for_id(store, id, locale: Spree::EmailTemplate::ANY_LOCALE)
+        definition = Spree.editable_email_templates[id.to_s.tr('.', '/')]
+        raise ActiveRecord::RecordNotFound, "Couldn't find email template #{id}" unless definition
+
+        locale = locale.presence || Spree::EmailTemplate::ANY_LOCALE
+        new(
+          definition: definition, locale: locale,
+          published: store.email_templates.published.where(key: definition.key, locale: [locale, Spree::EmailTemplate::ANY_LOCALE]).
+                     min_by { |template| template.locale == locale ? 0 : 1 },
+          draft: store.email_template_drafts.for_key(definition.key, locale).first,
+          customized_locales: store.email_templates.published.where(key: definition.key).order(:locale).pluck(:locale)
+        )
+      end
+
+      # The key with dots, so it fits in a URL segment.
+      def id
+        key.tr('/', '.')
+      end
+      alias prefixed_id id
+
+      def customized?
+        published.present?
+      end
+
+      # @return [Spree::Emails::Template, nil] the template file Spree or the app ships
+      def default
+        @default ||= Spree::Emails::TemplateResolver.for_mailers.find_default(key)
+      end
+
+      # @return [String, nil] the language of the published version customers
+      #   receive: this one, or "any" when the version for every language applies
+      def published_locale
+        published&.locale
+      end
+
+      # What customers receive now.
+      def subject
+        readable(customized? ? published.subject : default&.subject, escape: false)
+      end
+
+      def body
+        readable(customized? ? published.body : default&.body)
+      end
+
+      def default_subject
+        readable(default&.subject, escape: false)
+      end
+
+      def default_body
+        readable(default&.body)
+      end
+
+      def base_subject
+        readable(outdated_version&.base_subject, escape: false)
+      end
+
+      def base_body
+        readable(outdated_version&.base_body)
+      end
+
+      # The default the store's version started from, when Spree's default has
+      # changed since, so the editor can show what changed.
+      #
+      # @return [Spree::EmailTemplate, Spree::EmailTemplateDraft, nil]
+      def outdated_version
+        # An open draft is what gets published next, so it alone decides.
+        version = draft || published
+        version if version&.default_changed?(default)
+      end
+
+      private
+
+      def readable(text, escape: true)
+        return text if locale == Spree::EmailTemplate::ANY_LOCALE
+
+        Spree::Emails::TranslationInliner.call(text, locale: locale, escape: escape)
+      end
+    end
+  end
+end

data/app/models/spree/email_templates/sample_record.rb

@@ -0,0 +1,16 @@
+module Spree
+  module EmailTemplates
+    # A record of the store an email can be previewed with, as the editor's
+    # record picker lists it.
+    class SampleRecord
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :id, :string
+      attribute :label, :string
+      attribute :created_at, :datetime
+
+      alias prefixed_id id
+    end
+  end
+end

data/app/models/spree/emails/branding.rb

@@ -0,0 +1,80 @@
+module Spree
+  module Emails
+    # How a store's customer emails look: its colors and font over the
+    # defaults the shipped layout was designed with. Templates read it as
+    # `store.branding`, so it outlives any edit or revert of a template.
+    class Branding
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      COLOR_FORMAT = /\A#\h{6}\z/
+
+      # Email-safe fonts, with fallback stacks for clients that do not load
+      # web fonts. Family names stay unquoted: templates escape what they print.
+      FONTS = {
+        'inter' => { family: 'Inter, Helvetica, Arial, sans-serif', heading_family: 'Geist, Inter, Helvetica, Arial, sans-serif' },
+        'system' => { family: '-apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Helvetica, Arial, sans-serif' },
+        'helvetica' => { family: 'Helvetica, Arial, sans-serif' },
+        'georgia' => { family: 'Georgia, Times New Roman, Times, serif' },
+        'roboto' => { family: 'Roboto, Helvetica, Arial, sans-serif', url: 'https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700' },
+        'lato' => { family: 'Lato, Helvetica, Arial, sans-serif', url: 'https://fonts.googleapis.com/css2?family=Lato:wght@400;700' },
+        'merriweather' => { family: 'Merriweather, Georgia, serif', url: 'https://fonts.googleapis.com/css2?family=Merriweather:wght@400;700' }
+      }.freeze
+
+      DEFAULT_FONT = 'inter'.freeze
+      DEFAULT_COLORS = {
+        background_color: '#FFFFFF', card_color: '#F6F6F6', text_color: '#726A6A', heading_color: '#332C2C'
+      }.freeze
+      COLORS = %i[accent_color background_color card_color text_color heading_color].freeze
+
+      COLORS.each { |color| attribute color, :string }
+      attribute :font, :string
+
+      validates(*COLORS, format: { with: COLOR_FORMAT }, allow_blank: true)
+      validates :font, inclusion: { in: FONTS.keys }, allow_blank: true
+
+      # What templates read as `store.branding`. A value that is not a color
+      # or a known font falls back to the default, so nothing else ever reaches
+      # an email's CSS, unsaved preview values included.
+      #
+      # @return [Hash{String => String, nil}]
+      def to_h
+        accent = color(:accent_color)
+        typeface_key = FONTS.key?(font) ? font : DEFAULT_FONT
+        typeface = FONTS[typeface_key]
+        colors = DEFAULT_COLORS.to_h { |name, default| [name, color(name) || default] }
+
+        {
+          **colors,
+          accent_color: accent,
+          link_color: accent || colors[:heading_color],
+          # Without an accent, buttons keep the outlined look the layout ships with.
+          button_color: accent || '#FFFFFF',
+          button_text_color: accent ? readable_text_on(accent) : '#1F2222',
+          button_border: accent ? 'none' : '1px solid #E8E9E9',
+          font: typeface_key,
+          font_family: typeface[:family],
+          heading_font_family: typeface[:heading_family] || typeface[:family],
+          font_url: typeface[:url]
+        }.stringify_keys
+      end
+
+      private
+
+      def color(name)
+        value = public_send(name).to_s
+        value.upcase if value.match?(COLOR_FORMAT)
+      end
+
+      # Black or white, whichever reads better on the color (WCAG relative luminance).
+      def readable_text_on(hex)
+        red, green, blue = hex.delete('#').scan(/../).map do |channel|
+          value = channel.to_i(16) / 255.0
+          value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055)**2.4
+        end
+        luminance = (0.2126 * red) + (0.7152 * green) + (0.0722 * blue)
+        luminance > 0.179 ? '#000000' : '#FFFFFF'
+      end
+    end
+  end
+end

data/app/models/spree/exchange.rb

@@ -17,13 +17,14 @@ module Spree
     include Spree::HasStatus
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::PostSale::Taxation
 
     publishes_lifecycle_events
+    publishes_events :approved, :canceled, :fulfilled, :received, :requested
 
     has_status :requested, :approved, :received, :fulfilled, :canceled,
                default: :requested
 
-    belongs_to :store, class_name: 'Spree::Store'
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :exchanges
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
     belongs_to :reason, class_name: 'Spree::ReturnReason', optional: true, inverse_of: :exchanges
@@ -41,6 +42,7 @@ module Spree
     delegate :currency, to: :order
 
     self.whitelisted_ransackable_attributes = %w[number status created_at]
+    search_by :number
     self.whitelisted_ransackable_associations = %w[order reason]
 
     # Positive when the replacements cost more than what came back (the
@@ -53,5 +55,18 @@ module Spree
     def display_price_difference
       Spree::Money.new(price_difference, currency: currency)
     end
+
+    def taxed_lines
+      exchange_line_items
+    end
+
+    private
+
+    # The replacement is a sale of its own, taxed as the order would be today
+    # rather than read off the original line, whose category it may not share.
+    def estimate_tax(lines, amounts: nil)
+      super
+      order.tax_provider.estimate_replacement(order, lines, **order.tax_estimate_inputs)
+    end
   end
 end

data/app/models/spree/exchange_line_item.rb

@@ -1,7 +1,13 @@
 module Spree
   # One swap on a {Spree::Exchange}: a quantity of one variant going back,
   # the same quantity of another coming out.
+  #
+  # Both halves are taxed: the units coming back are credited the tax the
+  # customer paid on them (`original_*`), and the replacement is taxed as a new
+  # sale (`new_*`), each for the announced quantity.
   class ExchangeLineItem < Spree.base_class
+    include Spree::PostSale::TaxedLine
+
     has_prefix_id :eli
 
     belongs_to :exchange, class_name: 'Spree::Exchange', inverse_of: :exchange_line_items
@@ -19,24 +25,134 @@ module Spree
 
     delegate :order, :currency, to: :exchange
 
-    # What the customer paid for the units coming back, after discounts —
-    # not the list price, which would over-credit a discounted line.
+    extend Spree::DisplayMoney
+    money_methods :original_price, :new_variant_price, :price_difference, :original_tax_total, :new_tax_total
+
+    # What the customer paid for the units coming back, after discounts and
+    # with the tax charged on top — not the list price, which would
+    # over-credit a discounted line.
     def original_price
-      return 0 if line_item.nil? || line_item.quantity.to_i.zero?
+      original_amount_for(quantity) + original_additional_tax_total
+    end
+
+    def original_pre_tax_amount
+      original_amount_for(quantity) - original_included_tax_total
+    end
 
-      (line_item.amount / line_item.quantity) * quantity.to_i
+    def original_tax_total
+      original_included_tax_total + original_additional_tax_total
     end
 
+    # What the replacement costs, tax on top included.
     def new_variant_price
-      new_variant.price_in(currency)&.amount.to_d * quantity.to_i
+      replacement_amount_for(quantity) + new_additional_tax_total
+    end
+
+    def new_pre_tax_amount
+      replacement_amount_for(quantity) - new_included_tax_total
+    end
+
+    def new_tax_total
+      new_included_tax_total + new_additional_tax_total
     end
 
     def price_difference
       new_variant_price - original_price
     end
 
+    # The replacement keeps the deal the customer had on what it replaces:
+    # its price carries the original line's discount in the same proportion,
+    # so swapping a size of a discounted item costs nothing.
+    #
+    # @param units [Integer]
+    # @return [BigDecimal]
+    def replacement_amount_for(units)
+      price = new_variant&.price_in(currency)&.amount.to_d
+
+      Spree::Money::Rounding.to_currency(price * units.to_i * discount_ratio, currency)
+    end
+
+    # The units this swap covers: none once canceled, what arrived once the
+    # warehouse has counted, what was announced before.
+    #
+    # @return [Integer]
+    def credited_quantity
+      return 0 if exchange.canceled?
+
+      exchange.received? || exchange.fulfilled? ? received_quantity.to_i : quantity.to_i
+    end
+
+    # @return [BigDecimal] what the units coming back are worth, tax included
+    def credited_worth
+      units = credited_quantity
+      return 0.to_d if quantity.to_i.zero?
+
+      original_amount_for(units) +
+        Spree::Money::Rounding.to_currency((original_additional_tax_total / quantity) * units, currency)
+    end
+
+    # What the provider taxes the replacement on (see
+    # Spree::TaxProvider::Base#estimate_replacement).
+    def taxable_basis
+      replacement_amount_for(credited_quantity)
+    end
+
+    def tax_category_id
+      new_variant&.tax_category_id
+    end
+
+    # What the units that arrived are credited, from the rows as they stand.
+    #
+    # @return [BigDecimal]
+    def settled_credit
+      original_amount_for(received_quantity) + tax_lines.credits.additional.sum(:amount)
+    end
+
+    # What their replacements cost, from the rows as they stand.
+    #
+    # @return [BigDecimal]
+    def settled_charge
+      replacement_amount_for(received_quantity) + tax_lines.charges.additional.sum(:amount)
+    end
+
+    # The tax inside {#settled_credit} less the tax inside {#settled_charge}.
+    #
+    # @return [BigDecimal]
+    def settled_tax
+      credited_tax_total - tax_lines.charges.sum(:amount)
+    end
+
+    # @return [void]
+    def fold_tax_lines!
+      rows = tax_lines.reload.to_a
+      original_included, original_additional = tax_totals_from(rows.select(&:credit?))
+      new_included, new_additional = tax_totals_from(rows.reject(&:credit?))
+
+      update_columns(
+        original_included_tax_total: original_included,
+        original_additional_tax_total: original_additional,
+        new_included_tax_total: new_included,
+        new_additional_tax_total: new_additional
+      )
+    end
+
     private
 
+    def original_amount_for(units)
+      line_item&.discounted_amount_for(units) || 0.to_d
+    end
+
+    def discount_ratio
+      amount = line_item&.amount.to_d
+      return 1 unless amount.positive?
+
+      [line_item.discounted_amount, 0].max / amount
+    end
+
+    def recorded_tax_total
+      original_tax_total + new_tax_total
+    end
+
     def set_original_variant_from_line_item
       self.original_variant ||= line_item&.variant
     end

data/app/models/spree/export.rb

@@ -30,7 +30,6 @@ module Spree
     #
     # Associations
     #
-    belongs_to :store, class_name: 'Spree::Store'
     # Optional so secret-API-key callers (apps / server-to-server) can create
     # exports without a human user attached. The email notification is
     # skipped for these — apps poll instead.