spree_core 6.0.0.rc5 → 6.0.0.rc7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e7960e9257c5de15c7d9e69d8916c669c5ab082fccd02e17c5ee9c9d9d378c8
-  data.tar.gz: 3c160cd58beb2d3fc3c99bead42bc0d3f365952ae7c2b2c103d92004303f7d13
+  metadata.gz: 820fa04cc9e7d880ff2a324afaf5fa2dce0f197c809b7d0af3aa59b69b65f8b6
+  data.tar.gz: be3a6fac21d4524551c479cd02b8256f34ee9957e838f382bd37555fa40e9689
 SHA512:
-  metadata.gz: b396fb4c3d553e372dab904f57cb794015b4c2670028fea33c775fc343ac844db1d0d2733a9c47cfb2450898408ad4696ba312114719f7b3d1ad55716149f674
-  data.tar.gz: 89e9eb2e33742ec34f5c89e5e732544a868e4241ba5886cfa357e0ca43929107d895024ff6e936952c3648cf51ac379e7839ac2d211dc2515697d2ff52d8e7a7
+  metadata.gz: 8941ff574c4ba3455b1e67d90d500a61180d2567e6c5f5fa74e3db43aefb62d79d720753565a0ef4c29a6628f9e02a92385b6af7345548c8074815f6d212fa17
+  data.tar.gz: 9e0ac49d08274a0cc82a1aea9fb8ea74bfb093b49d276401e62e34ef57b0fee0e30b3f814d465718d2d758ab855d35a36f16b31b281245a377e7d6ced174af9f

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

@@ -62,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?
@@ -270,9 +274,20 @@ module Spree
           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

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/spree/admin_user.rb

@@ -8,6 +8,7 @@ module Spree
 
     include Spree::AdminUserMethods
     include Spree::AccountLockout
+    include Spree::AccountDeactivation
     include Spree::PasswordPolicy
 
     validates :email, presence: true, uniqueness: { case_sensitive: false }

data/app/models/spree/base.rb

@@ -46,13 +46,21 @@ class Spree::Base < ApplicationRecord
     select("#{klass.table_name}.*").select(*(fields || klass::TRANSLATABLE_FIELDS))
   }
 
+  # The store's own rows of this model, through the association named after
+  # it. A model the store has no association for answers nothing: a tenant
+  # boundary that quietly widened to every store's rows is how a cross-store
+  # read ships unnoticed. Global reference data (countries, roles) and
+  # records reached through a parent are fetched as such, never through here.
+  #
+  # @param store [Spree::Store]
+  # @return [ActiveRecord::Relation]
   def self.for_store(store)
     plural_model_name = model_name.plural.gsub(/spree_/, '').to_sym
 
     if store.respond_to?(plural_model_name)
       store.send(plural_model_name)
     else
-      self
+      none
     end
   end
 
@@ -81,6 +89,30 @@ class Spree::Base < ApplicationRecord
     association(name).loaded? || lazy_preload_context.present?
   end
 
+  # Recomputes a counter cache for many records at once. Rails'
+  # +reset_counters+ spends two queries per record, which a bulk write pays
+  # for every row it touched; this is one grouped count plus one UPDATE per
+  # distinct value.
+  #
+  # @param ids [Array] the records whose counter is recomputed
+  # @param association [Symbol] the has_many whose rows are counted
+  # @return [void]
+  def self.reset_counters_in_bulk(ids, association)
+    ids = Array(ids).compact.uniq
+    return if ids.empty?
+
+    reflection = reflect_on_association(association)
+    counter = reflection.klass.reflect_on_all_associations(:belongs_to).find do |belongs_to|
+      belongs_to.foreign_key.to_s == reflection.foreign_key.to_s && belongs_to.options[:counter_cache]
+    end.counter_cache_column
+
+    counts = reflection.klass.where(reflection.foreign_key => ids).group(reflection.foreign_key).count
+
+    ids.group_by { |id| counts.fetch(id, 0) }.each do |count, grouped_ids|
+      unscoped.where(id: grouped_ids).where.not(counter => count).update_all(counter => count)
+    end
+  end
+
   # @see Spree.mysql? — the single definition; this reads it so a model can
   #   branch without reaching for the connection itself.
   def mysql_adapter?

data/app/models/spree/calculator/shipping/digital_delivery.rb

@@ -3,7 +3,9 @@ module Spree
     class DigitalDelivery < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :money, default: 0
+      # Blank once its figure has moved into `amounts`, so the method quotes
+      # nothing outside the hash.
+      preference :amount, :money, default: 0, nullable: true
       preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
       def self.description

data/app/models/spree/calculator/shipping/flat_rate.rb

@@ -3,7 +3,9 @@ module Spree
     class FlatRate < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :money, default: 0
+      # Blank once its figure has moved into `amounts`, so the method quotes
+      # nothing outside the hash.
+      preference :amount, :money, default: 0, nullable: true
       # @deprecated Together with the single `amount`, superseded by the
       #   per-currency `amounts` hash; kept as the fallback for its own
       #   currency so upgraded stores quote unchanged.

data/app/models/spree/calculator/shipping/per_item.rb

@@ -3,7 +3,9 @@ module Spree
     class PerItem < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :money, default: 0
+      # Blank once its figure has moved into `amounts`, so the method quotes
+      # nothing outside the hash.
+      preference :amount, :money, default: 0, nullable: true
       preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
       def self.description

data/app/models/spree/cart.rb

@@ -203,10 +203,13 @@ module Spree
     # delivery_unavailable warning per affected line item (parity with the
     # order-side ensure_available_delivery_rates).
     def prune_undeliverable_fulfillments!
-      undeliverable = fulfillments.reload.select { |fulfillment| fulfillment.delivery_rates.empty? }
+      candidates = fulfillments.reload.to_a
+      ActiveRecord::Associations::Preloader.new(records: candidates, associations: :delivery_rates).call
+      undeliverable = candidates.select { |fulfillment| fulfillment.delivery_rates.empty? }
       return if undeliverable.empty?
 
       affected_line_items = undeliverable.flat_map(&:line_items).uniq
+      ActiveRecord::Associations::Preloader.new(records: affected_line_items, associations: { variant: :product }).call
       undeliverable.each(&:destroy)
       self.warnings |= affected_line_items.map do |line_item|
         {