spree_core 5.4.3 → 5.5.0.rc1

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?
 

data/app/models/spree/promotion_action.rb

@@ -12,6 +12,15 @@ module Spree
 
     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
@@ -27,25 +36,22 @@ module Spree
       type == 'Spree::Promotion::Actions::FreeShipping'
     end
 
-    # Returns the human name of the promotion action
-    #
-    # @return [String] eg. Free Shipping
-    def human_name
-      Spree.t("promotion_action_types.#{key}.name")
+    def self.human_name
+      Spree.t("promotion_action_types.#{api_type}.name", default: api_type.titleize)
     end
 
-    # Returns the human description of the promotion action
-    #
-    # @return [String]
-    def human_description
-      Spree.t("promotion_action_types.#{key}.description")
+    def self.human_description
+      Spree.t("promotion_action_types.#{api_type}.description", default: '')
     end
 
+    def human_name = self.class.human_name
+    def human_description = self.class.human_description
+
     # Returns the key of the promotion action
     #
     # @return [String] eg. free_shipping
     def key
-      type.demodulize.underscore
+      self.class.api_type
     end
 
     protected

data/app/models/spree/promotion_rule.rb

@@ -10,7 +10,15 @@ module Spree
     scope :of_type, ->(t) { where(type: t) }
 
     validates :promotion, presence: true
-    validate :unique_per_promotion, on: :create
+    validates :type, uniqueness: { scope: [:promotion_id, *spree_base_uniqueness_scope] }
+
+    # Per-subclass permitted attributes beyond `type` and `preferences`.
+    # Override in STI subclasses that accept association IDs (e.g.
+    # Rules::Product needs `product_ids`). The Admin API merges these
+    # into its `params.permit(...)` allowlist.
+    def self.additional_permitted_attributes
+      []
+    end
 
     def self.for(promotable)
       all.select { |rule| rule.applicable?(promotable) }
@@ -34,35 +42,26 @@ module Spree
       @eligibility_errors ||= ActiveModel::Errors.new(self)
     end
 
-    # Returns the human name of the promotion rule
-    #
-    # @return [String] eg. Currency
-    def human_name
-      Spree.t("promotion_rule_types.#{key}.name")
+    def self.human_name
+      Spree.t("promotion_rule_types.#{api_type}.name", default: api_type.titleize)
     end
 
-    # Returns the human description of the promotion rule
-    #
-    # @return [String]
-    def human_description
-      Spree.t("promotion_rule_types.#{key}.description")
+    def self.human_description
+      Spree.t("promotion_rule_types.#{api_type}.description", default: '')
     end
 
+    def human_name = self.class.human_name
+    def human_description = self.class.human_description
+
     # Returns the key of the promotion rule
     #
     # @return [String] eg. currency
     def key
-      type.demodulize.underscore
+      self.class.api_type
     end
 
     private
 
-    def unique_per_promotion
-      if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
-        errors.add(:base, 'Promotion already contains this rule type')
-      end
-    end
-
     def eligibility_error_message(key, options = {})
       Spree.t(key, Hash[scope: [:eligibility_errors, :messages]].merge(options))
     end

data/app/models/spree/search_provider/meilisearch.rb

@@ -233,7 +233,7 @@ module Spree
       end
 
       def filterable_attributes
-        %w[product_id status in_stock store_ids locale currency discontinue_on price category_ids tags option_value_ids]
+        %w[product_id status in_stock store_ids channel_ids locale currency available_on discontinue_on price category_ids tags option_value_ids]
       end
 
       def sortable_attributes
@@ -259,12 +259,22 @@ module Spree
       # System scoping — always applied. Rarely overridden.
       # Mirrors the AR scope: store.products.active(currency) with locale.
       def system_filter_conditions
+        now = Time.current
         conditions = []
         conditions << "store_ids = '#{store.id}'"
+        conditions << "channel_ids = '#{Spree::Current.channel.id}'" if Spree::Current.channel
         conditions << "status = 'active'"
         conditions << "locale = '#{locale.to_s.gsub(/[^a-zA-Z_-]/, '')}'"
         conditions << "currency = '#{currency.to_s.gsub(/[^A-Z]/, '')}'"
-        conditions << "(discontinue_on = 0 OR discontinue_on > #{Time.current.to_i})"
+        # Exclude future-dated products — mirrors +Product.available(Time.current)+.
+        # ISO 8601 strings sort lexicographically in chronological order, so the
+        # string compare is sound. +NOT EXISTS+ catches docs indexed before this
+        # attribute was emitted (legacy indexes), +IS NULL+ catches docs where
+        # the field was emitted as explicit null, and the +<=+ clause filters
+        # the remaining future-dated docs — so the upgrade is non-breaking and
+        # no reindex is required.
+        conditions << "(available_on NOT EXISTS OR available_on IS NULL OR available_on <= '#{now.iso8601}')"
+        conditions << "(discontinue_on = 0 OR discontinue_on > #{now.to_i})"
         conditions
       end
 

data/app/models/spree/stock/availability_validator.rb

@@ -28,7 +28,7 @@ module Spree
       private
 
       def item_available?(line_item, quantity)
-        Spree::Stock::Quantifier.new(line_item.variant).can_supply?(quantity)
+        Spree::Stock::Quantifier.new(line_item.variant, excluded_order: line_item.order).can_supply?(quantity)
       end
     end
   end

data/app/models/spree/stock/quantifier.rb

@@ -1,25 +1,89 @@
 module Spree
   module Stock
     class Quantifier
-      attr_reader :variant, :stock_location
+      attr_reader :variant, :stock_location, :excluded_order
 
-      def initialize(variant, stock_location = nil)
-        @variant        = variant
-        @stock_location = stock_location
+      # @param excluded_order [Spree::Order, nil] when given, reservations
+      #   belonging to this order are not counted against availability. Used
+      #   when checking an order's own line items so the customer's own
+      #   checkout hold doesn't make their item look out of stock.
+      def initialize(variant, stock_location = nil, excluded_order: nil)
+        @variant         = variant
+        @stock_location  = stock_location
+        @excluded_order  = excluded_order
       end
 
+      # Units a customer can purchase right now: physical pool minus
+      # already-allocated units minus active checkout reservations. Clamped
+      # at zero so callers never see a negative count.
+      #
+      # Returns +BigDecimal::INFINITY+ when the variant does not track
+      # inventory (effectively unlimited supply).
+      #
+      # @return [Integer, BigDecimal] purchasable quantity, or +INFINITY+
       def total_on_hand
         @total_on_hand ||= if variant.should_track_inventory?
-                             if association_loaded?
-                               stock_items.sum(&:count_on_hand)
-                             else
-                               stock_items.sum(:count_on_hand)
-                             end
+                             [available_stock - reserved_quantity, 0].max
                            else
                              BigDecimal::INFINITY
                            end
       end
 
+      # Physical pool minus already-allocated units, summed across the
+      # variant's active stock items.
+      #
+      # In Spree 5.5 {Spree::StockItem#allocated_count} is a Ruby shim that
+      # always returns 0, so this equals +SUM(count_on_hand)+. In 6.0
+      # (Typed Stock Movements) +allocated_count+ becomes a real column and
+      # the SQL path subtracts it natively.
+      #
+      # @return [Integer] units available before checkout reservations
+      def available_stock
+        if association_loaded?
+          stock_items.sum(&:available_count)
+        elsif self.class.allocated_count_column?
+          stock_items.sum('count_on_hand - allocated_count')
+        else
+          stock_items.sum(:count_on_hand)
+        end
+      end
+
+      # Units currently held by active checkout reservations on the
+      # location-filtered stock items. Returns 0 when stock reservations
+      # are globally disabled.
+      #
+      # Reads through the same {#stock_items} collection as {#available_stock}
+      # so a per-location query (filtered by `stock_location`) only counts
+      # reservations that belong to those same stock items — otherwise a
+      # multi-location variant would subtract reservations from other
+      # warehouses.
+      #
+      # When +excluded_order+ is set, that order's own reservations are left
+      # out of the count so an order's own checkout hold doesn't count
+      # against the availability of its own line items.
+      #
+      # @return [Integer]
+      def reserved_quantity
+        return @reserved_quantity if defined?(@reserved_quantity)
+        return @reserved_quantity = 0 unless Spree::Config[:stock_reservations_enabled]
+        return @reserved_quantity = 0 if stock_items.blank?
+
+        excluded_order_id = excluded_order&.id
+
+        @reserved_quantity = if reservations_preloaded?
+                               stock_items.sum do |si|
+                                 reservations = si.active_stock_reservations
+                                 reservations = reservations.reject { |r| r.order_id == excluded_order_id } if excluded_order_id
+                                 reservations.sum(&:quantity)
+                               end
+                             else
+                               reservations = Spree::StockReservation.active.where(stock_item_id: stock_items.map(&:id))
+                               reservations = reservations.where.not(order_id: excluded_order_id) if excluded_order_id
+                               reservations.sum(:quantity)
+                             end
+      end
+
+      # Check if any of variant stock items is backorderable
       def backorderable?
         @backorderable ||= stock_items.any?(&:backorderable)
       end
@@ -32,12 +96,28 @@ module Spree
         @stock_items ||= scope_to_location(variant.stock_items)
       end
 
+      # Memoized schema check so {#available_stock} doesn't introspect the
+      # column list on every call. Flips from false → true when 6.0 Typed
+      # Stock Movements adds the `allocated_count` column.
+      #
+      # @return [Boolean]
+      def self.allocated_count_column?
+        return @allocated_count_column if defined?(@allocated_count_column)
+
+        @allocated_count_column = Spree::StockItem.connection.column_exists?(:spree_stock_items, :allocated_count)
+      end
+
       private
 
       def association_loaded?
         variant.association(:stock_items).loaded?
       end
 
+      def reservations_preloaded?
+        association_loaded? &&
+          stock_items.all? { |si| si.association(:active_stock_reservations).loaded? }
+      end
+
       def scope_to_location(collection)
         if stock_location.blank?
           if association_loaded?

data/app/models/spree/stock_item.rb

@@ -15,6 +15,8 @@ module Spree
       belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant'
     end
     has_many :stock_movements, inverse_of: :stock_item
+    has_many :stock_reservations, class_name: 'Spree::StockReservation', inverse_of: :stock_item, dependent: :destroy
+    has_many :active_stock_reservations, -> { active }, class_name: 'Spree::StockReservation', inverse_of: :stock_item
 
     validates :stock_location, :variant, presence: true
     validates :variant_id, uniqueness: { scope: :stock_location_id }, unless: :deleted_at
@@ -38,6 +40,18 @@ module Spree
 
     scope :with_active_stock_location, -> { joins(:stock_location).merge(Spree::StockLocation.active) }
 
+    # Stock items for products assigned to `store`. Walks
+    # `variant → product → stores`, dedups via `distinct` so a product
+    # in multiple stores doesn't double-count its stock items.
+    #
+    # Used by the admin API as the base scope (`StockItem.for_store`)
+    # so the controller can filter directly by stock_location/variant
+    # without inheriting `Spree::Store#stock_items`'s extra joins or
+    # the variant default ordering.
+    scope :for_store, ->(store) {
+      joins(variant: :product).where(spree_products: { store_id: store.id })
+    }
+
     def backordered_inventory_units
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end
@@ -64,6 +78,28 @@ module Spree
       in_stock? || backorderable?
     end
 
+    # Units already allocated to pending shipments at this stock item.
+    #
+    # Always returns 0 in Spree 5.5. The 6.0 Typed Stock Movements plan
+    # (see docs/plans/6.0-typed-stock-movements.md) adds an indexed
+    # `allocated_count` column updated by typed movements (`allocated`,
+    # `released`, `shipped`); the Rails column accessor then takes
+    # precedence over this method automatically.
+    #
+    # @return [Integer]
+    def allocated_count
+      0
+    end
+
+    # Physical stock minus allocated units at this stock item. Distinct from
+    # {Spree::Stock::Quantifier#available_stock}, which sums this across all
+    # stock items belonging to a variant.
+    #
+    # @return [Integer]
+    def available_count
+      count_on_hand - allocated_count
+    end
+
     def reduce_count_on_hand_to_zero
       set_count_on_hand(0) if count_on_hand > 0
     end

data/app/models/spree/stock_location.rb

@@ -2,6 +2,15 @@ module Spree
   class StockLocation < Spree.base_class
     has_prefix_id :sloc  # Spree-specific: stock location
 
+    # Categorizes the location. Open string — extensible by setting any value;
+    # KINDS lists the built-in options used by the admin UI dropdown.
+    KINDS = %w[warehouse store fulfillment_center].freeze
+
+    # Pickup stock policy: 'local' = only items physically at this location are
+    # collectable; 'any' = items can be transferred from other locations
+    # (ship-to-store). See docs/plans/6.0-fulfillment-and-delivery.md.
+    PICKUP_STOCK_POLICIES = %w[local any].freeze
+
     include Spree::UniqueName
     if defined?(Spree::Security::StockLocations)
       include Spree::Security::StockLocations
@@ -20,14 +29,41 @@ module Spree
     belongs_to :state, class_name: 'Spree::State', optional: true
     belongs_to :country, class_name: 'Spree::Country'
 
+    validates :kind, presence: true
+    validates :pickup_stock_policy, inclusion: { in: PICKUP_STOCK_POLICIES }
+    validates :pickup_ready_in_minutes,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 },
+              allow_nil: true
+
+    self.whitelisted_ransackable_attributes = %w[
+      name active default kind pickup_enabled
+      country_id state_id created_at updated_at
+    ]
+
     scope :active, -> { where(active: true) }
+    scope :pickup_enabled, -> { where(pickup_enabled: true) }
     scope :order_default, -> { order(default: :desc, name: :asc) }
 
+    before_validation :normalize_country
+    before_validation :normalize_state
+
     after_create :create_stock_items, if: :propagate_all_variants?
     after_save :ensure_one_default
     after_update :conditional_touch_records
 
     delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true, allow_nil: true
+    delegate :abbr, to: :state, prefix: true, allow_nil: true
+
+    # Writer methods for API convenience — accept ISO/abbr codes instead of FK IDs.
+    # Mirrors Spree::Address: SDK clients use country_iso/state_abbr because
+    # Country/State don't expose prefixed IDs (their `iso` is the public handle).
+    def country_iso=(value)
+      @country_iso_input = value
+    end
+
+    def state_abbr=(value)
+      @state_abbr_input = value
+    end
 
     def state_text
       state.try(:abbr) || state.try(:name) || state_name
@@ -168,6 +204,22 @@ module Spree
 
     private
 
+    def normalize_country
+      iso = @country_iso_input
+      return if iso.blank?
+
+      self.country = Spree::Country.by_iso(iso)
+      @country_iso_input = nil
+    end
+
+    def normalize_state
+      abbr = @state_abbr_input
+      return if abbr.blank? || country.blank?
+
+      self.state = country.states.find_by(abbr: abbr)
+      @state_abbr_input = nil
+    end
+
     def create_stock_items
       Spree::StockLocations::StockItems::CreateJob.perform_later(self)
     end