spree_core 5.4.3 → 5.5.0.rc1

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

@@ -0,0 +1,81 @@
+module Spree
+  module OrderRouting
+    module Strategy
+      # Default order routing strategy: walks Spree::OrderRoutingRule rows in
+      # priority order, runs the Reducer to fully rank eligible locations,
+      # packs each location, and lets Spree::Stock::Prioritizer distribute
+      # inventory units across packages so units that the top-ranked
+      # location can't cover spill over to subsequent locations.
+      #
+      # See docs/plans/6.0-order-routing.md.
+      class Rules < Base
+        def for_allocation
+          locations = eligible_locations
+          return [] if locations.empty?
+
+          ordered = Reducer.new(applicable_rules.to_a, order: order).rank_all(locations)
+          return [] if ordered.empty?
+
+          packages = build_packages(ordered)
+          packages = prioritize_packages(packages)
+          estimate_rates(packages)
+        end
+
+        # Stock decrement / restock today happens via Spree::Shipment's state
+        # machine (after_ship / after_cancel). The strategy methods below are
+        # part of the contract for the future reservation + typed-movement
+        # phase — see 6.0-stock-reservations.md and 6.0-typed-stock-movements.md.
+        # In 5.5 they are no-ops; the existing model callbacks already do the
+        # right thing.
+        def for_sale(fulfillment:); end
+        def for_release; end
+        def for_cancellation; end
+
+        private
+
+        def applicable_rules
+          order.channel.order_routing_rules.active.ordered
+        end
+
+        def eligible_locations
+          Spree::StockLocation.active
+            .joins(:stock_items)
+            .where(spree_stock_items: { 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)
+          locations.flat_map do |location|
+            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters).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.
+        def prioritize_packages(packages)
+          Spree::Stock::Prioritizer.new(packages).prioritized_packages
+        end
+
+        def estimate_rates(packages)
+          estimator = Spree::Stock::Estimator.new(order)
+          packages.each { |pkg| pkg.shipping_rates = estimator.shipping_rates(pkg) }
+          packages
+        end
+      end
+    end
+  end
+end

data/app/models/spree/order_routing_rule.rb

@@ -0,0 +1,75 @@
+module Spree
+  # STI base for order routing rules. Subclasses live in
+  # app/models/spree/order_routing/rules/ and implement #rank(order, locations).
+  #
+  # Plugins extend the engine by defining a new subclass:
+  #
+  #   class AcmeFresh::OrderRouting::RefrigeratedRule < Spree::OrderRoutingRule
+  #     preference :max_temp_c, :integer, default: 4
+  #
+  #     def rank(order, locations)
+  #       # ... return Array<LocationRanking>
+  #     end
+  #   end
+  #
+  # See docs/plans/6.0-order-routing.md.
+  class OrderRoutingRule < Spree.base_class
+    self.table_name = 'spree_order_routing_rules'
+
+    # `rank` is integer (lower = better) when the rule has an opinion,
+    # nil to abstain (the reducer skips abstaining rankings).
+    LocationRanking = Struct.new(:location, :rank, keyword_init: true)
+
+    has_prefix_id :orule
+
+    include Spree::SingleStoreResource
+
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :channel, class_name: 'Spree::Channel'
+
+    attribute :active, :boolean, default: true
+
+    validates :type, :channel, presence: true
+    validates :position, presence: true, numericality: { only_integer: true }
+    validate :channel_belongs_to_store
+
+    scope :active, -> { where(active: true) }
+    scope :ordered, -> { order(:position) }
+    scope :for_channel, ->(channel) { where(channel_id: channel.id) }
+
+    acts_as_list scope: :channel_id
+
+    self.whitelisted_ransackable_attributes = %w[type position active store_id channel_id]
+
+    validate :type_must_be_registered
+
+    # Subclasses override. Returns an Array<LocationRanking> — one per location,
+    # with rank=nil to abstain.
+    #
+    # @param order     [Spree::Order]
+    # @param locations [Array<Spree::StockLocation>]
+    # @return [Array<LocationRanking>]
+    def rank(_order, _locations)
+      raise NotImplementedError, "#{self.class} must implement #rank(order, locations)"
+    end
+
+    private
+
+    # The +type+ presence validation already covers blank; here we only reject
+    # a present-but-unregistered STI type so arbitrary class names can't be
+    # persisted via the +type+ column.
+    def type_must_be_registered
+      return if type.blank?
+      return if Spree.order_routing.rules.any? { |rule| rule.to_s == type }
+
+      errors.add(:type, Spree.t(:invalid_order_routing_rule, scope: [:errors, :messages], default: 'is not a registered order routing rule'))
+    end
+
+    def channel_belongs_to_store
+      return if channel.nil? || store_id.nil?
+      return if channel.store_id == store_id
+
+      errors.add(:channel, Spree.t('errors.messages.channel_store_mismatch'))
+    end
+  end
+end

data/app/models/spree/permission_sets/configuration_management.rb

@@ -23,15 +23,31 @@ module Spree
         can :manage, Spree::Zone
         can :manage, Spree::ZoneMember
 
+        # Markets — Channel / Market is the long-term replacement for
+        # Zone (see docs/plans/6.0-tax-provider.md), but both coexist
+        # during the migration and need admin read/write either way.
+        can :manage, Spree::Market
+
         # Tax configuration
         can :manage, Spree::TaxCategory
         can :manage, Spree::TaxRate
 
+        # CORS allowlist used by Rack::Cors + admin cookie auth (see
+        # docs/plans/5.5-admin-auth-cookie-refresh.md).
+        can :manage, Spree::AllowedOrigin
+
+        # Webhooks
+        can :manage, Spree::WebhookEndpoint
+        can :manage, Spree::WebhookDelivery
+
         # General configuration
         can :manage, Spree::RefundReason
         can :manage, Spree::ReimbursementType
         can :manage, Spree::ReturnReason
 
+        # Channels
+        can :manage, Spree::Channel
+
         # Restrictions on immutable types
         cannot [:edit, :update], Spree::RefundReason, mutable: false
         cannot [:edit, :update], Spree::ReimbursementType, mutable: false

data/app/models/spree/permission_sets/product_display.rb

@@ -19,6 +19,8 @@ module Spree
         can [:read, :admin], Spree::Taxonomy
         can [:read, :admin], Spree::Classification
         can [:read, :admin], Spree::Price
+        can [:read, :admin], Spree::PriceList
+        can [:read, :admin], Spree::PriceRule
       end
     end
   end

data/app/models/spree/permission_sets/product_management.rb

@@ -18,6 +18,8 @@ module Spree
         can :manage, Spree::Taxonomy
         can :manage, Spree::Classification
         can :manage, Spree::Price
+        can :manage, Spree::PriceList
+        can :manage, Spree::PriceRule
         can :manage, Spree::Asset
       end
     end

data/app/models/spree/price.rb

@@ -55,7 +55,20 @@ module Spree
     money_methods :amount, :price, :compare_at_amount
     alias display_compare_at_price display_compare_at_amount
 
-    self.whitelisted_ransackable_attributes = ['amount', 'compare_at_amount']
+    self.whitelisted_ransackable_attributes = %w[amount compare_at_amount currency price_list_id variant_id]
+    self.whitelisted_ransackable_associations = %w[variant price_list]
+    self.whitelisted_ransackable_scopes = %i[search]
+
+    # Free-text search delegated to `Spree::Variant.search` (SKU + product
+    # name + option-value presentation), wrapped in a subquery so that
+    # multi-option-value variants don't produce duplicate Price rows —
+    # the prices index has `collection_distinct?` off (PG DISTINCT +
+    # ORDER BY incompat), so any join-based predicate would double up.
+    scope :search, ->(query) {
+      next all if query.blank?
+
+      where(variant_id: Spree::Variant.search(query).select(:id))
+    }
 
     attribute :eligible_for_taxon_matching, :boolean, default: false
     before_validation -> { self.eligible_for_taxon_matching = new_record? ? discounted? : discounted? != was_discounted? }

data/app/models/spree/price_list.rb

@@ -11,10 +11,11 @@ module Spree
 
     belongs_to :store, class_name: 'Spree::Store'
 
-    has_many :price_rules, class_name: 'Spree::PriceRule', dependent: :destroy
+    has_many :price_rules, class_name: 'Spree::PriceRule', autosave: true, dependent: :destroy
+    alias rules price_rules
     has_many :prices, class_name: 'Spree::Price', dependent: :destroy_async
-    has_many :variants, -> { where(spree_prices: { deleted_at: nil }).distinct }, through: :prices, source: :variant
-    has_many :products, -> { where(spree_prices: { deleted_at: nil }).distinct }, through: :variants, source: :product
+    has_many :variants, -> { distinct }, through: :prices, source: :variant
+    has_many :products, -> { distinct }, through: :variants, source: :product
     alias price_list_products products
 
     # Override default nested attributes to use bulk_update_prices for performance
@@ -28,20 +29,59 @@ module Spree
     end
 
     after_update :process_bulk_prices_update
+    after_save :apply_pending_rules
+    after_save :apply_pending_product_ids
+    after_save :apply_pending_prices
+
+    # @return [Array<String>] prefixed product ids in this list,
+    #   encoded inline to avoid hydrating N Product records.
+    def product_prefixed_ids
+      prefix = Spree::Product._prefix_id_prefix
+      product_ids.sort.map { |pk| "#{prefix}_#{Spree::PrefixedId::SQIDS.encode([pk])}" }
+    end
 
-    # Processes the bulk prices update
+    # Reconciles list membership. Removes prices for products no longer
+    # in `ids` and adds placeholder prices for the new ones.
+    #
+    # @param ids [Array<String>] raw product PKs (prefixed strings are
+    #   resolved upstream by `Spree::Base#assign_attributes`).
     # @return [void]
-    def process_bulk_prices_update
-      return if @prices_attributes.blank?
+    def product_ids=(ids)
+      @pending_product_ids = Array(ids).compact.uniq
+    end
 
-      bulk_update_prices(@prices_attributes)
-      @prices_attributes = nil
+    # Flat-payload writer for `prices`. Bulk-upserts the listed rows in
+    # `after_save` so newly-added products have their placeholder rows
+    # materialized first. Nullability contract:
+    #   - `nil` → no-op
+    #   - `[]`  → clear every override on this list
+    #   - `[…]` → upsert listed rows, leave the rest alone
+    #
+    # @param rows [Array<Hash>, Array<Spree::Price>, nil]
+    # @return [void]
+    def prices=(rows)
+      first = Array(rows).first
+      return super(rows) if first.is_a?(Spree::Price)
+      return if rows.nil?
+
+      @pending_prices = Array(rows).map do |row|
+        row.respond_to?(:to_unsafe_h) ? row.to_unsafe_h.with_indifferent_access : row.with_indifferent_access
+      end
+      @pending_prices_clear = rows.empty?
+    end
+
+    # Flat-payload writer for `rules`. See
+    # {Spree::TypedAssociations#assign_typed_association}.
+    def rules=(rows)
+      assign_typed_association(:price_rules, rows)
     end
 
     validates :name, :store, presence: true
     validates :match_policy, presence: true, inclusion: { in: MATCH_POLICIES }
     validate :starts_at_before_ends_at
 
+    self.whitelisted_ransackable_attributes = %w[status match_policy starts_at ends_at]
+
     scope :by_position, -> { order(position: :asc) }
     scope :for_store, ->(store) { where(store: store) }
     scope :current, lambda { |timezone = nil|
@@ -119,9 +159,10 @@ module Spree
       active_or_scheduled? && within_date_range?(Time.current)
     end
 
-    # Adds products to the price list
-    # Creates placeholder prices (with nil amount) for all variants and currencies
-    # @param product_ids [Array<String>] of product ids
+    # Adds products to the list, materializing a placeholder price
+    # (amount nil) for every variant × store currency.
+    #
+    # @param product_ids [Array<String>] raw product PKs
     # @return [void]
     def add_products(product_ids)
       return if product_ids.blank?
@@ -130,7 +171,6 @@ module Spree
       variant_ids = Spree::Variant.eligible.where(product_id: product_ids).distinct.pluck(:id)
       return if variant_ids.empty?
 
-      # Get existing variant_id/currency combinations to avoid duplicates
       existing = prices.where(variant_id: variant_ids)
                        .pluck(:variant_id, :currency)
                        .to_set
@@ -160,9 +200,12 @@ module Spree
       touch
     end
 
-    # Removes products from the price list
-    # Hard deletes prices (not soft delete) to allow re-adding products later
-    # @param product_ids [Array<String>] of product ids
+    # Removes products from the list. Hard-deletes their prices so the
+    # unique index doesn't block re-adding the same products later
+    # (acts_as_paranoid would leave soft-deleted rows blocking the
+    # `(variant_id, currency, price_list_id)` slot).
+    #
+    # @param product_ids [Array<String>] raw product PKs
     # @return [void]
     def remove_products(product_ids)
       return if product_ids.blank?
@@ -195,7 +238,12 @@ module Spree
         next if attrs[:id].blank?
 
         price_id = attrs[:id].to_i
-        current = current_values[price_id] || {}
+        # Reject rows that aren't in *this* list's prices — `upsert_all`
+        # otherwise keys solely by primary id and would silently cross
+        # list boundaries.
+        next unless current_values.key?(price_id)
+
+        current = current_values[price_id]
 
         # Parse amounts using LocalizedNumber for proper decimal handling
         amount = attrs[:amount].present? ? Spree::LocalizedNumber.parse(attrs[:amount]) : nil
@@ -222,7 +270,7 @@ module Spree
       return true if records_to_upsert.empty?
 
       opts = { update_only: [:amount, :compare_at_amount], on_duplicate: :update }
-      opts[:unique_by] = :id unless ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+      opts[:unique_by] = :id unless mysql_adapter?
 
       Spree::Price.upsert_all(records_to_upsert, **opts)
 
@@ -232,6 +280,70 @@ module Spree
 
     private
 
+    # Processes the bulk prices update
+    # @return [void]
+    def process_bulk_prices_update
+      return if @prices_attributes.blank?
+
+      bulk_update_prices(@prices_attributes)
+      @prices_attributes = nil
+    end
+
+    def apply_pending_rules
+      flush_pending_typed_association(:price_rules)
+    end
+
+    def apply_pending_product_ids
+      return unless @pending_product_ids
+
+      desired = @pending_product_ids
+      @pending_product_ids = nil
+
+      current = product_ids
+      to_remove = current - desired
+      to_add = desired - current
+
+      remove_products(to_remove) if to_remove.any?
+      add_products(to_add) if to_add.any?
+    end
+
+    def apply_pending_prices
+      pending = @pending_prices
+      cleared = @pending_prices_clear
+      return if pending.nil?
+
+      @pending_prices = nil
+      @pending_prices_clear = nil
+
+      if cleared
+        variant_ids = prices.distinct.pluck(:variant_id)
+        prices.update_all(amount: nil, compare_at_amount: nil, updated_at: Time.current)
+        touch_variants(variant_ids)
+        return
+      end
+
+      rows = pending.filter_map do |row|
+        # `variant_id` may arrive as a prefixed string (legacy callers,
+        # console) or already decoded (the controller's `permitted_params`
+        # runs through `normalize_params`). Handle both.
+        raw = row[:variant_id]
+        variant_id = Spree::PrefixedId.prefixed_id?(raw) ? Spree::PrefixedId.decode_prefixed_id(raw) : raw
+        next if variant_id.blank? || row[:currency].blank?
+
+        {
+          variant_id: variant_id,
+          currency: row[:currency],
+          price_list_id: id,
+          amount: row[:amount],
+          compare_at_amount: row[:compare_at_amount]
+        }
+      end
+      return if rows.empty?
+
+      Spree::Prices::BulkUpsert.call(rows: rows)
+      touch_variants(rows.map { |r| r[:variant_id] }.uniq)
+    end
+
     # Touches the variants in a background job
     # @param variant_ids [Array<String>] array of variant ids
     # @return [void]

data/app/models/spree/price_rule.rb

@@ -4,7 +4,10 @@ module Spree
 
     belongs_to :price_list, class_name: 'Spree::PriceList', touch: true
 
-    validates :type, :price_list,presence: true
+    delegate :store, to: :price_list
+
+    validates :type, :price_list, presence: true
+    validates :type, uniqueness: { scope: [:price_list_id, *spree_base_uniqueness_scope] }
 
     # Returns true if the price rule is applicable to the context
     # @param context [Spree::Pricing::Context]
@@ -24,5 +27,12 @@ module Spree
     def self.description
       ''
     end
+
+    # Pull the rule registry off the global pricing config so
+    # PreferenceSchema's `.subclasses_with_preference_schema` can power
+    # the admin's "Add rule" picker.
+    def self.registered_subclasses
+      Array(Spree.pricing&.rules)
+    end
   end
 end

data/app/models/spree/price_rules/customer_group_rule.rb

@@ -1,7 +1,21 @@
 module Spree
   module PriceRules
     class CustomerGroupRule < Spree::PriceRule
-      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 compare
+      # against raw `customer_group_id` rows directly. Scope confines
+      # the existence check to the price-list's store.
+      preference :customer_group_ids, :array, default: [],
+                 parse_on_set: normalize_id_preference(
+                   klass: Spree::CustomerGroup,
+                   scope: ->(rule) { rule.store.customer_groups }
+                 )
+
+      def customer_groups
+        return [] if preferred_customer_group_ids.blank?
+
+        Spree::CustomerGroup.where(id: preferred_customer_group_ids)
+      end
 
       def applicable?(context)
         return false unless context.user

data/app/models/spree/price_rules/market_rule.rb

@@ -1,7 +1,22 @@
 module Spree
   module PriceRules
     class MarketRule < Spree::PriceRule
-      preference :market_ids, :array, default: []
+      # Stored as raw IDs. Accepts prefixed IDs (`mkt_…`) from API
+      # callers and decodes them on write so eligibility checks compare
+      # against raw `market_id` rows directly. Scope confines the
+      # existence check to the price-list's store so cross-store market
+      # IDs can't sneak in.
+      preference :market_ids, :array, default: [],
+                 parse_on_set: normalize_id_preference(
+                   klass: Spree::Market,
+                   scope: ->(rule) { rule.store.markets }
+                 )
+
+      def markets
+        return [] if preferred_market_ids.blank?
+
+        Spree::Market.where(id: preferred_market_ids)
+      end
 
       def applicable?(context)
         return false unless context.market

data/app/models/spree/price_rules/user_rule.rb

@@ -1,7 +1,19 @@
 module Spree
   module PriceRules
     class UserRule < Spree::PriceRule
-      preference :user_ids, :array, default: []
+      # Stored as raw IDs. Accepts prefixed IDs (the user class's prefix,
+      # e.g. `usr_…`) from API callers and decodes them on write. Resolves
+      # `Spree.user_class` lazily — the user class is configured at boot,
+      # and class-body evaluation runs before that on cold loads.
+      preference :user_ids, :array, default: [], parse_on_set: ->(values) {
+        normalize_id_preference(klass: Spree.user_class).call(values)
+      }
+
+      def users
+        return [] if preferred_user_ids.blank?
+
+        Spree.user_class.where(id: preferred_user_ids)
+      end
 
       def applicable?(context)
         return false unless context.user
@@ -12,7 +24,14 @@ module Spree
       end
 
       def self.description
-        'Apply pricing to specific users'
+        'Apply pricing to specific customers'
+      end
+
+      # Public-facing label — keeps the wire `api_type` as `user_rule`
+      # (preference column is `user_ids`) so existing data stays valid,
+      # but every UI surface reads "Customer rule".
+      def self.human_name
+        'Customer rule'
       end
     end
   end