spree_core 5.4.2 → 5.5.0.rc1

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

data/app/models/spree/product/channels.rb

@@ -0,0 +1,149 @@
+module Spree
+  class Product
+    module Channels
+      extend ActiveSupport::Concern
+
+      DEPRECATED_DATE_TO_PUBLICATION_FIELD = {
+        available_on:   :published_at,
+        discontinue_on: :unpublished_at
+      }.freeze
+
+      included do
+        belongs_to :store, class_name: 'Spree::Store', optional: true
+
+        # No +dependent: :destroy+: Product uses +acts_as_paranoid+, so destroy
+        # soft-deletes and publications outlive the product.
+        # +inverse_of: :product+ is what wires the parent into a child built off
+        # an unsaved Product (via +accepts_nested_attributes_for+ on the legacy
+        # alias below). Without it the child fails +validates :product,
+        # presence: true+ on +create+. Declared on both associations to keep
+        # the two in-memory caches symmetric (V-3454).
+        has_many :product_publications, class_name: 'Spree::ProductPublication',
+                                        inverse_of: :product, autosave: true
+        has_many :channels, -> { distinct }, through: :product_publications, class_name: 'Spree::Channel'
+
+        # Legacy Rails admin alias. The admin form submits
+        # +legacy_product_publications_attributes+ (with +_destroy+ flags and
+        # +reject_if+ semantics); the v3 API submits +product_publications+
+        # and goes through the custom writer below. Two names, one table —
+        # no +dependent:+ for the same +acts_as_paranoid+ reason as above.
+        has_many :legacy_product_publications, class_name: 'Spree::ProductPublication',
+                                               foreign_key: :product_id,
+                                               inverse_of: :product, autosave: true
+        accepts_nested_attributes_for :legacy_product_publications,
+                                      allow_destroy: true,
+                                      reject_if: ->(attrs) { attrs[:channel_id].blank? }
+
+        before_validation :assign_default_store, if: -> { store.nil? }
+        after_create :apply_pending_publications, if: :pending_publications?
+
+        DEPRECATED_DATE_TO_PUBLICATION_FIELD.each do |legacy_attr, publication_attr|
+          define_method("#{legacy_attr}=") do |value|
+            Spree::Deprecation.warn(
+              "Spree::Product##{legacy_attr}= is deprecated; set #{publication_attr} on " \
+              "ProductPublication instead (writes to every channel's publication). "
+            )
+            super(value)
+            product_publications.each { |publication| publication.public_send("#{publication_attr}=", value) }
+          end
+
+          # Reading +available_on+/+discontinue_on+ prefers the current-channel
+          # publication's date and falls back to the legacy Product column
+          # whenever the publication's value is nil. This 5.5 transition
+          # behavior is dropped in 6.0 when the legacy columns are removed.
+          define_method(legacy_attr) do
+            channel = Spree::Current.channel
+            publication = channel && publication_for(channel)
+            (publication && publication.public_send(publication_attr)) || super()
+          end
+        end
+      end
+
+      # Returns the publication for the given channel, or nil if the product isn't published there.
+      # @param channel [Spree::Channel] the channel to find the publication for
+      # @return [Spree::ProductPublication, nil] the publication for the channel, or nil if not published
+      def publication_for(channel)
+        return nil unless channel
+
+        if product_publications.loaded?
+          product_publications.find { |p| p.channel_id == channel.id }
+        else
+          product_publications.find_by(channel_id: channel.id)
+        end
+      end
+
+      # Syncs product publications from an array of hashes.
+      # Creates new publications, updates existing ones (matched by +:id+ or
+      # +:channel_id+), and removes ones absent from the payload. An empty
+      # array detaches the product from every channel.
+      # @param publications_params [Array<Hash>] array of publication attribute hashes
+      # @return [void]
+      def product_publications=(publications_params)
+        return super if publications_params.nil?
+        return super if publications_params.respond_to?(:first) && publications_params.first.is_a?(Spree::ProductPublication)
+
+        if new_record?
+          @pending_publications_params = publications_params
+          return
+        end
+
+        apply_product_publications(publications_params)
+      end
+
+      private
+
+      def assign_default_store
+        self.store ||= Spree::Current.store || Spree::Store.default
+      end
+
+      def pending_publications?
+        @pending_publications_params.present?
+      end
+
+      def apply_pending_publications
+        return unless @pending_publications_params
+
+        apply_product_publications(@pending_publications_params)
+        @pending_publications_params = nil
+      end
+
+      def apply_product_publications(publications_params)
+        publication_ids_in_payload = []
+
+        publications_params.each do |publication_data|
+          publication_data = publication_data.to_h.with_indifferent_access
+          publication_id = publication_data.delete(:id)
+          channel_id = decode_publication_channel_id(publication_data[:channel_id])
+
+          if publication_id.present?
+            decoded_id = Spree::PrefixedId.prefixed_id?(publication_id) ?
+                           Spree::PrefixedId.decode_prefixed_id(publication_id) :
+                           publication_id
+            publication = product_publications.find_by(id: decoded_id)
+            next unless publication
+
+            # Channel is immutable; ignore any rebind attempt.
+            publication.update!(publication_data.slice(:published_at, :unpublished_at))
+            publication_ids_in_payload << publication.id
+          elsif channel_id.present?
+            # Upsert by channel_id so repeat submissions are idempotent
+            # against the unique (product_id, channel_id) index.
+            publication = product_publications.find_or_initialize_by(channel_id: channel_id)
+            publication.assign_attributes(publication_data.slice(:published_at, :unpublished_at))
+            publication.save!
+            publication_ids_in_payload << publication.id
+          end
+        end
+
+        product_publications.where.not(id: publication_ids_in_payload).destroy_all
+      end
+
+      def decode_publication_channel_id(value)
+        return nil if value.blank?
+        return value unless Spree::PrefixedId.prefixed_id?(value)
+
+        Spree::PrefixedId.decode_prefixed_id(value) || value
+      end
+    end
+  end
+end

data/app/models/spree/product/legacy_multi_store_support.rb

@@ -0,0 +1,40 @@
+module Spree
+  class Product
+    # Legacy multi-store support. In Spree 5.5+ the +Spree::ProductPublication+ model
+    # handles the Product↔Store relation, so this module only provides a fallback
+    # for legacy code that still references +Spree::Product#stores+.
+    module LegacyMultiStoreSupport
+      extend ActiveSupport::Concern
+
+      included do
+        def stores
+          Spree::Deprecation.warn(
+            "Spree::Product#stores is deprecated. Please use Spree::Product.store instead. If you want to continue using multiple stores please install spree_multi_store gem"
+          )
+          store ? [store] : []
+        end
+
+        def store_ids
+          Spree::Deprecation.warn(
+            "Spree::Product#store_ids is deprecated. Please use Spree::Product.store_id instead. If you want to continue using multiple stores please install spree_multi_store gem"
+          )
+          store_id ? [store_id] : []
+        end
+
+        def stores=(stores)
+          Spree::Deprecation.warn(
+            "Spree::Product#stores= is deprecated. Please use Spree::Product.store= instead. If you want to continue using multiple stores please install spree_multi_store gem"
+          )
+          self.store = Array(stores).compact.first
+        end
+
+        def store_ids=(store_ids)
+          Spree::Deprecation.warn(
+            "Spree::Product#store_ids= is deprecated. Please use Spree::Product.store_id= instead. If you want to continue using multiple stores please install spree_multi_store gem"
+          )
+          self.store_id = Array(store_ids).compact_blank.first
+        end
+      end
+    end
+  end
+end

data/app/models/spree/product/slugs.rb

@@ -28,7 +28,7 @@ module Spree
 
           def generate_slug
             if name.blank? && slug.blank?
-              translated_model.name.to_url
+              translated_model.name&.to_url
             elsif slug.blank?
               name.to_url
             else