spree_core 5.4.2 → 5.5.0.rc1

data/app/models/spree/market.rb

@@ -10,7 +10,7 @@ module Spree
     #
     # Associations
     #
-    belongs_to :store, class_name: 'Spree::Store', touch: true
+    belongs_to :store, class_name: 'Spree::Store', touch: true, inverse_of: :markets
     has_many :market_countries, class_name: 'Spree::MarketCountry', dependent: :destroy
     has_many :countries, through: :market_countries, class_name: 'Spree::Country'
     has_many :orders, class_name: 'Spree::Order', dependent: :nullify
@@ -28,6 +28,7 @@ module Spree
     # Callbacks
     #
     before_save :ensure_single_default
+    before_destroy :ensure_can_be_deleted
 
     #
     # Scopes
@@ -80,12 +81,67 @@ module Spree
       @supported_locales_list ||= (supported_locales.to_s.split(',').map(&:strip) << default_locale).compact.uniq.sort
     end
 
+    # Accepts an Array of locale codes and persists them as a comma-separated
+    # string on the `supported_locales` column. Strings are still accepted
+    # verbatim so legacy callers (the Rails admin form, raw seed scripts)
+    # keep working.
+    #
+    # @param value [Array<String>, String, nil]
+    def supported_locales=(value)
+      @supported_locales_list = nil
+      normalized = value.is_a?(Array) ? value.compact.uniq.reject(&:blank?).join(',') : value
+      super(normalized)
+    end
+
+    # Read companion for `country_isos=`. Returns the sorted list of ISO codes
+    # currently assigned to the market.
+    #
+    # @return [Array<String>]
+    def country_isos
+      countries.map(&:iso).compact.sort
+    end
+
+    # Accepts an Array of 2-letter ISO codes and resolves them to the matching
+    # `Spree::Country` records, replacing the market's countries. Unknown codes
+    # are silently dropped — the `validates :countries, presence: true` covers
+    # the "every ISO was bogus" case.
+    #
+    # @param values [Array<String>]
+    def country_isos=(values)
+      isos = Array(values).compact.map { |v| v.to_s.upcase }.reject(&:blank?)
+      self.countries = isos.any? ? Spree::Country.where(iso: isos) : []
+    end
+
+    # Returns true when the market is safe to delete. A market cannot be deleted
+    # if it is the default market or the only market in the store, since
+    # Spree::Current.currency would have no fallback.
+    #
+    # @return [Boolean]
+    def can_be_deleted?
+      !default? && !last_in_store?
+    end
+
     private
 
+    def last_in_store?
+      !self.class.where(store_id: store_id).where.not(id: id).exists?
+    end
+
     def ensure_single_default
       return unless default? && default_changed?
 
       self.class.where(store_id: store_id, default: true).where.not(id: id).update_all(default: false)
     end
+
+    def ensure_can_be_deleted
+      return if can_be_deleted?
+
+      if default?
+        errors.add(:base, :cannot_destroy_default_market)
+      else
+        errors.add(:base, :cannot_destroy_last_market)
+      end
+      throw(:abort)
+    end
   end
 end

data/app/models/spree/metafield.rb

@@ -1,5 +1,26 @@
 module Spree
   class Metafield < Spree.base_class
+    # Map of API-facing tokens to Ruby STI class names. The wire format is the
+    # token (`short_text`); the database column stores the class name. Reads
+    # translate to the token via `field_type`; writes accept either form.
+    # Plugin-defined types fall through to the raw class name until 6.0 when a
+    # registration API lands.
+    TYPE_TOKENS = {
+      'short_text' => 'Spree::Metafields::ShortText',
+      'long_text'  => 'Spree::Metafields::LongText',
+      'rich_text'  => 'Spree::Metafields::RichText',
+      'number'     => 'Spree::Metafields::Number',
+      'boolean'    => 'Spree::Metafields::Boolean',
+      'json'       => 'Spree::Metafields::Json'
+    }.freeze
+    TYPE_CLASS_TO_TOKEN = TYPE_TOKENS.invert.freeze
+
+    # Array form consumed by serializers via
+    # `typelize field_type: Spree::Metafield::FIELD_TYPE_TOKENS`. Typelizer
+    # emits a string-literal union in TypeScript and `{type: string, enum: […]}`
+    # in OpenAPI (string-array form was added in typelizer 0.10.0).
+    FIELD_TYPE_TOKENS = TYPE_TOKENS.keys.freeze
+
     has_prefix_id :cf
 
     #
@@ -8,6 +29,21 @@ module Spree
     belongs_to :resource, polymorphic: true, touch: true
     belongs_to :metafield_definition, class_name: 'Spree::MetafieldDefinition'
 
+    #
+    # API naming bridge — internal column rename lands in 6.0
+    #
+    alias_attribute :custom_field_definition_id, :metafield_definition_id
+
+    # API-facing form of the STI `type` column. Returns the token
+    # (`short_text`) when the row's type is a registered built-in; falls
+    # through to the raw class name for plugin types.
+    #
+    # `self[:type]` reads the raw column to bypass AR's STI reader (which
+    # returns the resolved class constant, not a string).
+    def field_type
+      TYPE_CLASS_TO_TOKEN[self[:type]] || self[:type]
+    end
+
     #
     # Delegations
     #
@@ -43,6 +79,8 @@ module Spree
     private
 
     def set_type_from_metafield_definition
+      return if metafield_definition.blank?
+
       self.type ||= metafield_definition.metafield_type
     end
 

data/app/models/spree/metafield_definition.rb

@@ -18,6 +18,7 @@ module Spree
     validates :metafield_type, presence: true, inclusion: { in: :valid_available_types }
     validates :resource_type, presence: true, inclusion: { in: :valid_available_resources }
     validates :key, uniqueness: { scope: spree_base_uniqueness_scope + [:resource_type, :namespace] }
+    validate :field_type_input_must_be_recognized
 
     #
     # Scopes
@@ -51,14 +52,29 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[key namespace name resource_type display_on]
     self.whitelisted_ransackable_scopes = %w[search multi_search]
 
-    # 5.5 API naming bridge (DB column rename in 6.0)
-    # Aligns with OptionType/OptionValue which also expose `label` for the display name.
-    def label
-      name
+    # API naming bridge — internal columns rename in 6.0. `label` matches
+    # OptionType/OptionValue conventions. (`storefront_visible` lives on
+    # the `Spree::DisplayOn` concern, shared with PaymentMethod + ShippingMethod —
+    # see docs/plans/5.5-6.0-display-on-to-boolean.md.)
+    alias_attribute :label, :name
+
+    # API-facing token for the STI subclass name stored in `metafield_type`.
+    # Reader returns the registered token (`short_text`); writer accepts either
+    # the token or the legacy class-name form for back-compat.
+    def field_type
+      Spree::Metafield::TYPE_CLASS_TO_TOKEN[metafield_type] || metafield_type
     end
 
-    def label=(value)
-      self.name = value
+    def field_type=(value)
+      v = value.to_s
+      mapped = Spree::Metafield::TYPE_TOKENS[v]
+      # An input is "recognized" when it's either a known token (mapped to a
+      # class) or already a known class name. Anything else gets surfaced as
+      # an error on `field_type` so API clients get a token-vocabulary
+      # message instead of the raw class-name inclusion error on
+      # `metafield_type`.
+      @field_type_input_recognized = !mapped.nil? || Spree::Metafield::TYPE_CLASS_TO_TOKEN.key?(v)
+      self.metafield_type = mapped || value
     end
 
     # Returns the full key with namespace
@@ -91,6 +107,13 @@ module Spree
       self.class.available_types.map(&:to_s)
     end
 
+    def field_type_input_must_be_recognized
+      return if @field_type_input_recognized.nil? || @field_type_input_recognized
+
+      tokens = Spree::Metafield::TYPE_TOKENS.keys.join(', ')
+      errors.add(:field_type, "is not a known custom field type (expected one of: #{tokens})")
+    end
+
     def valid_available_resources
       self.class.available_resources.map(&:to_s)
     end

data/app/models/spree/metafields/json.rb

@@ -3,6 +3,16 @@ module Spree
     class Json < Spree::Metafield
       validate :value_must_be_valid_json
 
+      # Accept either a JSON-serialized String (from CSV / Admin UI text
+      # input) or a raw Hash / Array (from API callers that ship parsed
+      # objects). Non-String inputs get JSON-serialized so the underlying
+      # text column always holds canonical JSON.
+      #
+      # @param raw [String, Hash, Array, nil]
+      def value=(raw)
+        super(raw.is_a?(Hash) || raw.is_a?(Array) ? raw.to_json : raw)
+      end
+
       def serialize_value
         JSON.parse(value)
       rescue JSON::ParserError

data/app/models/spree/newsletter_subscriber.rb

@@ -3,6 +3,7 @@ module Spree
     has_prefix_id :sub
 
     include Spree::Metafields
+    include Spree::SingleStoreResource
 
     publishes_lifecycle_events
 
@@ -12,6 +13,7 @@ module Spree
     # Associations
     #
     belongs_to :user, optional: true, class_name: Spree.user_class&.name
+    belongs_to :store, class_name: 'Spree::Store', required: true
 
     #
     # Validations
@@ -19,7 +21,7 @@ module Spree
     validates :email,
               presence: true,
               format: { with: URI::MailTo::EMAIL_REGEXP },
-              uniqueness: { case_sensitive: false, scope: spree_base_uniqueness_scope }
+              uniqueness: { case_sensitive: false, scope: spree_base_uniqueness_scope + [:store_id] }
 
     #
     # Scopes
@@ -30,6 +32,7 @@ module Spree
     #
     # Callbacks
     #
+    before_validation :set_store, unless: :store_id?
     normalizes :email, with: ->(email) { email.to_s.strip.downcase.presence }
 
     #
@@ -52,8 +55,15 @@ module Spree
       Spree::CSV::NewsletterSubscriberPresenter.new(self).call
     end
 
-    def self.subscribe(email:, user: nil)
-      Spree::Newsletter::Subscribe.new(email: email, current_user: user).call
+    def self.subscribe(email:, user: nil, store: nil, redirect_url: nil)
+      store ||= Spree::Current.store
+
+      Spree::Newsletter::Subscribe.new(
+        email: email,
+        current_user: user,
+        current_store: store,
+        redirect_url: redirect_url
+      ).call
     end
 
     def self.verify(token:)
@@ -61,5 +71,11 @@ module Spree
 
       Spree::Newsletter::Verify.new(subscriber: subscriber).call
     end
+
+    private
+
+    def set_store
+      self.store ||= Spree::Current.store
+    end
   end
 end

data/app/models/spree/option_type.rb

@@ -27,7 +27,14 @@ module Spree
     #
     # Associations
     with_options dependent: :destroy, inverse_of: :option_type do
-      has_many :option_values, -> { order(:position) }
+      # `autosave: true` makes the parent's `save`/`update`:
+      #   - persist any built / mutated children in one transaction,
+      #   - collect their validation errors onto `self.errors`,
+      #   - destroy any child marked via `mark_for_destruction`.
+      # The custom `option_values=` writer below leans on this so the v3
+      # ResourceController gets `save returning false` + structured errors
+      # rather than raised exceptions.
+      has_many :option_values, -> { order(:position) }, autosave: true
       has_many :product_option_types
     end
     has_many :products, through: :product_option_types
@@ -73,12 +80,6 @@ module Spree
     after_update :touch_all_products, if: -> { saved_changes.key?(:presentation) }
     after_destroy :touch_all_products
 
-    # legacy, name itself is now parameterized before saving
-    def filter_param
-      Spree::Deprecation.warn('Spree::OptionType#filter_param is deprecated and will be removed in Spree 5.5. Please use Spree::OptionType#name instead.')
-      name.parameterize
-    end
-
     def self.color
       colors.first
     end
@@ -94,6 +95,46 @@ module Spree
       color_swatch?
     end
 
+    # Syncs option values from an array of hashes by mutating the in-memory
+    # `option_values` association — built/assigned children get persisted by
+    # `autosave: true` when the parent saves, and absent IDs get destroyed
+    # via `mark_for_destruction`. The single transaction is owned by the
+    # parent's `save`, so validation failures surface as `errors` and the
+    # whole thing rolls back together.
+    #
+    # Falls back to ActiveRecord's collection writer when given OptionValue
+    # records (e.g. from `accepts_nested_attributes_for` used by the legacy admin).
+    #
+    # @param option_values_params [Array<Hash>] array of option value attribute hashes
+    # @return [void]
+    def option_values=(option_values_params)
+      return super if option_values_params.blank? || option_values_params.first.is_a?(Spree::OptionValue)
+
+      # Load the association into the in-memory collection so subsequent
+      # `option_values.build` / `mark_for_destruction` mutations stay on the
+      # same instances `autosave` will traverse at parent-save time.
+      existing_by_id = option_values.to_a.index_by(&:id)
+      retained_ids = []
+
+      option_values_params.each do |value_data|
+        data = value_data.to_h.with_indifferent_access
+        value_id = data.delete(:id)
+
+        record = if value_id.present?
+                   existing_by_id[Spree::PrefixedId.decode_prefixed_id(value_id) || value_id] ||
+                     raise(ActiveRecord::RecordNotFound.new("Couldn't find Spree::OptionValue with param=#{value_id}", 'Spree::OptionValue'))
+                 else
+                   option_values.build
+                 end
+        record.assign_attributes(data)
+        retained_ids << record.id if record.persisted?
+      end
+
+      existing_by_id.each_value do |existing|
+        existing.mark_for_destruction unless retained_ids.include?(existing.id)
+      end
+    end
+
     private
 
     def touch_all_products

data/app/models/spree/order/checkout.rb

@@ -135,7 +135,7 @@ module Spree
           def subscribe_to_newsletter
             return unless accept_marketing?
 
-            Spree::NewsletterSubscriber.subscribe(email: email, user: user)
+            Spree::NewsletterSubscriber.subscribe(email: email, user: user, store: store)
           end
 
           def self.go_to_state(name, options = {})
@@ -317,8 +317,8 @@ module Spree
           # attributes for a single payment and its source, discarding attributes
           # for payment methods other than the one selected
           #
-          # In case a existing credit card is provided it needs to build the payment
-          # attributes from scratch so we can set the amount. example payload:
+          # If an existing credit card is provided, build the payment attributes
+          # from scratch so the amount can be set. Example payload:
           #
           #   {
           #     "order": {

data/app/models/spree/order.rb

@@ -9,6 +9,11 @@ module Spree
   class Order < Spree.base_class
     has_prefix_id :or  # Stripe: or_
 
+    # Legacy free-text `channel` column was replaced by the `channel_id` FK
+    # (see 6.0-order-routing.md). The string column stays in the DB so the
+    # 5.4-to-5.5 backfill rake can read it; AR ignores it everywhere else.
+    self.ignored_columns += ['channel']
+
     PAYMENT_STATES = %w(balance_due credit_owed failed paid void)
     SHIPMENT_STATES = %w(backorder canceled partial pending ready shipped)
     LINE_ITEM_REMOVABLE_STATES = %w(cart address delivery payment confirm resumed)
@@ -104,23 +109,42 @@ module Spree
       go_to_state :complete
     end
 
-    self.whitelisted_ransackable_associations = %w[shipments user created_by approver canceler promotions bill_address ship_address line_items store]
+    self.whitelisted_ransackable_associations = %w[shipments user created_by approver canceler promotions bill_address ship_address line_items store channel tags]
     self.whitelisted_ransackable_attributes = %w[
-      completed_at email number state payment_state shipment_state
-      total item_total item_count considered_risky channel
+      completed_at email number state status payment_state shipment_state
+      total item_total item_count considered_risky channel_id currency
     ]
-    self.whitelisted_ransackable_scopes = %w[refunded partially_refunded search multi_search]
+    self.whitelisted_ransackable_scopes = %w[complete incomplete refunded partially_refunded search multi_search]
 
     attr_reader :coupon_code
     attr_accessor :temporary_address
 
+    # Set to false on admin-initiated flows to suppress customer-facing emails.
+    attr_accessor :notify_customer
+
     attribute :state_machine_resumed, :boolean
 
+    STATUSES = %w[draft placed canceled].freeze
+
+    attribute :status, :string, default: 'draft'
+    validates :status, inclusion: { in: STATUSES }
+
+    scope :drafts,         -> { where(status: 'draft') }
+    scope :placed_orders,  -> { where(status: 'placed') }
+    scope :canceled_orders, -> { where(status: 'canceled') }
+
     acts_as_taggable_on :tags
     acts_as_taggable_tenant :store_id
 
+    def tags=(tags)
+      self.tag_list = tags
+    end
+
     ASSOCIATED_USER_ATTRIBUTES = [:user_id, :email, :bill_address_id, :ship_address_id]
 
+    # 6.0 forward-compat: User→Customer rename. Column stays user_id in 5.x.
+    alias_attribute :customer_id, :user_id
+
     belongs_to :user, class_name: "::#{Spree.user_class}", optional: true, autosave: true
     belongs_to :created_by, class_name: "::#{Spree.admin_user_class}", optional: true
     belongs_to :approver, class_name: "::#{Spree.admin_user_class}", optional: true
@@ -140,6 +164,8 @@ module Spree
 
     belongs_to :store, class_name: 'Spree::Store'
     belongs_to :market, class_name: 'Spree::Market', optional: true
+    belongs_to :channel, class_name: 'Spree::Channel', optional: true
+    belongs_to :preferred_stock_location, class_name: 'Spree::StockLocation', optional: true
 
     with_options dependent: :destroy do
       has_many :state_changes, as: :stateful, class_name: 'Spree::StateChange'
@@ -148,11 +174,14 @@ module Spree
       has_many :payment_sessions, inverse_of: :order, class_name: 'Spree::PaymentSession'
       has_many :return_authorizations, inverse_of: :order, class_name: 'Spree::ReturnAuthorization'
       has_many :adjustments, -> { order(:created_at) }, as: :adjustable, class_name: 'Spree::Adjustment'
+      has_many :cancellations, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::OrderCancellation'
+      has_many :approvals, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::OrderApproval'
     end
     has_many :reimbursements, inverse_of: :order, class_name: 'Spree::Reimbursement'
     has_many :customer_returns, class_name: 'Spree::CustomerReturn', through: :return_authorizations
     has_many :line_item_adjustments, through: :line_items, source: :adjustments
     has_many :inventory_units, inverse_of: :order, class_name: 'Spree::InventoryUnit'
+    has_many :stock_reservations, class_name: 'Spree::StockReservation', inverse_of: :order, dependent: :destroy
     has_many :return_items, through: :inventory_units, class_name: 'Spree::ReturnItem'
     has_many :variants, through: :line_items
     has_many :products, through: :variants
@@ -194,6 +223,7 @@ module Spree
     # Needs to happen before save_permalink is called
     before_validation :ensure_store_presence
     before_validation :ensure_market_presence
+    before_validation :ensure_channel_presence
     before_validation :ensure_currency_presence
     before_validation :ensure_locale_presence
     before_validation :resolve_market_from_currency, if: -> { persisted? && currency_changed? && !skip_market_resolution }
@@ -348,6 +378,21 @@ module Spree
       completed_at.present?
     end
 
+    # True when the order is mid-checkout: past the `cart` state but not yet
+    # completed or canceled. Used by stock reservation hooks and any flow
+    # that should only run during the active checkout phase.
+    def in_checkout?
+      !cart? && !complete? && !canceled?
+    end
+
+    def draft?
+      status == 'draft'
+    end
+
+    def placed?
+      status == 'placed'
+    end
+
     # Checks if the order is fully refunded
     # @return [Boolean]
     def order_refunded?
@@ -459,6 +504,12 @@ module Spree
       self.market ||= Spree::Current.market || store&.default_market
     end
 
+    def ensure_channel_presence
+      return if channel_id.present?
+
+      self.channel = store&.default_channel
+    end
+
     def allow_cancel?
       return false if !completed? || canceled?
 
@@ -591,6 +642,7 @@ module Spree
       end
 
       updater.update_shipment_state
+      self.status = 'placed'
       save!
       updater.run_hooks
 
@@ -719,7 +771,34 @@ module Spree
       # and are not returned or shipped should be deleted
       inventory_units.on_hand_or_backordered.delete_all
 
-      self.shipments = Spree::Stock::Coordinator.new(self).shipments
+      self.shipments = order_routing_strategy.for_allocation.map do |package|
+        package.to_shipment.tap { |s| s.address_id = ship_address_id }
+      end
+    end
+
+    # Resolves the routing strategy from the channel override first, then the
+    # store default. Only a registered Spree::OrderRouting::Strategy::Base
+    # subclass is used; any other value (an unregistered/typo'd class, or a
+    # strategy that was unregistered after being persisted) is logged and
+    # skipped rather than raised, falling back to the default Rules strategy so
+    # a misconfiguration can't take down cart display or checkout.
+    #
+    # @return [Spree::OrderRouting::Strategy::Base]
+    def order_routing_strategy
+      klass = valid_order_routing_strategy_class(channel&.preferred_order_routing_strategy) ||
+              valid_order_routing_strategy_class(store.preferred_order_routing_strategy) ||
+              Spree::OrderRouting::Strategy::Rules
+
+      klass.new(order: self)
+    end
+
+    # Cascade for the `preferred_location` rule kind. Channel and B2B sources
+    # are layered in by their respective plans.
+    #
+    # @return [Integer, nil]
+    def inferred_preferred_stock_location_id
+      preferred_stock_location_id.presence ||
+        created_by&.try(:preferred_stock_location_id)
     end
 
     # Returns the total weight of the inventory units in the order
@@ -965,6 +1044,19 @@ module Spree
 
     private
 
+    def valid_order_routing_strategy_class(klass_name)
+      return if klass_name.blank?
+
+      klass = Spree.order_routing.strategies.find { |strategy| strategy.to_s == klass_name.to_s }
+      return klass if klass
+
+      Rails.logger.warn(
+        "[Spree] Ignoring unregistered order routing strategy #{klass_name.inspect} " \
+        "for order #{number.inspect}; falling back to the default strategy."
+      )
+      nil
+    end
+
     def link_by_email
       self.email = user.email if user
     end
@@ -998,6 +1090,8 @@ module Spree
     end
 
     def after_cancel
+      update_column(:status, 'canceled')
+
       shipments.each(&:cancel!)
 
       # payments fully covered by gift card won't be refunded
@@ -1015,6 +1109,8 @@ module Spree
     end
 
     def after_resume
+      update_column(:status, 'placed')
+
       shipments.each(&:resume!)
       consider_risk
       send_order_resumed_webhook
@@ -1089,7 +1185,7 @@ module Spree
     end
 
     def publish_order_completed_event
-      publish_event('order.completed')
+      publish_event('order.completed', event_payload.merge(notify_customer: notify_customer))
     end
 
     def publish_order_resumed_event

data/app/models/spree/order_approval.rb

@@ -0,0 +1,19 @@
+module Spree
+  class OrderApproval < Spree.base_class
+    has_prefix_id :appr
+
+    STATUSES = %w[pending approved rejected].freeze
+
+    attribute :metadata, default: -> { {} }
+
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :approvals
+    belongs_to :approver, polymorphic: true, optional: true
+
+    validates :order, presence: true
+    validates :status, presence: true, inclusion: { in: STATUSES }
+
+    scope :approved, -> { where(status: 'approved') }
+    scope :pending,  -> { where(status: 'pending') }
+    scope :rejected, -> { where(status: 'rejected') }
+  end
+end

data/app/models/spree/order_cancellation.rb

@@ -0,0 +1,19 @@
+module Spree
+  class OrderCancellation < Spree.base_class
+    has_prefix_id :cncl
+
+    REASONS = %w[customer declined fraud inventory staff other expired].freeze
+
+    attribute :restock_items, :boolean, default: false
+    attribute :refund_payments, :boolean, default: false
+    attribute :notify_customer, :boolean, default: false
+    attribute :metadata, default: -> { {} }
+
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :cancellations
+    belongs_to :canceled_by, polymorphic: true, optional: true
+
+    validates :order, presence: true
+    validates :reason, presence: true, inclusion: { in: REASONS }
+    validates :refund_amount, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+  end
+end

data/app/models/spree/order_inventory.rb

@@ -17,13 +17,23 @@ module Spree
     # In case shipment is passed the stock location should only unstock or
     # restock items if the order is completed. That is so because stock items
     # are always unstocked when the order is completed through +shipment.finalize+
-    def verify(shipment = nil, is_updated: false)
+    def verify(shipment = nil, is_updated: false, removing: false)
       return unless order.completed? || shipment.present?
 
       units_count = inventory_units.reload.sum(&:quantity)
       line_item_changed = is_updated ? !line_item.saved_changes? : !line_item.changed?
 
-      if units_count < line_item.quantity
+      if removing
+        # When the line item is being destroyed, only remove existing inventory.
+        # Adding here would create units that the LineItem `dependent: :destroy`
+        # cascade can't see (set_up_inventory writes through shipment.inventory_units,
+        # leaving line_item.inventory_units stale), producing an orphaned unit.
+        #
+        # Bypass `remove` because it routes through `set_quantity_to_remove` which
+        # assumes a quantity-change scenario; here we want to drain everything tied
+        # to this line item regardless of `line_item.quantity`.
+        remove_all_units(units_count, shipment) if units_count.positive?
+      elsif units_count < line_item.quantity
         quantity = line_item.quantity - units_count
 
         shipment ||= determine_target_shipment
@@ -49,6 +59,18 @@ module Spree
       end
     end
 
+    def remove_all_units(quantity, target_shipment = nil)
+      if target_shipment.present?
+        remove_from_shipment(target_shipment, quantity)
+      else
+        order.shipments.each do |shipment|
+          break if quantity.zero?
+
+          quantity -= remove_from_shipment(shipment, quantity)
+        end
+      end
+    end
+
     def set_quantity_to_remove(units_count)
       if (units_count - line_item.quantity).zero?
         line_item.quantity