spree_core 5.6.1 → 6.0.0.beta2

data/app/services/spree/catalogs/set_order_minimums.rb

@@ -0,0 +1,44 @@
+module Spree
+  module Catalogs
+    # Replaces a catalog's order minimums with the given set.
+    #
+    # A currency absent from the payload has its minimum lifted, so the whole
+    # set arrives in one request — the agreement editor stages every term
+    # behind the catalog's Save, and applying half of them would leave the
+    # agreement in a state the merchant never asked for.
+    class SetOrderMinimums
+      prepend Spree::ServiceModule::Base
+
+      # @param catalog [Spree::Catalog]
+      # @param order_minimums [Array<Hash>] :currency, :amount
+      # @return [Spree::ServiceModule::Result] value is the catalog
+      def call(catalog:, order_minimums:)
+        rows = Array(order_minimums).reject { |row| row[:currency].blank? }
+
+        invalid = nil
+
+        ApplicationRecord.transaction do
+          keep = rows.map { |row| row[:currency].to_s.upcase }
+          catalog.order_minimums.where.not(currency: keep).destroy_all if keep.any?
+          catalog.order_minimums.destroy_all if keep.empty?
+
+          rows.each do |row|
+            minimum = catalog.order_minimums.find_or_initialize_by(currency: row[:currency].to_s.upcase)
+            minimum.amount = row[:amount]
+            next if minimum.save
+
+            # A plain service's `failure` returns rather than raising, so a
+            # bad row has to take the transaction down itself — otherwise the
+            # rest of the set applies and the caller is told it all worked.
+            invalid = minimum
+            raise ActiveRecord::Rollback
+          end
+        end
+
+        return failure(invalid) if invalid
+
+        success(catalog.reload)
+      end
+    end
+  end
+end

data/app/services/spree/catalogs/set_product_terms.rb

@@ -0,0 +1,83 @@
+module Spree
+  module Catalogs
+    # Applies a catalog's per-product quantity terms as a set.
+    #
+    # Terms are stored per variant but stated per product, so a product's
+    # pair is written to every one of its variants. A pair of blanks clears
+    # that product's terms.
+    #
+    # Stating terms for a product outside the assortment **adds it**: a term
+    # with nothing to apply to is not a state worth being able to reach, and
+    # a merchant naming a minimum for a product plainly means to sell it
+    # under this agreement (docs/plans/6.0-b2b-quantity-rules.md).
+    class SetProductTerms
+      prepend Spree::ServiceModule::Base
+
+      # @param catalog [Spree::Catalog]
+      # @param terms [Hash{Spree::Product => Hash}] :minimum_order_quantity,
+      #   :order_multiple — either may be nil, meaning "defer to the catalog"
+      # @return [Spree::ServiceModule::Result] value is the catalog
+      def call(catalog:, terms:)
+        return success(catalog) if terms.empty?
+
+        foreign = terms.keys.reject { |product| product.store_id == catalog.store_id }
+        return failure(catalog, Spree.t('catalogs.product_not_in_store')) if foreign.any?
+
+        invalid = nil
+
+        ApplicationRecord.transaction do
+          catalog.add_products(terms.keys.reject { |product| catalog.product_ids.include?(product.id) }.map(&:id))
+
+          terms.each do |product, values|
+            invalid = apply(catalog, product, values)
+            # A plain service's `failure` returns rather than raising, so one
+            # bad row has to take the transaction down itself — otherwise the
+            # rest of the set commits, the products are added, and the caller
+            # is told the whole thing worked.
+            raise ActiveRecord::Rollback if invalid
+          end
+        end
+
+        return failure(invalid) if invalid
+
+        success(catalog.reload)
+      end
+
+      private
+
+      # @return [Spree::CatalogQuantityRule, nil] the first row that would not
+      #   save, so the caller can roll the whole set back
+      def apply(catalog, product, values)
+        minimum = normalize(values[:minimum_order_quantity])
+        multiple = normalize(values[:order_multiple])
+        variant_ids = product.variants.ids
+
+        # Both blank is a deletion: the product falls back to the catalog's
+        # own default, which is what an empty pair means on the row.
+        if minimum.nil? && multiple.nil?
+          catalog.quantity_rules.where(variant_id: variant_ids).destroy_all
+          return nil
+        end
+
+        variant_ids.each do |variant_id|
+          rule = catalog.quantity_rules.find_or_initialize_by(variant_id: variant_id)
+          rule.assign_attributes(minimum_order_quantity: minimum, order_multiple: multiple)
+          return rule unless rule.save
+        end
+
+        nil
+      end
+
+      # A blank arrives as nil or an empty string depending on the client;
+      # both mean "say nothing", which is not the same as zero. Anything else
+      # is passed through as given — a negative or fractional entry has to
+      # reach the model's validation and be refused, not be coerced into a
+      # different rule than the merchant typed.
+      def normalize(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        value
+      end
+    end
+  end
+end

data/app/services/spree/categories/add_products.rb

@@ -0,0 +1,51 @@
+module Spree
+  module Categories
+    class AddProducts
+      prepend Spree::ServiceModule::Base
+
+      # Creates product-category links for the given categories and products in bulk.
+      #
+      # @param categories [Array<Spree::Category>]
+      # @param products [Array<Spree::Product>]
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(categories:, products:)
+        return if categories.blank? || products.blank?
+
+        # build the params for the insert_all
+        product_categories_params = categories.pluck(:id).flat_map do |category_id|
+          position = Spree::ProductCategory.where(category_id: category_id).count
+
+          products.pluck(:id).map do |product_id|
+            {
+              category_id: category_id,
+              product_id: product_id,
+              position: (position += 1),
+              created_at: Time.current,
+              updated_at: Time.current
+            }
+          end
+        end
+        # doing a quick insert_all here to avoid the overhead of instantiating
+        Spree::ProductCategory.insert_all(product_categories_params)
+
+        # update counter caches
+        category_ids = categories.pluck(:id)
+        product_ids = products.pluck(:id)
+        product_ids.each { |id| Spree::Product.reset_counters(id, :product_categories) }
+        # Recompute the descendant-inclusive products_count for the categories and
+        # their ancestors (bulk insert skips ProductCategory callbacks).
+        Spree::Category.recalculate_products_count(category_ids)
+
+        # clear cache & index products
+        Spree::Product.where(id: product_ids).touch_all
+        products.each(&:enqueue_search_index)
+
+        Spree::Category.where(id: category_ids).touch_all
+        # Optional external hook (e.g. storefront featured sections); namespace owned by that gem.
+        Spree::Taxons::TouchFeaturedSections.call(taxon_ids: category_ids) if defined?(Spree::Taxons::TouchFeaturedSections)
+
+        success(true)
+      end
+    end
+  end
+end

data/app/services/spree/categories/remove_products.rb

@@ -0,0 +1,72 @@
+module Spree
+  module Categories
+    class RemoveProducts
+      prepend Spree::ServiceModule::Base
+
+      # Removes the given products from the given categories.
+      #
+      # @param categories [Array<Spree::Category>]
+      # @param products [Array<Spree::Product>]
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(categories:, products:)
+        return if categories.blank? || products.blank?
+
+        category_ids = categories.pluck(:id)
+        product_ids = products.pluck(:id)
+
+        ApplicationRecord.transaction do
+          category_ids.each do |category_id|
+            Spree::ProductCategory.where(category_id: category_id, product_id: product_ids).delete_all
+          end
+
+          product_categories_params = category_ids.flat_map do |category_id|
+            position = 0
+            existing_product_ids = Spree::ProductCategory.where(category_id: category_id).pluck(:product_id)
+
+            existing_product_ids.map do |product_id|
+              {
+                category_id: category_id,
+                product_id: product_id,
+                position: (position += 1),
+                created_at: Time.current,
+                updated_at: Time.current
+              }
+            end
+          end
+
+          if product_categories_params.any?
+            opts = {}
+            opts[:unique_by] = %i[product_id category_id] unless mysql_adapter?
+
+            Spree::ProductCategory.upsert_all(
+              product_categories_params,
+              **opts
+            )
+          end
+        end
+
+        # update counter caches
+        product_ids.each { |id| Spree::Product.reset_counters(id, :product_categories) }
+        # Recompute the descendant-inclusive products_count for the categories and
+        # their ancestors (delete_all skips ProductCategory callbacks).
+        Spree::Category.recalculate_products_count(category_ids)
+
+        # clear cache & index products
+        Spree::Product.where(id: product_ids).touch_all
+        products.each(&:enqueue_search_index)
+
+        Spree::Category.where(id: category_ids).touch_all
+        # Optional external hook (e.g. storefront featured sections); namespace owned by that gem.
+        Spree::Taxons::TouchFeaturedSections.call(taxon_ids: category_ids) if defined?(Spree::Taxons::TouchFeaturedSections)
+
+        success(true)
+      end
+
+      private
+
+      def mysql_adapter?
+        Spree.mysql?
+      end
+    end
+  end
+end

data/app/services/spree/checkout/add_store_credit.rb

@@ -1,83 +1,15 @@
 module Spree
   module Checkout
-    class AddStoreCredit
-      prepend Spree::ServiceModule::Base
-
-      def call(order:, amount: nil)
-        @order = order
-        return failed unless @order
-
-        remaining_total = amount ? [amount, @order.outstanding_balance].min : @order.outstanding_balance
-
-        return failure(nil, Spree.t(:error_user_does_not_have_any_store_credits)) unless @order.user&.store_credits&.any?
-
-        ApplicationRecord.transaction do
-          existing = @order.payments.store_credits.where(state: :checkout)
-
-          if existing.any?
-            update_existing_payments(existing, remaining_total)
-          else
-            apply_store_credits(remaining_total)
-          end
-        end
-
-        if @order.reload.payments.store_credits.valid.any?
-          @order.updater.run_hooks
-          success(@order)
-        else
-          failure(@order)
-        end
-      end
-
-      private
-
-      # Update existing checkout store credit payments in place to avoid
-      # creating unnecessary invalid payment records on every recalculation.
-      def update_existing_payments(payments, remaining_total)
-        payments.each do |payment|
-          credit = payment.source
-          available = credit.amount_remaining + payment.amount
-          new_amount = [available, remaining_total].min
-
-          if new_amount.positive?
-            payment.update_column(:amount, new_amount)
-            remaining_total -= new_amount
-          else
-            payment.invalidate!
-          end
-        end
-
-        # If there's still remaining total, apply from additional store credits
-        apply_store_credits(remaining_total) if remaining_total.positive?
-      end
-
-      def apply_store_credits(remaining_total)
-        payment_method = Spree::PaymentMethod::StoreCredit.available.first
-        raise 'Store credit payment method could not be found' unless payment_method
-
-        @order.user.store_credits.for_store(@order.store).order_by_priority.each do |credit|
-          break if remaining_total.zero?
-          next if credit.amount_remaining.zero?
-
-          amount_to_take = store_credit_amount(credit, remaining_total)
-          create_store_credit_payment(payment_method, credit, amount_to_take)
-          remaining_total -= amount_to_take
-        end
-      end
-
-      def create_store_credit_payment(payment_method, credit, amount)
-        @order.payments.create!(
-          source: credit,
-          payment_method: payment_method,
-          amount: amount,
-          state: 'checkout',
-          response_code: credit.generate_authorization_code
-        )
-      end
-
-      def store_credit_amount(credit, total)
-        [credit.amount_remaining, total].min
-      end
-    end
+    # Deprecation alias for Spree::StoreCredits::Apply, renamed in 6.0 for
+    # symmetry with Spree::GiftCards::Apply. Retained one release so existing
+    # code and extensions keep working. A constant assignment rather than a
+    # subclass, so is_a? and class_name: references keep resolving; the file
+    # is named for the constant because Zeitwerk requires it. Removed in 6.1.
+    AddStoreCredit = Spree::StoreCredits::Apply
+
+    Spree::Deprecation.warn(
+      'Spree::Checkout::AddStoreCredit is deprecated and will be removed in Spree 6.1. ' \
+      'Use Spree::StoreCredits::Apply instead.'
+    )
   end
 end

data/app/services/spree/checkout/advance.rb

@@ -1,57 +1,57 @@
 module Spree
   module Checkout
+    # Requirements-driven replacement for machine advancement: there are no
+    # states to walk, so "advancing" a cart means recalculating it (prices,
+    # promotions, tax, delivery proposals) so its requirements reflect the
+    # latest data. The optional +shipping_method_id+ keeps the quick-checkout
+    # flows working (Google Pay does not always send a separate selection).
     class Advance
       prepend Spree::ServiceModule::Base
 
       def call(order:, state: nil, shipping_method_id: nil)
-        return failure(order) if state.present? && !order.has_checkout_step?(state)
-        return success(order) if state.present? && order.passed_checkout_step?(state)
+        cart = order
 
-        old_state = order.state
-        order_updater_ran = false
-
-        # We need to check how many times we transitioned between checkout steps and return the error if no transition has been made
-        # We'll always return an error when passing the `state` arg and not reaching the targeted state
-        transitions_count = 0
-
-        until cannot_make_transition?(order, state)
-          next_result = Spree.checkout_next_service.call(order: order)
-          return failure(order, order.errors) if next_result.failure? && (transitions_count.zero? || state.present?)
-
-          transitions_count +=1
-
-          # Quick Checkout with Google Pay not always sends events for shipping method selection
-          # we have to check this after payment
-
-          if order.delivery? &&
-              shipping_method_id.present? &&
-              order.shipments.count == 1 &&
-              order.shipping_method.id != shipping_method_id
-
-            result = Spree::Checkout::SelectShippingMethod.call(order: order, params: { shipping_method_id: shipping_method_id })
-
-            # We're running the order update inside Spree::Checkout::SelectShippingMethod
-            order_updater_ran = result.success?
-          end
+        # A destination is either a shipping address or a pickup intent — a
+        # pure-pickup cart never gets an address, but still needs proposals.
+        has_destination = cart.ship_address.present? || cart.preferred_stock_location_id.present?
+        if cart.fulfillments.empty? && cart.delivery_step_required? && has_destination && cart.respond_to?(:rebuild_fulfillments!)
+          cart.rebuild_fulfillments!
         end
 
-        if order.state != old_state && !order_updater_ran
-          order.updater.update_shipment_state
-          order.updater.update_payment_state
-          order.save! if order.changed?
+        if shipping_method_id.present? && cart.fulfillments.count == 1 &&
+            cart.fulfillments.first.delivery_method&.id != shipping_method_id
+          result = select_delivery_method(cart, shipping_method_id)
+          return result if result.failure?
         end
 
-        success(order)
+        cart.recalculate_totals!
+        success(cart)
       end
 
       private
 
-      def cannot_make_transition?(order, state = nil)
-        order.state == state || order.confirm? || order.complete? || order.errors.present? || order.passed_checkout_step?(state)
-      end
+      # Quick-checkout convenience: wallets (Google Pay) send the chosen
+      # method alongside the address instead of as a separate selection, so
+      # the rate is picked here. Normal checkout selects a rate directly on
+      # the fulfillment.
+      def select_delivery_method(cart, delivery_method_id)
+        delivery_method = Spree::DeliveryMethod.find_by(id: delivery_method_id)
+        return failure(:delivery_method_not_found) if delivery_method.nil?
+
+        fulfillment = cart.fulfillments.first
+        rate = fulfillment.delivery_rates.find_by(delivery_method: delivery_method)
+
+        if rate.nil?
+          return failure(
+            :selected_delivery_method_not_found,
+            "Couldn't find delivery rates for Delivery Method with ID = #{delivery_method.id} and Fulfillment with ID = #{fulfillment.id}"
+          )
+        end
+
+        # Assigning the rate updates the fulfillment amount and order totals.
+        fulfillment.selected_delivery_rate_id = rate.id
 
-      def report_advance_error(error, order)
-        # You can report checkout advance error here
+        success(fulfillment)
       end
     end
   end

data/app/services/spree/checkout/remove_store_credit.rb

@@ -1,17 +1,12 @@
 module Spree
   module Checkout
-    class RemoveStoreCredit
-      prepend Spree::ServiceModule::Base
+    # Deprecation alias for Spree::StoreCredits::Remove — see
+    # Spree::Checkout::AddStoreCredit. Removed in 6.1.
+    RemoveStoreCredit = Spree::StoreCredits::Remove
 
-      def call(order:)
-        return failed unless order
-
-        ApplicationRecord.transaction do
-          order.payments.checkout.store_credits.map(&:invalidate!) unless order.completed?
-        end
-
-        order.reload.payments.store_credits.valid.any? ? failure(order) : success(order)
-      end
-    end
+    Spree::Deprecation.warn(
+      'Spree::Checkout::RemoveStoreCredit is deprecated and will be removed in Spree 6.1. ' \
+      'Use Spree::StoreCredits::Remove instead.'
+    )
   end
 end

data/app/services/spree/collections/add_products.rb

@@ -0,0 +1,42 @@
+module Spree
+  module Collections
+    class AddProducts
+      prepend Spree::ServiceModule::Base
+
+      # Adds the given products to the given collections (manual curation), in bulk.
+      #
+      # @param collections [Array<Spree::Collection>]
+      # @param products [Array<Spree::Product>]
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(collections:, products:)
+        return if collections.blank? || products.blank?
+
+        product_collections_params = collections.pluck(:id).flat_map do |collection_id|
+          position = Spree::ProductCollection.where(collection_id: collection_id).count
+
+          products.pluck(:id).map do |product_id|
+            {
+              collection_id: collection_id,
+              product_id: product_id,
+              position: (position += 1),
+              created_at: Time.current,
+              updated_at: Time.current
+            }
+          end
+        end
+        Spree::ProductCollection.insert_all(product_collections_params)
+
+        collection_ids = collections.pluck(:id)
+        product_ids = products.pluck(:id)
+        collection_ids.each { |id| Spree::Collection.reset_counters(id, :product_collections) }
+        product_ids.each { |id| Spree::Product.reset_counters(id, :product_collections) }
+
+        Spree::Product.where(id: product_ids).touch_all
+        products.each(&:enqueue_search_index)
+        Spree::Collection.where(id: collection_ids).touch_all
+
+        success(true)
+      end
+    end
+  end
+end

data/app/services/spree/collections/regenerate_products.rb

@@ -0,0 +1,67 @@
+module Spree
+  module Collections
+    class RegenerateProducts
+      prepend ::Spree::ServiceModule::Base
+
+      # Rebuilds a collection's materialized ProductCollection membership from its rules.
+      #
+      # @param collection [Spree::Collection]
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(collection:)
+        return if collection.nil?
+        return if collection.destroyed?
+        return if collection.manual?
+
+        previous_products_ids = collection.product_collections.order(position: :asc).pluck(:product_id)
+
+        # Hard-delete the join rows (no callbacks). Class-level delete on the collection
+        # scope rather than the association proxy, which under `dependent: :destroy_async`
+        # doesn't reliably remove rows here.
+        Spree::ProductCollection.where(collection_id: collection.id).delete_all
+
+        products_matching_rules = collection.products_matching_rules
+        product_ids_to_insert = products_matching_rules.ids
+
+        previous_filtered_products_ids = previous_products_ids & product_ids_to_insert
+        max_products_position = previous_filtered_products_ids.size || 0
+
+        if product_ids_to_insert.any?
+          records_to_insert = product_ids_to_insert.map do |product_id|
+            position = previous_filtered_products_ids.index(product_id)
+            position = position.present? ? position + 1 : max_products_position += 1
+
+            product_collection_attributes(product_id, collection, position)
+          end
+
+          Spree::ProductCollection.insert_all(records_to_insert)
+        end
+
+        # Expire cache + reindex the union of previous and new members, so products
+        # dropped when the match set empties also refresh their stale collection_ids.
+        products = Spree::Product.where(id: (previous_products_ids + product_ids_to_insert).uniq)
+        products.touch_all
+        products.each(&:enqueue_search_index)
+
+        # counter caches — bulk insert/delete bypass the ProductCollection counter_cache callbacks
+        Spree::Collection.reset_counters(collection.id, :product_collections)
+        all_product_ids = (previous_products_ids + product_ids_to_insert).uniq
+        existing_product_ids = Spree::Product.where(id: all_product_ids).pluck(:id)
+        existing_product_ids.each { |id| Spree::Product.reset_counters(id, :product_collections) }
+
+        success(collection)
+      end
+
+      private
+
+      def product_collection_attributes(product_id, collection, position)
+        {
+          product_id: product_id,
+          collection_id: collection.id,
+          position: position,
+          created_at: Time.current,
+          updated_at: Time.current
+        }
+      end
+    end
+  end
+end

data/app/services/spree/collections/remove_products.rb

@@ -0,0 +1,65 @@
+module Spree
+  module Collections
+    class RemoveProducts
+      prepend Spree::ServiceModule::Base
+
+      # Removes the given products from the given collections and re-packs positions.
+      #
+      # @param collections [Array<Spree::Collection>]
+      # @param products [Array<Spree::Product>]
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(collections:, products:)
+        return if collections.blank? || products.blank?
+
+        collection_ids = collections.pluck(:id)
+        product_ids = products.pluck(:id)
+
+        ApplicationRecord.transaction do
+          collection_ids.each do |collection_id|
+            Spree::ProductCollection.where(collection_id: collection_id, product_id: product_ids).delete_all
+          end
+
+          product_collections_params = collection_ids.flat_map do |collection_id|
+            position = 0
+            existing_product_ids = Spree::ProductCollection.where(collection_id: collection_id).pluck(:product_id)
+
+            existing_product_ids.map do |product_id|
+              {
+                collection_id: collection_id,
+                product_id: product_id,
+                position: (position += 1),
+                created_at: Time.current,
+                updated_at: Time.current
+              }
+            end
+          end
+
+          if product_collections_params.any?
+            opts = {}
+            # Column list rather than the index name — the composite unique index is named
+            # index_product_collections_on_collection_and_product (shortened to fit the
+            # identifier limit), so match by columns to stay name-independent.
+            opts[:unique_by] = %i[collection_id product_id] unless mysql_adapter?
+
+            Spree::ProductCollection.upsert_all(product_collections_params, **opts)
+          end
+        end
+
+        collection_ids.each { |id| Spree::Collection.reset_counters(id, :product_collections) }
+        product_ids.each { |id| Spree::Product.reset_counters(id, :product_collections) }
+
+        Spree::Product.where(id: product_ids).touch_all
+        products.each(&:enqueue_search_index)
+        Spree::Collection.where(id: collection_ids).touch_all
+
+        success(true)
+      end
+
+      private
+
+      def mysql_adapter?
+        Spree.mysql?
+      end
+    end
+  end
+end