spree_core 5.6.1 → 6.0.0.beta2

data/app/models/spree/promotion/rules/taxon.rb

@@ -1,137 +1,16 @@
+# frozen_string_literal: true
+
 module Spree
   class Promotion
     module Rules
-      class Taxon < PromotionRule
-        #
-        # Associations
-        #
-        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon',
-                                         foreign_key: 'promotion_rule_id',
-                                         dependent: :destroy
-        has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
-
-        def self.additional_permitted_attributes
-          [category_ids: []]
-        end
-
-        # Wire-format shorthand is `category` (the model is still `Taxon`
-        # pre-6.0 rename). `key` (instance) cascades through `api_type`.
-        def self.api_type
-          'category'
-        end
-
-        # PrefixedId's auto-resolver in `assign_attributes` only fires
-        # when the `_ids` stem matches an association — `categories`
-        # doesn't, so decode prefixed IDs explicitly here.
-        def category_ids=(ids)
-          self.taxon_ids = Array(ids).map do |id|
-            Spree::PrefixedId.prefixed_id?(id) ? Spree::Taxon.find_by_param!(id).id : id
-          end
-        end
-
-        def category_ids
-          taxon_ids
-        end
-
-        #
-        # Preferences
-        #
-        MATCH_POLICIES = %w(any all)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
-
-        #
-        # Attributes
-        #
-        attr_accessor :taxon_ids_to_add
-
-        #
-        # Callbacks
-        #
-        after_save :add_taxons
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible_taxon_ids
-          @eligible_taxon_ids ||= promotion_rule_taxons.pluck(:taxon_id)
-        end
-
-        def eligible?(order, _options = {})
-          return true if eligible_taxon_ids.empty?
-
-          if preferred_match_policy == 'all'
-            order_taxon_ids_with_ancestors = taxon_ids_in_order_including_ancestors(order)
-            unless eligible_taxon_ids.all? { |id| order_taxon_ids_with_ancestors.include?(id) }
-              eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
-            end
-          else
-            order_taxon_ids_with_ancestors = taxon_ids_in_order_including_ancestors(order)
-            unless eligible_taxon_ids.any? { |id| order_taxon_ids_with_ancestors.include?(id) }
-              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
-            end
-          end
-
-          eligibility_errors.empty?
-        end
-
-        def actionable?(line_item)
-          Spree::Classification.where(taxon_id: eligible_taxon_ids_including_children, product_id: line_item.product_id).exists?
-        end
-
-        def taxon_ids_string
-          ActiveSupport::Deprecation.warn(
-            'Please use `taxon_ids=` instead.'
-          )
-          taxons.pluck(:id).join(',')
-        end
-
-        def taxon_ids_string=(s)
-          ActiveSupport::Deprecation.warn(
-            'Please use `taxon_ids=` instead.'
-          )
-          ids = s.to_s.split(',').map(&:strip)
-          self.taxons = Spree::Taxon.for_stores(stores).find(ids)
-        end
-
-        private
-
-        # IDs of taxons in rule including all their children
-        def eligible_taxon_ids_including_children
-          @eligible_taxon_ids_including_children ||= begin
-            return [] if eligible_taxon_ids.empty?
-
-            Spree::Taxon.where(id: eligible_taxon_ids).flat_map(&:cached_self_and_descendants_ids).uniq
-          end
-        end
-
-        # IDs of taxons in order that match rule taxons (or their children), plus all ancestors
-        def taxon_ids_in_order_including_ancestors(order)
-          # Get taxon IDs from order products that are within rule taxons or their children
-          order_taxon_ids = Spree::Classification.where(product_id: order.product_ids, taxon_id: eligible_taxon_ids_including_children).pluck(:taxon_id).uniq
-
-          return [] if order_taxon_ids.empty?
-
-          # Get those taxons plus all their ancestors
-          Spree::Taxon.where(id: order_taxon_ids).flat_map { |taxon| taxon.self_and_ancestors.ids }.uniq
-        end
-
-        def add_taxons
-          return if taxon_ids_to_add.nil?
-
-          promotion_rule_taxons.delete_all
-
-          if taxon_ids_to_add.any?
-            Spree::PromotionRuleTaxon.insert_all(
-              taxon_ids_to_add.map { |taxon_id| { taxon_id: taxon_id, promotion_rule_id: id } }
-            )
-          end
-
-          # Clear memoized values
-          @eligible_taxon_ids = nil
-          @eligible_taxon_ids_including_children = nil
-        end
-      end
+      # Deprecation alias for Spree::Promotion::Rules::Category, renamed from
+      # Spree::Promotion::Rules::Taxon in 6.0. A true constant alias, so old STI type
+      # strings (`'Spree::Promotion::Rules::Taxon'`) still instantiate correctly until
+      # the Phase 4 migration rewrites them. The warning fires when this file loads.
+      # Removed in 6.1.
+      Taxon = Category
+
+      Spree::Deprecation.warn('Spree::Promotion::Rules::Taxon is deprecated and will be removed in Spree 6.1. Use Spree::Promotion::Rules::Category instead.')
     end
   end
 end

data/app/models/spree/promotion/rules/user.rb

@@ -1,36 +1,28 @@
 module Spree
   class Promotion
     module Rules
-      class User < PromotionRule
+      class User < Spree::PromotionRule
         #
         # Associations
         #
         has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
                                         foreign_key: :promotion_rule_id,
                                         dependent: :destroy
-        has_many :users, through: :promotion_rule_users, class_name: "::#{Spree.user_class}"
+        has_many :customers, through: :promotion_rule_users, source: :customer,
+                             class_name: "::#{Spree.customer_class}"
+        has_many :users, through: :promotion_rule_users, source: :customer,
+                         class_name: "::#{Spree.customer_class}", deprecated: true
 
-        # Customers, not admin users — the rule keys off `Spree::Order#user_id`.
-        # The data layer keeps the `users` association (legacy column name);
-        # the API exposes the same set as `customer_ids`.
-        def self.additional_permitted_attributes
-          [customer_ids: []]
-        end
+        # Customers, not admin users — the rule keys off `Spree::Order#customer_id`.
+        # `customer_ids` / `customer_ids=` come from the `customers` association.
+        self.additional_permitted_attributes = [customer_ids: []]
 
-        # Wire-format shorthand is `customer` (the model is still `User`
-        # pre-6.0 rename, see docs/plans/6.0-platform-auth.md).
+        # Wire-format shorthand is `customer`; the rule class keeps the `User`
+        # name until the 6.1 rename (see docs/plans/6.0-platform-auth.md).
         def self.api_type
           'customer'
         end
 
-        def customer_ids
-          user_ids
-        end
-
-        def customer_ids=(ids)
-          self.user_ids = ids
-        end
-
         #
         # Attributes
         #
@@ -42,15 +34,15 @@ module Spree
         after_save :add_users
 
         def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
+          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
         end
 
         def eligible_user_ids
-          @eligible_user_ids ||= promotion_rule_users.pluck(:user_id)
+          @eligible_user_ids ||= promotion_rule_users.pluck(:customer_id)
         end
 
         def eligible?(order, _options = {})
-          eligible_user_ids.include?(order.user_id)
+          eligible_user_ids.include?(order.customer_id)
         end
 
         def user_ids_string
@@ -78,7 +70,7 @@ module Spree
 
           if user_ids_to_add.any?
             Spree::PromotionRuleUser.insert_all(
-              user_ids_to_add.map { |user_id| { user_id: user_id, promotion_rule_id: id } }
+              user_ids_to_add.map { |customer_id| { customer_id: customer_id, promotion_rule_id: id } }
             )
           end
 

data/app/models/spree/promotion/rules/user_logged_in.rb

@@ -1,7 +1,7 @@
 module Spree
   class Promotion
     module Rules
-      class UserLoggedIn < PromotionRule
+      class UserLoggedIn < Spree::PromotionRule
         # Wire-format shorthand is `customer_logged_in` (the model is still
         # `UserLoggedIn` pre-6.0 rename, see docs/plans/6.0-platform-auth.md).
         def self.api_type
@@ -9,11 +9,11 @@ module Spree
         end
 
         def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
+          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
         end
 
         def eligible?(order, _options = {})
-          unless order.user.present?
+          unless order.customer.present?
             eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
           end
           eligibility_errors.empty?

data/app/models/spree/promotion.rb

@@ -3,13 +3,11 @@ module Spree
     has_prefix_id :promo  # Spree-specific: promotion
 
     include Spree::SingleStoreResource
-    include Spree::Metafields
+    include Spree::HasCustomFields
     include Spree::Metadata
     if defined?(Spree::Security::Promotions)
       include Spree::Security::Promotions
     end
-    # Multi-store sharing moved to the spree_multi_store extension in 5.6.
-    include Spree::LegacyMultiStoreSupport unless defined?(SpreeMultiStore)
 
     publishes_lifecycle_events
 
@@ -39,7 +37,6 @@ module Spree
     has_many :coupon_codes, -> { order(created_at: :asc) }, dependent: :destroy, class_name: 'Spree::CouponCode'
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
-    belongs_to :store, class_name: 'Spree::Store'
 
     after_save :apply_pending_rules_and_actions, if: :pending_rules_or_actions?
 
@@ -61,7 +58,6 @@ module Spree
     #
     validates_associated :rules
     validates :name, presence: true
-    validates :store, presence: true, unless: -> { Spree::Config[:disable_store_presence_validation] }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }, allow_blank: true
     validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }
@@ -90,7 +86,7 @@ module Spree
     #
     # `name` is whitelisted so the admin global search / command palette can
     # filter via the `name_or_code_cont` predicate without a dedicated scope.
-    self.whitelisted_ransackable_attributes = ['name', 'path', 'promotion_category_id', 'code', 'starts_at', 'expires_at']
+    self.whitelisted_ransackable_attributes = ['name', 'path', 'promotion_category_id', 'code', 'kind', 'starts_at', 'expires_at']
     self.whitelisted_ransackable_associations = %w[coupon_codes]
 
     def self.with_coupon_code(coupon_code)
@@ -110,12 +106,13 @@ module Spree
         where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.current)
     end
 
-    def self.order_activatable?(order)
-      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    def self.order_activatable?(promotable)
+      # Carts have no cancellation concept — only placed orders can be canceled.
+      promotable && !promotable.completed? && !(promotable.is_a?(Spree::Order) && promotable.canceled?)
     end
 
     def generate_code=(generating_code)
-      if ActiveModel::Type::Boolean.new.cast(generating_code)
+      if generating_code.to_b
         self.code = random_code
       end
     end
@@ -203,7 +200,7 @@ module Spree
       action_taken
     end
 
-    # called anytime order.update_with_updater! happens
+    # called anytime order.recalculate_totals! happens
     def eligible?(promotable, options = {})
       return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
 
@@ -243,7 +240,7 @@ module Spree
     end
 
     def products
-      rules.where(type: 'Spree::Promotion::Rules::Product').map(&:products).flatten.uniq
+      rules.where(type: %w[Spree::Promotion::Rules::Product Spree::Promotion::Rules::Product]).map(&:products).flatten.uniq
     end
 
     def usage_limit_exceeded?(promotable)
@@ -251,16 +248,34 @@ module Spree
     end
 
     def adjusted_credits_count(promotable)
-      adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
-      credits_count - adjustments.eligible.promotion.where(source_id: actions.pluck(:id)).select(:order_id).distinct.count
+      own_credits = case promotable
+                    when Spree::Cart
+                      # Cart-side discount rows carry no order_id and are
+                      # never part of credits_count — nothing to subtract.
+                      0
+                    when Order
+                      # A checkout that divided across sellers left a discount
+                      # row on every child, so what this promotable already
+                      # accounts for is its whole group, not just itself.
+                      checkouts_credited(credits.where(order_id: promotable.sibling_order_ids))
+                    else
+                      checkouts_credited(credits.where(line_item_id: promotable.id))
+                    end
+      credits_count - own_credits
     end
 
     def credits
-      Adjustment.eligible.promotion.where(source_id: actions.map(&:id))
+      Spree::Discount.promotion.where(promotion_action_id: actions.map(&:id))
     end
 
+    # How many times this promotion has been redeemed.
+    #
+    # Counted in checkouts rather than orders: a basket spanning several
+    # sellers becomes several orders, each carrying its own discount rows, and
+    # counting those as separate uses would spend a limited promotion two or
+    # three times over on one customer's single redemption.
     def credits_count
-      credits.select(:order_id).distinct.count
+      checkouts_credited(credits)
     end
 
     def line_item_actionable?(order, line_item)
@@ -278,11 +293,18 @@ module Spree
       end
     end
 
+    # @param excluded_orders [Array<Spree::Order>] orders whose own use does
+    #   not count — an order asking on its own behalf. Excluding one of a split
+    #   checkout's orders excludes its siblings too, since they are one
+    #   redemption between them rather than several.
     def used_by?(user, excluded_orders = [])
-      user.orders.complete.joins(:promotions).joins(:all_adjustments).
-        where.not(spree_orders: { id: excluded_orders.map(&:id) }).
-        where(spree_promotions: { id: id }).
-        where(spree_adjustments: { source_type: 'Spree::PromotionAction', eligible: true }).any?
+      # A cart is not an order and has no siblings; it simply has nothing to
+      # exclude, since its own discounts carry no order_id.
+      excluded_ids = excluded_orders.flat_map { |record| record.try(:sibling_order_ids) || [] }.uniq
+
+      user.orders.complete.joins(:discounts).
+        where.not(spree_orders: { id: excluded_ids }).
+        where(Spree::Discount.table_name => { promotion_id: id, kind: 'promotion' }).any?
     end
 
     def name_for_order(order)
@@ -303,6 +325,22 @@ module Spree
 
     private
 
+    # Counts distinct checkouts behind a set of discount rows.
+    #
+    # An order placed on its own is one checkout; the several orders a split
+    # checkout produced are one between them, which is what their shared group
+    # identifies. Collapsing on the group is what makes a redemption cost the
+    # same whether the customer bought from one seller or four.
+    #
+    # @param scope [ActiveRecord::Relation<Spree::Discount>]
+    # @return [Integer]
+    def checkouts_credited(scope)
+      orders = Spree::Order.arel_table
+      checkout = Arel::Nodes::NamedFunction.new('COALESCE', [orders[:order_group_id], orders[:id]])
+
+      scope.joins(:order).distinct.count(checkout)
+    end
+
     def apply_pending_rules_and_actions
       flush_pending_typed_association(:promotion_rules)
       flush_pending_typed_association(:promotion_actions)
@@ -311,7 +349,7 @@ module Spree
     def not_used?
       return true if orders.empty?
 
-      errors.add(:base, Spree.t('promotion_already_used'))
+      errors.add(:base, :promotion_already_used, message: Spree.t('promotion_already_used'))
       throw(:abort)
     end
 
@@ -367,7 +405,7 @@ module Spree
       when Spree::LineItem
         !promotable.product.promotionable?
       when Spree::Order
-        (promotable.item_count.positive? || promotable.line_items.any?) &&
+        (promotable.total_quantity.positive? || promotable.line_items.any?) &&
           promotable.line_items.joins(:product).where(spree_products: { promotionable: true }).none?
       end
     end

data/app/models/spree/promotion_action.rb

@@ -4,23 +4,16 @@ module Spree
   class PromotionAction < Spree.base_class
     has_prefix_id :pact
 
+    registers_subclasses_via { Spree.promotions.actions }
+
     acts_as_paranoid
 
     belongs_to :promotion, class_name: 'Spree::Promotion', touch: true
 
-    validates :promotion, :type, presence: true
+    validates :type, presence: true
 
     scope :of_type, ->(t) { where(type: t) }
 
-    # Per-subclass permitted attributes beyond `type` and `preferences`.
-    # Override in STI subclasses that accept nested attributes (e.g.
-    # CreateLineItems needs `promotion_action_line_items_attributes`,
-    # CreateAdjustment needs `calculator_type` + `calculator_attributes`).
-    # The Admin API merges these into its `params.permit(...)` allowlist.
-    def self.additional_permitted_attributes
-      []
-    end
-
     # This method should be overridden in subclass
     # Updates the state of the order or performs some other action depending on the subclass
     # options will contain the payload from the event that activated the promotion. This will include
@@ -29,11 +22,45 @@ module Spree
       raise 'perform should be implemented in a sub-class of PromotionAction'
     end
 
+    # Which competition group this action's discounts belong to
+    # (+:line_item+, +:fulfillment+, +:order+), or nil for actions that don't
+    # write Discount rows. Drives Spree::Adjusters::Promotion.
+    #
+    # @return [Symbol, nil]
+    def discount_scope
+      nil
+    end
+
+    # Whether this action's Discount rows persist at zero amount (only
+    # FreeShipping — row existence is the signal).
+    def persist_at_zero?
+      false
+    end
+
     # Returns true if the promotion action is a free shipping action
     #
     # @return [Boolean]
     def free_shipping?
-      type == 'Spree::Promotion::Actions::FreeShipping'
+      type.to_s.demodulize == 'FreeShipping'
+    end
+
+    # STI type names for a discount scope, covering both the 6.0 names and
+    # the legacy names still present in the type column until the 6.1 data
+    # migration.
+    #
+    # @param scope [Symbol] :line_item, :fulfillment or :order
+    # @return [Array<String>]
+    def self.types_for_discount_scope(scope)
+      case scope
+      when :line_item
+        %w[Spree::Promotion::Actions::CreateItemAdjustments Spree::Promotion::Actions::CreateItemAdjustments]
+      when :fulfillment
+        %w[Spree::Promotion::Actions::FreeShipping Spree::Promotion::Actions::FreeShipping]
+      when :order
+        %w[Spree::Promotion::Actions::CreateAdjustment Spree::Promotion::Actions::CreateAdjustment]
+      else
+        []
+      end
     end
 
     def self.human_name
@@ -56,6 +83,20 @@ module Spree
 
     protected
 
+    # Shared perform for discount-writing actions: report whether this action
+    # currently yields a candidate (that connects the promotion to the order,
+    # so it keeps competing on later recalculations even if it loses now),
+    # then settle rows immediately.
+    def apply_via_adjuster(options)
+      order = options[:order]
+      promotion = options[:promotion] || self.promotion
+
+      adjuster = Spree::Adjusters::Promotion.new(order, extra_promotions: [promotion])
+      produced = adjuster.candidate_for?(self)
+      adjuster.update if produced
+      produced
+    end
+
     def label
       Spree.t(:promotion_label, name: promotion.name)
     end

data/app/models/spree/promotion_action_line_item.rb

@@ -3,7 +3,7 @@ module Spree
     belongs_to :promotion_action, class_name: 'Spree::Promotion::Actions::CreateLineItems'
     belongs_to :variant, class_name: 'Spree::Variant'
 
-    validates :promotion_action, :variant, :quantity, presence: true
+    validates :quantity, presence: true
     validates :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
   end
 end

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

@@ -12,6 +12,9 @@ module Spree
 
       def apply
         if gift_cards_enabled? && load_gift_card_code
+          # The entered code is a gift card, not a coupon — drop the pending
+          # coupon_code assignment so locking flows don't see a dirty record.
+          order.restore_attributes([:coupon_code]) if order.has_attribute?(:coupon_code) && order.will_save_change_to_attribute?(:coupon_code)
 
           if @gift_card.expired?
             set_error_code :gift_card_expired
@@ -26,7 +29,18 @@ module Spree
           if result.success?
             set_success_code(:gift_card_applied)
           else
-            set_error_code(result.value, result.error.value || {})
+            # A workflow failure carries a symbolic code, but a hook rejection
+            # carries an ActiveModel::Errors — translating that would render
+            # the object's inspect string to the shopper.
+            error = result.error.value
+            if error.is_a?(Symbol)
+              set_error_code(error)
+            else
+              @status_code = :gift_card_not_applied
+              # The rejection message is what the hook author wrote for the
+              # shopper; fall back to the generic string if it says nothing.
+              @error = result.error.to_s.presence || Spree.t(:gift_card_not_applied)
+            end
           end
 
           return self
@@ -63,6 +77,7 @@ module Spree
         if promotion.present?
           # Order promotion has to be destroyed before line item removing
           order.promotions.delete(promotion)
+          clear_persisted_coupon_code(coupon_code)
 
           if promotion.multi_codes?
             coupon_code = promotion.coupon_codes.find_by(order: order)
@@ -73,7 +88,7 @@ module Spree
 
           remove_promotion_adjustments(promotion)
           remove_promotion_line_items(promotion)
-          order.update_with_updater!
+          order.recalculate_totals!
 
           set_success_code :adjustments_deleted
         else
@@ -101,13 +116,13 @@ module Spree
         ).with_coupon_code(order.coupon_code)
       end
 
-      # Returns the amount of adjustments for the promotion
+      # Returns the amount of discounts for the promotion
       #
       # @return [Numeric]
       def adjustments_amount
         @adjustments_amount ||=
-          @order.all_adjustments.promotion.eligible.
-          where(source: promotion&.actions).
+          @order.discounts.promotion.
+          where(promotion_action_id: promotion&.actions&.ids).
           sum(:amount)
       end
 
@@ -120,20 +135,29 @@ module Spree
 
       private
 
+      # Carts persist the entered code (adjuster candidacy) — removing the
+      # promotion must clear it or recalculation re-applies immediately.
+      def clear_persisted_coupon_code(code)
+        return unless order.has_attribute?(:coupon_code)
+        return unless order.read_attribute(:coupon_code).to_s.casecmp?(code.to_s.strip)
+
+        order.update_column(:coupon_code, nil)
+      end
+
       def remove_promotion_adjustments(promotion)
-        promotion_actions_ids = promotion.actions.pluck(:id)
-        order.all_adjustments.where(source_id: promotion_actions_ids,
-                                    source_type: 'Spree::PromotionAction').destroy_all
+        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: 'Spree::Promotion::Actions::CreateLineItems').pluck(:id)
+        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?
 
-          Spree.cart_remove_item_service.call(order: order, variant: item.variant, quantity: item.quantity)
+          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
       end
 
@@ -143,6 +167,10 @@ module Spree
         return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
 
         unless promotion.eligible?(order, options)
+          # Rules that explain themselves keep their message, but the status
+          # code is always :coupon_code_not_eligible so callers can park the
+          # code for retry on recalculation.
+          self.status_code = :coupon_code_not_eligible
           self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
           return (error || ineligible_for_this_order)
         end
@@ -175,10 +203,10 @@ module Spree
       def determine_promotion_application_result
         coupon_code = order.coupon_code.downcase
 
-        # Check for applied adjustments.
-        discount = order.all_adjustments.promotion.eligible.detect do |p|
-          p.source.promotion.code.try(:downcase) == coupon_code ||
-            Spree::CouponCode.unused.where(promotion_id: p.source.promotion_id, code: coupon_code).exists?
+        # Check for applied discounts.
+        discount = order.discounts.promotion.includes(:promotion).detect do |row|
+          row.promotion&.code.try(:downcase) == coupon_code ||
+            Spree::CouponCode.unused.where(promotion_id: row.promotion_id, code: coupon_code).exists?
         end
 
         # Check for applied line items.
@@ -191,7 +219,7 @@ module Spree
         if discount || created_line_items
           handle_coupon_code(discount, coupon_code) if discount
 
-          order.update_with_updater!
+          order.recalculate_totals!
           set_success_code :coupon_code_applied
         elsif order.promotions.with_coupon_code(order.coupon_code)
           # since CouponCode is disposable...
@@ -209,7 +237,7 @@ module Spree
       end
 
       def handle_coupon_code(discount, coupon_code)
-        Spree::CouponCode.unused.find_by(promotion_id: discount.source.promotion_id, code: coupon_code)&.apply_order!(order)
+        Spree::CouponCode.unused.find_by(promotion_id: discount.promotion_id, code: coupon_code)&.apply_order!(order)
       end
 
       # Whether the coupon handler should also handle gift card codes.

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

@@ -23,7 +23,7 @@ module Spree
 
       def promotions
         store.promotions.active.joins(:promotion_actions).
-          where(Spree::PromotionAction.table_name => { type: 'Spree::Promotion::Actions::FreeShipping' }, path: nil).distinct
+          where(Spree::PromotionAction.table_name => { type: Spree::PromotionAction.types_for_discount_scope(:fulfillment) }, path: nil).distinct
       end
     end
   end