spree_core 6.0.0.rc3 → 6.0.0.rc5

data/app/models/spree/stock/estimator.rb

@@ -1,8 +1,6 @@
 module Spree
   module Stock
     class Estimator
-      include Spree::VatPriceCalculation
-
       attr_reader :order, :currency
 
       def initialize(order)
@@ -69,7 +67,7 @@ module Spree
       # through the calculator, carrier providers call their API and may
       # return several estimates (one per carrier service). An empty result
       # suppresses the method, matching the calculator contract. Service
-      # filtering, markup, naming, VAT gross-up, tax resolution and sorting
+      # filtering, markup, naming, tax resolution and sorting
       # stay here so every provider gets them identically.
       def calculate_delivery_rates(package, audience)
         delivery_methods(package, audience).flat_map do |delivery_method|
@@ -103,14 +101,12 @@ module Spree
       end
 
       # An unpriced quote has no amount to mark up or tax — a percentage of an
-      # unknown price is still unknown, and rounding zero through the VAT
-      # gross-up would only invent a number. Its cost stays zero and every
-      # display surface reads +unpriced+ instead.
+      # unknown price is still unknown. Its cost stays zero and every display
+      # surface reads +unpriced+ instead.
       def rate_cost(estimate, delivery_method, service_row, provider)
         return 0 if estimate.unpriced
 
-        cost = apply_markup(estimate.cost, delivery_method, service_row, provider)
-        gross_amount(cost, taxation_options_for(delivery_method))
+        apply_markup(estimate.cost, delivery_method, service_row, provider)
       end
 
       # Handling fee on top of provider quotes: the service row's values when
@@ -132,18 +128,6 @@ module Spree
           [estimate.carrier, estimate.service_level].compact.join(' ').presence
       end
 
-      # Override this if you need the prices for delivery methods to be handled just like the
-      # prices for products in terms of included tax manipulation.
-      #
-      def taxation_options_for(delivery_method)
-        {
-          tax_category: delivery_method.tax_category,
-          address: @order.tax_address,
-          country: @order.tax_country,
-          market: @order.market
-        }
-      end
-
       def first_tax_rate_for(tax_category)
         return unless @order.tax_address && tax_category
 

data/app/models/spree/store.rb

@@ -8,6 +8,12 @@ module Spree
 
     include FriendlyId
     include Spree::TranslatableResource
+
+    # The store itself is settings — see Admin::StoreController.
+    def self.translation_write_permission
+      'write_settings'
+    end
+
     include Spree::HasCustomFields
     include Spree::Metadata
     include Spree::Stores::Setup
@@ -209,6 +215,7 @@ module Spree
     has_many :claim_reasons, class_name: 'Spree::ClaimReason', inverse_of: :store, dependent: :destroy
     has_many :refund_reasons, class_name: 'Spree::RefundReason', inverse_of: :store, dependent: :destroy
     has_many :order_cancellation_reasons, class_name: 'Spree::OrderCancellationReason', inverse_of: :store, dependent: :destroy
+    has_many :tax_exemption_reasons, class_name: 'Spree::TaxExemptionReason', inverse_of: :store, dependent: :destroy
 
     # :nullify (not :destroy) — clearing the collection must not cascade into
     # Promotion#not_used? / payment records; orphaned rows are detached, not deleted.
@@ -339,6 +346,7 @@ module Spree
     has_many :catalogs, class_name: 'Spree::Catalog', dependent: :destroy, inverse_of: :store
 
     has_many :api_keys, class_name: 'Spree::ApiKey', dependent: :destroy
+    has_many :oauth_applications, class_name: 'Spree::OauthApplication', dependent: :destroy
     has_many :allowed_origins, class_name: 'Spree::AllowedOrigin', dependent: :destroy
 
     #

data/app/models/spree/tax_exemption/item_override.rb

@@ -17,6 +17,20 @@ module Spree
       def exempt?
         exempt
       end
+
+      # @return [Hash]
+      def to_snapshot
+        attributes
+      end
+
+      # Unknown keys are dropped rather than raising: a snapshot is read back
+      # long after it was written, possibly by a different version of Spree.
+      #
+      # @param snapshot [Hash]
+      # @return [Spree::TaxExemption::ItemOverride]
+      def self.from_snapshot(snapshot)
+        new(snapshot.to_h.stringify_keys.slice(*attribute_names).symbolize_keys)
+      end
     end
   end
 end

data/app/models/spree/tax_exemption.rb

@@ -14,6 +14,9 @@ module Spree
     # Why the sale is exempt, in the provider's vocabulary — Avalara's
     # entityUseCode territory.
     attribute :reason_code, :string
+    # The merchant's wording for the reason, kept with the claim so a placed
+    # order still reads the way it did when it was taxed.
+    attribute :reason_name, :string
     attribute :certificate_number, :string
 
     # Where the claim holds. Nil country = everywhere the provider taxes,
@@ -62,6 +65,29 @@ module Spree
       override_for(item)&.reason_code.presence || reason_code
     end
 
+    # The claim as plain data, for freezing onto a placed order. Certificates
+    # lapse, get revoked and are edited, so a provider filing or crediting that
+    # sale later has to read the evidence the sale was priced with rather than
+    # whatever resolves on the day.
+    #
+    # @return [Hash]
+    def to_snapshot
+      attributes.except('item_overrides').
+        merge('item_overrides' => Array(item_overrides).map(&:to_snapshot))
+    end
+
+    # Unknown keys are dropped rather than raising: a snapshot is read back long
+    # after it was written, possibly by a different version of Spree.
+    #
+    # @param snapshot [Hash]
+    # @return [Spree::TaxExemption]
+    def self.from_snapshot(snapshot)
+      snapshot = snapshot.to_h.stringify_keys
+      overrides = Array(snapshot['item_overrides']).map { |override| ItemOverride.from_snapshot(override) }
+
+      new(snapshot.slice(*attribute_names).symbolize_keys.merge(item_overrides: overrides))
+    end
+
     private
 
     # An override that cannot say which line it applies to does not narrow this

data/app/models/spree/tax_exemption_certificate.rb

@@ -22,6 +22,7 @@ module Spree
     has_status :pending, :verified, :expired, :revoked, default: :pending
 
     belongs_to :company, class_name: 'Spree::Company', inverse_of: :tax_exemption_certificates
+    belongs_to :tax_exemption_reason, class_name: 'Spree::TaxExemptionReason', inverse_of: :tax_exemption_certificates
     belongs_to :verified_by, class_name: Spree.admin_user_class.to_s, optional: true
 
     # Confidential, so the private service rather than the public one that
@@ -29,12 +30,15 @@ module Spree
     has_one_attached :document, service: Spree.private_storage_service_name
     signed_id_attachments :document
 
-    validates :certificate_number, :reason_code, presence: true
+    validates :certificate_number, presence: true
     # Certificates exist only on legal-entity nodes — a division's purchases
     # read exemption through its legal entity. A validation rather than a
     # schema difference, so a per-division registration can be allowed later
     # by relaxing this alone.
     validate :company_is_legal_entity
+    # Checked when the reason is set, not on every save: a reason the merchant
+    # retires later leaves the certificates that already record it valid.
+    validate :reason_offered_by_store, if: :will_save_change_to_tax_exemption_reason_id?
 
     # A certificate is a scanned form, not an archive. Bounded because the
     # download action reads the whole blob into memory to serve it, so an
@@ -64,7 +68,7 @@ module Spree
         where(state_code: [address.state_code.presence, nil].uniq)
     }
 
-    self.whitelisted_ransackable_attributes = %w[certificate_number reason_code status expires_at]
+    self.whitelisted_ransackable_attributes = %w[certificate_number tax_exemption_reason_id status expires_at]
 
     delegate :store, :store_id, to: :company
 
@@ -94,5 +98,12 @@ module Spree
 
       errors.add(:company, :must_be_legal_entity)
     end
+
+    def reason_offered_by_store
+      return if tax_exemption_reason.nil? || company.nil?
+      return if tax_exemption_reason.active? && tax_exemption_reason.store_id == store_id
+
+      errors.add(:tax_exemption_reason, :not_offered)
+    end
   end
 end

data/app/models/spree/tax_exemption_reason.rb

@@ -0,0 +1,62 @@
+module Spree
+  # Why a business buys without tax — "Resale", "Government", "Charitable
+  # organisation". Certificates point at a reason the way products point at a
+  # tax category: the `name` is the merchant's own wording, and the `code` is
+  # what a tax engine reads. Spree's own engine only keeps the code for
+  # reference, while an external one (Avalara's entity use codes) decides the
+  # exemption by it, so changing the code changes what every certificate
+  # holding the reason sends from then on.
+  class TaxExemptionReason < Spree.base_class
+    has_prefix_id :txr
+
+    include Spree::NamedType
+    include Spree::Metadata
+
+    # Guarded by hand rather than with :restrict_with_error, which would also
+    # refuse when the whole store is being destroyed.
+    has_many :tax_exemption_certificates, class_name: 'Spree::TaxExemptionCertificate',
+                                          inverse_of: :tax_exemption_reason, dependent: nil
+
+    self.whitelisted_ransackable_attributes = %w[name code active]
+
+    # Upper case because tax engines read codes case-insensitively: `g` and
+    # `G` would be two reasons here and one to Avalara.
+    normalizes :code, with: ->(value) { value.to_s.strip.upcase.presence }
+
+    validates :code, presence: true, length: { maximum: 64 }
+    validates_store_uniqueness :code
+
+    before_destroy :ensure_unused
+
+    # Finds the reason already holding the code, else the one holding the
+    # name, so seeding a store never collides with a reason the merchant added
+    # or renamed. Code first: it is what a tax engine reads, so a match on it
+    # is the same reason whatever the merchant called it.
+    #
+    # @param code [String]
+    # @param name [String]
+    # @return [Spree::TaxExemptionReason]
+    def self.find_or_create_by_code_or_name!(code:, name:)
+      code = normalize_value_for(:code, code)
+
+      find_by(code: code) || find_by(name: name) || create!(code: code, name: name)
+    end
+
+    # Mirrors the destroy guard, so the dashboard can hide the delete control
+    # rather than offer one the model will refuse.
+    #
+    # @return [Boolean]
+    def can_be_deleted?
+      !tax_exemption_certificates.exists?
+    end
+
+    private
+
+    def ensure_unused
+      return if destroyed_by_association.present? || can_be_deleted?
+
+      errors.add(:base, :in_use)
+      throw :abort
+    end
+  end
+end

data/app/models/spree/tax_line.rb

@@ -22,10 +22,11 @@ module Spree
     # core doesn't know about registers its reason here. The bar for a new
     # value: it distinguishes a treatment that reporting or invoicing has to
     # tell apart, not merely a different amount.
-    class_attribute :taxability_reasons,
-                    default: %w[standard_rated reduced_rated zero_rated reverse_charge
-                                intra_community_supply export customer_exempt product_exempt
-                                not_collecting not_subject_to_tax]
+    BUILT_IN_TAXABILITY_REASONS = %w[standard_rated reduced_rated zero_rated reverse_charge
+                                     intra_community_supply export customer_exempt product_exempt
+                                     not_collecting not_subject_to_tax].freeze
+
+    class_attribute :taxability_reasons, default: BUILT_IN_TAXABILITY_REASONS.dup
 
     # Provider payloads (jurisdiction breakdowns, external ids) read nil-safe.
     attribute :data, default: -> { {} }

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

@@ -41,6 +41,16 @@ module Spree
         name.demodulize.titleize
       end
 
+      # The exemption reason codes this engine understands, `{ code => label }`,
+      # offered to a merchant adding a {Spree::TaxExemptionReason}. Nil for an
+      # engine that does not read the code, Spree's own included: any code a
+      # merchant chooses is then as good as another.
+      #
+      # @return [Hash{String => String}, nil]
+      def self.exemption_reason_codes
+        nil
+      end
+
       # The declared limits with the strings a merchant can act on. A capability
       # with no translation degrades to its humanized key rather than a missing
       # translation, so an extension that declares one without shipping strings
@@ -69,6 +79,7 @@ module Spree
           name: display_name,
           available: available_for_store?(store),
           unsupported_capabilities: unsupported_capability_details,
+          exemption_reason_codes: exemption_reason_codes&.map { |code, label| { value: code.to_s, label: label.to_s } },
           default: name == Spree.default_tax_provider.to_s
         }
       end
@@ -85,10 +96,18 @@ module Spree
       # @param tax_identifier [Spree::TaxIdentifier, nil] resolved buyer
       #   registration, nil for a consumer sale
       # @param exemptions [Array] exemption evidence to apply
+      # @param tax_inclusive [Boolean, nil] whether the owner's prices already
+      #   include tax, which its market decides (Spree::Market#tax_inclusive);
+      #   nil = ask the owner (+owner.tax_inclusive?+)
       # @param context [Hash] untyped provider extras from set_tax_line_context
-      # @return [void] the written rows are the output; raise when the
-      #   calculation cannot be completed
-      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], context: {})
+      # @return [void] the written rows are the output
+      # @raise [Spree::Tax::ProviderUnavailable] when the engine could not
+      #   answer — refused, timed out, unreachable. Raise this (or a subclass,
+      #   as a provider's own request error may) rather than a bare error: core
+      #   turns it into a refusal the customer can retry, where anything else
+      #   reaches them as a broken checkout. A provider a merchant switched off
+      #   is not this — it has no opinion and writes no rows.
+      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil, context: {})
         raise NotImplementedError, "Please implement 'estimate' in your tax provider: #{self.class.name}"
       end
 
@@ -171,9 +190,10 @@ module Spree
       # @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
+      # @param tax_inclusive [Boolean, nil] as for +estimate+
       # @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: [])
+      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil)
         raise NotImplementedError, "Please implement 'estimate_replacement' in your tax provider: #{self.class.name}"
       end
 

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

@@ -1,12 +1,19 @@
 module Spree
   module TaxProvider
     # Computes tax directly from TaxRate configuration: rate × discounted
-    # base, with VAT included-in-price math backed out of the gross basis.
+    # base, backed out of the price instead when the market's prices include
+    # tax.
     # Rates are matched on the owner's tax address, each naming its own country
     # and optionally a state. Fees without a tax category are taxed with the
     # default tax category's rates — except customs duties, which +taxable_items+
     # withholds (see Spree::Purchase::Taxation).
     class Internal < Base
+      # What a merchant sees when picking a market's tax engine: the class name
+      # says nothing to someone who never read the code.
+      def self.display_name
+        I18n.t('spree.tax_providers.internal')
+      end
+
       # Rates are configured per country or state with no local-tax breakdown, no buyer
       # registration handling, no distance-selling thresholds, and delivery taxed
       # at its own method's rate rather than apportioned across the rates of the
@@ -20,7 +27,8 @@ module Spree
       # period, so there is only ever one version of the configuration to read.
       # +tax_identifier+ likewise — reverse charge is on the unsupported list,
       # so a buyer registration changes nothing here.
-      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], context: {})
+      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil, context: {})
+        tax_inclusive = owner.tax_inclusive? if tax_inclusive.nil?
         full_estimate = items.nil?
         items ||= owner.taxable_items
         # A duty this engine taxed before it was excluded — or through an
@@ -38,7 +46,7 @@ module Spree
           Spree::TaxLine.where(Spree::TaxLine.adjustable_key_for(klass) => group.map(&:id)).delete_all
         end
 
-        items.each { |item| tax_item(owner, item, rates, exemptions) }
+        items.each { |item| tax_item(owner, item, rates, exemptions, tax_inclusive) }
       end
 
       # Gives back each credited unit's share of the TaxLines the sale actually
@@ -57,16 +65,17 @@ module Spree
       # 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: [])
+      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil)
         return if items.empty?
 
+        tax_inclusive = order.tax_inclusive? if tax_inclusive.nil?
         Spree::TaxLine.charges.where(exchange_line_item_id: items.map(&:id)).delete_all
 
         rates = rates_for(order)
         items.each do |item|
           next unless item.credited_quantity.to_i.positive?
 
-          tax_item(order, item, rates, exemptions, exemption_subject: item.line_item || item)
+          tax_item(order, item, rates, exemptions, tax_inclusive, exemption_subject: item.line_item || item)
         end
       end
 
@@ -74,11 +83,8 @@ module Spree
       # else, matched on where the invoiced business sits and taxed under the
       # store's default category — this engine has no separate notion of a
       # services category, and a marketplace commission is standard-rated
-      # nearly everywhere.
-      #
-      # Additional (not included-in-price) rates only: a commission is quoted
-      # net and its VAT is added on top, so a rate configured as
-      # tax-inclusive describes consumer pricing rather than this supply.
+      # nearly everywhere. A commission is quoted net and its tax added on top,
+      # whatever the store's markets do with their prices.
       #
       # Nil when the jurisdiction is unknown or configured with no matching
       # rate at all, so the caller falls back to its own default instead of
@@ -91,8 +97,7 @@ module Spree
 
         rates = Spree::TaxRate.for_store(store).
                 for_jurisdiction(address.country_code, address.state_code).
-                for_tax_category(category).
-                where(included_in_price: false)
+                for_tax_category(category)
         return nil if rates.empty?
 
         rates.sum(:amount)
@@ -114,7 +119,7 @@ module Spree
         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)
+      def tax_item(owner, item, rates, exemptions, tax_inclusive, 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:
@@ -129,15 +134,15 @@ module Spree
         # 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)
+        store_pre_tax_amount(item, relevant_rates - exempt_rates, tax_inclusive)
 
         taxed.each do |rate, jurisdiction, exemption|
           if exemption
-            write_tax_line(owner, item, rate, 0, 'customer_exempt', jurisdiction,
+            write_tax_line(owner, item, rate, 0, 'customer_exempt', jurisdiction, tax_inclusive,
                            data: exemption_data(exemption, exemption_subject))
           else
-            write_tax_line(owner, item, rate, compute_tax(rate, item, relevant_rates, owner.currency),
-                           reason_for(rate), jurisdiction)
+            write_tax_line(owner, item, rate, compute_tax(rate, item, relevant_rates, owner.currency, tax_inclusive),
+                           reason_for(rate), jurisdiction, tax_inclusive)
           end
         end
       end
@@ -171,13 +176,11 @@ module Spree
 
       # Rounded per line, half up, to the order's currency — the internal
       # provider's choice; other providers round as their jurisdictions require.
-      def compute_tax(rate, item, relevant_rates, currency)
+      def compute_tax(rate, item, relevant_rates, currency, tax_inclusive)
         basis = taxable_basis(item)
 
-        tax = if rate.included_in_price
-                included_sum = relevant_rates.select(&:included_in_price).sum(&:amount)
-                included_sum = rate.amount if included_sum.zero?
-                basis / (1 + included_sum) * rate.amount
+        tax = if tax_inclusive
+                basis / (1 + relevant_rates.sum(&:amount)) * rate.amount
               else
                 basis * rate.amount
               end
@@ -186,12 +189,11 @@ module Spree
 
       # Pre-tax amounts are stored so refund and reporting code can weigh
       # discounted, tax-exclusive values later (see #4318).
-      def store_pre_tax_amount(item, rates)
+      def store_pre_tax_amount(item, rates, tax_inclusive)
         return unless item.respond_to?(:pre_tax_amount)
 
         pre_tax_amount = taxable_basis(item)
-        included_rates = rates.select(&:included_in_price)
-        pre_tax_amount /= (1 + included_rates.sum(&:amount)) if included_rates.any?
+        pre_tax_amount /= (1 + rates.sum(&:amount)) if tax_inclusive && rates.any?
 
         item.update_column(:pre_tax_amount, pre_tax_amount)
       end
@@ -226,15 +228,20 @@ module Spree
       # a genuinely exempt supply depends on which exemption applied, which the
       # reason alone cannot say.
       def exemption_data(exemption, item)
+        reason_code = exemption.reason_code_for(item)
+
         {
           'exemption' => {
-            'reason_code' => exemption.reason_code_for(item),
+            'reason_code' => reason_code,
+            # A per-line override names only a code, so the entry's name would
+            # describe a different reason.
+            'reason_name' => (exemption.reason_name if reason_code == exemption.reason_code),
             'certificate_number' => exemption.certificate_number
           }.compact
         }
       end
 
-      def write_tax_line(owner, item, rate, amount, reason, jurisdiction, data: {})
+      def write_tax_line(owner, item, rate, amount, reason, jurisdiction, tax_inclusive, data: {})
         owner_key = owner.is_a?(Spree::Order) ? :order : :cart
         Spree::TaxLine.create!(
           {
@@ -243,8 +250,8 @@ module Spree
             tax_rate: rate,
             amount: amount,
             rate: rate.amount,
-            label: rate.adjustment_label,
-            included: rate.included_in_price,
+            label: rate.adjustment_label(included: tax_inclusive),
+            included: tax_inclusive,
             provider_id: 'internal',
             taxability_reason: reason,
             data: data

data/app/models/spree/tax_rate.rb

@@ -9,6 +9,10 @@ module Spree
     # zone_id any more, but the column stays in the database through 6.0: it is
     # what `spree:migrate_tax_zones` converts from, and that task runs after
     # db:migrate. The physical drop lands in 6.1.
+    #
+    # The same goes for included_in_price: whether tax sits inside a price is
+    # the market's choice (Spree::Market#tax_inclusive), and the column is read
+    # only by `spree:markets:backfill_tax_inclusive`, which clears it.
 
     acts_as_paranoid
 
@@ -52,15 +56,10 @@ module Spree
     }
     # The same question asked with an address in hand.
     scope :for_address, ->(address) { for_jurisdiction(address&.country_code, address&.state_code) }
-    # Country-wide: unlike for_jurisdiction(country_code, nil) this leaves the
-    # state unconstrained, so it sums a country's state-level rates too. Used
-    # where the state is irrelevant — backing VAT out of a gross price.
-    scope :for_country, ->(country_code) { where(country_code: [country_code.presence, nil].uniq) }
     scope :for_tax_category,
           ->(category) { where(tax_category_id: category.try(:id)) }
-    scope :included_in_price, -> { where(included_in_price: true) }
 
-    self.whitelisted_ransackable_attributes = %w[amount rate country_code state_code tax_category_id included_in_price name]
+    self.whitelisted_ransackable_attributes = %w[amount rate country_code state_code tax_category_id name]
     ransack_alias :rate, :amount
     search_by :name
 
@@ -92,38 +91,13 @@ module Spree
       self.rate_percent = value
     end
 
-    # The included-in-price rate to back out of a gross price.
-    #
-    # @param options [Hash] +:country+ (or +:address+) and +:tax_category+
-    # @return [BigDecimal] 0 when the jurisdiction or category is unknown
-    def self.included_tax_amount_for(options)
-      # +:country+ is a documented override point and the VAT path still hands
-      # it a Spree::Country, so take the code off whichever arrives.
-      country = options[:country]
-      country_code = country.try(:iso) || country.presence || options[:address]&.country_code
-      return 0 unless country_code && options[:tax_category]
-
-      scope = options[:address] ? for_address(options[:address]) : for_country(country_code)
-      # Per-store tax configuration is the norm since 6.0, so without this the
-      # sum would add up every store's rate for the same country.
-      store = options[:store] || Spree::Current.store
-      scope = scope.for_store(store) if store
-      scope.included_in_price.for_tax_category(options[:tax_category]).sum(:amount)
-    end
-
-    def included?
-      included_in_price
-    end
-
-    def additional?
-      !included_in_price
-    end
-
     # The customer-facing label snapshotted onto TaxLine rows.
     #
+    # @param included [Boolean] whether the tax sits inside the price, which
+    #   the sale's market decides (Spree::Market#tax_inclusive)
     # @return [String]
-    def adjustment_label
-      I18n.t "spree.adjustment_labels.tax_rates.#{included_in_price? ? :including_tax : :excluding_tax}",
+    def adjustment_label(included: false)
+      I18n.t "spree.adjustment_labels.tax_rates.#{included ? :including_tax : :excluding_tax}",
               name: name.presence || tax_category.name,
               amount: amount_for_label
     end

data/app/models/spree/translations/batch.rb

@@ -45,12 +45,22 @@ module Spree
         @records = []
       end
 
-      # Distinct +write_<resource>+ scopes a caller needs to authorize this
-      # batch — one per resource type present. Lets the API layer gate an
-      # API-key request without re-deriving scope names.
+      # Distinct write permissions a caller needs to authorize this batch —
+      # one per resource type present.
+      #
+      # Each resource names its own, because several are guarded by a
+      # permission not named after them: an option type rides
+      # `write_products`, a policy rides `write_settings`. Deriving the name
+      # from the type produced strings outside the permission catalog, which
+      # no credential could hold and which the API therefore skipped — so a
+      # grant narrowed to reading could still rewrite a store's policy text.
+      #
+      # A type that resolves to nothing is left out; `resolve_record!` is what
+      # reports it, one entry at a time with its index.
+      #
       # @return [Array<String>]
       def required_scopes
-        @entries.map { |entry| "write_#{entry[:resource_type].to_s.pluralize}" }.uniq
+        @entries.filter_map { |entry| resource_class(entry[:resource_type])&.translation_write_permission }.uniq
       end
 
       # Upserts every entry in one transaction. Yields each resolved record

data/app/services/spree/carts/destroy.rb

@@ -52,9 +52,14 @@ module Spree
         success(cart: cart)
       end
 
+      # Lets go of everything the cart was only borrowing, so the cascade that
+      # follows reaches nothing but the cart's own rows. An entry in somebody's
+      # address book stays in it, and a row a fulfillment or a completed order
+      # still points at is detached rather than soft-deleted out from under
+      # them.
       def clear_addresses(cart:)
-        cart.ship_address = nil unless cart.ship_address&.can_be_deleted?
-        cart.bill_address = nil unless cart.bill_address&.can_be_deleted?
+        cart.ship_address = nil unless cart.owns_address?(cart.ship_address) && cart.ship_address.can_be_deleted?
+        cart.bill_address = nil unless cart.owns_address?(cart.bill_address) && cart.bill_address.can_be_deleted?
 
         success(cart: cart)
       end

data/app/services/spree/carts/price_items.rb

@@ -71,20 +71,14 @@ module Spree
         resolutions = Array(resolutions)
         return if resolutions.empty?
 
-        # One derivation for the batch: every line in a resolution set belongs
-        # to the same cart, and tax_address / tax_country walk associations and
-        # a store preference that would otherwise be re-read per line.
-        owner = resolutions.first.first.owner
-        vat_inputs = { address: owner&.tax_address, country: owner&.tax_country, market: owner&.market }
-
         resolutions.each do |line_item, price|
           # Probe-based flows resolve against stand-ins, so the guard has to
           # hold at the write too.
           next if line_item.manual_price?
 
-          amount = price.price_including_vat_for(**vat_inputs)
+          amount = price.price
           # Marked before the blank guard: the provider has already answered,
-          # so a restatement that comes back blank must still not send the
+          # so a price that comes back blank must still not send the
           # after_save callback back to the provider from inside the caller's
           # transaction. Only the assign-for-a-coming-save case needs it — a
           # persisted write goes through update_columns and fires no callbacks.