spree_core 6.0.0 → 6.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 579b3e333d378aec89721e12502e86fe2f529d99e18f087ecaf29cebe6e6b772
-  data.tar.gz: 29411570d9588634cfa2a4f559bea3bf6622c8672b90415a38ee1372a996494f
+  metadata.gz: 95b9df74c721a763fd81c0ca389f4bf996400ed8e1a262ca031228387157be16
+  data.tar.gz: ff8cd8cc1294aaa4eea49a2fbcd0c6319b15ed59d77988af865d48ae56782bf2
 SHA512:
-  metadata.gz: 38eef7cff0fce557dd3b14460d3bbdf50e410fc28ae7e9c74fa59f92767078cc74531f221d7a615ba53af0297c3dd8bd9e72ab15a5f09dd5ab88ceff20b0e653
-  data.tar.gz: dd2f38e2a6c8b179610ae41ded85992b051081ed71ac110e3a078ebd595b4ea273bbdabf6b64226af1831ce7e93eda1e32591dda4f5da9969dc700aaa3d6f587
+  metadata.gz: 94d512c61c6b2e6aa3c8672c883ea406af8efb8c509fe7ba0f0a49d58c02aa767d23a9ff82e8532965e32217130aeff39074c78d5b8d0896de6f8dac9e7e19e7
+  data.tar.gz: cb944067256bc44223bca95b0c00bcf17f242745c2885ea063d7549592ebdbb013c0138359fb60326b662ae4b4ed583fdba553fc2f42378fa3952049b69d7af2

data/README.md

@@ -110,6 +110,6 @@ bundle exec rspec
 
 ## Documentation
 
-- [Official Documentation](https://docs.spreecommerce.org)
+- [Official Documentation](https://spreecommerce.org/docs)
 - [API Reference](https://api.spreecommerce.org)
-- [Guides](https://docs.spreecommerce.org/developer)
+- [Guides](https://spreecommerce.org/docs/developer)

data/app/jobs/spree/seller_transfers/execute_pending_due_job.rb

@@ -1,6 +1,7 @@
 module Spree
   module SellerTransfers
-    # Hands every seller holding an unconfirmed earning to a job of their own.
+    # Hands every seller holding an unconfirmed earning or reversal to a job of
+    # their own.
     #
     # The transfer level's counterpart to {Spree::SellerPayouts::SweepDueJob},
     # and deliberately a separate schedule rather than something the settlement
@@ -39,17 +40,18 @@ module Spree
       # @param store [Spree::Store]
       # @return [ActiveRecord::Relation<Spree::Seller>]
       def sellers_awaiting_provider(store)
-        scope = store.sellers.approved.
-                where(id: Spree::SellerTransfer.for_store(store).awaiting_provider.select(:seller_id))
+        transfers = Spree::SellerTransfer.for_store(store)
+        sending = store.sellers.approved.where(id: transfers.awaiting_provider.select(:seller_id))
 
         # A seller the provider will not accept yet keeps their earnings
         # unconfirmed, and the job would return at once. Skipped rather than
         # enqueued, because a marketplace's half-onboarded sellers are a
         # standing population and this runs often — and nothing is lost by it:
         # finishing onboarding runs the job for them directly.
-        return scope unless store.payout_provider_class.requires_payout_account?
+        sending = sending.where.not(payouts_enabled_at: nil) if store.payout_provider_class.requires_payout_account?
 
-        scope.where.not(payouts_enabled_at: nil)
+        # Money owed back is pursued whatever the seller's standing.
+        sending.or(store.sellers.where(id: transfers.reversals_awaiting_provider.select(:seller_id)))
       end
     end
   end

data/app/jobs/spree/seller_transfers/execute_pending_job.rb

@@ -14,6 +14,9 @@ module Spree
     # seller who was payable all along would never see a refused earning tried
     # again, since nothing about them ever changes to prompt it.
     #
+    # Reversals are retried the same way: a provider that pulls money back can
+    # refuse too, and one cannot be pulled back before its earning was sent.
+    #
     # It takes the retryable rows — never sent, or refused outright. A transfer
     # whose outcome the provider could not report is left alone: asking again
     # is precisely how the same money moves twice, and only a person can say
@@ -24,30 +27,47 @@ module Spree
       # @param seller_id [Integer]
       def perform(seller_id)
         seller = Spree::Seller.find_by(id: seller_id)
-        return if seller.nil? || !seller.payouts_enabled?
+        return if seller.nil?
 
         Spree::Current.store = seller.store
+        send_earnings(seller) if seller.payouts_enabled?
+
+        # Never through `transfer!`: a reversal's amount is negative, and the
+        # amount sent is its absolute value, so it would pay the seller the
+        # money it exists to take back. Through the provider that made the
+        # earning, which is not necessarily the store's current one. And for
+        # every seller, payable or not — a seller suspended after a wave of
+        # refunds is exactly the one whose money must come back.
+        seller.seller_transfers.reversals_awaiting_provider.includes(:reversed_from, :order).find_each do |reversal|
+          execute(reversal) { reversal.payout_provider_instance.reverse!(reversal) }
+        end
+      end
+
+      private
+
+      # Before the reversals, so a reversal waiting on its earning finds it sent.
+      def send_earnings(seller)
         provider = seller.store.payout_provider_instance
 
-        # Earnings only — see the scope. A reversal is retryable the same way
-        # when its own provider call is refused, but sending one through
-        # `transfer!` would pay the seller the amount it exists to take back:
-        # the row is negative and the amount sent is its absolute value.
         seller.seller_transfers.awaiting_provider.find_each do |transfer|
-          provider.transfer!(transfer)
-        rescue Spree::Core::AmbiguousGatewayError => e
-          # The money may already have moved, so this row must not be offered
-          # again: left retryable, the next run would send it a second time,
-          # and an idempotency key stops that only while the provider still
-          # holds its record.
-          transfer.update!(status: 'unresolved')
-          Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
-        rescue StandardError => e
-          # A refusal — the money did not move. One seller's stuck earning must
-          # not stop the rest, and the row stays retryable for the next run.
-          Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+          execute(transfer) { provider.transfer!(transfer) }
         end
       end
+
+      def execute(transfer)
+        yield
+      rescue Spree::Core::AmbiguousGatewayError => e
+        # The money may already have moved, so this row must not be offered
+        # again: left retryable, the next run would move it a second time,
+        # and an idempotency key stops that only while the provider still
+        # holds its record.
+        transfer.update!(status: 'unresolved')
+        Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+      rescue StandardError => e
+        # A refusal — the money did not move. One stuck row must not stop the
+        # rest, and it stays retryable for the next run.
+        Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+      end
     end
   end
 end

data/app/maintenance_tasks/spree/maintenance_tasks/upgrade/store_regional_settings.rb

@@ -0,0 +1,63 @@
+module Spree
+  module MaintenanceTasks
+    module Upgrade
+      # 5.6 → 6.0 conversion of the store's time zone into an IANA identifier
+      # ("Eastern Time (US & Canada)" becomes "America/New_York") and of its
+      # admin language into a listed locale code (`en_US` becomes `en-US`), the
+      # only forms the API accepts and browsers read.
+      #
+      # A time zone that names no zone falls back to the store default, which is
+      # what the store already ran on: Ruby could not read it either. An admin
+      # language Spree does not list is cleared, so the dashboard shows each
+      # staff member their own language.
+      class StoreRegionalSettings < Spree::MaintenanceTask
+        supports_dry_run
+
+        def collection
+          Spree::Store.with_deleted.order(:id)
+        end
+
+        # Locks the store's row, so a settings save made meanwhile is read
+        # rather than overwritten, and counts each change once it is written.
+        #
+        # @param store [Spree::Store]
+        # @return [void]
+        def process(store)
+          store.with_lock do
+            changes = time_zone_change(store).merge(admin_locale_change(store))
+            next if changes.empty?
+
+            if dry_run?
+              changes.each_value { |outcome, _value| tally(:"would_#{outcome}") }
+              next
+            end
+
+            changes.each { |name, (_outcome, value)| store.set_preference(name, value) }
+            store.update_columns(preferences: store.preferences, updated_at: Time.current)
+            changes.each_value { |outcome, _value| tally(outcome) }
+          end
+        end
+
+        private
+
+        def time_zone_change(store)
+          stored = store.preferred_timezone
+          return {} if Spree::TimeZones.valid?(stored)
+
+          converted = Spree::TimeZones.normalize(stored)
+          return { timezone: [:time_zone_converted, converted] } if Spree::TimeZones.valid?(converted)
+
+          { timezone: [:time_zone_reset_to_default, store.preference_default(:timezone)] }
+        end
+
+        def admin_locale_change(store)
+          stored = store.preferred_admin_locale
+          return {} if stored.blank? || Spree::Locales::ALL.include?(stored)
+
+          listed = Spree::Locales.listed(stored)
+          { admin_locale: listed ? [:admin_locale_converted, listed] : [:admin_locale_cleared, nil] }
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,8 @@ module Spree
   module AdminUserMethods
     extend ActiveSupport::Concern
 
+    STATUSES = %w[active locked deactivated].freeze
+
     include Spree::Actor
     include Spree::PrefixedId
     include Spree::SignedIdAttachments
@@ -43,6 +45,8 @@ module Spree
 
       # Associations
       has_many :identities, class_name: 'Spree::UserIdentity', as: :user, dependent: :destroy
+      # Signed-in sessions, on the admin and the seller API alike.
+      has_many :refresh_tokens, class_name: 'Spree::RefreshToken', as: :user, dependent: :delete_all
       # The order operations became polymorphic in 6.0, so these read through
       # the association rather than a bare foreign key: matching on the id
       # alone would hand this user the rows an API key with the same numeric
@@ -84,6 +88,25 @@ module Spree
       Spree::Store.current.users.where.not(id: id).exists?
     end
 
+    # Whether the account can sign in. Duck-typed: a custom admin user class
+    # may lack deactivation or lockout.
+    # @return [String] +active+, +locked+ or +deactivated+
+    def status
+      if try(:deactivated?)
+        'deactivated'
+      elsif try(:locked?)
+        'locked'
+      else
+        'active'
+      end
+    end
+
+    # Sessions that can still be refreshed, most recently used first.
+    # @return [ActiveRecord::Relation<Spree::RefreshToken>]
+    def active_sessions
+      refresh_tokens.active.order(created_at: :desc)
+    end
+
     # Returns the full name of the user
     # @return [String]
     def full_name

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

@@ -5,6 +5,9 @@ module Spree
     included do
       extend Mobility
       default_scope { i18n }
+
+      # Before the translations are autosaved, so it has to run first.
+      after_update :discard_blank_new_translations, prepend: true
     end
 
     class_methods do
@@ -178,6 +181,22 @@ module Spree
 
     private
 
+    # Clearing a translation's last value deletes its row, and Mobility then
+    # rebuilds a blank one for that locale while it finalizes dirty tracking.
+    # Saved, that blank row is either junk or, where translation rows are soft
+    # deleted (stores), a duplicate of the deleted row.
+    def discard_blank_new_translations
+      return unless association(:translations).loaded?
+
+      columns = self.class.translatable_fields.map(&:to_s)
+      translations.each do |translation|
+        next unless translation.new_record?
+        next if columns.any? { |column| translation[column].present? }
+
+        translation.mark_for_destruction
+      end
+    end
+
     # @raise [ActiveRecord::RecordInvalid] if any locale isn't supported by the store
     def validate_translation_locales!(locales)
       supported = translatable_store&.supported_locales_list || []

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

@@ -57,10 +57,15 @@ module Spree
         has_spree_role?(Spree::Role::ADMIN_ROLE, resource)
       end
 
-      # Returns the user who invited the current user
-      # @return [Spree.admin_user_class]
-      def invited_by
-        invitations.first&.inviter
+      # Who sent the invitation this user accepted to get a role on +resource+.
+      # Nil for a user given a role without one, such as the store owner.
+      #
+      # @param resource [Spree::Base] the store or seller; defaults to the current store
+      # @return [Object, nil] an actor (see Spree.actor_classes)
+      def invited_by(resource = nil)
+        resource ||= Spree::Store.current
+
+        invitations.accepted.where(resource: resource).order(:created_at).first&.inviter
       end
 
       # Whether this user belongs to any marketplace seller. The seller login

data/app/models/spree/invitation.rb

@@ -116,6 +116,15 @@ module Spree
       publish_event('invitation.resent')
     end
 
+    # The staff account holding the invited address, if one exists. Matched
+    # the way the account's email uniqueness is, case-insensitively, so an
+    # address typed in another case still finds the one account it can belong
+    # to. Resolved by record rather than by comparing strings in Ruby, whose
+    # case folding is wider than the database's.
+    def invitee_account
+      Spree.admin_user_class.where('LOWER(email) = LOWER(?)', email).first
+    end
+
     private
 
     def publish_invitation_created_event
@@ -161,7 +170,7 @@ module Spree
       return if resource.blank?
 
       # Check role_users directly for better performance and to avoid potential source_type issues
-      user_to_check = invitee || Spree.admin_user_class.find_by(email: email)
+      user_to_check = invitee || invitee_account
       return if user_to_check.blank?
 
       if resource.role_users.exists?(user: user_to_check)
@@ -172,7 +181,7 @@ module Spree
     def set_invitee_from_email
       return if invitee.present?
 
-      self.invitee = Spree.admin_user_class.find_by(email: email)
+      self.invitee = invitee_account
     end
   end
 end

data/app/models/spree/order.rb

@@ -337,8 +337,10 @@ module Spree
     scope :reverse_chronological, -> { order(Arel.sql('spree_orders.completed_at IS NULL'), completed_at: :desc, created_at: :desc) }
 
     def self.search(query)
+      # Ransack passes `true` when the scope is called as a bare flag (`q[search]=1`)
+      return none unless query.is_a?(String) && query.present?
+
       sanitized_query = sanitize_query_for_search(query)
-      return none if query.blank?
 
       query_pattern = "%#{sanitized_query}%"
 

data/app/models/spree/order_promotion.rb

@@ -8,7 +8,7 @@ module Spree
     belongs_to :cart, class_name: 'Spree::Cart', optional: true, inverse_of: :order_promotions
     belongs_to :promotion, class_name: 'Spree::Promotion'
 
-    delegate :name, :description, :code, to: :promotion
+    delegate :name, :description, :code, to: :promotion, allow_nil: true
     delegate :currency, to: :owner
 
     validates :order, uniqueness: { scope: :promotion }, allow_nil: true
@@ -35,6 +35,8 @@ module Spree
     end
 
     def amount
+      return BigDecimal(0) if promotion.nil?
+
       owner.discounts.promotion.where(promotion_action_id: promotion.actions.ids).sum(:amount)
     end
 

data/app/models/spree/order_routing/strategy/rules.rb

@@ -10,7 +10,7 @@ module Spree
       # See docs/plans/6.0-order-routing.md.
       class Rules < Base
         def for_allocation
-          locations = eligible_locations
+          locations = coordinator.candidate_stock_locations
           return [] if locations.empty?
 
           ordered = Spree::OrderRouting::Strategy::Reducer
@@ -18,9 +18,11 @@ module Spree
             .rank_all(locations)
           return [] if ordered.empty?
 
-          packages = build_packages(ordered)
-          packages = prioritize_packages(packages)
-          estimate_rates(packages)
+          # Packed in rank order through the Coordinator, so an order allocates
+          # under the same delivery profile and channel coverage as its cart,
+          # and the Prioritizer's first-package-wins-on-hand logic honors the
+          # routing decision between origins that can reach the destination.
+          coordinator.estimate_packages(coordinator.allocated_packages(ordered))
         end
 
         # Stock decrement / restock today happens via Spree::Fulfillment's state
@@ -39,50 +41,8 @@ module Spree
           order.channel.order_routing_rules.active.ordered
         end
 
-        def eligible_locations
-          order.store.stock_locations.active
-            .joins(:stock_levels)
-            .where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids })
-            .distinct
-            .to_a
-        end
-
-        def requested_variant_ids
-          inventory_units.map(&:variant_id).uniq
-        end
-
-        def inventory_units
-          @inventory_units ||= Spree::Stock::InventoryUnitBuilder.new(order).units
-        end
-
-        # Pack each ranked location independently. Packages are emitted in
-        # rank order so the Prioritizer's first-package-wins-on-hand logic
-        # honors the routing decision.
-        def build_packages(locations)
-          stock_levels = Spree::Stock::Packer.stock_levels_by_location(locations, requested_variant_ids)
-
-          locations.flat_map do |location|
-            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters, owner: order,
-                                     stock_levels: stock_levels.fetch(location.id, {})).packages
-          end
-        end
-
-        # Prioritizer's Adjuster distributes each inventory_unit across
-        # packages: the first package with on-hand stock fulfills the unit,
-        # and downstream packages have that unit removed. Packages whose
-        # items all get stripped are pruned. Rank only decides between origins
-        # that can reach the destination — the Prioritizer demotes the rest.
-        def prioritize_packages(packages)
-          Spree::Stock::Prioritizer.new(packages, estimator: estimator).prioritized_packages
-        end
-
-        def estimate_rates(packages)
-          packages.each { |pkg| pkg.delivery_rates = estimator.delivery_rates(pkg) }
-          packages
-        end
-
-        def estimator
-          @estimator ||= Spree::Stock::Estimator.new(order)
+        def coordinator
+          @coordinator ||= Spree::Stock::Coordinator.new(order)
         end
       end
     end

data/app/models/spree/payment.rb

@@ -27,6 +27,11 @@ module Spree
     INVALID_STATES      = INVALID_STATUSES
     deprecate_constant :INVALID_STATES
 
+    # Statuses a payment can be voided / captured from, before the payment
+    # method is consulted. Extend them to support gateways with other flows.
+    VOIDABLE_STATUSES   = %w[pending processing completed checkout].freeze
+    CAPTURABLE_STATUSES = %w[checkout pending].freeze
+
     with_options inverse_of: :payments do
       belongs_to :order, class_name: 'Spree::Order', touch: true, optional: true
       belongs_to :cart, class_name: 'Spree::Cart', optional: true
@@ -219,8 +224,18 @@ module Spree
       status.in?(%w[checkout processing])
     end
 
+    # Whether the payment is in a status that can be voided and its payment
+    # method agrees. A gateway that cannot void a capture returns false from
+    # +can_void?(payment)+ for completed payments.
     def can_void?
-      status.in?(%w[pending processing completed checkout])
+      status.in?(VOIDABLE_STATUSES) &&
+        (!payment_method.respond_to?(:can_void?) || payment_method.can_void?(self))
+    end
+
+    # Whether the payment can be captured from the back office.
+    def can_capture?
+      status.in?(CAPTURABLE_STATUSES) &&
+        (!payment_method.respond_to?(:can_capture?) || payment_method.can_capture?(self))
     end
 
     # @deprecated read +status+ — removed in 6.1

data/app/models/spree/payment_method/store_credit.rb

@@ -18,8 +18,10 @@ module Spree
       ['checkout', 'pending'].include?(payment.status)
     end
 
+    # Mirrors Spree::StoreCredit#can_void?: a checkout payment can still be
+    # voided while its order is incomplete.
     def can_void?(payment)
-      payment.pending?
+      payment.pending? || (payment.checkout? && !payment.order&.completed?)
     end
 
     def authorize(money, store_credit, gateway_options = {})

data/app/models/spree/payment_method.rb

@@ -197,7 +197,7 @@ module Spree
     def webhook_url
       return nil unless store
 
-      "#{store.url_or_custom_domain}/api/v3/webhooks/payments/#{prefixed_id}"
+      "#{store.formatted_url_or_custom_domain}/api/v3/webhooks/payments/#{prefixed_id}"
     end
 
     class WebhookSignatureError < StandardError; end
@@ -309,6 +309,19 @@ module Spree
       raise ::NotImplementedError, 'You must implement cancel method for this payment method.'
     end
 
+    # Whether the payment can be voided in its current state. Gateways that
+    # cannot void a captured payment override this.
+    # @param _payment [Spree::Payment]
+    def can_void?(_payment)
+      true
+    end
+
+    # Whether the payment can be captured in its current state.
+    # @param _payment [Spree::Payment]
+    def can_capture?(_payment)
+      true
+    end
+
     def store_credit?
       self.class == Spree::PaymentMethod::StoreCredit
     end

data/app/models/spree/payment_source.rb

@@ -17,7 +17,9 @@ module Spree
     #
     # Validations
     #
-    validates_uniqueness_of :gateway_payment_profile_id, scope: :type
+    # A gateway profile id is only unique within the gateway account that issued it, so the same
+    # buyer needs a separate source under each payment method they pay through.
+    validates_uniqueness_of :gateway_payment_profile_id, scope: %i[type payment_method_id]
 
     #
     # Delegations

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -22,7 +22,7 @@ module Spree
         # clamped against its line's remaining discounted base, so the order net
         # can never go below zero.
         def compute_amount(line_item)
-          return 0 unless promotion.line_item_actionable?(line_item.order, line_item)
+          return 0 unless promotion.line_item_actionable?(line_item.owner, line_item)
 
           [line_item.amount, compute(line_item)].min * -1
         end

data/app/models/spree/promotion.rb

@@ -51,7 +51,8 @@ module Spree
     before_validation :set_starts_at_to_current_time, if: -> { starts_at.blank? }
     after_commit :generate_coupon_codes, if: -> { multi_codes? }, on: [:create, :update]
     after_commit :remove_coupons, on: :update
-    before_destroy :not_used?
+    before_destroy :detach_from_open_carts, prepend: true
+    before_destroy :not_used?, prepend: true
 
     #
     # Validations
@@ -376,6 +377,14 @@ module Spree
       flush_pending_typed_association(:promotion_actions)
     end
 
+    # Runs before the promotion's actions are destroyed, since the carts'
+    # discounts are tied back to the promotion through them.
+    def detach_from_open_carts
+      Spree::Cart.where(id: order_promotions.where.not(cart_id: nil).select(:cart_id)).find_each do |cart|
+        Spree::Promotions::DetachFromOwner.call(owner: cart, promotion: self, clear_coupon_code: true)
+      end
+    end
+
     def not_used?
       return true if orders.empty?
 

data/app/models/spree/promotion_handler/cart.rb

@@ -16,14 +16,20 @@ module Spree
       attr_reader :line_item, :order, :store
       attr_accessor :error, :success
 
-      def initialize(order, line_item = nil)
+      # @param order [Spree::Cart, Spree::Order]
+      # @param line_item [Spree::LineItem, nil]
+      # @param excluded_promotion_ids [Array<String, Integer>] promotions to leave alone, e.g. one that is being removed
+      def initialize(order, line_item = nil, excluded_promotion_ids: [])
         @order = order
         @line_item = line_item
         @store = order.store
+        @excluded_promotion_ids = Array(excluded_promotion_ids).map(&:to_s)
       end
 
       def activate
         promotions.each do |promotion|
+          next if @excluded_promotion_ids.include?(promotion.id.to_s)
+
           if (line_item && promotion.eligible?(line_item)) || promotion.eligible?(order)
             promotion.activate(line_item: line_item, order: order)
           else

data/app/models/spree/promotion_handler/coupon.rb

@@ -166,35 +166,7 @@ module Spree
       end
 
       def detach_promotion(promotion)
-        # Order promotion has to be destroyed before line item removing
-        order.promotions.delete(promotion)
-
-        if promotion.multi_codes?
-          promotion.coupon_codes.held_by(order).first&.remove_from_order
-        else
-          promotion.touch
-        end
-
-        remove_promotion_adjustments(promotion)
-        remove_promotion_line_items(promotion)
-        order.recalculate_totals!
-      end
-
-      def remove_promotion_adjustments(promotion)
-        order.discounts.where(promotion_action_id: promotion.actions.pluck(:id)).destroy_all
-      end
-
-      def remove_promotion_line_items(promotion)
-        create_line_item_actions_ids = promotion.actions.
-          where(type: %w[Spree::Promotion::Actions::CreateLineItems Spree::Promotion::Actions::CreateLineItems]).pluck(:id)
-
-        Spree::PromotionActionLineItem.where(promotion_action: create_line_item_actions_ids).find_each do |item|
-          line_item = order.find_line_item_by_variant(item.variant)
-          next if line_item.blank?
-
-          remove_service = order.is_a?(Spree::Cart) ? Spree.cart_remove_item_service : Spree.order_remove_item_service
-          remove_service.call(**{ (order.is_a?(Spree::Cart) ? :cart : :order) => order }, variant: item.variant, quantity: item.quantity)
-        end
+        Spree::Promotions::DetachFromOwner.call(owner: order, promotion: promotion)
       end
 
       def handle_present_promotion