spree_core 5.4.2 → 5.5.0.rc1

data/app/models/spree/authentication/strategy_registry.rb

@@ -0,0 +1,72 @@
+require 'forwardable'
+
+module Spree
+  module Authentication
+    # Keyed registry of authentication strategy classes for the Store and Admin APIs.
+    #
+    # Strategies are dispatched by the `provider` value the client sends to the auth
+    # endpoint, so the registry is a key → class map. The `:email` key is reserved for
+    # the built-in {Spree::Authentication::Strategies::EmailPasswordStrategy}; integrators
+    # can override it by adding a different class under the same key.
+    #
+    # @example Registering a custom provider
+    #   Spree.store_authentication_strategies.add(:auth0, MyApp::Auth::Auth0Strategy)
+    #
+    # @example Removing a provider
+    #   Spree.store_authentication_strategies.remove(:email)
+    #
+    # @example Reading a strategy class
+    #   Spree.store_authentication_strategies[:email]
+    class StrategyRegistry
+      extend Forwardable
+      include Enumerable
+
+      def_delegators :@strategies, :keys, :values, :each
+
+      def initialize(strategies = {})
+        @strategies = {}
+        strategies.each { |key, klass| add(key, klass) }
+      end
+
+      # Register a strategy class under the given provider key. Overwrites any
+      # existing entry for that key.
+      #
+      # @param key [Symbol, String] provider identifier sent by the client
+      # @param strategy_class [Class] strategy class (typically a subclass of
+      #   {Spree::Authentication::Strategies::BaseStrategy})
+      # @return [Class] the registered class
+      def add(key, strategy_class)
+        @strategies[key.to_sym] = strategy_class
+      end
+
+      # Unregister a strategy. Idempotent — returns `nil` if the key is not present.
+      #
+      # @param key [Symbol, String]
+      # @return [Class, nil] the removed class, or nil if no such key
+      def remove(key)
+        @strategies.delete(key.to_sym)
+      end
+
+      # Look up a registered strategy class.
+      #
+      # @param key [Symbol, String] provider identifier
+      # @return [Class, nil] the registered strategy class, or nil if no such key
+      def [](key)
+        @strategies[key.to_sym]
+      end
+
+      # Whether a strategy is registered under the given provider key.
+      #
+      # @param key [Symbol, String]
+      # @return [Boolean]
+      def key?(key)
+        @strategies.key?(key.to_sym)
+      end
+
+      # @return [Hash{Symbol => Class}] a shallow copy of the underlying map
+      def to_h
+        @strategies.dup
+      end
+    end
+  end
+end

data/app/models/spree/base.rb

@@ -1,10 +1,12 @@
 class Spree::Base < ApplicationRecord
   include Spree::Preferences::Preferable
+  include Spree::PreferenceSchema
   include Spree::RansackableAttributes
   include Spree::TranslatableResourceScopes
   include Spree::IntegrationsConcern
   include Spree::Publishable
   include Spree::PrefixedId
+  include Spree::TypedAssociations
 
   after_initialize do
     if has_attribute?(:preferences) && !preferences.nil?
@@ -57,6 +59,10 @@ class Spree::Base < ApplicationRecord
     true
   end
 
+  def mysql_adapter?
+    ActiveRecord::Base.connection.adapter_name.downcase.include?('mysql')
+  end
+
   def self.json_api_columns
     column_names.reject { |c| c.match(/_id$|id|preferences|(.*)password|(.*)token|(.*)api_key|^original_(.*)/) }
   end
@@ -71,10 +77,21 @@ class Spree::Base < ApplicationRecord
     column_names.reject { |c| skipped_attributes.include?(c.to_s) }
   end
 
-  def self.json_api_type
+  # Public-API shorthand for this class, used as the `type` value on the
+  # wire (e.g. `"currency"` for `Spree::Promotion::Rules::Currency`,
+  # `"flat_rate"` for `Spree::Calculator::FlatRate`). Defaults to the
+  # demodulized + underscored leaf; override on a subclass when the wire
+  # format should stay stable across class renames.
+  def self.api_type
     to_s.demodulize.underscore
   end
 
+  # Backwards-compatible alias for `.api_type`. Delegates so subclass
+  # overrides of `api_type` are honored.
+  def self.json_api_type
+    api_type
+  end
+
   def self.to_tom_select_json
     pluck(:name, :id).map do |name, id|
       {

data/app/models/spree/channel.rb

@@ -0,0 +1,159 @@
+module Spree
+  # Lightweight distribution surface within a Store: online storefront, POS,
+  # marketplace integration, wholesale portal. Channels carry order
+  # attribution and the routing-strategy override.
+  class Channel < Spree.base_class
+    DEFAULT_CODE = 'online'.freeze
+
+    has_prefix_id :ch
+
+    include Spree::SingleStoreResource
+    include Spree::Metafields
+    include Spree::Metadata
+    include Spree::OrderRouting::HasStrategyPreference
+
+    # Empty -> falls back to the Store-level preference.
+    preference :order_routing_strategy, :string, default: nil
+
+    belongs_to :store, class_name: 'Spree::Store'
+
+    has_many :orders, class_name: 'Spree::Order', inverse_of: :channel, dependent: :nullify
+    has_many :order_routing_rules, class_name: 'Spree::OrderRoutingRule', dependent: :destroy
+    has_many :publications, class_name: 'Spree::ProductPublication', dependent: :destroy
+    has_many :products, through: :publications, class_name: 'Spree::Product'
+
+    attribute :active, :boolean, default: true
+
+    # HTTP headers arrive as ASCII-8BIT; +parameterize+ raises on those.
+    normalizes :code, with: ->(value) { value.to_s.dup.force_encoding(Encoding::UTF_8).parameterize.presence }
+
+    before_validation :backfill_code_from_name, if: -> { code.blank? && name.present? }
+    before_validation :promote_first_channel_to_default
+
+    validates :name, :store, presence: true
+    validates :code, presence: true, uniqueness: { scope: spree_base_uniqueness_scope + [:store_id] }
+
+    # Demote any prior default in the same transaction so the partial unique
+    # index ("only one default per store") never sees two TRUE rows. Runs
+    # before save so MySQL — which can't enforce a partial unique index — also
+    # arrives at a single default without relying on DB constraints.
+    before_save :demote_other_defaults, if: -> { default? && will_save_change_to_default? }
+    before_destroy :ensure_not_default
+    after_create :ensure_default_order_routing_rules
+
+    scope :active, -> { where(active: true) }
+    scope :default, -> { where(default: true) }
+
+    self.whitelisted_ransackable_attributes = %w[name code active default store_id]
+
+    # Publishes the given products on this channel by creating/upserting ProductPublications.
+    # Optionally sets the publication window; if not given, the products will be published immediately
+    # with no end date.
+    # @param product_ids [Array<Integer>, Integer] the IDs of the products to publish on this channel
+    # @param published_at [Time, nil] when the publications go live; nil means immediately
+    # @param unpublished_at [Time, nil] when the publications come down; nil means never
+    # @return [Integer] the number of ProductPublications created or updated
+    def add_products(product_ids, published_at: nil, unpublished_at: nil)
+      product_ids = Array(product_ids).map(&:to_s).uniq
+      return 0 if product_ids.empty?
+
+      now = Time.current
+      # Only include window columns in the upsert payload when the caller
+      # explicitly passed a value. Leaving them out keeps existing
+      # publication schedules intact on re-publish — otherwise +on_duplicate:
+      # :update+ + +update_only+ would rewrite scheduled +published_at+ /
+      # +unpublished_at+ to NULL whenever the bulk action re-runs without
+      # dates.
+      base = { channel_id: id, created_at: now, updated_at: now }
+      base[:published_at] = published_at unless published_at.nil?
+      base[:unpublished_at] = unpublished_at unless unpublished_at.nil?
+
+      records_to_upsert = product_ids.map { |product_id| base.merge(product_id: product_id) }
+
+      # Only update the window columns the caller passed. When neither was
+      # passed, treat re-publish as a no-op (+on_duplicate: :skip+ → MySQL
+      # +INSERT IGNORE+, PG/SQLite +ON CONFLICT DO NOTHING+).
+      update_columns = []
+      update_columns << :published_at unless published_at.nil?
+      update_columns << :unpublished_at unless unpublished_at.nil?
+      opts = if update_columns.empty?
+               { on_duplicate: :skip }
+             else
+               { record_timestamps: false, update_only: update_columns, on_duplicate: :update }
+             end
+      # MySQL infers the conflict target from the table's unique constraints
+      # and rejects an explicit +unique_by+; PostgreSQL/SQLite require it.
+      opts[:unique_by] = %i[product_id channel_id] unless mysql_adapter?
+
+      Spree::ProductPublication.upsert_all(records_to_upsert, **opts)
+
+      products = Spree::Product.where(id: product_ids)
+      products.touch_all
+      products.each(&:enqueue_search_index)
+      touch
+
+      records_to_upsert.size
+    end
+
+    # Unpublishes the given products from this channel.
+    # @param product_ids [Array<Integer>, Integer] the IDs of the products to unpublish
+    # @return [Integer] the number of ProductPublications destroyed
+    def remove_products(product_ids)
+      product_ids = Array(product_ids).map(&:to_s).uniq
+      return 0 if product_ids.empty?
+
+      count = publications.where(product_id: product_ids).destroy_all.size
+
+      products = Spree::Product.where(id: product_ids)
+      products.touch_all
+      products.each(&:enqueue_search_index)
+
+      touch if count.positive?
+      count
+    end
+
+    # @return [Boolean]
+    def can_be_deleted?
+      !default?
+    end
+
+    private
+
+    def ensure_not_default
+      return if can_be_deleted?
+      return if destroyed_by_association.present?
+
+      errors.add(:base, Spree.t('errors.messages.cannot_delete_default_channel'))
+      throw :abort
+    end
+
+    def backfill_code_from_name
+      self.code = name
+    end
+
+    # First channel on a store becomes the default. Lets the
+    # +Stores::Channels#ensure_default_channel+ seed path and the legacy
+    # admin "create channel" form both produce a sensible default without
+    # the caller having to know.
+    def promote_first_channel_to_default
+      return if default
+      return unless new_record? && store_id.present?
+
+      self.default = true unless Spree::Channel.where(store_id: store_id).exists?
+    end
+
+    def demote_other_defaults
+      Spree::Channel.where(store_id: store_id, default: true).where.not(id: id).update_all(default: false)
+    end
+
+    # Default ordering: preferred location wins, then minimize splits, then
+    # fall back to StockLocation.default. See docs/plans/6.0-order-routing.md.
+    def ensure_default_order_routing_rules
+      return if order_routing_rules.any?
+
+      Spree::OrderRouting::Rules::PreferredLocation.create!(store: store, channel: self, position: 1)
+      Spree::OrderRouting::Rules::MinimizeSplits.create!(store: store , channel: self, position: 2)
+      Spree::OrderRouting::Rules::DefaultLocation.create!(store: store, channel: self, position: 3)
+    end
+  end
+end

data/app/models/spree/country.rb

@@ -1,5 +1,7 @@
 module Spree
   class Country < Spree.base_class
+    self.whitelisted_ransackable_attributes = %w[iso iso3 iso_name name]
+
     has_many :addresses, dependent: :restrict_with_error
     has_many :states,
              -> { order name: :asc },

data/app/models/spree/current.rb

@@ -4,7 +4,7 @@ module Spree
   # All attributes are automatically reset between requests by Rails.
   # Fallback chains ensure sensible defaults when attributes are not explicitly set.
   class Current < ::ActiveSupport::CurrentAttributes
-    attribute :store, :market, :currency, :locale, :zone, :default_tax_zone, :price_lists, :global_pricing_context
+    attribute :store, :channel, :market, :currency, :locale, :zone, :default_tax_zone, :price_lists, :global_pricing_context
 
     resets { @default_tax_zone_loaded = false }
 
@@ -14,6 +14,10 @@ module Spree
       super || Spree::Store.default
     end
 
+    def channel
+      super || (self.channel = store&.default_channel)
+    end
+
     # Returns the current market, falling back to the store's default market.
     # @return [Spree::Market, nil]
     def market

data/app/models/spree/custom_field.rb

@@ -0,0 +1,9 @@
+module Spree
+  # Constant alias for the legacy Spree::Metafield class. Lets controllers,
+  # serializers, and 5.5+ extensions reference the model by its 6.0-bound name
+  # without the actual class rename (which lands with the table rename in 6.0).
+  #
+  # This is a true constant alias — the underlying class, table, STI subclasses,
+  # and `model_name` are all `Spree::Metafield`. Only the constant name differs.
+  CustomField = Metafield
+end

data/app/models/spree/custom_field_definition.rb

@@ -0,0 +1,7 @@
+module Spree
+  # Constant alias for the legacy Spree::MetafieldDefinition class. Lets
+  # controllers, serializers, and 5.5+ extensions reference the model by its
+  # 6.0-bound name without the actual class rename (which lands with the table
+  # rename in 6.0).
+  CustomFieldDefinition = MetafieldDefinition
+end

data/app/models/spree/customer_group.rb

@@ -10,6 +10,11 @@ module Spree
     belongs_to :store, class_name: 'Spree::Store', inverse_of: :customer_groups
     has_many :customer_group_users, class_name: 'Spree::CustomerGroupUser', dependent: :destroy
     has_many :users, through: :customer_group_users, source: :user, source_type: Spree.user_class.to_s
+    # `customers` is the public name across the v3 API; declaring it as its
+    # own association (rather than `alias_method`) is what lets `customer_ids=`
+    # exist and what makes the `PrefixedId` auto-decoder in `assign_attributes`
+    # recognise the key — that lookup keys off `reflect_on_association(:customers)`.
+    has_many :customers, through: :customer_group_users, source: :user, source_type: Spree.user_class.to_s
 
     #
     # Validations
@@ -25,9 +30,10 @@ module Spree
     #
     # Instance Methods
     #
-    def users_count
-      customer_group_users.count
+    def customers_count
+      customer_group_users.size
     end
+    alias_method :users_count, :customers_count
 
     # Bulk add customers to the group
     # @param user_ids [Array] array of user IDs to add

data/app/models/spree/event.rb

@@ -6,20 +6,20 @@ module Spree
   # Events are immutable objects that carry information about something
   # that happened in the system. They contain:
   # - An id (UUID)
-  # - A name (e.g., 'order.complete', 'product.create')
+  # - A name (e.g., 'order.completed', 'product.created')
   # - A store_id (the store where the event originated)
   # - A payload (serialized data about the event)
   # - Metadata (contextual information like spree_version)
   #
   # @example Creating an event
   #   event = Spree::Event.new(
-  #     name: 'order.complete',
+  #     name: 'order.completed',
   #     payload: order.serializable_hash
   #   )
   #
   # @example Accessing event data
   #   event.id         # => "550e8400-e29b-41d4-a716-446655440000"
-  #   event.name       # => 'order.complete'
+  #   event.name       # => 'order.completed'
   #   event.store_id   # => 1
   #   event.payload    # => { 'id' => 1, 'number' => 'R123456' }
   #   event.created_at # => 2024-01-15 10:30:00 UTC
@@ -61,19 +61,19 @@ module Spree
     end
 
     # Returns the resource type from the event name
-    # @return [String] The resource type (e.g., 'order' from 'order.complete')
+    # @return [String] The resource type (e.g., 'order' from 'order.completed')
     def resource_type
       @resource_type ||= name.to_s.split('.').first
     end
 
     # Returns the action from the event name
-    # @return [String] The action (e.g., 'complete' from 'order.complete')
+    # @return [String] The action (e.g., 'completed' from 'order.completed')
     def action
       @action ||= name.to_s.split('.').drop(1).join('.')
     end
 
     # Checks if the event matches a pattern
-    # Supports wildcards: 'order.*' matches 'order.complete', 'order.cancel'
+    # Supports wildcards: 'order.*' matches 'order.completed', 'order.canceled'
     # @param pattern [String] The pattern to match against
     # @return [Boolean]
     def matches?(pattern)

data/app/models/spree/export.rb

@@ -22,13 +22,16 @@ module Spree
     # Associations
     #
     belongs_to :store, class_name: 'Spree::Store'
-    belongs_to :user, class_name: Spree.admin_user_class.to_s
+    # Optional so secret-API-key callers (apps / server-to-server) can create
+    # exports without a human user attached. The email notification is
+    # skipped for these — apps poll instead.
+    belongs_to :user, class_name: Spree.admin_user_class.to_s, optional: true
     belongs_to :vendor, -> { with_deleted }, class_name: 'Spree::Vendor', optional: true
 
     #
     # Validations
     #
-    validates :format, :store, :user, :type, presence: true
+    validates :format, :store, :type, presence: true
 
     #
     # Enums
@@ -83,10 +86,10 @@ module Spree
           batch.each do |record|
             if multi_line_csv?
               record.to_csv(store).each do |line|
-                csv << line
+                csv << Spree::CSV::FormulaSanitizer.row(line)
               end
             else
-              csv << record.to_csv(store)
+              csv << Spree::CSV::FormulaSanitizer.row(record.to_csv(store))
             end
           end
         end
@@ -127,12 +130,34 @@ module Spree
 
     def records_to_export
       if search_params.present?
-        scope.ransack(search_params.is_a?(String) ? JSON.parse(search_params.to_s).to_h : search_params)
+        params = search_params.is_a?(String) ? JSON.parse(search_params.to_s).to_h : search_params
+        scope.ransack(decode_prefixed_id_filters(params))
       else
         scope.ransack
       end.result
     end
 
+    # Replace any prefixed IDs in `search_params` with their raw DB IDs so
+    # Ransack can match them. Without this, an admin filtering an export by
+    # a foreign key (`promotion_id_eq: 'promo_xxx'`, `vendor_id_in: [...]`)
+    # would always get zero rows. We only touch values that look like
+    # prefixed IDs — anything else (numeric IDs, code strings, ranges,
+    # state names) passes through untouched.
+    def decode_prefixed_id_filters(params)
+      params.transform_values { |value| decode_search_value(value) }
+    end
+
+    def decode_search_value(value)
+      case value
+      when String
+        Spree::PrefixedId.prefixed_id?(value) ? (Spree::PrefixedId.decode_prefixed_id(value) || value) : value
+      when Array
+        value.map { |v| decode_search_value(v) }
+      else
+        value
+      end
+    end
+
     def scope_includes
       []
     end
@@ -181,6 +206,8 @@ module Spree
     end
 
     def send_export_done_email
+      return if user.blank? # App-created exports (secret API key) have no user to email.
+
       Spree::ExportMailer.export_done(self).deliver_later
     end
 

data/app/models/spree/exports/product_translations.rb

@@ -30,7 +30,7 @@ module Spree
           records_to_export.includes(scope_includes).find_in_batches do |batch|
             batch.each do |product|
               product.to_translation_csv(store, locales).each do |line|
-                csv << line
+                csv << Spree::CSV::FormulaSanitizer.row(line)
               end
             end
           end

data/app/models/spree/gateway/bogus.rb

@@ -120,9 +120,14 @@ module Spree
       true
     end
 
+    def payment_setup_session_class
+      PaymentSetupSessions::Bogus
+    end
+
     def create_payment_setup_session(customer:, external_data: {})
-      payment_setup_sessions.create(
+      payment_setup_session_class.create(
         customer: customer,
+        payment_method: self,
         status: 'pending',
         external_id: "bogus_seti_#{SecureRandom.hex(12)}",
         external_client_secret: "bogus_seti_secret_#{SecureRandom.hex(8)}",

data/app/models/spree/gateway.rb

@@ -6,6 +6,31 @@ module Spree
 
     validates :type, presence: true, inclusion: { in: :valid_providers_list }
 
+    # Payment provider gems conventionally ship a top-level `Gateway`
+    # class — `SpreeStripe::Gateway`, `SpreeAdyen::Gateway`,
+    # `SpreePaypalCheckout::Gateway`. The default demodulized
+    # `api_type` collapses every provider to `"gateway"`, which
+    # collides in the registry and produces duplicate keys in admin
+    # UIs. For gateway subclasses, use the outer module instead (with
+    # a leading `Spree` namespace stripped), matching the labelling
+    # convention in `PreferenceSchema#subclass_label`:
+    #
+    #   SpreeStripe::Gateway          → "stripe"
+    #   SpreeAdyen::Gateway           → "adyen"
+    #   SpreePaypalCheckout::Gateway  → "paypal_checkout"
+    #   MyShop::Gateway               → "my_shop"
+    #
+    # Subclasses nested under a Gateway module (e.g.
+    # `Spree::Gateway::Bogus`) demodulize to their own leaf and
+    # bypass this fallback.
+    def self.api_type
+      leaf = super
+      return leaf unless leaf == 'gateway'
+
+      outer = to_s.deconstantize.delete_prefix('Spree::').delete_prefix('Spree').presence
+      outer ? outer.underscore : leaf
+    end
+
     def payment_source_class
       CreditCard
     end

data/app/models/spree/gift_card.rb

@@ -62,7 +62,7 @@ module Spree
     #
     # Ransack
     #
-    self.whitelisted_ransackable_attributes = %w[code user_id state]
+    self.whitelisted_ransackable_attributes = %w[code user_id state gift_card_batch_id created_by_id]
     self.whitelisted_ransackable_associations = %w[users orders batch]
     self.whitelisted_ransackable_scopes = %w[active expired redeemed partially_redeemed]
 

data/app/models/spree/gift_card_batch.rb

@@ -18,7 +18,10 @@ module Spree
     # Validations
     #
     validates :codes_count, :amount, :prefix, presence: true
-    validates :codes_count, numericality: { greater_than: 0, less_than_or_equal_to: Spree::Config[:gift_card_batch_limit].to_i }
+    validates :codes_count, numericality: {
+      greater_than: 0,
+      less_than_or_equal_to: ->(_record) { Spree::Config[:gift_card_batch_limit].to_i }
+    }
     validates :store, :currency, presence: true
     validates :amount, numericality: { greater_than: 0 }
 

data/app/models/spree/import.rb

@@ -62,6 +62,7 @@ module Spree
       event :complete do
         transition from: :processing, to: :completed
       end
+      after_transition to: :completed, do: :touch_store
       after_transition to: :completed, do: :publish_import_completed_event
       # NOTE: send_import_completed_email and update_loader_in_import_view
       # are now handled by Spree::Admin::ImportSubscriber listening to 'import.completed' event
@@ -181,6 +182,10 @@ module Spree
       "#{Spree.t(type.demodulize.pluralize.downcase)} #{number}"
     end
 
+    def touch_store
+      store.touch
+    end
+
     def publish_import_completed_event
       publish_event('import.completed')
     end

data/app/models/spree/import_row.rb

@@ -41,6 +41,11 @@ module Spree
       # are now handled by Spree::Admin::ImportRowSubscriber
     end
 
+    # How long a row may sit in `processing` before we consider its owning worker dead
+    # (OOM, SIGKILL, deploy without graceful drain — none of these trigger a Sidekiq
+    # retry). After this window, stalled rows no longer block the import from completing.
+    STALLED_PROCESSING_AFTER = 1.hour
+
     #
     # Scopes
     #
@@ -48,6 +53,13 @@ module Spree
     scope :completed, -> { where(status: :completed) }
     scope :failed, -> { where(status: :failed) }
     scope :processed, -> { where(status: %i[completed failed]) }
+    # Rows still legitimately blocking import completion: `pending` (not started) or
+    # `processing` with a recent updated_at (worker still alive). Orphaned `processing`
+    # rows past the stall window are excluded so a dead worker can't permanently block
+    # completion — operators can clean those up separately.
+    scope :in_flight, -> {
+      where(status: :pending).or(where(status: :processing).where(updated_at: STALLED_PROCESSING_AFTER.ago..))
+    }
 
     def data_json
       @data_json ||= JSON.parse(data)

data/app/models/spree/line_item.rb

@@ -24,6 +24,7 @@ module Spree
     has_many :inventory_units, class_name: 'Spree::InventoryUnit', inverse_of: :line_item, dependent: :destroy
     has_many :shipments, through: :inventory_units, source: :shipment
     has_many :digital_links, dependent: :destroy
+    has_many :stock_reservations, class_name: 'Spree::StockReservation', inverse_of: :line_item, dependent: :destroy
 
     before_validation :copy_price
     before_validation :copy_tax_category
@@ -164,9 +165,13 @@ module Spree
 
     # Returns true if the line item has sufficient stock
     #
+    # The order's own active stock reservations are excluded from the
+    # availability check — a customer's own checkout hold must not make
+    # their own line item look out of stock.
+    #
     # @return [Boolean]
     def sufficient_stock?
-      can_supply? quantity
+      Spree::Stock::Quantifier.new(variant, excluded_order: order).can_supply?(quantity)
     end
 
     # Returns true if the line item has insufficient stock
@@ -293,7 +298,7 @@ module Spree
     end
 
     def verify_order_inventory_before_destroy
-      Spree::OrderInventory.new(order, self).verify(target_shipment)
+      Spree::OrderInventory.new(order, self).verify(target_shipment, removing: true)
     end
 
     def update_adjustments