spree_core 5.4.2 → 5.5.0.rc1

data/app/models/spree/product.rb

@@ -27,13 +27,14 @@ module Spree
     normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
 
     include Spree::ProductScopes
-    include Spree::StoreScopedResource
     include Spree::TranslatableResource
     include Spree::MemoizedData
     include Spree::Metafields
     include Spree::Metadata
     include Spree::Product::Webhooks
     include Spree::Product::Slugs
+    include Spree::Product::Channels
+    include Spree::Product::LegacyMultiStoreSupport unless defined?(SpreeMultiStore)
     include Spree::SearchIndexable
     if defined?(Spree::VendorConcern)
       include Spree::VendorConcern
@@ -121,8 +122,6 @@ module Spree
 
     has_many :prices_including_master, -> { non_zero }, through: :variants_including_master, source: :prices
 
-    has_many :store_products, class_name: 'Spree::StoreProduct'
-    has_many :stores, through: :store_products, class_name: 'Spree::Store'
     has_many :digitals, through: :variants_including_master
 
     after_initialize :ensure_master
@@ -133,6 +132,8 @@ module Spree
 
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
+    after_create :apply_pending_variants, if: :pending_variants?
+    after_save :apply_pending_media, if: :pending_media?
 
     after_save :save_master
     after_save :run_touch_callbacks, if: :anything_changed?
@@ -153,7 +154,7 @@ module Spree
 
     validate :discontinue_on_must_be_later_than_make_active_at, if: -> { make_active_at && discontinue_on }
 
-    scope :for_store, ->(store) { joins(:store_products).where(StoreProduct.table_name => { store_id: store.id }) }
+    scope :for_store, ->(store) { where(store_id: store.id) }
     scope :draft, -> { where(status: 'draft') }
     scope :archived, -> { where(status: 'archived') }
     scope :not_archived, -> { where.not(status: 'archived') }
@@ -197,8 +198,71 @@ module Spree
 
     alias options product_option_types
 
+    # Maps tags array to tag_list for API convenience.
+    # @param tags [Array<String>]
+    def tags=(tags)
+      self.tag_list = tags
+    end
+
+    # Sets prices on the master variant.
+    # Accepts array of { currency:, amount:, compare_at_amount: } hashes.
+    def prices=(prices_params)
+      find_or_build_master.prices = prices_params
+    end
+
+    # Maps 6.0 API name (category_ids) to model column (taxon_ids).
+    # Accepts both prefixed IDs and raw integer IDs.
+    def category_ids=(ids)
+      self.taxon_ids = Array(ids).filter_map do |id|
+        id.to_s.include?('_') ? Spree::Taxon.decode_prefixed_id(id) : id
+      end
+    end
+
+    # Sync media inline. Entries with `id` patch the existing asset
+    # (alt/position/variant_ids); entries with `signed_id` create + attach a
+    # fresh upload; missing items are left alone (delete still goes through
+    # the dedicated DELETE /media endpoint to avoid accidental data loss when
+    # a form ships stale state).
+    #
+    # Deferred: ActiveStorage attaches require a persisted record, so on new
+    # records we stash the params and replay them in `after_create`.
+    # @param media_params [Array<Hash>]
+    # @return [void]
+    def media=(media_params)
+      # Blank input is a no-op — never call `super` with an empty array,
+      # because the ActiveRecord collection setter would replace media with
+      # `[]` and trigger `dependent: :destroy` on every persisted asset.
+      # Explicit deletes go through the dedicated DELETE /media endpoint.
+      return if media_params.blank?
+      return super if media_params.first.is_a?(Spree::Asset)
+
+      if new_record?
+        @pending_media_params = media_params
+        return
+      end
+
+      apply_media(media_params)
+    end
+
+    # Syncs variants from an array of hashes.
+    # Creates new variants, updates existing ones (matched by :id), and removes unlisted ones.
+    # Must be called on a persisted product (use after_save or call explicitly after create).
+    # @param variants_params [Array<Hash>] array of variant attribute hashes
+    # @return [void]
+    def variants=(variants_params)
+      return super if variants_params.blank? || variants_params.first.is_a?(Spree::Variant)
+
+      # Store for deferred processing if product is not yet persisted
+      if new_record?
+        @pending_variants_params = variants_params
+        return
+      end
+
+      apply_variants(variants_params)
+    end
+
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at]
-    self.whitelisted_ransackable_associations = %w[taxons categories stores variants_including_master master variants tags labels
+    self.whitelisted_ransackable_associations = %w[taxons categories store channels variants_including_master master variants tags labels
                                                    shipping_category classifications option_types]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon in_category in_categories price_between
                                              price_lte price_gte
@@ -495,7 +559,11 @@ module Spree
       @total_on_hand ||= if any_variants_not_track_inventory?
                            BigDecimal::INFINITY
                          else
-                           stock_items.loaded? ? stock_items.sum(&:count_on_hand) : stock_items.sum(:count_on_hand)
+                           if variants_including_master.loaded?
+                             variants_including_master.sum(&:total_on_hand)
+                           else
+                             stock_items.loaded? ? stock_items.sum(&:count_on_hand) : stock_items.sum(:count_on_hand)
+                           end
                          end
     end
 
@@ -506,19 +574,6 @@ module Spree
       super || variants_including_master.with_deleted.find_by(is_master: true)
     end
 
-    # Returns the brand for the product
-    # If a brand association is defined (e.g., belongs_to :brand), it will be used
-    # Otherwise, falls back to brand_taxon for compatibility
-    # @return [Spree::Brand, Spree::Taxon]
-    def brand
-      if self.class.reflect_on_association(:brand)
-        super
-      else
-        Spree::Deprecation.warn('Spree::Product#brand is deprecated and will be removed in Spree 5.5. Please use Spree::Product#brand_taxon instead.')
-        brand_taxon
-      end
-    end
-
     # Returns the brand taxon for the product
     # @return [Spree::Taxon]
     def brand_taxon
@@ -538,7 +593,7 @@ module Spree
     # Returns the brand name for the product
     # @return [String]
     def brand_name
-      brand&.name
+      brand_taxon&.name
     end
 
     def main_taxon
@@ -573,15 +628,13 @@ module Spree
     def auto_match_taxons
       return if deleted?
       return if archived?
-
-      store = stores.find_by(default: true) || stores.first
       return if store.nil? || store.taxons.automatic.none?
 
       Spree::Products::AutoMatchTaxonsJob.set(wait: 30.seconds).perform_later(id)
     end
 
     def to_csv(store = nil)
-      store ||= stores.default || stores.first
+      store ||= self.store
       properties_for_csv = if respond_to?(:product_properties) && Spree::Config.respond_to?(:product_properties_enabled) && Spree::Config[:product_properties_enabled]
                              Spree::Property.order(:position).flat_map do |property|
                                [
@@ -645,6 +698,100 @@ module Spree
       nil
     end
 
+    def pending_variants?
+      @pending_variants_params.present?
+    end
+
+    def apply_pending_variants
+      return unless @pending_variants_params
+
+      apply_variants(@pending_variants_params)
+      @pending_variants_params = nil
+    end
+
+    def pending_media?
+      @pending_media_params.present?
+    end
+
+    def apply_pending_media
+      return unless @pending_media_params
+
+      apply_media(@pending_media_params)
+      @pending_media_params = nil
+    end
+
+    def apply_media(media_params)
+      # Eager-load Asset descendants once so the type allowlist is stable across
+      # the loop (and across requests once subclasses are referenced). Computed
+      # per-call rather than at class-load to avoid forcing autoload of every
+      # Asset subclass during boot.
+      allowed_types = [Spree::Asset, *Spree::Asset.descendants].map(&:name).to_set
+      media_params.each do |raw|
+        attrs = raw.respond_to?(:to_h) ? raw.to_h : raw
+        attrs = attrs.with_indifferent_access
+
+        # Upsert path: entries with an `id` patch an existing asset (alt,
+        # position, variant_ids). Entries with a `signed_id` create+attach.
+        # Omitting an entry leaves it alone — explicit DELETE on the dedicated
+        # media endpoint is still the only way to remove an asset.
+        asset_id = attrs.delete(:id)
+        if asset_id.present?
+          asset = media.find_by_param(asset_id) || next
+          asset.update!(attrs.except(:signed_id, :type))
+          next
+        end
+
+        signed_id = attrs.delete(:signed_id)
+        next if signed_id.blank?
+
+        media_type = attrs.delete(:type) || 'Spree::Image'
+        next unless allowed_types.include?(media_type)
+
+        asset = media.build(attrs.except(:id))
+        asset.type = media_type
+        asset.attachment.attach(signed_id)
+        asset.save!
+      end
+    end
+
+    def apply_variants(variants_params)
+      variant_ids_in_payload = []
+      master_touched = false
+
+      variants_params.each do |variant_data|
+        variant_data = variant_data.to_h.with_indifferent_access
+        variant_id = variant_data.delete(:id)
+        options = variant_data[:options]
+
+        if variant_id.present?
+          variant = variants_including_master.find_by_param!(variant_id)
+          variant.update!(variant_data)
+          variant_ids_in_payload << variant.id
+        elsif options.blank? || (options.is_a?(Array) && options.empty?)
+          # An entry with no options addresses the master variant. Building a
+          # non-master here would create a phantom duplicate (the auto-built
+          # master already exists, and `variants` excludes it). Upsert onto
+          # the master instead — the merchant-visible "default variant" on a
+          # simple product IS the master.
+          variant_data = variant_data.except(:options)
+          target = find_or_build_master
+          target.assign_attributes(variant_data)
+          target.save!
+          master_touched = true
+        else
+          variant = variants.build
+          variant.assign_attributes(variant_data)
+          variant.save!
+          variant_ids_in_payload << variant.id
+        end
+      end
+
+      # Remove variants not in the payload (only non-master). If only the
+      # master was touched (simple product), leave existing non-master
+      # variants alone — the payload is partial, not a full replacement.
+      variants.where.not(id: variant_ids_in_payload).destroy_all if variant_ids_in_payload.any? && !master_touched
+    end
+
     def add_associations_from_prototype
       if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
         self.option_types = prototype.option_types
@@ -668,7 +815,7 @@ module Spree
       values = option_values_hash.values
       values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
 
-      default_currency = stores.first&.default_currency || Spree::Store.default.default_currency
+      default_currency = store&.default_currency || Spree::Store.default.default_currency
       master_price = master.price_in(default_currency).amount
 
       values.each do |ids|
@@ -678,12 +825,6 @@ module Spree
       save
     end
 
-    def default_variant_cache_key
-      Spree::Deprecation.warn('Spree::Product#default_variant_cache_key is deprecated and will be removed in Spree 5.5. Please remove any occurrences of it.')
-
-      "spree/default-variant/#{cache_key_with_version}/#{Spree::Config[:track_inventory_levels]}"
-    end
-
     def ensure_master
       return unless new_record?
 
@@ -691,7 +832,7 @@ module Spree
     end
 
     def assign_default_tax_category
-      self.tax_category = Spree::TaxCategory.default if new_record?
+      self.tax_category = Spree::TaxCategory.default if new_record? && self[:tax_category_id].blank?
     end
 
     def anything_changed?

data/app/models/spree/product_publication.rb

@@ -0,0 +1,43 @@
+module Spree
+  # Per-channel publication record. A Product is "published" on a Channel when
+  # a ProductPublication exists for that pair; the optional window
+  # (+published_at+/+unpublished_at+) gates customer visibility.
+  #
+  # The owning Store is derived via +channel.store+ — no +store_id+ column
+  # lives on this table. Historic core had a +spree_products_stores+ join that
+  # also carried the Product↔Store relation; in 5.5+ that responsibility moves
+  # onto +Spree::Product#store_id+ directly, leaving this table single-purpose.
+  class ProductPublication < Spree.base_class
+    has_prefix_id :pp
+
+    belongs_to :product, class_name: 'Spree::Product', touch: true
+    belongs_to :channel, class_name: 'Spree::Channel'
+
+    validates :product, :channel, presence: true
+    validates :product_id, uniqueness: { scope: :channel_id }
+    validate :unpublished_at_after_published_at, if: -> { published_at && unpublished_at }
+
+    scope :published, lambda {
+      where('published_at IS NULL OR published_at <= ?', Time.current)
+        .where('unpublished_at IS NULL OR unpublished_at > ?', Time.current)
+    }
+
+    self.whitelisted_ransackable_attributes = %w[product_id channel_id published_at unpublished_at]
+    self.whitelisted_ransackable_associations = %w[product channel]
+
+    delegate :store, :store_id, to: :channel
+
+    def published?
+      (published_at.nil? || published_at <= Time.current) &&
+        (unpublished_at.nil? || unpublished_at > Time.current)
+    end
+
+    private
+
+    def unpublished_at_after_published_at
+      return if unpublished_at > published_at
+
+      errors.add(:unpublished_at, :must_be_after_published_at)
+    end
+  end
+end

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

@@ -7,6 +7,10 @@ module Spree
 
         before_validation -> { self.calculator ||= Calculator::FlatPercentItemTotal.new }
 
+        def self.additional_permitted_attributes
+          [calculator: [:type, { preferences: {} }]]
+        end
+
         def perform(options = {})
           order = options[:order]
 

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

@@ -7,6 +7,10 @@ module Spree
 
         before_validation -> { self.calculator ||= Calculator::PercentOnLineItem.new }
 
+        def self.additional_permitted_attributes
+          [calculator: [:type, { preferences: {} }]]
+        end
+
         def perform(options = {})
           order     = options[:order]
           promotion = options[:promotion]

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

@@ -8,6 +8,17 @@ module Spree
 
         after_save :handle_promotion_action_line_items
 
+        def self.additional_permitted_attributes
+          [line_items: [:variant_id, :quantity]]
+        end
+
+        # API v3 flat alias for `promotion_action_line_items_attributes`.
+        # Accepts an array of `{ variant_id:, quantity: }` rows; the list
+        # is the *desired* set, so anything missing on save is removed.
+        def line_items=(rows)
+          self.promotion_action_line_items_attributes = rows
+        end
+
         delegate :eligible?, to: :promotion
 
         # Adds a line item to the Order if the promotion is eligible
@@ -85,29 +96,36 @@ module Spree
 
         private
 
-        # Handles the creation and updating of promotion action line items
-        #
-        # This is a hacky replacement for accepts_nested_attributes_for
-        # that allows us to save the PromotionAction and PromotionActionLineItems
-        # at the same time.
+        # Handles the creation, updating, and pruning of promotion action
+        # line items. The submitted list is the *desired* set — variants
+        # not present are deleted, ones that are get upserted. Accepts
+        # both the legacy Rails admin hash shape (`{ "0" => attrs }`) and
+        # a flat array from the API. Variant IDs may be raw or prefixed.
         def handle_promotion_action_line_items
           return unless promotion_action_line_items_attributes
 
-          # remove the ones marked for destruction
-          ids_for_destruction = promotion_action_line_items_attributes.map { |key, params| params["_destroy"] == "1" ? params["id"] : nil }.compact
-          promotion_action_line_items.where(id: ids_for_destruction).delete_all if ids_for_destruction.present?
+          rows = promotion_action_line_items_attributes.is_a?(Hash) ? promotion_action_line_items_attributes.values : promotion_action_line_items_attributes
+          rows = rows.map { |row| row.respond_to?(:to_h) ? row.to_h.with_indifferent_access : row.with_indifferent_access }
+
+          rows = rows.map do |row|
+            variant_id = row['variant_id']
+            variant_id = Spree::Variant.find_by_param(variant_id)&.id if Spree::PrefixedId.prefixed_id?(variant_id)
+            row.merge('variant_id' => variant_id)
+          end
+
+          desired_variant_ids = rows.map { |row| row['variant_id'] }.compact
+          promotion_action_line_items.where.not(variant_id: desired_variant_ids).delete_all
 
-          # upsert the rest
-          records_for_upsert = promotion_action_line_items_attributes.map { |key, params| params["_destroy"] != "1" ? params : nil }.compact
+          return if rows.empty?
 
           opts = {}
-          opts[:unique_by] = [:promotion_action_id, :variant_id] unless ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+          opts[:unique_by] = [:promotion_action_id, :variant_id] unless mysql_adapter?
 
           promotion_action_line_items.upsert_all(
-            records_for_upsert.map do |params|
+            rows.map do |params|
               {
-                variant_id: params["variant_id"],
-                quantity: params["quantity"],
+                variant_id: params['variant_id'],
+                quantity: params['quantity'],
                 promotion_action_id: id
               }
             end,

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

@@ -1,39 +1,61 @@
-# A rule to limit a promotion based on shipment country.
+# A rule to limit a promotion based on shipment country. Stores an
+# array of ISO codes — countries are inherently identified by ISO
+# in the API. The legacy single `country_id` / `country_iso`
+# preferences still work; they fold into the multi-country list.
 module Spree
   class Promotion
     module Rules
       class Country < PromotionRule
-        preference :country_id, :integer
-        preference :country_iso, :string # Alternative way to configure the rule
+        preference :country_isos, :array, default: [], parse_on_set: lambda { |values|
+          normalize_id_preference.call(values).map(&:upcase)
+        }
+        preference :country_id, :integer # legacy single-country shortcut
+        preference :country_iso, :string # legacy ISO-based shortcut
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
-          if preferred_country_iso.present?
-            validate_eligibility_by_country_iso(order)
-          else
-            validate_eligibility_by_country_id(order, options)
-          end
+        def countries
+          isos = preferred_country_isos.presence || [preferred_country_iso].compact_blank
+          return Spree::Country.none if isos.blank?
+
+          Spree::Country.where(iso: isos.map { |s| s.to_s.upcase })
         end
 
-        private
+        def eligible?(order, options = {})
+          allowed_isos = eligible_country_isos(order)
+          shipping_iso = options[:country_iso] || order.ship_address&.country_iso
 
-        def validate_eligibility_by_country_id(order, options)
-          country_id = options[:country_id] || order.ship_address.try(:country_id)
-          return true if country_id == (preferred_country_id || order.store.default_country_id)
+          return true if allowed_isos.include?(shipping_iso)
 
           eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
           false
         end
 
-        def validate_eligibility_by_country_iso(order)
-          country_iso = order.ship_address&.country_iso
-          return true if country_iso == (preferred_country_iso || order.store.default_market&.default_country&.iso)
+        # Effective list of eligible country ISOs, merging legacy
+        # single-country preferences into the multi-country list.
+        # Order-of-precedence: explicit ISO list > legacy single ISO
+        # > legacy single ID > store default. Memoized per-instance —
+        # eligibility checks fire repeatedly per cart change.
+        def eligible_country_isos(order = nil)
+          @eligible_country_isos ||= compute_eligible_country_isos(order)
+        end
 
-          eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
-          false
+        private
+
+        def compute_eligible_country_isos(order)
+          return preferred_country_isos.map { |v| v.to_s.upcase } if preferred_country_isos.present?
+          return [preferred_country_iso.to_s.upcase] if preferred_country_iso.present?
+
+          if preferred_country_id.present?
+            iso = Spree::Country.where(id: preferred_country_id).pick(:iso)
+            return [iso.to_s.upcase] if iso.present?
+          end
+
+          return [] if order.nil?
+
+          [order.store&.default_country&.iso, order.store&.default_market&.default_country&.iso].compact.map(&:upcase).uniq
         end
       end
     end

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

@@ -2,12 +2,21 @@ module Spree
   class Promotion
     module Rules
       class CustomerGroup < PromotionRule
-        preference :customer_group_ids, :array, default: []
+        # Stored as raw IDs. Accepts prefixed IDs (`cg_…`) from API
+        # callers and decodes them on write so eligibility checks can
+        # compare against raw `customer_group_id` rows directly.
+        preference :customer_group_ids, :array, default: [], parse_on_set: normalize_id_preference(klass: Spree::CustomerGroup)
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
 
+        def customer_groups
+          return Spree::CustomerGroup.none if preferred_customer_group_ids.blank?
+
+          Spree::CustomerGroup.where(id: preferred_customer_group_ids)
+        end
+
         def eligible?(order, _options = {})
           return false unless order.user_id.present?
           return false if preferred_customer_group_ids.empty?

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

@@ -13,6 +13,10 @@ module Spree
                                            dependent: :destroy
         has_many :products, through: :product_promotion_rules, class_name: 'Spree::Product'
 
+        def self.additional_permitted_attributes
+          [product_ids: []]
+        end
+
         #
         # Preferences
         #

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

@@ -10,11 +10,34 @@ module Spree
                                          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, default: MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first
 
         #
         # Attributes

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

@@ -10,6 +10,27 @@ module Spree
                                         dependent: :destroy
         has_many :users, through: :promotion_rule_users, class_name: "::#{Spree.user_class}"
 
+        # 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
+
+        # Wire-format shorthand is `customer` (the model is still `User`
+        # pre-6.0 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
         #

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

@@ -2,6 +2,12 @@ module Spree
   class Promotion
     module Rules
       class UserLoggedIn < 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
+          'customer_logged_in'
+        end
+
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end

data/app/models/spree/promotion.rb

@@ -39,7 +39,8 @@ module Spree
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
     has_many :store_promotions, class_name: 'Spree::StorePromotion'
     has_many :stores, class_name: 'Spree::Store', through: :store_promotions
-    accepts_nested_attributes_for :promotion_actions, :promotion_rules
+
+    after_save :apply_pending_rules_and_actions, if: :pending_rules_or_actions?
 
     #
     # Callbacks
@@ -115,6 +116,21 @@ module Spree
       end
     end
 
+    # Flat-payload writer for `rules`. See
+    # {Spree::TypedAssociations#assign_typed_association}.
+    def rules=(rows)
+      assign_typed_association(:promotion_rules, rows)
+    end
+
+    # Mirrors `rules=` for promotion actions.
+    def actions=(rows)
+      assign_typed_association(:promotion_actions, rows)
+    end
+
+    def pending_rules_or_actions?
+      @pending_promotion_rules.present? || @pending_promotion_actions.present?
+    end
+
     def active?
       starts_at.present? && starts_at < Time.current && (expires_at.blank? || !expired?)
     end
@@ -283,6 +299,11 @@ module Spree
 
     private
 
+    def apply_pending_rules_and_actions
+      flush_pending_typed_association(:promotion_rules)
+      flush_pending_typed_association(:promotion_actions)
+    end
+
     def not_used?
       return true if orders.empty?