spree_core 5.4.3 → 5.5.0.rc1

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

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,