spree_core 5.4.2 → 5.5.0.rc1

data/app/models/spree/order_routing/has_strategy_preference.rb

@@ -0,0 +1,28 @@
+module Spree
+  module OrderRouting
+    # Shared validation for models carrying a +preferred_order_routing_strategy+
+    # preference (Spree::Store, Spree::Channel). A blank value is allowed (it
+    # falls back to the next level / the default Rules strategy); a present value
+    # must name a registered Spree::OrderRouting::Strategy::Base subclass.
+    module HasStrategyPreference
+      extend ActiveSupport::Concern
+
+      included do
+        validate :order_routing_strategy_must_be_registered
+      end
+
+      private
+
+      def order_routing_strategy_must_be_registered
+        value = preferred_order_routing_strategy
+        return if value.blank?
+        return if Spree.order_routing.strategies.any? { |strategy| strategy.to_s == value.to_s }
+
+        errors.add(
+          :preferred_order_routing_strategy,
+          Spree.t(:invalid_order_routing_strategy, scope: [:errors, :messages], default: 'is not a registered order routing strategy')
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Spree
+  module OrderRouting
+    module Rules
+      # Ranks the StockLocation marked `default: true` at 0 and others at 1.
+      # Provides a deterministic baseline so the reducer always has a winner
+      # once higher-priority rules abstain or tie.
+      class DefaultLocation < Spree::OrderRoutingRule
+        def rank(_order, locations)
+          locations.map do |loc|
+            LocationRanking.new(location: loc, rank: loc.default? ? 0 : 1)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Spree
+  module OrderRouting
+    module Rules
+      # Prefers locations that can fulfill more demand on their own.
+      # Higher coverage → lower (better) rank, so the location that single-handedly
+      # covers the most variants wins. Coverage is counted per distinct variant
+      # so a variant repeated across multiple line items isn't double-counted.
+      class MinimizeSplits < Spree::OrderRoutingRule
+        def rank(order, locations)
+          demand = required_quantity_by_variant(order)
+          counts = stock_item_counts(demand.keys, locations)
+
+          locations.map do |loc|
+            coverage = demand.count do |variant_id, qty|
+              (counts[[loc.id, variant_id]] || 0) >= qty
+            end
+
+            LocationRanking.new(location: loc, rank: -coverage)
+          end
+        end
+
+        private
+
+        def required_quantity_by_variant(order)
+          order.line_items.each_with_object(Hash.new(0)) do |li, h|
+            next if li.variant_id.nil?
+
+            h[li.variant_id] += li.quantity
+          end
+        end
+
+        # One query for the entire location × variant matrix instead of
+        # N variants × M locations stock_item lookups.
+        def stock_item_counts(variant_ids, locations)
+          return {} if variant_ids.empty? || locations.empty?
+
+          Spree::StockItem
+            .where(stock_location_id: locations.map(&:id), variant_id: variant_ids)
+            .pluck(:stock_location_id, :variant_id, :count_on_hand)
+            .each_with_object({}) { |(loc_id, var_id, count), h| h[[loc_id, var_id]] = count }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Spree
+  module OrderRouting
+    module Rules
+      # Ranks the order's inferred preferred location at 0 and abstains for
+      # everything else. Lets admins / staff / B2B contexts pin "fulfill from
+      # this location" without preventing fallback when the preferred location
+      # doesn't actually stock the items — subsequent rules tie-break.
+      class PreferredLocation < Spree::OrderRoutingRule
+        def rank(order, locations)
+          preferred_id = order.inferred_preferred_stock_location_id
+
+          locations.map do |loc|
+            LocationRanking.new(
+              location: loc,
+              rank: (preferred_id.present? && loc.id.to_s == preferred_id.to_s) ? 0 : nil
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Spree
+  module OrderRouting
+    module Strategy
+      # Contract for order routing strategies. Subclasses implement all four
+      # methods — there are no defaults. New routing *signals* (proximity,
+      # day-of-week, etc.) ship as STI subclasses of Spree::OrderRoutingRule;
+      # a custom strategy is appropriate only when the algorithm itself is a
+      # different shape (OMS delegation, ML model, optimization solver).
+      #
+      # Selected per Order via Spree::Order#order_routing_strategy.
+      # See docs/plans/6.0-order-routing.md.
+      class Base
+        attr_reader :order
+
+        # Human label for admin strategy pickers. Override in a subclass or add
+        # an i18n key under +spree.order_routing.strategies+.
+        #
+        # @return [String]
+        def self.display_name
+          Spree.t(name.demodulize.underscore, scope: 'order_routing.strategies', default: name.demodulize.titleize)
+        end
+
+        def initialize(order:)
+          @order = order
+        end
+
+        # @return [Array<Spree::Stock::Package>]
+        def for_allocation
+          raise NotImplementedError, "#{self.class} must implement #for_allocation"
+        end
+
+        # @param fulfillment [Spree::Shipment]
+        def for_sale(fulfillment:)
+          raise NotImplementedError, "#{self.class} must implement #for_sale"
+        end
+
+        def for_release
+          raise NotImplementedError, "#{self.class} must implement #for_release"
+        end
+
+        def for_cancellation
+          raise NotImplementedError, "#{self.class} must implement #for_cancellation"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Spree
+  module OrderRouting
+    module Strategy
+      # Pre-5.5 routing behavior. Delegates to Spree::Stock::Coordinator,
+      # which packs every active stock location and lets Prioritizer's
+      # Adjuster distribute units across the resulting packages — no rules
+      # consulted, no merchant-driven preferences, location order is
+      # whatever the database returns.
+      #
+      # Provided as an opt-in escape hatch for merchants upgrading from 5.4
+      # who are not ready to adopt rules-based routing. Configure via:
+      #
+      #   store.update!(preferred_order_routing_strategy: 'Spree::OrderRouting::Strategy::Legacy')
+      #
+      # Spree 6.0 drops this strategy along with the underlying Coordinator.
+      # See docs/plans/6.0-order-routing.md.
+      class Legacy < Base
+        def for_allocation
+          Spree::Stock::Coordinator.new(order).packages
+        end
+
+        # Stock decrement / restock today happens via Spree::Shipment's state
+        # machine (after_ship / after_cancel). The strategy hooks below are
+        # part of the contract for the future reservation + typed-movement
+        # phase. In 5.5 they are no-ops; existing model callbacks already do
+        # the right thing.
+        def for_sale(fulfillment:); end
+        def for_release; end
+        def for_cancellation; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'set'
+
+module Spree
+  module OrderRouting
+    module Strategy
+      # Walks rules in priority order and applies a "first non-tie wins" reducer.
+      #
+      # For each rule:
+      #   1. Drop rankings where rank is nil (rule abstains for that location).
+      #   2. Find the location(s) with the lowest rank (best).
+      #   3. Unique winner -> return it.
+      #   4. Tie -> carry the tied set forward to the next rule.
+      #
+      # Out of rules with ties: prefer the StockLocation marked default,
+      # then by id. Guarantees a winner whenever locations is non-empty.
+      class Reducer
+        def initialize(rules, order:)
+          @rules = rules
+          @order = order
+        end
+
+        # @param locations [Array<Spree::StockLocation>]
+        # @return [Spree::StockLocation, nil]
+        def pick(locations)
+          return nil if locations.empty?
+
+          remaining = locations
+          remaining_ids = remaining.map(&:id).to_set
+
+          @rules.each do |rule|
+            rankings = rule.rank(@order, remaining).select do |r|
+              r.rank && remaining_ids.include?(r.location.id)
+            end
+            next if rankings.empty?
+
+            min_rank = rankings.map(&:rank).min
+            top = rankings.select { |r| r.rank == min_rank }.map(&:location)
+
+            return top.first if top.size == 1
+
+            remaining = top
+            remaining_ids = top.map(&:id).to_set
+          end
+
+          remaining.min_by { |l| [l.default? ? 0 : 1, l.id] }
+        end
+
+        # Returns every input location, ordered best-first by the same rule
+        # chain that drives #pick. Each successive location is the best of
+        # what remains — used by Strategy::Rules to fan out an allocation
+        # across multiple locations when no single location covers the cart.
+        #
+        # @param locations [Array<Spree::StockLocation>]
+        # @return [Array<Spree::StockLocation>]
+        def rank_all(locations)
+          remaining = locations.dup
+          ordered = []
+          until remaining.empty?
+            chosen = pick(remaining) or break
+            ordered << chosen
+            remaining = remaining.reject { |l| l.id == chosen.id }
+          end
+          ordered
+        end
+      end
+    end
+  end
+end

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/payment_setup_sessions/bogus.rb

@@ -0,0 +1,4 @@
+module Spree
+  class PaymentSetupSessions::Bogus < PaymentSetupSession
+  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? }