spree_core 6.0.0.rc4 → 6.0.0.rc6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc7dbcacac8f33d70f236f52c52070ee495d7d4e366797055c17d4b119eec6d4
-  data.tar.gz: 3a2e290f02c8d3c9f367c2b4d649d94f69e58449a3ca47179ea58480a3cb1375
+  metadata.gz: 6ac170eb6008053ca9eea6d6694bb98d49cc4e66e28826f4aac5bc97fad29e15
+  data.tar.gz: 8a883557c01ab2211232eab518443521435e1d6bc10dee6778f3f96119ea6334
 SHA512:
-  metadata.gz: ec7a1dc11ffe7aaa8b4cdd82e8e050f39d2d38fedb81c2b3a70901c3db5dbedd0b51bfad12164d2e28962b231ffff777c9ff22a884acc78e631e19a4741ab283
-  data.tar.gz: 4e7f9a59e472892e07722d15a598ca76dc1257c76c1cc969c77dcba8a73b7d78ceccfe88a61c9aa2fb084f633064256df3493bc2b91e79cecb86a9ca6a545259
+  metadata.gz: df3bff4364790fe3205baec9790c4fa123afc7945b68340afb583e56966e73acbd694f1c3016f11e9b880ba9a34bb1622620ee568970e3b625fca96da4807a09
+  data.tar.gz: 85bb8941d3648914ad037195c0e090b5e1df40ce3fb46b67aa6ca86a18784af3f1a0cb3ca1a9d656d54e52aead1050a2510fec3b1ccc5288e25d0f5f1f66a309

data/app/jobs/spree/images/save_from_url_job.rb

@@ -75,6 +75,7 @@ module Spree
 
       def download_and_attach_image(external_url, image)
         max_size = Spree::Config.max_image_download_size
+        streamed_body = nil
 
         response = SsrfFilter.get(
           external_url,
@@ -90,12 +91,12 @@ module Spree
             read_timeout: 60,
             open_timeout: 30
           }
-        )
+        ) { |fetched| streamed_body = read_within(fetched, max_size) }
 
-        body = response.body
-        if body.bytesize > max_size
-          raise StandardError, "Image file size exceeds the maximum allowed size of #{max_size} bytes"
-        end
+        # A fetch that did not stream (a test double, say) is read whole and
+        # held to the same limit.
+        body = streamed_body || response.body
+        raise_too_large(max_size) if body.bytesize > max_size
 
         uri = URI.parse(external_url)
         filename = File.basename(uri.path)
@@ -114,6 +115,24 @@ module Spree
         end
       end
 
+      # Reads the body as it arrives and stops at the limit, so an oversized
+      # or endless response is refused mid-stream rather than held in memory
+      # first; a declared length over the limit is refused before any of it.
+      def read_within(response, max_size)
+        raise_too_large(max_size) if response['Content-Length'].to_i > max_size
+
+        buffer = +''
+        response.read_body do |chunk|
+          buffer << chunk
+          raise_too_large(max_size) if buffer.bytesize > max_size
+        end
+        buffer
+      end
+
+      def raise_too_large(max_size)
+        raise StandardError, "Image file size exceeds the maximum allowed size of #{max_size} bytes"
+      end
+
       def image_already_saved?(image, external_url)
         image.persisted? && image.attachment.attached? && image.external_url.present? && external_url == image.external_url
       end

data/app/models/concerns/spree/account_deactivation.rb

@@ -0,0 +1,54 @@
+module Spree
+  # Switches a staff account off without deleting it. Deleting a staff member
+  # clears them from every record that names them as its actor, so the history
+  # of who approved, refunded or created what is lost; deactivating keeps the
+  # account and refuses every way back in.
+  #
+  # Enforcement lives in the API: a deactivated account cannot sign in by any
+  # strategy, accept an invitation, finish a password reset or refresh a
+  # session, and its access tokens stop working on the next request. Including
+  # this concern opts a model in; the checks are duck-typed, so a custom admin
+  # user class without it is never refused.
+  #
+  # Secret API keys are left alone: they belong to the store, not to the person
+  # who created them, and revoking them would break the store's integrations.
+  module AccountDeactivation
+    # @return [Boolean]
+    def deactivated?
+      deactivated_at.present?
+    end
+
+    # Deactivates the account and ends every session it holds: refresh tokens
+    # are deleted, and OAuth tokens and grants issued to apps on its behalf are
+    # revoked. Access tokens already issued are refused from the next request.
+    #
+    # Safe to call again. The first deactivation time is kept, but sessions
+    # are ended every time, so an account whose column was set some other way
+    # still loses the credentials it holds.
+    #
+    # Skips validations: switching an account off must not fail because some
+    # unrelated attribute no longer passes today's rules.
+    #
+    # @return [void]
+    def deactivate!
+      now = Time.current
+      transaction do
+        update_columns(deactivated_at: now, updated_at: now) unless deactivated?
+        Spree::RefreshToken.revoke_all_for(self)
+        oauth_owner = { resource_owner_type: self.class.polymorphic_name, resource_owner_id: id, revoked_at: nil }
+        Spree::OauthAccessToken.where(oauth_owner).update_all(revoked_at: now)
+        Spree::OauthAccessGrant.where(oauth_owner).update_all(revoked_at: now)
+      end
+    end
+
+    # Lets the account sign in again. Sessions ended by deactivation stay
+    # ended; the person signs in afresh.
+    #
+    # @return [void]
+    def reactivate!
+      return unless deactivated?
+
+      update_columns(deactivated_at: nil, updated_at: Time.current)
+    end
+  end
+end

data/app/models/concerns/spree/calculator/currency_amounts.rb

@@ -6,9 +6,12 @@ module Spree
     # currency directly, so one method serves every currency it has an
     # amount for — no more method-per-currency duplication.
     #
-    # The 5.x single `amount` + `currency` preferences keep working as the
-    # fallback for their own currency, so upgraded stores quote unchanged
-    # until they fill in the hash.
+    # Once the hash holds an amount it alone decides, and a currency it leaves
+    # out is not offered. The 5.x single `amount` + `currency` pair quotes its
+    # own currency only while the hash is empty, so upgraded stores quote
+    # unchanged until they fill it in. The pair's untouched default (0 in the
+    # store's currency) can never be read as a price someone set beside the
+    # hash.
     module CurrencyAmounts
       extend ActiveSupport::Concern
 
@@ -17,14 +20,15 @@ module Spree
       end
 
       # The amount this calculator quotes for a currency: the per-currency
-      # hash first, then the legacy single amount when its currency matches.
+      # hash when it holds any amount, otherwise the legacy single amount for
+      # its own currency.
       #
       # @param currency [String]
       # @return [BigDecimal, nil] nil when the currency has no amount — the
       #   method is not offered for that cart
       def amount_for(currency)
-        explicit = preferred_amounts&.transform_keys { |key| key.to_s.upcase }&.dig(currency.to_s.upcase)
-        return BigDecimal(explicit.to_s) if explicit.present?
+        amounts = currency_amounts
+        return amounts[currency.to_s.upcase] if amounts.any?
 
         legacy_currency = respond_to?(:preferred_currency) ? preferred_currency : nil
         return preferred_amount if legacy_currency.blank? || legacy_currency.casecmp(currency.to_s).zero?
@@ -38,6 +42,15 @@ module Spree
       def supports_currency?(currency)
         amount_for(currency).present?
       end
+
+      private
+
+      # The hash's amounts by upper-case currency, without blank entries.
+      def currency_amounts
+        (preferred_amounts || {}).each_with_object({}) do |(key, value), amounts|
+          amounts[key.to_s.upcase] = BigDecimal(value.to_s) if value.present?
+        end
+      end
     end
   end
 end

data/app/models/concerns/spree/derived_number.rb

@@ -58,7 +58,7 @@ module Spree
     end
 
     def sibling_association_name
-      self.class.name.demodulize.underscore.pluralize
+      self.class.name.demodulize.underscore.pluralize.to_sym
     end
   end
 end

data/app/models/concerns/spree/has_external_references.rb

@@ -43,8 +43,31 @@ module Spree
     # @return [Spree::ExternalReference, nil] nil when the reference was removed
     def set_external_id(system, external_id, metadata: nil)
       key = Spree::ExternalReference.normalize_system(system)
-      reference = external_references.for_system(key).first
+      write_external_reference(key, external_references.for_system(key).first, external_id, metadata)
+    end
 
+    # Writes several references at once, leaving systems the payload does not
+    # mention untouched — a connector states its own key without disturbing
+    # another system's. Accepts the `{ system => external_id }` map the admin
+    # serializers render, or a list of `{ system:, external_id: }` entries.
+    #
+    # @param references [Hash{String,Symbol=>String}, Array<Hash>]
+    # @return [void]
+    def assign_external_references(references)
+      entries = Spree::ExternalReference.normalize_references(references)
+      return if entries.empty?
+
+      keys = entries.map { |entry| Spree::ExternalReference.normalize_system(entry[:system]) }
+      existing = external_references.where(system: keys).order(:id).group_by(&:system).transform_values(&:first)
+
+      entries.zip(keys).each do |entry, key|
+        existing[key] = write_external_reference(key, existing[key], entry[:external_id], entry[:metadata])
+      end
+    end
+
+    private
+
+    def write_external_reference(key, reference, external_id, metadata)
       if external_id.to_s.strip.blank?
         reference&.destroy
         external_references.reset
@@ -64,21 +87,6 @@ module Spree
       reference
     end
 
-    # Writes several references at once, leaving systems the payload does not
-    # mention untouched — a connector states its own key without disturbing
-    # another system's. Accepts the `{ system => external_id }` map the admin
-    # serializers render, or a list of `{ system:, external_id: }` entries.
-    #
-    # @param references [Hash{String,Symbol=>String}, Array<Hash>]
-    # @return [void]
-    def assign_external_references(references)
-      Spree::ExternalReference.normalize_references(references).each do |reference|
-        set_external_id(reference[:system], reference[:external_id], metadata: reference[:metadata])
-      end
-    end
-
-    private
-
     # A reference belongs to the same store as the record it identifies.
     #
     # Store-owning models answer directly;

data/app/models/concerns/spree/prefixed_id.rb

@@ -123,12 +123,22 @@ module Spree
 
         return values unless klass
 
+        # A model with a lookup of its own (Order) resolves each id through it.
+        unless klass.method(:find_by_param).owner == Spree::PrefixedId::ClassMethods
+          return values.map { |v| Spree::PrefixedId.prefixed_id?(v) ? klass.find_by_param!(v).id : v }
+        end
+
+        # One lookup for the whole list rather than one per id.
+        decoded = values.select { |v| Spree::PrefixedId.prefixed_id?(v) }.index_with { |v| klass.decode_own_prefixed_id(v) }
+        existing_ids = decoded.empty? ? [] : klass.where(id: decoded.values.compact).pluck(:id)
+
         values.map do |v|
-          if Spree::PrefixedId.prefixed_id?(v)
-            klass.find_by_param!(v).id
-          else
-            v
-          end
+          next v unless decoded.key?(v)
+
+          id = decoded[v]
+          raise ActiveRecord::RecordNotFound.new("Couldn't find #{klass.name} with param=#{v}", klass.name) unless id && existing_ids.include?(id)
+
+          id
         end
       end
 

data/app/models/concerns/spree/publishable.rb

@@ -91,9 +91,14 @@ module Spree
         end
 
         if events.include?(:delete)
-          before_destroy :capture_pre_destroy_payload, if: :should_publish_events?
+          before_destroy :capture_pre_destroy_payload, if: :lifecycle_publishing_enabled?
           after_commit :publish_delete_event, on: :destroy, if: :should_publish_events?
         end
+
+        after_save :note_lifecycle_write
+        after_destroy :note_lifecycle_destroy
+        after_commit :close_lifecycle_write
+        after_rollback :close_lifecycle_write
       end
 
       # A subclass publishes its lifecycle events under its own prefix, which may
@@ -308,9 +313,50 @@ module Spree
     end
 
     def should_publish_events?
+      !silenced_lifecycle_write? && lifecycle_publishing_enabled?
+    end
+
+    def lifecycle_publishing_enabled?
       self.class.publish_events && Spree::Events.lifecycle_enabled?
     end
 
+    # Lifecycle events publish at commit, which can come after the block that
+    # silenced the write ended — a default record created in its parent's
+    # `after_create` commits together with the parent. Each write records
+    # whether events were on, so a record written only while they were off
+    # stays silent at commit; one written with them on still publishes.
+    #
+    # The marker is read, never cleared, at commit: Rails may check several
+    # commit callbacks for one commit (a soft delete is also an update), and
+    # the order commit callbacks run in is the host app's setting. A commit or
+    # rollback only closes it, and the next write starts a fresh one.
+    def note_lifecycle_write
+      reopen_lifecycle_write
+      @_spree_lifecycle_write_enabled ||= Spree::Events.lifecycle_enabled?
+    end
+
+    # A destroy commits as the delete event alone, so an earlier update made
+    # with events on must not carry it through.
+    def note_lifecycle_destroy
+      reopen_lifecycle_write
+      @_spree_lifecycle_write_enabled = Spree::Events.lifecycle_enabled?
+    end
+
+    def silenced_lifecycle_write?
+      @_spree_lifecycle_write_enabled == false
+    end
+
+    def close_lifecycle_write
+      @_spree_lifecycle_write_closed = true
+    end
+
+    def reopen_lifecycle_write
+      return unless @_spree_lifecycle_write_closed
+
+      @_spree_lifecycle_write_closed = false
+      @_spree_lifecycle_write_enabled = nil
+    end
+
     # True when this commit was caused only by `touch` — no real save ran
     # (`after_update` fires for saves, never for touches). Flags reset every
     # commit so a later genuine update publishes normally.

data/app/models/concerns/spree/purchase/addresses.rb

@@ -3,8 +3,8 @@ module Spree
     # The full address surface shared by Spree::Cart and Spree::Order:
     # the bill/ship associations and their public aliases, default filling
     # from the customer's saved addresses, address-row deduplication on
-    # write, ownership-guarded address_id assignment, promotion of checkout
-    # addresses to the customer's defaults, and the ship→bill cloning
+    # write, ownership-guarded address_id assignment and deletion, promotion
+    # of checkout addresses to the customer's defaults, and the ship→bill cloning
     # predicate. The shipping address is canonical: use_shipping copies it
     # onto the billing address; the reverse use_billing direction is a
     # deprecated 6.1-removal bridge. Clone callbacks are wired per model.
@@ -12,8 +12,13 @@ module Spree
       extend ActiveSupport::Concern
 
       included do
-        belongs_to :bill_address, class_name: 'Spree::Address', optional: true, dependent: :destroy
-        belongs_to :ship_address, class_name: 'Spree::Address', optional: true, dependent: :destroy
+        belongs_to :bill_address, class_name: 'Spree::Address', optional: true
+        belongs_to :ship_address, class_name: 'Spree::Address', optional: true
+
+        # Stands in for `dependent: :destroy`, which would take any attached
+        # row down with the purchase. See {#owns_address?} for why only some
+        # of them may go.
+        after_destroy :destroy_own_addresses
 
         # The writers these generate are shadowed by the hand-written ones
         # below, which deduplicate address rows. The declarations still earn
@@ -40,9 +45,12 @@ module Spree
         before_validation :clone_shipping_address, if: :use_shipping?
       end
 
+      # Whether both addresses are present and match. With neither present
+      # there is nothing to call the same.
+      #
       # @return [Boolean]
       def shipping_eq_billing_address?
-        bill_address == ship_address
+        ship_address.present? && bill_address == ship_address
       end
 
       # Whether checkout must collect a customer shipping address. Selected
@@ -54,7 +62,11 @@ module Spree
       #
       # @return [Boolean]
       def shipping_address_required?
-        selected_methods = fulfillments.filter_map(&:delivery_method)
+        candidates = fulfillments.to_a
+        if candidates.many? && candidates.all?(ActiveRecord::Base)
+          ActiveRecord::Associations::Preloader.new(records: candidates, associations: { selected_delivery_rate: :delivery_method }).call
+        end
+        selected_methods = candidates.filter_map(&:delivery_method)
         return selected_methods.any?(&:requires_address?) if selected_methods.any?
 
         return false if preferred_stock_location_id.present?
@@ -90,6 +102,68 @@ module Spree
         use_shipping.in?([true, 'true', '1'])
       end
 
+      # The address behind an id a client may select, or nil when the id names
+      # one this purchase has no business shipping to. Takes a prefixed id or a
+      # raw primary key, so the services that resolve a client-supplied id and
+      # the writers below share one rule rather than each inventing their own.
+      #
+      # Two books qualify. The buyer's own is the ordinary case. The company's
+      # is the B2B one: a purchase for a node ships to that node's sites, and
+      # to its ancestors' — the same self-and-ancestors chain the node's
+      # default address is prefilled from, so a division can pick the
+      # headquarters address it already inherits.
+      #
+      # @param id [Integer, String, nil]
+      # @return [Spree::Address, nil]
+      def selectable_address(id)
+        address = ::Spree::Address.not_deleted.find_by_param(id) || ::Spree::Address.not_deleted.find_by(id: id)
+        return if address.nil?
+
+        return address if customer_id.present? && address.customer_owned? && address.owner_id == customer_id
+
+        company = readable_company
+        return if company.nil? || address.owner_type != 'Spree::Company'
+
+        company.self_and_ancestors.any? { |node| node.id == address.owner_id } ? address : nil
+      end
+
+      # Everything a checkout address picker may offer for this purchase: the
+      # buyer's own book plus the book of the company it names, that node's
+      # own entries and the ones it inherits, limited to the countries the
+      # purchase's market sells to. A subset of what {#selectable_address}
+      # accepts, so a picker built from it never offers an address the
+      # checkout cannot deliver to.
+      #
+      # @return [ActiveRecord::Relation<Spree::Address>]
+      def selectable_addresses
+        books = []
+        books << ::Spree::Address.not_deleted.where(owner_type: ::Spree.customer_class.to_s, owner_id: customer_id) if customer_id.present?
+        books << readable_company&.address_book
+
+        addresses = books.compact.reduce { |left, right| left.or(right) } || ::Spree::Address.none
+        return addresses if market.nil?
+
+        addresses.where(country_code: market.market_countries.select(:country_code))
+      end
+
+      # Whether an attached address row is this purchase's own to delete.
+      #
+      # Only the ownerless rows are: the one a guest typed in, and the
+      # snapshot completion copies onto the order. Everything else is an entry
+      # in somebody's address book — the buyer's, a company node's, a seller's
+      # — which the purchase is merely pointing at. A cart may name a company
+      # site every other member ships from, so taking an attached row down
+      # with the cart would let one member empty the shared book.
+      #
+      # A business snapshot keeps its +owner_type+ to stay addressed to a
+      # company rather than to a person, so ownership is the id, not the type.
+      #
+      # @param address [Spree::Address, nil]
+      # @return [Boolean]
+      def owns_address?(address)
+        address.present? && address.owner_id.blank?
+      end
+
       # Fills any blank bill/ship address from the customer's valid saved
       # defaults. The ship address is skipped when no physical delivery is
       # required, so shipping-address validations never fire on digital-only
@@ -174,46 +248,50 @@ module Spree
 
       private
 
+      # The company whose book this purchase may read: only the one the
+      # client named, never one inferred from a sole membership. A cart asks
+      # again rather than trusting the column, which nothing clears when a
+      # membership is revoked; an order's authority is staff or a completed
+      # cart, so it keeps what it was given.
+      #
+      # @return [Spree::Company, nil]
+      def readable_company
+        return company if company.nil? || !is_a?(Spree::Cart)
+
+        company if customer&.standing_for?(company)
+      end
+
+      # Both slots often hold the same row, so destroy it once.
+      def destroy_own_addresses
+        [bill_address, ship_address].compact.uniq.each do |address|
+          address.destroy if owns_address?(address)
+        end
+      end
+
       def items_require_shipping_address?
         # Answered by the profile kind, resolved once per profile.
         profile_requires_address = Hash.new do |cache, profile|
           cache[profile] = profile.present? && profile.requires_shipping_address?
         end
 
-        # Both profile paths are preloaded: the variant's own override, and the
-        # product's for the variants that inherit it.
-        line_items.includes(variant: [:delivery_profile, { product: :delivery_profile }]).any? do |line_item|
+        # On a list the association batches across the page, so a fresh
+        # `includes` query would load every cart's items separately. Read
+        # alone, both profile paths are preloaded: the variant's own override,
+        # and the product's for the variants that inherit it.
+        profile_paths = { variant: [:delivery_profile, { product: :delivery_profile }] }
+        items = if !read_association_in_memory?(:line_items)
+                  line_items.includes(profile_paths)
+                elsif lazy_preload_context.nil?
+                  line_items.tap { |loaded| ActiveRecord::Associations::Preloader.new(records: loaded.to_a, associations: profile_paths).call }
+                else
+                  line_items
+                end
+
+        items.any? do |line_item|
           profile_requires_address[line_item.variant&.resolved_delivery_profile]
         end
       end
 
-      # The address behind an id a client may select, or nil when the id names
-      # one this purchase has no business shipping to.
-      #
-      # Two books qualify. The buyer's own is the ordinary case. The company's
-      # is the B2B one: a purchase for a node ships to that node's sites, and
-      # to its ancestors' — the same self-and-ancestors chain the node's
-      # default address is prefilled from, so a division can pick the
-      # headquarters address it already inherits.
-      #
-      # Standing is not re-checked here: a cart cannot name a company its
-      # customer lacks standing over, so reaching this point already means the
-      # buyer may act for the node.
-      #
-      # @param id [Integer, String, nil]
-      # @return [Spree::Address, nil]
-      def selectable_address(id)
-        address = ::Spree::Address.find_by(id: id)
-        return nil if address.nil?
-
-        return address if customer_id.present? && address.customer_owned? && address.owner_id == customer_id
-
-        company = resolved_company
-        return nil if company.nil? || address.owner_type != 'Spree::Company'
-
-        company.self_and_ancestors.any? { |node| node.id == address.owner_id } ? address : nil
-      end
-
       # Reuse never reaches past what the buyer already owns: a signed-in buyer
       # may name any entry of their own address book, and a guest — who keeps
       # no book — may only edit the row already in the slot being written.

data/app/models/concerns/spree/purchase/digital_items.rb

@@ -9,7 +9,7 @@ module Spree
         if total_quantity.zero? || line_items.empty?
           false
         else
-          line_items.includes(variant: :product).all?(&:digital?)
+          line_items_with_variants(variant: :product).all?(&:digital?)
         end
       end
 
@@ -18,7 +18,7 @@ module Spree
         if total_quantity.zero? || line_items.empty?
           false
         else
-          line_items.includes(variant: :product).any?(&:digital?)
+          line_items_with_variants(variant: :product).any?(&:digital?)
         end
       end
 
@@ -27,7 +27,7 @@ module Spree
         if total_quantity.zero? || line_items.empty?
           false
         else
-          line_items.includes(:variant).any?(&:with_digital_assets?)
+          line_items_with_variants(variant: :digital_assets).any?(&:with_digital_assets?)
         end
       end
 
@@ -55,6 +55,20 @@ module Spree
       def delivery_step_required?
         line_items.any? && !digital?
       end
+
+      private
+
+      # Lines already in memory get the associations preloaded onto them —
+      # onto every line of their preload context when they sit in a list, so
+      # the list batches them instead of querying once per purchase.
+      def line_items_with_variants(associations)
+        return line_items.includes(associations) unless read_association_in_memory?(:line_items)
+
+        loaded = line_items.to_a
+        records = loaded.first&.lazy_preload_context&.records || loaded
+        ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+        loaded
+      end
     end
   end
 end

data/app/models/concerns/spree/purchase/freight.rb

@@ -42,7 +42,8 @@ module Spree
       # twice. Two freight consignments are still one load to the forwarder,
       # so they are merged rather than listed.
       def build_freight_summary
-        summaries = fulfillments.valid.filter_map { |fulfillment| fulfillment.selected_delivery_rate&.freight_summary }
+        shipping = read_association_in_memory?(:fulfillments) ? fulfillments.reject(&:canceled?) : fulfillments.valid
+        summaries = shipping.filter_map { |fulfillment| fulfillment.selected_delivery_rate&.freight_summary }
         return if summaries.empty?
 
         Spree::FreightSummary.merge(summaries)

data/app/models/concerns/spree/purchase/payment_processing.rb

@@ -55,7 +55,7 @@ module Spree
       # @return [Boolean]
       def confirmation_required?
         Spree::StorePreferences.read(store, :always_include_confirm_step) ||
-          payments.valid.map(&:payment_method).compact.any?(&:confirmation_required?)
+          valid_payments.filter_map(&:payment_method).any?(&:confirmation_required?)
       end
 
       def unprocessed_payments
@@ -64,6 +64,12 @@ module Spree
 
       private
 
+      # On a list the association batches across the page, so the loaded rows
+      # are filtered rather than queried through `valid` once per record.
+      def valid_payments
+        read_association_in_memory?(:payments) ? payments.reject(&:has_invalid_status?) : payments.valid
+      end
+
       def process_payments_with(action)
         # Don't run if there is nothing to pay. Read from the database, not
         # the in-memory attribute: settlements land through the order status

data/app/models/concerns/spree/purchase/quantity_rules.rb

@@ -104,6 +104,8 @@ module Spree
         # accuse a completed sale of breaking a rule written after it.
         return [] if staff_initiated? || (is_a?(Spree::Order) && completed?)
 
+        ActiveRecord::Associations::Preloader.new(records: line_items.to_a, associations: { variant: :product }).call
+
         line_items.filter_map do |line_item|
           variant = line_item.variant
           next if variant.nil?

data/app/models/concerns/spree/stores/channels.rb

@@ -13,7 +13,9 @@ module Spree
       def ensure_default_channel
         return if default_channel
 
-        channels.create!(name: 'Online Store', code: Spree::Channel::DEFAULT_CODE)
+        Spree::Events.disable do
+          channels.create!(name: 'Online Store', code: Spree::Channel::DEFAULT_CODE)
+        end
       end
     end
   end

data/app/models/concerns/spree/translatable_resource.rb

@@ -168,7 +168,12 @@ module Spree
     def translatable_store
       return self if is_a?(Spree::Store)
 
-      try(:store) || Spree::Current.store
+      current_store = Spree::Current.store
+      # The request's store instance already carries its markets, so a batch
+      # of records does not re-read them once per record's own store copy.
+      return current_store if current_store && try(:store_id) == current_store.id
+
+      try(:store) || current_store
     end
 
     private

data/app/models/concerns/spree/webhook_payload_redaction.rb

@@ -32,6 +32,7 @@ module Spree
       reset_token
       unsubscribe_token
       verification_token
+      confirmation_token
       download_url
       external_client_secret
       client_secret