spree_core 6.0.0 → 6.0.2

data/app/models/spree/refresh_token.rb

@@ -6,12 +6,19 @@ module Spree
 
     has_secure_token :token
 
+    # Personal data. Rows written before encryption was enabled stay readable
+    # and are encrypted when the token next rotates.
+    encrypts :ip_address, support_unencrypted_data: true if ActiveRecord::Encryption.config.has_primary_key?
+
     validates :user, :expires_at, presence: true
     # On create only: rows minted before the column exists keep their NULL and
     # stay loadable (they are simply unredeemable), while nothing new is born
     # without the surface it belongs to.
     validates :audience, presence: true, on: :create
 
+    # Starting a session and refreshing one both create a row.
+    after_create :record_user_activity
+
     scope :active, -> { where('expires_at > ?', Time.current) }
     scope :expired, -> { where('expires_at <= ?', Time.current) }
 
@@ -23,6 +30,12 @@ module Spree
       expires_at <= Time.current
     end
 
+    # Each refresh replaces the row, so its creation is the session's last use.
+    # @return [ActiveSupport::TimeWithZone]
+    def last_active_at
+      created_at
+    end
+
     # Rotate: destroy this token and create a new one.
     # Returns the new token.
     def rotate!(request_env: {})
@@ -74,5 +87,18 @@ module Spree
     rescue StandardError
       30.days
     end
+
+    private
+
+    # Outlives the session itself, which signing out deletes. Skips callbacks
+    # and +updated_at+: activity is not an edit to the account, and an older
+    # session committing last never moves it back. Users without the column
+    # (customers, custom admin classes) are left alone.
+    def record_user_activity
+      return unless user.has_attribute?(:last_active_at)
+
+      stale = user.class.where(id: user.id).where('last_active_at IS NULL OR last_active_at < ?', created_at)
+      stale.update_all(last_active_at: created_at)
+    end
   end
 end

data/app/models/spree/seller_transfer.rb

@@ -89,6 +89,16 @@ module Spree
     # amount is negative, and sending one as a transfer pays the seller the
     # money it exists to take back.
     scope :awaiting_provider, -> { earnings.retryable.where(payout_id: nil) }
+    # Reversals still owing the provider a call: refused, or waiting for their
+    # earning to reach the provider first. Kept apart from `awaiting_provider`
+    # so a caller has to choose `reverse!` for these by name.
+    #
+    # A reversal of an earning nobody can account for waits with it: there is
+    # nothing to take back from until a person settles what happened.
+    scope :reversals_awaiting_provider, lambda {
+      reversals_only.retryable.where(payout_id: nil).
+        where.not(reversed_from_id: Spree::SellerTransfer.with_status('unresolved').select(:id))
+    }
     # Earned and confirmed, but not yet swept into a settlement — what the next
     # payout will pick up.
     scope :unsettled, -> { completed.where(payout_id: nil) }
@@ -138,6 +148,47 @@ module Spree
       [amount - reversals.sum(:amount).abs, 0].max
     end
 
+    # The provider that moved this row's money, not whichever one the store
+    # uses now. A marketplace that changes provider still has money sitting
+    # with the old one, and asking the new one to reverse a transfer it never
+    # made leaves the original standing.
+    #
+    # No silent fallback when that provider is no longer installed: handing
+    # the row to a different one would mark it done while the money stayed
+    # where it was. An operator has to know.
+    #
+    # @return [Spree::PayoutProvider::Base]
+    # @raise [Spree::Core::GatewayError] when the provider is not registered
+    def payout_provider_instance
+      configured = Spree::ApiTyped.registered_class(Spree.payout_providers, provider)
+      raise Spree::Core::GatewayError, "Payout provider #{provider} is not registered" if configured.nil?
+
+      configured.new
+    end
+
+    # The settlement a reversal of part of this earning records.
+    #
+    # A clawback has to settle where its earning settled. Payouts are swept by
+    # settlement currency, so a reversal left in the sale's currency would
+    # never join the batch that pays the earning it cancels — the seller would
+    # be paid in full for goods that came back.
+    #
+    # Prorated from this earning's settled figure rather than converted at
+    # today's rate, so the money comes back at the rate it went out at.
+    #
+    # @param part [BigDecimal] how much of this earning is reversed, positive
+    # @return [Hash] negative `settled_amount` and `settled_currency`
+    def reversal_settlement(part)
+      return {} if settled_amount.blank? || amount.zero?
+
+      share = settled_amount * (part / amount)
+
+      {
+        settled_amount: -Spree::Money::Rounding.quantize(share, Spree::Money::Rounding.precision(settlement_currency)),
+        settled_currency: settled_currency
+      }
+    end
+
     # @return [Boolean]
     def earning?
       kind == 'earning'

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

@@ -22,13 +22,45 @@ module Spree
       end
 
       def packages
-        packages = build_packages
-        packages = prioritize_packages(packages)
-        packages = estimate_packages(packages)
+        estimate_packages(allocated_packages)
       end
 
-      def build_packages(packages = [])
-        stock_locations = stock_locations_with_requested_variants.to_a
+      # Where each unit comes from, without quoting a rate, so a caller that
+      # only needs the origins — a checkout hold — never costs a carrier request.
+      #
+      # @param stock_locations [Array<Spree::StockLocation>] candidate origins, preferred first
+      # @return [Array<Spree::Stock::Package>]
+      def allocated_packages(stock_locations = candidate_stock_locations)
+        prioritize_packages(build_packages(stock_locations: stock_locations))
+      end
+
+      # Whether any delivery method can carry the package to the order's
+      # address, by the rule allocation ranked origins with, so no rate is requested.
+      #
+      # @param package [Spree::Stock::Package]
+      # @return [Boolean]
+      def deliverable?(package)
+        estimator.deliverable?(package)
+      end
+
+      # @param packages [Array<Spree::Stock::Package>]
+      # @return [Array<Spree::Stock::Package>] the same packages, with their delivery rates
+      def estimate_packages(packages)
+        packages.each do |package|
+          package.delivery_rates = estimator.delivery_rates(package)
+        end
+        packages
+      end
+
+      # Active locations stocking any requested variant, in database order.
+      #
+      # @return [Array<Spree::StockLocation>]
+      def candidate_stock_locations
+        order.store.stock_locations.active.joins(:stock_levels)
+             .where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids }).distinct.to_a
+      end
+
+      def build_packages(packages = [], stock_locations: candidate_stock_locations)
         stock_levels = Packer.stock_levels_by_location(stock_locations, requested_variant_ids)
 
         stock_locations.each do |stock_location|
@@ -44,11 +76,6 @@ module Spree
 
       private
 
-      def stock_locations_with_requested_variants
-        order.store.stock_locations.active.joins(:stock_levels).
-          where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids }).distinct
-      end
-
       # An item may only be allocated from locations its delivery profile
       # covers — a profile narrowed to the cold-storage warehouse never packs
       # from anywhere else — intersected with the channel's served set when
@@ -104,13 +131,6 @@ module Spree
         prioritizer.prioritized_packages
       end
 
-      def estimate_packages(packages)
-        packages.each do |package|
-          package.delivery_rates = estimator.delivery_rates(package)
-        end
-        packages
-      end
-
       # Shared between prioritization (which origins can deliver at all) and
       # the rate refresh, so both answer with the same eligibility rules.
       def estimator

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

@@ -44,25 +44,35 @@ module Spree
         package = build_package
 
         # Group by variant_id as grouping by variant fires cached query.
-        units_by_variant_id = inventory_units.index_by(&:variant_id)
+        units_by_variant_id = inventory_units.group_by(&:variant_id)
         # The package's variants and their levels here, each in one query
         # rather than one per variant. Lowest id first, as StockLocation#stock_level reads.
         variants = variants_for(units_by_variant_id)
         stock_levels = @stock_levels || stock_location.stock_levels.where(variant_id: units_by_variant_id.keys).order(:id).
                        group_by(&:variant_id).transform_values(&:first)
 
-        units_by_variant_id.each do |variant_id, inventory_unit|
+        units_by_variant_id.each do |variant_id, units|
           variant = variants[variant_id] || Spree::Variant.find(variant_id)
-          unit = inventory_unit.dup # Can be used by others, do not use directly
+          # Can be used by others, do not use directly
+          units = units.map(&:dup)
           if variant.should_track_inventory?
             stock_level = stock_levels[variant_id]
             next if stock_level.nil?
 
-            on_hand, backordered = stock_location.fill_status(variant, unit.quantity, stock_level: stock_level)
-            package.add(FulfillmentItem.split(unit, backordered), :backordered) if backordered.positive?
-            package.add(FulfillmentItem.split(unit, on_hand), :on_hand) if on_hand.positive?
+            on_hand, backordered = stock_location.fill_status(variant, units.sum(&:quantity), stock_level: stock_level)
+            # Two lines of one variant draw on one shelf, so it is split
+            # between them in order rather than offered to each in full.
+            units.each do |unit|
+              unit_on_hand = [on_hand, unit.quantity].min
+              unit_backordered = [backordered, unit.quantity - unit_on_hand].min
+              on_hand -= unit_on_hand
+              backordered -= unit_backordered
+
+              package.add(FulfillmentItem.split(unit, unit_backordered), :backordered) if unit_backordered.positive?
+              package.add(FulfillmentItem.split(unit, unit_on_hand), :on_hand) if unit_on_hand.positive?
+            end
           else
-            package.add unit
+            units.each { |unit| package.add unit }
           end
         end
 
@@ -84,8 +94,8 @@ module Spree
       # The units' own variants when they carry them, so a cart's variants are
       # read once however many locations are packed.
       def variants_for(units_by_variant_id)
-        variants = units_by_variant_id.each_with_object({}) do |(variant_id, unit), loaded|
-          loaded[variant_id] = unit.variant if unit.association(:variant).loaded?
+        variants = units_by_variant_id.each_with_object({}) do |(variant_id, units), loaded|
+          loaded[variant_id] = units.first.variant if units.first.association(:variant).loaded?
         end
         missing_ids = units_by_variant_id.keys - variants.keys
         missing_ids.empty? ? variants : variants.merge(Spree::Variant.where(id: missing_ids).index_by(&:id))

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

@@ -18,6 +18,7 @@ module Spree
 
       def prioritized_packages
         sort_packages
+        withdraw_covered_items
         adjust_packages
         prune_packages
         packages
@@ -44,11 +45,10 @@ module Spree
       end
 
       # Origins that can deliver go first, so the Adjuster fills each unit from
-      # one of them and the origins that cannot are left empty and pruned. A
-      # profile with per-region origin groups would otherwise allocate to
-      # whichever warehouse came first, and when that warehouse's group has no
-      # method for the destination the item is dropped as undeliverable even
-      # though another warehouse could have shipped it.
+      # one of them. A profile with per-region origin groups would otherwise
+      # allocate to whichever warehouse came first, and when that warehouse's
+      # group has no method for the destination the item is dropped as
+      # undeliverable even though another warehouse could have shipped it.
       #
       # The caller's order survives within each group, so routing rank and the
       # store's location order still decide between origins that can both
@@ -56,25 +56,40 @@ module Spree
       def sort_packages
         return if estimator.nil?
 
-        ranked = packages.each_with_index.sort_by do |package, index|
-          [estimator.deliverable?(package) ? 0 : 1, index]
+        deliverable, @undeliverable_packages = packages.partition { |package| estimator.deliverable?(package) }
+        packages.replace(deliverable + @undeliverable_packages)
+      end
+
+      # Ordering alone loses to the Adjuster, which takes stock on hand anywhere
+      # over a backorder; a unit the capable origins cannot cover stays, so it is
+      # still reported as undeliverable rather than lost.
+      def withdraw_covered_items
+        return if @undeliverable_packages.blank? || @undeliverable_packages.size == packages.size
+
+        supplied = supplied_quantities(packages - @undeliverable_packages)
+
+        @undeliverable_packages.each do |package|
+          package.contents.each do |item|
+            package.remove_item(item) if supplied[hash_item(item)] >= item.inventory_unit.required_quantity
+          end
         end
+      end
 
-        packages.replace(ranked.map(&:first))
+      def supplied_quantities(packages)
+        packages.flat_map(&:contents).each_with_object(Hash.new(0)) do |item, supplied|
+          supplied[hash_item(item)] += item.quantity
+        end
       end
 
       def prune_packages
         packages.reject!(&:empty?)
       end
 
+      # A proposed unit has no fulfillment, so its line item keeps two lines of
+      # one variant apart; a pair, as XORed ids collide whenever they match.
       def hash_item(item)
-        shipment = item.inventory_unit.fulfillment
-        variant  = item.inventory_unit.variant
-        if shipment.present?
-          variant.hash ^ shipment.hash
-        else
-          variant.hash
-        end
+        unit = item.inventory_unit
+        [unit.variant, unit.fulfillment || unit.line_item_id]
       end
     end
   end

data/app/models/spree/store.rb

@@ -42,6 +42,11 @@ module Spree
       acts_as_paranoid
       # deleted translation values still need to be accessible - remove deleted_at scope
       default_scope { unscope(where: :deleted_at) }
+
+      # Mobility deletes a row once its last value is cleared. The soft delete
+      # stamps only `deleted_at`, and the row stays readable, so the cleared
+      # values have to be written too or the old translation keeps showing.
+      before_destroy { update_columns(changes_to_save.transform_values(&:last)) if has_changes_to_save? }
     end
 
     #
@@ -50,8 +55,9 @@ module Spree
     UNIT_SYSTEMS = %w[metric imperial].freeze
 
     # general preferences
-    preference :admin_locale, :string, format: :locale
-    preference :timezone, :string, format: :timezone, default: Time.zone.name
+    preference :admin_locale, :string, format: :locale, parse_on_set: ->(value) { Spree::Locales.listed(value) || value.presence }
+    preference :timezone, :string, format: :timezone, default: Spree::TimeZones.normalize(Time.zone.name),
+                                   parse_on_set: ->(value) { Spree::TimeZones.normalize(value) }
     preference :weight_unit, :string, default: 'lb', choices: -> { Spree::Variant::WEIGHT_UNITS }
     preference :unit_system, :string, default: 'imperial', choices: -> { UNIT_SYSTEMS }
     # Anonymous identifier of this installation, kept on the default store
@@ -403,6 +409,8 @@ module Spree
                         message: :invalid_document_number_affix }
     validates :preferred_capture_method, inclusion: { in: Spree::CaptureMethod::CAPTURE_METHODS }
     validate :preferred_storefront_url_is_an_origin
+    validate :preferred_admin_locale_is_listed
+    validate :preferred_timezone_is_a_time_zone
     validate :order_number_sequence_start_unchanged_after_first_number, on: :update
     validates :mail_from_address, email: { allow_blank: false }
     validates :customer_support_email, email: { allow_blank: true }
@@ -836,6 +844,31 @@ module Spree
       errors.add(:preferred_storefront_url, :invalid)
     end
 
+    def preferred_admin_locale_is_listed
+      locale = preferred_admin_locale
+      return if locale.blank? || Spree::Locales::ALL.include?(locale)
+      return if awaiting_upgrade?(:admin_locale) { Spree::Locales.listed(locale) }
+
+      errors.add(:preferred_admin_locale, :inclusion)
+    end
+
+    def preferred_timezone_is_a_time_zone
+      return if Spree::TimeZones.valid?(preferred_timezone)
+      return if awaiting_upgrade?(:timezone) { Spree::TimeZones.valid?(Spree::TimeZones.normalize(preferred_timezone)) }
+
+      errors.add(:preferred_timezone, :invalid)
+    end
+
+    # A value saved before 6.0 that the store settings upgrade step converts
+    # must not block saving the store's other settings until the step runs.
+    # The block says whether the step can convert it.
+    def awaiting_upgrade?(name)
+      return false unless persisted?
+      return false unless public_send(:"preferred_#{name}") == (attribute_was('preferences') || {})[name]
+
+      yield.present?
+    end
+
     # The starting value only shapes a counter that does not exist yet — once
     # the first number is issued the counter owns the value, so accepting a
     # change here would persist a setting that can never apply again. The

data/app/models/spree/variant.rb

@@ -71,7 +71,7 @@ module Spree
       has_many :stock_reservations
     end
 
-    has_many :option_value_variants, class_name: 'Spree::OptionValueVariant'
+    has_many :option_value_variants, class_name: 'Spree::OptionValueVariant', dependent: :destroy
     has_many :option_values, through: :option_value_variants, dependent: :destroy, class_name: 'Spree::OptionValue'
 
     has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: 'Spree::Media'

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

@@ -252,12 +252,13 @@ module Spree
 
       # Three-way dispatch on the cart→checkout transition:
       # entering checkout → Reserve, mid-checkout mutation → Extend, reverting to cart → Release.
+      # A new destination reserves again, because it can move the units to another origin.
       # A failed Reserve raises so the enclosing transaction rolls back and the
       # outer rescue surfaces the error to the API caller.
       def sync_stock_reservations(was_in_checkout:)
         if !cart.in_checkout?
           Spree::StockReservations::Release.call(cart: cart) if was_in_checkout
-        elsif was_in_checkout
+        elsif was_in_checkout && !@destination_changed && !@new_delivery_destination
           Spree::StockReservations::Extend.call(cart: cart)
         else
           result = Spree::StockReservations::Reserve.call(cart: cart)

data/app/services/spree/promotions/detach_from_owner.rb

@@ -0,0 +1,72 @@
+module Spree
+  module Promotions
+    # Removes a promotion from a cart or an order the way a shopper removing the
+    # code does: the order promotion, held coupon code, discounts and items
+    # the promotion added are removed, then totals are recalculated.
+    #
+    # @example Removing a promotion from a cart
+    #   Spree::Promotions::DetachFromOwner.call(owner: cart, promotion: promotion)
+    class DetachFromOwner
+      prepend Spree::ServiceModule::Base
+
+      # Action types whose line items are removed along with the promotion.
+      CREATE_LINE_ITEMS_ACTION_TYPES = %w[Spree::Promotion::Actions::CreateLineItems].freeze
+
+      # @param owner [Spree::Cart, Spree::Order] the cart or order holding the promotion
+      # @param promotion [Spree::Promotion] the promotion to remove
+      # @param clear_coupon_code [Boolean] also clear the code the shopper entered on the
+      #   owner, so recalculating does not apply the promotion again. Leave it off when the
+      #   shopper should be told the code was lost.
+      # @return [Spree::ServiceModule::Result] success, holding the owner; a failure when the
+      #   owner is already completed, since placed orders are never changed this way
+      def call(owner:, promotion:, clear_coupon_code: false)
+        return failure(owner, 'Cannot remove a promotion from a completed order') if owner.completed?
+
+        held_code = promotion.coupon_codes.held_by(owner).first if promotion.multi_codes?
+        clear_entered_coupon_code(owner, held_code&.code || promotion.code) if clear_coupon_code
+
+        # The order promotion has to go before line items are removed
+        owner.promotions.delete(promotion)
+
+        if held_code
+          held_code.remove_from_order
+        else
+          promotion.touch
+        end
+
+        owner.discounts.where(promotion_action_id: promotion.actions.ids).destroy_all
+        remove_promotion_line_items(owner, promotion)
+        owner.recalculate_totals!
+
+        success(owner)
+      end
+
+      private
+
+      # Carts keep the entered code, and recalculation would apply it again.
+      # Callers that let the shopper be told the code went keep it.
+      def clear_entered_coupon_code(owner, code)
+        return if code.blank? || !owner.has_attribute?(:coupon_code)
+        return unless owner.read_attribute(:coupon_code).to_s.casecmp?(code)
+
+        owner.update_column(:coupon_code, nil)
+      end
+
+      # Removes the line items a promotion's create-line-items actions added.
+      def remove_promotion_line_items(owner, promotion)
+        action_ids = promotion.actions.where(type: CREATE_LINE_ITEMS_ACTION_TYPES).ids
+        remove_service = owner.is_a?(Spree::Cart) ? Spree.cart_remove_item_service : Spree.order_remove_item_service
+        owner_key = owner.is_a?(Spree::Cart) ? :cart : :order
+
+        Spree::PromotionActionLineItem.where(promotion_action: action_ids).find_each do |item|
+          next if owner.find_line_item_by_variant(item.variant).blank?
+
+          # The promotion is still active here, so recalculating would add its items back;
+          # other promotions are still re-evaluated.
+          options = owner.is_a?(Spree::Cart) ? { excluded_promotion_ids: [promotion.id] } : {}
+          remove_service.call(owner_key => owner, variant: item.variant, quantity: item.quantity, options: options)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/stock_reservations/reserve.rb

@@ -14,13 +14,17 @@ module Spree
 
         ApplicationRecord.transaction do
           targets = build_targets(cart)
-          break if targets.empty?
 
           # Pessimistic lock + fresh read of count_on_hand. The lock serializes
           # concurrent checkouts and we use the locked rows below so we never
-          # check stock against a stale association cache.
+          # check stock against a stale association cache. The shelves held
+          # now are locked with the new ones, in id order, so two checkouts
+          # moving holds past each other cannot deadlock.
+          stock_level_ids = targets.map { |_, si, _| si.id } |
+                            Spree::StockReservation.for_order(cart).pluck(:stock_level_id)
           locked_stock_levels = Spree::StockLevel
-            .where(id: targets.map { |_, si| si.id })
+            .where(id: stock_level_ids)
+            .order(:id)
             .lock
             .index_by(&:id)
 
@@ -29,22 +33,17 @@ module Spree
 
           this_order_used = Hash.new(0)
 
-          targets.each do |line_item, stock_level|
-            stock_level = locked_stock_levels.fetch(stock_level.id)
+          reservations = targets.filter_map do |line_item, stock_level, quantity|
+            # A shelf deleted since the allocation was read (a variant being
+            # discontinued removes its stock) has nothing left to hold.
+            stock_level = locked_stock_levels[stock_level.id]
+            next if stock_level.nil?
+
             available = stock_level.available_count - held.fetch(stock_level.id, 0) - this_order_used[stock_level.id]
 
-            if available < line_item.quantity
-              raise InsufficientStockError.new(
-                line_item,
-                I18n.t(
-                  'spree.insufficient_stock_for_reservation',
-                  item: line_item.variant.name,
-                  available: [available, 0].max
-                )
-              )
-            end
+            raise_insufficient_stock(line_item, available) if available < quantity
 
-            this_order_used[stock_level.id] += line_item.quantity
+            this_order_used[stock_level.id] += quantity
 
             reservation = existing[[stock_level.id, line_item.id]] ||
                           Spree::StockReservation.new(stock_level: stock_level, line_item: line_item)
@@ -55,10 +54,15 @@ module Spree
               reservation.order = cart
               reservation.cart = nil
             end
-            reservation.quantity = line_item.quantity
+            reservation.quantity = quantity
             reservation.expires_at = expires_at
             reservation.save!
+            reservation
           end
+
+          # Left in place, a hold the allocation moved away from blocks other buyers until it expires.
+          moved = Spree::StockReservation.for_order(cart).where.not(id: reservations.map(&:id))
+          Spree::StockReservation.withdraw(moved)
         end
 
         success(cart)
@@ -68,23 +72,71 @@ module Spree
 
       private
 
+      # Held where the allocation packs each unit, so the hold protects the stock the order will ship.
       def build_targets(cart)
-        cart.line_items.includes(variant: [:product, { stock_levels: :stock_location }]).filter_map do |line_item|
+        cart.line_items.reset
+        coordinator = Spree::Stock::Coordinator.new(cart)
+        packages = coordinator.allocated_packages
+        check_allocated_in_full(cart, packages_items(packages))
+
+        # Once the address is known, a unit only an origin unable to reach it
+        # would pack cannot ship, so it is left to the delivery check rather
+        # than held where it blocks buyers that origin does serve.
+        packages = packages.select { |package| coordinator.deliverable?(package) } if cart.ship_address.present?
+        items = packages_items(packages)
+        stock_levels = Spree::Stock::Packer.stock_levels_by_location(packages.map(&:stock_location).uniq,
+                                                                     cart.line_items.map(&:variant_id).uniq)
+
+        # Summed because a splitter can pack one line into several packages from one location.
+        quantities = Hash.new(0)
+        items.each do |stock_location, item|
+          next unless item.on_hand?
+
+          line_item = item.inventory_unit.line_item
           variant = line_item.variant
-          next unless variant&.should_track_inventory?
-
-          stock_level = select_stock_level(variant)
+          stock_level = stock_levels.dig(stock_location.id, variant.id)
           # Backorderable and pre-cart variants oversell past count_on_hand,
           # so a reservation capped at on-hand stock would wrongly reject them;
           # their cap is enforced by Stock::Quantifier#can_supply? instead.
+          next unless variant.should_track_inventory?
           next if stock_level.nil? || stock_level.backorderable? || variant.preorder?
 
-          [line_item, stock_level]
+          quantities[[line_item, stock_level]] += item.quantity
+        end
+
+        quantities.map { |(line_item, stock_level), quantity| [line_item, stock_level, quantity] }
+      end
+
+      def packages_items(packages)
+        packages.flat_map { |package| package.contents.map { |item| [package.stock_location, item] } }
+      end
+
+      # A line placed nowhere is left to the delivery check, which can say why;
+      # one placed in part has shelves that fall short, and is refused.
+      def check_allocated_in_full(cart, items)
+        allocated = items.each_with_object(Hash.new(0)) do |(_, item), quantities|
+          quantities[item.inventory_unit.line_item_id] += item.quantity
+        end
+
+        cart.line_items.each do |line_item|
+          variant = line_item.variant
+          next unless variant&.should_track_inventory?
+          next if variant.preorder?
+
+          placed = allocated[line_item.id]
+          raise_insufficient_stock(line_item, placed) if placed.positive? && placed < line_item.quantity
         end
       end
 
-      def select_stock_level(variant)
-        variant.stock_levels.detect { |si| si.stock_location&.active? && si.available? }
+      def raise_insufficient_stock(line_item, available)
+        raise InsufficientStockError.new(
+          line_item,
+          I18n.t(
+            'spree.insufficient_stock_for_reservation',
+            item: line_item.variant.name,
+            available: [available, 0].max
+          )
+        )
       end
 
       def held_by_others(stock_level_ids, owner)
@@ -104,8 +156,8 @@ module Spree
       def existing_reservations_for(targets)
         return {} if targets.empty?
 
-        stock_level_ids = targets.map { |_, si| si.id }
-        line_item_ids = targets.map { |li, _| li.id }
+        stock_level_ids = targets.map { |_, si, _| si.id }
+        line_item_ids = targets.map { |li, _, _| li.id }
 
         Spree::StockReservation
           .where(stock_level_id: stock_level_ids, line_item_id: line_item_ids)

data/app/workflows/spree/carts/recalculate.rb

@@ -9,6 +9,8 @@ module Spree
 
       # @param cart [Spree::Cart, Spree::Order] draft orders ride the same pipeline
       # @param line_item [Spree::LineItem, nil] the item whose change triggered this
+      # @param options [Hash] +excluded_promotion_ids:+ lists promotions to leave out of activation,
+      #   for callers that are removing a promotion's effects
       def perform(cart: nil, order: nil, line_item: nil, line_item_created: false, options: {})
         if order
           Spree::Deprecation.warn('Calling Spree::Carts::Recalculate with order: is deprecated and will be removed in Spree 6.1. Pass cart: instead.')
@@ -47,7 +49,9 @@ module Spree
       def activate_promotions
         @promotion_context = run_hooks :set_promotion_context
 
-        ::Spree::PromotionHandler::Cart.new(cart, line_item).activate
+        ::Spree::PromotionHandler::Cart.new(
+          cart, line_item, excluded_promotion_ids: options[:excluded_promotion_ids] || []
+        ).activate
       end
     end
   end