spree_core 5.4.0.beta → 5.4.0.beta2

data/app/models/spree/product.rb

@@ -72,9 +72,6 @@ module Spree
 
     has_many :product_option_types, -> { order(:position) }, dependent: :destroy, inverse_of: :product
     has_many :option_types, through: :product_option_types
-    has_many :product_properties, dependent: :destroy, inverse_of: :product
-    has_many :properties, through: :product_properties
-
     has_many :classifications, -> { order(created_at: :asc) }, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
     has_many :taxonomies, through: :taxons
@@ -215,9 +212,6 @@ module Spree
 
     attr_accessor :option_values_hash
 
-    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp|
-                                                                                         pp[:property_id].blank? || (pp[:id].blank? && pp[:value].blank?)
-                                                                                       }
     accepts_nested_attributes_for(
       :variants,
       allow_destroy: true,
@@ -236,7 +230,7 @@ module Spree
 
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at]
     self.whitelisted_ransackable_associations = %w[taxons stores variants_including_master master variants tags labels
-                                                   shipping_category classifications option_types properties]
+                                                   shipping_category classifications option_types]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon price_between
                                              multi_search in_stock_items out_of_stock_items with_option_value_ids
                                              ascend_by_price descend_by_price]
@@ -417,7 +411,7 @@ module Spree
     # Returns the short description for the product
     # @return [String]
     def storefront_description
-      property('short_description') || description
+      description
     end
 
     # Returns tax category for Product
@@ -479,13 +473,6 @@ module Spree
       Products::Duplicator.call(product: self)
     end
 
-    # use deleted? rather than checking the attribute directly. this
-    # allows extensions to override deleted? if they want to provide
-    # their own definition.
-    def deleted?
-      !!deleted_at
-    end
-
     # determine if product is available.
     # deleted products and products with status different than active
     # are not available
@@ -513,14 +500,6 @@ module Spree
       variants_including_master.any?(&:backordered?)
     end
 
-    # split variants list into hash which shows mapping of opt value onto matching variants
-    # eg categorise_variants_from_option(color) => {"red" -> [...], "blue" -> [...]}
-    def categorise_variants_from_option(opt_type)
-      return {} unless option_types.include?(opt_type)
-
-      variants.active.group_by { |v| v.option_values.detect { |o| o.option_type == opt_type } }
-    end
-
     def self.like_any(fields, values)
       conditions = fields.product(values).map do |(field, value)|
         arel_table[field].matches("%#{value}%")
@@ -537,48 +516,6 @@ module Spree
       variants.active(current_currency).joins(:option_value_variants)
     end
 
-    def empty_option_values?
-      options.empty? || options.any? do |opt|
-        opt.option_type.option_values.empty?
-      end
-    end
-
-    def property(property_name)
-      if product_properties.loaded?
-        product_properties.detect { |property| property.property.name == property_name }.try(:value)
-      else
-        product_properties.joins(:property).find_by(spree_properties: { name: property_name }).try(:value)
-      end
-    end
-
-    def set_property(property_name, property_value, property_presentation = property_name)
-      property_name = property_name.to_s.parameterize
-      ApplicationRecord.transaction do
-        # Manual first_or_create to work around Mobility bug
-        property = if Property.where(name: property_name).exists?
-                     existing_property = Property.where(name: property_name).first
-                     existing_property.presentation ||= property_presentation
-                     existing_property.save
-                     existing_property
-                   else
-                     Property.create(name: property_name, presentation: property_presentation)
-                   end
-
-        product_property = if ProductProperty.where(product: self, property: property).exists?
-                             ProductProperty.where(product: self, property: property).first
-                           else
-                             ProductProperty.new(product: self, property: property)
-                           end
-
-        product_property.value = property_value
-        product_property.save!
-      end
-    end
-
-    def remove_property(property_name)
-      product_properties.joins(:property).find_by(spree_properties: { name: property_name.parameterize })&.destroy
-    end
-
     def total_on_hand
       @total_on_hand ||= if any_variants_not_track_inventory?
                            BigDecimal::INFINITY
@@ -668,9 +605,7 @@ module Spree
     def taxons_for_store(store)
       return if classification_count.zero?
 
-      Rails.cache.fetch("#{cache_key_with_version}/taxons-per-store/#{store.id}") do
-        taxons.loaded? ? taxons.find_all { |taxon| taxon.taxonomy.store_id == store.id } : taxons.for_store(store)
-      end
+      taxons.loaded? ? taxons.find_all { |taxon| taxon.taxonomy.store_id == store.id } : taxons.for_store(store)
     end
 
     def any_variant_in_stock_or_backorderable?
@@ -702,7 +637,7 @@ module Spree
 
     def to_csv(store = nil)
       store ||= stores.default || stores.first
-      properties_for_csv = if Spree::Config[:product_properties_enabled]
+      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|
                                [
                                  property.name,
@@ -746,9 +681,6 @@ module Spree
 
     def add_associations_from_prototype
       if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
-        prototype.properties.each do |property|
-          product_properties.create(property: property, value: 'Placeholder')
-        end
         self.option_types = prototype.option_types
         self.taxons = prototype.taxons
       end

data/app/models/spree/promotion.rb

@@ -190,26 +190,14 @@ module Spree
       !!eligible_rules(promotable, options)
     end
 
-    # We cache the rules to avoid multiple database queries
-    # this is useful for orders with many line items
-    #
-    # @return [Array<Spree::PromotionRule>]
-    def cached_rules
-      Rails.cache.fetch("#{cache_key_with_version}/rules") do
-        rules.to_a
-      end
-    rescue TypeError # when using null_store in test environment
-      rules.to_a
-    end
-
     # eligible_rules returns an array of promotion rules where eligible? is true for the promotable
     # if there are no such rules, an empty array is returned
     # if the rules make this promotable ineligible, then nil is returned (i.e. this promotable is not eligible)
     def eligible_rules(promotable, options = {})
       # Promotions without rules are eligible by default.
-      return [] if cached_rules.none?
+      return [] if rules.none?
 
-      specific_rules = cached_rules.select { |rule| rule.applicable?(promotable) }
+      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
       return [] if specific_rules.none?
 
       rule_eligibility = Hash[specific_rules.map do |rule|

data/app/models/spree/promotion_handler/coupon.rb

@@ -177,8 +177,8 @@ module Spree
 
         # Check for applied adjustments.
         discount = order.all_adjustments.promotion.eligible.detect do |p|
-          p.cached_source.promotion.code.try(:downcase) == coupon_code ||
-            Spree::CouponCode.unused.where(promotion_id: p.cached_source.promotion_id, code: coupon_code).exists?
+          p.source.promotion.code.try(:downcase) == coupon_code ||
+            Spree::CouponCode.unused.where(promotion_id: p.source.promotion_id, code: coupon_code).exists?
         end
 
         # Check for applied line items.
@@ -209,7 +209,7 @@ module Spree
       end
 
       def handle_coupon_code(discount, coupon_code)
-        Spree::CouponCode.unused.find_by(promotion_id: discount.cached_source.promotion_id, code: coupon_code)&.apply_order!(order)
+        Spree::CouponCode.unused.find_by(promotion_id: discount.source.promotion_id, code: coupon_code)&.apply_order!(order)
       end
 
       def load_gift_card_code

data/app/models/spree/prototype.rb

@@ -4,9 +4,6 @@ module Spree
 
     include Spree::Metadata
 
-    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
-    has_many :properties, through: :property_prototypes, class_name: 'Spree::Property'
-
     has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
     has_many :option_types, through: :option_type_prototypes, class_name: 'Spree::OptionType'
 

data/app/models/spree/refund.rb

@@ -36,6 +36,10 @@ module Spree
 
     delegate :order, :currency, to: :payment
 
+    def amount=(amount)
+      self[:amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
     def money
       Spree::Money.new(amount, currency: currency)
     end
@@ -83,7 +87,7 @@ module Spree
       update_order
     end
 
-    # return an activemerchant response object if successful or else raise an error
+    # return a payment response object if successful or else raise an error
     def process!(credit_cents)
       refund_total_in_cents = calculate_refund_amount(credit_cents)
 
@@ -102,7 +106,7 @@ module Spree
       end
 
       response
-    rescue ActiveMerchant::ConnectionError => e
+    rescue Spree::PaymentConnectionError => e
       Rails.logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
       raise Core::GatewayError, Spree.t(:unable_to_connect_to_gateway)
     end

data/app/models/spree/shipment/emails.rb

@@ -2,6 +2,7 @@ module Spree
   class Shipment < Spree.base_class
     module Emails
       def send_shipped_email
+        Spree::Deprecation.warn("Shipment#send_shipped_email is deprecated and will be removed in Spree 5.5. Please use events")
         # you can overwrite this method in your application / extension to send out the confirmation email
         # or use `spree_emails` gem
         # YourEmailVendor.deliver_shipment_notification_email(@shipment.id)

data/app/models/spree/shipping_category.rb

@@ -16,10 +16,10 @@ module Spree
       find_by(name: DIGITAL_NAME)
     end
 
+    # Returns true if this shipping category includes a digital shipping method
+    # @return [Boolean]
     def includes_digital_shipping_method?
-      Rails.cache.fetch("#{cache_key_with_version}/includes-digital-shipping-method") do
-        shipping_methods.digital.exists?
-      end
+      @includes_digital_shipping_method ||= shipping_methods.digital.exists?
     end
   end
 end

data/app/models/spree/store.rb

@@ -75,7 +75,6 @@ module Spree
 
     has_many :store_products, class_name: 'Spree::StoreProduct'
     has_many :products, through: :store_products, class_name: 'Spree::Product'
-    has_many :product_properties, through: :products, class_name: 'Spree::ProductProperty'
     has_many :variants, through: :products, class_name: 'Spree::Variant', source: :variants_including_master
     has_many :stock_items, through: :variants, class_name: 'Spree::StockItem'
     has_many :inventory_units, through: :variants, class_name: 'Spree::InventoryUnit'
@@ -93,17 +92,12 @@ module Spree
 
     has_many :wishlists, class_name: 'Spree::Wishlist'
 
-    has_many :data_feeds, class_name: 'Spree::DataFeed'
-
     belongs_to :default_country, class_name: 'Spree::Country'
     belongs_to :checkout_zone, class_name: 'Spree::Zone'
 
     has_many :reports, class_name: 'Spree::Report'
     has_many :exports, class_name: 'Spree::Export'
 
-    has_many :posts, class_name: 'Spree::Post', dependent: :destroy, inverse_of: :store
-    has_many :post_categories, class_name: 'Spree::PostCategory', dependent: :destroy, inverse_of: :store
-
     has_many :integrations, class_name: 'Spree::Integration'
 
     has_many :gift_cards, class_name: 'Spree::GiftCard', dependent: :destroy
@@ -165,9 +159,7 @@ module Spree
     after_create :ensure_default_market
     after_create :ensure_default_taxonomies_are_created
     after_create :ensure_default_automatic_taxons
-    after_create :ensure_default_post_categories_are_created
     after_create :create_default_policies
-    after_commit :clear_cache
 
     #
     # Scopes
@@ -184,17 +176,15 @@ module Spree
 
     # @deprecated The or_initialize behavior will be removed in Spree 5.5.
     def self.default
-      Rails.cache.fetch('default_store') do
-        # workaround for Mobility bug with first_or_initialize
-        if where(default: true).any?
-          where(default: true).first
-        else
-          Spree::Deprecation.warn(
-            'Spree::Store.default returning a new unpersisted store when no default store exists is deprecated ' \
-            'and will be removed in Spree 5.5. Please ensure a default store is created before calling Store.default.'
-          )
-          new(default: true)
-        end
+      # workaround for Mobility bug with first_or_initialize
+      if where(default: true).any?
+        where(default: true).first
+      else
+        Spree::Deprecation.warn(
+          'Spree::Store.default returning a new unpersisted store when no default store exists is deprecated ' \
+          'and will be removed in Spree 5.5. Please ensure a default store is created before calling Store.default.'
+        )
+        new(default: true)
       end
     end
 
@@ -296,9 +286,7 @@ module Spree
     # @param country [Spree::Country] the country to get the states for
     # @return [Array<Spree::State>]
     def states_available_for_checkout(country)
-      Rails.cache.fetch(states_available_for_checkout_cache_key(country)) do
-        country.states.to_a
-      end
+      country.states.to_a
     end
 
     # @deprecated Use {Spree::Zone.all} or {#countries_with_shipping_coverage} instead.
@@ -388,18 +376,6 @@ module Spree
 
     private
 
-    def countries_available_for_checkout_cache_key
-      "#{cache_key_with_version}/countries_available_for_checkout"
-    end
-
-    def states_available_for_checkout_cache_key(country)
-      "#{cache_key_with_version}/states_available_for_checkout/#{country&.cache_key_with_version}"
-    end
-
-    def clear_cache
-      Rails.cache.delete('default_store')
-    end
-
     def ensure_default_market
       return if markets.exists?
 
@@ -463,21 +439,6 @@ module Spree
       end
     end
 
-    def ensure_default_post_categories_are_created
-      Spree::Events.disable do
-        [
-          translate_with_store_locale_fallback('spree.default_post_categories.resources'),
-          translate_with_store_locale_fallback('spree.default_post_categories.articles'),
-          translate_with_store_locale_fallback('spree.default_post_categories.news')
-        ].each do |category_title|
-          # Use exists?/create pattern for safety
-          next if post_categories.where(title: category_title).exists?
-
-          post_categories.create(title: category_title)
-        end
-      end
-    end
-
     def create_default_policies
       Spree::Events.disable do
         [

data/app/models/spree/store_credit.rb

@@ -54,6 +54,10 @@ module Spree
     extend Spree::DisplayMoney
     money_methods :amount, :amount_used, :amount_remaining, :amount_authorized
 
+    def amount=(amount)
+      self[:amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
     self.whitelisted_ransackable_attributes = %w[user_id created_by_id amount currency type_id]
     self.whitelisted_ransackable_associations = %w[type user created_by]
 

data/app/models/spree/tax_category.rb

@@ -10,15 +10,11 @@ module Spree
     has_many :variants, dependent: :nullify
 
     before_save :set_default_category
-    after_update :delete_cache
-    after_create :delete_cache
 
     self.whitelisted_ransackable_attributes = %w[name is_default tax_code]
 
     def self.default
-      Rails.cache.fetch('default_tax_category') do
-        find_by(is_default: true)
-      end
+      find_by(is_default: true)
     end
 
     def set_default_category
@@ -28,11 +24,5 @@ module Spree
         tax_category.update_columns(is_default: false, updated_at: Time.current)
       end
     end
-
-    private
-
-    def delete_cache
-      Rails.cache.delete('default_tax_category')
-    end
   end
 end

data/app/models/spree/taxon.rb

@@ -38,8 +38,6 @@ module Spree
     has_one :store, through: :taxonomy
     has_many :classifications, -> { order(:position) }, dependent: :destroy_async, inverse_of: :taxon
     has_many :products, through: :classifications
-    # @deprecated Use Spree::Taxon#image (Active Storage) instead. Will be removed in Spree 5.5.
-    has_one :icon, as: :viewable, dependent: :destroy, class_name: 'Spree::TaxonImage'
 
     has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
     has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
@@ -60,7 +58,6 @@ module Spree
     validates :taxonomy, presence: true
     validates :permalink, uniqueness: { case_sensitive: false, scope: [:parent_id, :taxonomy_id] }
     validates :hide_from_nav, inclusion: { in: [true, false] }
-    validates_associated :icon
     validate :check_for_root, on: :create
     validate :parent_belongs_to_same_taxonomy
     with_options length: { maximum: 255 }, allow_blank: true do
@@ -312,19 +309,6 @@ module Spree
       end
     end
 
-    # indicate which filters should be used for a taxon
-    # this method should be customized to your own site
-    def applicable_filters
-      Spree::Deprecation.warn('applicable_filters is deprecated and will be removed in Spree 5.5')
-      fs = []
-      # fs << ProductFilters.taxons_below(self)
-      ## unless it's a root taxon? left open for demo purposes
-
-      fs << Spree::Core::ProductFilters.price_filter if Spree::Core::ProductFilters.respond_to?(:price_filter)
-      fs << Spree::Core::ProductFilters.brand_filter if Spree::Core::ProductFilters.respond_to?(:brand_filter)
-      fs
-    end
-
     # Return meta_title if set otherwise generates from taxon name
     def seo_title
       meta_title.blank? ? name : meta_title

data/app/models/spree/variant.rb

@@ -88,8 +88,6 @@ module Spree
     after_create :increment_product_variant_count, unless: :is_master?
     after_destroy :decrement_product_variant_count, unless: :is_master?
 
-    after_touch :clear_in_stock_cache
-
     scope :in_stock, -> { left_joins(:stock_items).where("#{Spree::Variant.table_name}.track_inventory = ? OR #{Spree::StockItem.table_name}.count_on_hand > ?", false, 0) }
     scope :backorderable, -> { left_joins(:stock_items).where(spree_stock_items: { backorderable: true }) }
     scope :in_stock_or_backorderable, -> { in_stock.or(backorderable) }
@@ -281,14 +279,6 @@ module Spree
       is_master? ? name + ' - Master' : name + ' - ' + options_text
     end
 
-    # use deleted? rather than checking the attribute directly. this
-    # allows extensions to override deleted? if they want to provide
-    # their own definition.
-    # @return [Boolean] true if the variant is deleted.
-    def deleted?
-      !!deleted_at
-    end
-
     # Returns true if the variant has images.
     # Uses loaded association when available, otherwise falls back to counter cache.
     # @return [Boolean]
@@ -532,36 +522,16 @@ module Spree
       @compare_at_price ||= price_in(cost_currency).try(:compare_at_amount)
     end
 
-    # Returns the name and sku of the variant.
-    # @return [String] the name and sku of the variant
-    def name_and_sku
-      "#{name} - #{sku}"
-    end
-
-    # Returns the sku and options text of the variant.
-    # @return [String] the sku and options text of the variant
-    def sku_and_options_text
-      "#{sku} #{options_text}".strip
-    end
-
     # Returns true if the variant is in stock.
     # @return [Boolean] true if the variant is in stock
     def in_stock?
-      @in_stock ||= if association(:stock_items).loaded? && association(:stock_locations).loaded?
-                      total_on_hand.positive?
-                    else
-                      Rails.cache.fetch(in_stock_cache_key, version: cache_version) do
-                        total_on_hand.positive?
-                      end
-                    end
+      @in_stock ||= total_on_hand.positive?
     end
 
     # Returns true if the variant is backorderable.
     # @return [Boolean] true if the variant is backorderable
     def backorderable?
-      @backorderable ||= Rails.cache.fetch(['variant-backorderable', cache_key_with_version]) do
-        quantifier.backorderable?
-      end
+      @backorderable ||= quantifier.backorderable?
     end
 
     def on_sale?(currency)
@@ -619,10 +589,6 @@ module Spree
       digitals.any?
     end
 
-    def clear_in_stock_cache
-      Rails.cache.delete(in_stock_cache_key)
-    end
-
     private
 
     def ensure_not_in_complete_orders
@@ -674,10 +640,6 @@ module Spree
       end
     end
 
-    def in_stock_cache_key
-      "variant-#{id}-in_stock"
-    end
-
     def disable_sku_validation?
       Spree::Config[:disable_sku_validation]
     end

data/app/models/spree/zone.rb

@@ -27,9 +27,7 @@ module Spree
     self.whitelisted_ransackable_attributes = ['description']
 
     def self.default_tax
-      Rails.cache.fetch('default_tax') do
-        find_by(default_tax: true)
-      end
+      Spree::Current.default_tax_zone
     end
 
     def self.potential_matching_zones(zone)
@@ -186,7 +184,6 @@ module Spree
 
     def remove_previous_default
       Spree::Zone.with_default_tax.where.not(id: id).update_all(default_tax: false)
-      Rails.cache.delete('default_zone')
     end
 
     def set_zone_members(ids, type)

data/app/services/spree/cart/add_item.rb

@@ -3,7 +3,7 @@ module Spree
     class AddItem
       prepend Spree::ServiceModule::Base
 
-      def call(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
+      def call(order:, variant:, quantity: nil, metadata: {}, public_metadata: {}, private_metadata: {}, options: {})
         ApplicationRecord.transaction do
           run :add_to_line_item
           run Spree.cart_recalculate_service
@@ -12,7 +12,7 @@ module Spree
 
       private
 
-      def add_to_line_item(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
+      def add_to_line_item(order:, variant:, quantity: nil, metadata: {}, public_metadata: {}, private_metadata: {}, options: {})
         options ||= {}
         quantity ||= 1
 
@@ -34,8 +34,12 @@ module Spree
         end
 
         line_item.target_shipment = options[:shipment] if options.key? :shipment
-        line_item.public_metadata = public_metadata.to_h if public_metadata
-        line_item.private_metadata = private_metadata.to_h if private_metadata
+
+        # `metadata` is the primary API param (maps to private_metadata).
+        # Legacy `public_metadata`/`private_metadata` params kept for backward compatibility.
+        resolved_metadata = metadata.presence || private_metadata
+        line_item.metadata = resolved_metadata.to_h if resolved_metadata.present?
+        line_item.public_metadata = public_metadata.to_h if public_metadata.present?
 
         return failure(line_item) unless line_item.save
 

data/app/services/spree/cart/create.rb

@@ -3,18 +3,29 @@ module Spree
     class Create
       prepend Spree::ServiceModule::Base
 
-      def call(user:, store:, currency:, public_metadata: {}, private_metadata: {}, order_params: {})
+      # @param user [Spree.user_class, nil] the user to associate with the cart
+      # @param store [Spree::Store] the store for the cart
+      # @param currency [String, nil] ISO currency code, defaults to store's default currency
+      # @param locale [String, nil] locale for the cart (e.g. 'en', 'fr'), defaults to Spree::Current.locale
+      # @param public_metadata [Hash] public metadata for the order
+      # @param private_metadata [Hash] private metadata for the order
+      # @param order_params [Hash] additional order attributes
+      # @return [Spree::ServiceModule::Result]
+      def call(user:, store:, currency:, locale: nil, metadata: {}, public_metadata: {}, private_metadata: {}, order_params: {})
         order_params ||= {}
 
         # we cannot create an order without store
         return failure(:store_is_required) if store.nil?
 
+        resolved_metadata = metadata.presence || private_metadata
+
         default_params = {
           user: user,
           currency: currency || store.default_currency,
+          locale: locale || Spree::Current.locale,
           token: Spree::GenerateToken.new.call(Spree::Order),
           public_metadata: public_metadata.to_h,
-          private_metadata: private_metadata.to_h
+          private_metadata: resolved_metadata.to_h
         }
 
         order = store.orders.create!(default_params.merge(order_params))

data/app/services/spree/products/duplicator.rb

@@ -13,8 +13,6 @@ module Spree
         new_product.send(:duplicate_extra, product) if new_product.respond_to?(:duplicate_extra)
         new_product.save
 
-        new_product.product_properties = duplicate_properties(product.product_properties) if new_product.persisted?
-
         new_product.persisted? ? success(new_product) : failure(new_product, duplicate_error_message(new_product))
       end
 
@@ -89,16 +87,6 @@ module Spree
         new_image
       end
 
-      def duplicate_properties(product_properties)
-        product_properties.map do |prop|
-          new_prop = prop.dup
-          new_prop.product = nil
-          new_prop.created_at = nil
-          new_prop.updated_at = nil
-          new_prop
-        end
-      end
-
       def sku_generator(sku)
         return '' if sku.blank?
 

data/app/services/spree/products/prepare_nested_attributes.rb

@@ -61,18 +61,6 @@ module Spree
           end
         end
 
-        # mark resource properties to be removed
-        # when value is left blank
-        if params[:product_properties_attributes].present?
-          params[:product_properties_attributes].each do |key, product_property_params|
-            next unless product_property_params[:id].present?
-            next if product_property_params[:value].present?
-
-            # https://api.rubyonrails.org/v7.1.3.4/classes/ActiveRecord/NestedAttributes/ClassMethods.html
-            params[:product_properties_attributes][key]['_destroy'] = '1'
-          end
-        end
-
         # ensure there is at least one store
         params[:store_ids] = [store.id] if params[:store_ids].blank?