spree_core 5.6.1 → 6.0.0.beta1

data/app/jobs/spree/imports/create_rows_job.rb

@@ -1,69 +1,10 @@
 module Spree
   module Imports
+    # @deprecated Use {Spree::Imports::ProcessJob}; removed in 6.1.
     class CreateRowsJob < Spree::Imports::BaseJob
-      discard_on ::CSV::MalformedCSVError, EncodingError do |job, error|
-        import = Spree::Import.find(job.arguments.first)
-        import.update_columns(processing_errors: error.message, status: :failed, updated_at: Time.current)
-        Rails.error.report error
-      end
-
-      BATCH_SIZE = 1000
-
       def perform(import_id)
-        import = Spree::Import.find(import_id)
-        import.start_processing! if import.status != 'processing'
-
-        create_rows_sequentially(import)
-
-        # enqueue processing rows job after creating rows in a separate job
-        import.process_rows_async
-      end
-
-      private
-
-      def create_rows_sequentially(import)
-        rows_to_insert = []
-        row_number = 1
-
-        created_at = updated_at = Time.current
-
-        upsert_options = {}
-        if %w[PostgreSQL SQLite].include?(ActiveRecord::Base.connection.adapter_name)
-          upsert_options[:unique_by] = :index_spree_import_rows_on_import_id_and_row_number
-        end
-        # NOTE: Ensure a DB-level unique index on [:import_id, :row_number] for all adapters.
-
-        # Stream CSV to avoid loading entire file in memory
-        # This maintains order by processing sequentially
-        ::CSV.foreach(StringIO.new(import.attachment_file_content),
-                   headers: true,
-                   col_sep: import.preferred_delimiter,
-                   encoding: 'UTF-8') do |csv_row|
-
-          rows_to_insert << {
-            import_id: import.id,
-            row_number: row_number,
-            data: csv_row.to_h.to_json,
-            status: 'pending',
-            created_at: created_at,
-            updated_at: updated_at
-          }
-
-          row_number += 1
-
-          # Bulk upsert when we reach batch size
-          if rows_to_insert.size >= BATCH_SIZE
-            Spree::ImportRow.upsert_all(rows_to_insert, **upsert_options)
-            rows_to_insert.clear
-          end
-        end
-
-        # Upsert any remaining rows
-        if rows_to_insert.any?
-          Spree::ImportRow.upsert_all(rows_to_insert, **upsert_options)
-        end
-
-        Spree::Import.reset_counters(import.id, :rows)
+        Spree::Deprecation.warn('Spree::Imports::CreateRowsJob is deprecated and will be removed in Spree 6.1. Use Spree::Imports::ProcessJob instead.')
+        Spree::Imports::ProcessJob.perform_now(import_id)
       end
     end
   end

data/app/jobs/spree/imports/process_group_job.rb

@@ -115,7 +115,7 @@ module Spree
         import.reload
 
         if import.completed_groups_count >= import.processing_groups_count && import.rows.in_flight.none?
-          import.complete! if import.status == 'processing'
+          Spree.import_complete_workflow.call(import: import) if import.status == 'processing'
         elsif large && (import.completed_groups_count % 10).zero?
           import.publish_event('import.progress')
         end

data/app/jobs/spree/imports/process_job.rb

@@ -0,0 +1,164 @@
+module Spree
+  module Imports
+    # The sequential spine of the import pipeline on ActiveJob
+    # Continuations: CSV streaming into ImportRow records (cursor = row
+    # number, so a deploy mid-stream resumes instead of restarting the
+    # parse), then group dispatch. The parallel per-group processing stays
+    # on ProcessGroupJob — its crash-safety comes from row statuses and
+    # the completion counters. A malformed file is a permanent failure,
+    # handled inside the create_rows step, never a retry loop.
+    #
+    # `skip_row_creation: true` is the retry entry (rows already exist,
+    # only failed/pending ones get re-dispatched). Inline callers (seeds,
+    # sample data) run the same steps synchronously via `perform_now`.
+    class ProcessJob < Spree::Imports::BaseJob
+      include ActiveJob::Continuable
+
+      ROW_BATCH_SIZE = 1000
+      GROUP_BATCH_SIZE = 100
+      UNGROUPED_KEY = '__ungrouped__'.freeze
+
+      def perform(import_id, skip_row_creation: false)
+        # Outside the steps on purpose — runs on every execution, including
+        # resumes after an interruption.
+        @import = Spree::Import.find(import_id)
+
+        unless skip_row_creation
+          step :begin_processing do
+            if @import.status != 'processing'
+              result = Spree.import_start_processing_workflow.call(import: @import)
+              # Row creation must not start from an import the workflow
+              # refused to move; raising fails the job rather than building
+              # rows against a status that never advanced.
+              raise ActiveRecord::RecordInvalid, @import if result.failure?
+            end
+          end
+          step :create_rows, start: 1
+          # A permanent CSV failure marked the import failed inside the step
+          # (rescuing there, not via discard_on — Continuable resumes errors
+          # raised after progress, so discard handlers would never run).
+          return if @csv_failed
+
+          step :reset_row_counters do
+            Spree::Import.reset_counters(@import.id, :rows)
+          end
+        end
+
+        step :dispatch_row_groups
+      end
+
+      private
+
+      # Streams the CSV so the whole file never sits in memory; the cursor
+      # is the next row number to insert, checkpointed once per batch. On
+      # resume the stream is re-read but rows below the cursor are skipped —
+      # progress is monotonic even under a rolling-deploy storm.
+      def create_rows(step)
+        rows_to_insert = []
+        row_number = 1
+        created_at = updated_at = Time.current
+
+        upsert_options = {}
+        if %w[PostgreSQL SQLite].include?(ActiveRecord::Base.connection.adapter_name)
+          upsert_options[:unique_by] = :index_spree_import_rows_on_import_id_and_row_number
+        end
+
+        ::CSV.foreach(StringIO.new(@import.attachment_file_content),
+                      headers: true,
+                      col_sep: @import.preferred_delimiter,
+                      encoding: 'UTF-8') do |csv_row|
+          if row_number < step.cursor
+            row_number += 1
+            next
+          end
+
+          rows_to_insert << {
+            import_id: @import.id,
+            row_number: row_number,
+            data: csv_row.to_h.to_json,
+            status: 'pending',
+            created_at: created_at,
+            updated_at: updated_at
+          }
+          row_number += 1
+
+          if rows_to_insert.size >= ROW_BATCH_SIZE
+            Spree::ImportRow.upsert_all(rows_to_insert, **upsert_options)
+            rows_to_insert.clear
+            step.set!(row_number)
+          end
+        end
+
+        Spree::ImportRow.upsert_all(rows_to_insert, **upsert_options) if rows_to_insert.any?
+      rescue ::CSV::MalformedCSVError, EncodingError => e
+        @import.update_columns(processing_errors: e.message, status: :failed, updated_at: Time.current)
+        Rails.error.report(e)
+        @csv_failed = true
+      end
+
+      def dispatch_row_groups
+        group_field = @import.group_column
+        group_mapping = group_field && @import.mappings.mapped.find_by(schema_field: group_field)
+        file_column = group_mapping&.file_column
+
+        if file_column
+          dispatch_grouped(file_column)
+        else
+          dispatch_batched
+        end
+      end
+
+      # Inline callers need the group finished before `perform` returns; the
+      # group job's completion bookkeeping works either way.
+      def dispatch_group(row_ids)
+        return ProcessGroupJob.perform_now(@import.id, row_ids) if @import.preferred_inline
+
+        ProcessGroupJob.perform_later(@import.id, row_ids)
+      end
+
+      def dispatch_grouped(file_column)
+        groups = Hash.new { |hash, key| hash[key] = [] }
+
+        @import.rows.pending_and_failed.order(:row_number).pluck(:id, :data).each do |id, data|
+          parsed = JSON.parse(data)
+          key = parsed[file_column].to_s.strip.downcase.presence || UNGROUPED_KEY
+          groups[key] << id
+        rescue JSON::ParserError
+          groups[UNGROUPED_KEY] << id
+        end
+
+        # Rows without a group value don't depend on each other, so they don't have
+        # to share a single job — split them into bounded batches. Real groups stay
+        # intact: their rows must run sequentially (product row before variant rows).
+        ungrouped = groups.delete(UNGROUPED_KEY)
+        batches = groups.values
+        ungrouped&.each_slice(GROUP_BATCH_SIZE) { |row_ids| batches << row_ids }
+
+        # Set count before enqueuing so workers can't complete prematurely
+        @import.update_columns(
+          processing_groups_count: batches.size,
+          completed_groups_count: 0,
+          updated_at: Time.current
+        )
+
+        batches.each { |row_ids| dispatch_group(row_ids) }
+      end
+
+      def dispatch_batched
+        # Count first, then enqueue — prevents premature completion
+        row_id_batches = @import.rows.pending_and_failed.order(:row_number)
+                                .pluck(:id)
+                                .each_slice(GROUP_BATCH_SIZE)
+                                .to_a
+
+        @import.update_columns(
+          processing_groups_count: row_id_batches.size,
+          completed_groups_count: 0,
+          updated_at: Time.current
+        )
+
+        row_id_batches.each { |row_ids| dispatch_group(row_ids) }
+      end
+    end
+  end
+end

data/app/jobs/spree/imports/process_rows_job.rb

@@ -1,78 +1,11 @@
 module Spree
   module Imports
+    # @deprecated Use {Spree::Imports::ProcessJob} with skip_row_creation:
+    #   true; removed in 6.1.
     class ProcessRowsJob < Spree::Imports::BaseJob
-      BATCH_SIZE = 100
-      UNGROUPED_KEY = '__ungrouped__'.freeze
-
       def perform(import_id)
-        import = Spree::Import.find(import_id)
-        dispatch_groups(import)
-      end
-
-      private
-
-      def dispatch_groups(import)
-        group_field = import.group_column
-        group_mapping = group_field && import.mappings.mapped.find_by(schema_field: group_field)
-        file_column = group_mapping&.file_column
-
-        if file_column
-          dispatch_grouped(import, file_column)
-        else
-          dispatch_batched(import)
-        end
-      end
-
-      # Inline callers need the group finished before `perform` returns; the
-      # group job's completion bookkeeping works either way.
-      def dispatch_group(import, row_ids)
-        return ProcessGroupJob.perform_now(import.id, row_ids) if import.preferred_inline
-
-        ProcessGroupJob.perform_later(import.id, row_ids)
-      end
-
-      def dispatch_grouped(import, file_column)
-        groups = Hash.new { |h, k| h[k] = [] }
-
-        import.rows.pending_and_failed.order(:row_number).pluck(:id, :data).each do |id, data|
-          parsed = JSON.parse(data)
-          key = parsed[file_column].to_s.strip.downcase.presence || UNGROUPED_KEY
-          groups[key] << id
-        rescue JSON::ParserError
-          groups[UNGROUPED_KEY] << id
-        end
-
-        # Rows without a group value don't depend on each other, so they don't have
-        # to share a single job — split them into bounded batches. Real groups stay
-        # intact: their rows must run sequentially (product row before variant rows).
-        ungrouped = groups.delete(UNGROUPED_KEY)
-        batches = groups.values
-        ungrouped&.each_slice(BATCH_SIZE) { |row_ids| batches << row_ids }
-
-        # Set count before enqueuing so workers can't complete prematurely
-        import.update_columns(
-          processing_groups_count: batches.size,
-          completed_groups_count: 0,
-          updated_at: Time.current
-        )
-
-        batches.each { |row_ids| dispatch_group(import, row_ids) }
-      end
-
-      def dispatch_batched(import)
-        # Count first, then enqueue — prevents premature completion
-        row_id_batches = import.rows.pending_and_failed.order(:row_number)
-                              .pluck(:id)
-                              .each_slice(BATCH_SIZE)
-                              .to_a
-
-        import.update_columns(
-          processing_groups_count: row_id_batches.size,
-          completed_groups_count: 0,
-          updated_at: Time.current
-        )
-
-        row_id_batches.each { |row_ids| dispatch_group(import, row_ids) }
+        Spree::Deprecation.warn('Spree::Imports::ProcessRowsJob is deprecated and will be removed in Spree 6.1. Use Spree::Imports::ProcessJob instead.')
+        Spree::Imports::ProcessJob.perform_now(import_id, skip_row_creation: true)
       end
     end
   end

data/app/jobs/spree/orders/finalize_stale_drafts_job.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Orders
+    # Completion-recovery sweeper: retries FINALIZE for stale draft orders
+    # whose payment coverage succeeded but whose finalize transaction never
+    # committed (e.g. process crash after capture). Never auto-refunds —
+    # persistent failures are surfaced to operators via logs/monitoring.
+    class FinalizeStaleDraftsJob < Spree::BaseJob
+      queue_as Spree.queues.default
+
+      STALE_AFTER = 10.minutes
+
+      def perform
+        Spree::Order.drafts.
+          where.not(cart_id: nil).
+          where(completed_at: nil).
+          where(created_at: ...STALE_AFTER.ago).
+          find_each do |order|
+            cart = order.cart
+            next if cart.nil? || cart.completed?
+
+            result = Spree::Dependencies.carts_complete_workflow.constantize.call(cart: cart)
+            Rails.logger.error("[Spree] Completion recovery failed for order #{order.number}: #{result.error&.value}") if result.failure?
+          rescue StandardError => e
+            Rails.logger.error("[Spree] Completion recovery raised for order #{order.number}: #{e.message}")
+          end
+      end
+    end
+  end
+end

data/app/jobs/spree/payments/handle_webhook_job.rb

@@ -11,7 +11,7 @@ module Spree
         payment_method = Spree::PaymentMethod.find(payment_method_id)
         payment_session = Spree::PaymentSession.find(payment_session_id)
 
-        Spree::Dependencies.payments_handle_webhook_service.constantize.call(
+        Spree.payments_handle_webhook_workflow.call(
           payment_method: payment_method,
           action: action.to_sym,
           payment_session: payment_session

data/app/jobs/spree/price_lists/sync_currencies_job.rb

@@ -0,0 +1,42 @@
+module Spree
+  module PriceLists
+    # Gives every price list of a store the quantity-1 placeholder rows it is
+    # missing in a currency the store started selling in after the list's
+    # products were added.
+    #
+    # A list's membership is its price rows, and the price spreadsheet shows a
+    # currency's products through the rows in that currency — so a currency
+    # with no rows reads as a list with no products. `add_products` inserts
+    # only the (variant, currency) rows that do not exist yet, which is what
+    # makes this safe to run on every market change. A currency the store
+    # stopped selling in keeps its rows: dropping prices a merchant typed is
+    # not this job's call.
+    #
+    # A store with many lists is walked on a Continuation: the cursor is the
+    # last list synced, so a deploy or a worker restart mid-run resumes with
+    # the next list rather than starting the walk over. Each list's own write
+    # is idempotent, so a list interrupted mid-insert is simply redone.
+    class SyncCurrenciesJob < ::Spree::BaseJob
+      include ActiveJob::Continuable
+
+      # @param store_id [String, Integer]
+      def perform(store_id)
+        # Outside the step on purpose: runs on every execution, resumes included.
+        @store = Spree::Store.find_by(id: store_id)
+        return if @store.nil?
+
+        step :sync_price_lists
+      end
+
+      private
+
+      def sync_price_lists(step)
+        @store.price_lists.find_each(start: step.cursor) do |price_list|
+          product_ids = price_list.products.ids
+          price_list.add_products(product_ids) if product_ids.any?
+          step.advance! from: price_list.id
+        end
+      end
+    end
+  end
+end

data/app/jobs/spree/product_types/apply_to_products_job.rb

@@ -0,0 +1,74 @@
+module Spree
+  module ProductTypes
+    # Backfills a product type's option types and categories onto its existing
+    # products, on ActiveJob Continuations: the cursor is the last product id
+    # applied, so a deploy or timeout mid-backfill resumes from there instead of
+    # restarting a catalog-sized run.
+    #
+    # Products are walked in id order — a stable ordering is what makes the
+    # cursor meaningful, unlike `find_in_batches`' batching alone. Each batch is
+    # additive and idempotent, so re-running the batch that was in flight when
+    # the job died changes nothing.
+    class ApplyToProductsJob < ::Spree::BaseJob
+      include ActiveJob::Continuable
+
+      queue_as Spree.queues.products
+
+      def perform(product_type_id)
+        # Outside the steps on purpose — runs on every execution, resumes
+        # included.
+        @product_type = Spree::ProductType.find_by(id: product_type_id)
+        return if @product_type.nil?
+
+        service = Spree::ProductTypes::ApplyToProducts.new
+        return if service.nothing_to_apply?(@product_type)
+
+        step :apply_to_products, start: 0
+        step :settle_bookkeeping
+      end
+
+      private
+
+      # Cursor = the highest product id already applied. Checkpointed after each
+      # batch, so a resume re-reads nothing it has finished.
+      def apply_to_products(step)
+        service = Spree::ProductTypes::ApplyToProducts.new
+
+        loop do
+          product_ids = @product_type.products.where(Spree::Product.arel_table[:id].gt(step.cursor)).
+                        order(:id).limit(Spree::ProductTypes::ApplyToProducts::BATCH_SIZE).pluck(:id)
+          break if product_ids.empty?
+
+          service.apply_batch(@product_type, product_ids)
+          step.set!(product_ids.last)
+        end
+      end
+
+      # Counter caches, branch counts and reindexing settle once for the whole
+      # run — each is a subtree-wide recount or a job per product, so doing it
+      # per batch would cost more than the backfill itself.
+      #
+      # The set of touched products is re-derived from the join table rather
+      # than carried across batches: a resumed job has no memory of what earlier
+      # executions changed, and every product of the type is in the right state
+      # by now regardless of which execution put it there.
+      def settle_bookkeeping
+        category_ids = @product_type.category_ids
+        return if category_ids.empty?
+
+        service = Spree::ProductTypes::ApplyToProducts.new
+        store = @product_type.store
+
+        # Per-product counters batch — the whole point of the cursor is not
+        # holding a catalog-sized id list in memory.
+        @product_type.products.select(:id).
+          find_in_batches(batch_size: Spree::ProductTypes::ApplyToProducts::BATCH_SIZE) do |products|
+          service.settle_product_counters(store, products.map(&:id))
+        end
+
+        # The subtree-wide category recount runs once.
+        service.settle_category_counters(store, category_ids)
+      end
+    end
+  end
+end

data/app/jobs/spree/products/auto_match_collections_job.rb

@@ -0,0 +1,14 @@
+module Spree
+  module Products
+    class AutoMatchCollectionsJob < ::Spree::BaseJob
+      queue_as Spree.queues.collections
+
+      def perform(product_id)
+        product = Spree::Product.find_by(id: product_id)
+        return unless product.present?
+
+        Spree::Products::AutoMatchCollections.call(product: product)
+      end
+    end
+  end
+end

data/app/jobs/spree/products/auto_match_taxons_job.rb

@@ -1,13 +1,12 @@
 module Spree
   module Products
-    class AutoMatchTaxonsJob < ::Spree::BaseJob
-      queue_as Spree.queues.taxons
-
+    # @deprecated Renamed to AutoMatchCollectionsJob in 6.0 (behavior moved to
+    #   collections). Subclasses it so jobs enqueued under the old class name still
+    #   deserialize and run; removed in 6.1.
+    class AutoMatchTaxonsJob < AutoMatchCollectionsJob
       def perform(product_id)
-        product = Spree::Product.find_by(id: product_id)
-        return unless product.present?
-
-        Spree::Products::AutoMatchTaxons.call(product: product)
+        Spree::Deprecation.warn('Spree::Products::AutoMatchTaxonsJob is deprecated and will be removed in Spree 6.1. Use Spree::Products::AutoMatchCollectionsJob instead.')
+        super
       end
     end
   end

data/app/jobs/spree/products/refresh_metrics_job.rb

@@ -8,7 +8,7 @@ module Spree
         return unless product
 
         completed_order_ids = product.completed_orders.select(:id)
-        variant_ids = product.variants_including_master.ids
+        variant_ids = product.variants.ids
 
         line_items = Spree::LineItem.joins(:order)
           .where(spree_orders: { id: completed_order_ids })

data/app/jobs/spree/products/touch_categories_job.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Products
+    class TouchCategoriesJob < ::Spree::BaseJob
+      queue_as Spree.queues.categories
+
+      # @param category_ids [Array<Integer>]
+      # @param _legacy_taxonomy_ids [Array<Integer>] ignored; accepted so jobs
+      #   enqueued before 6.0 stopped touching taxonomies still deserialize.
+      #   Removed in 6.1.
+      def perform(category_ids, _legacy_taxonomy_ids = nil)
+        Spree::Category.where(id: category_ids).update_all(updated_at: Time.current)
+      end
+    end
+  end
+end

data/app/jobs/spree/products/touch_taxons_job.rb

@@ -1,11 +1,12 @@
 module Spree
   module Products
-    class TouchTaxonsJob < ::Spree::BaseJob
-      queue_as Spree.queues.taxons
-
-      def perform(taxon_ids, taxonomy_ids)
-        Spree::Taxon.where(id: taxon_ids).update_all(updated_at: Time.current)
-        Spree::Taxonomy.where(id: taxonomy_ids).update_all(updated_at: Time.current)
+    # @deprecated Renamed to Spree::Products::TouchCategoriesJob in 6.0. Subclasses it
+    #   so jobs enqueued under the old class name before the deploy still deserialize
+    #   and run; removed in 6.1.
+    class TouchTaxonsJob < TouchCategoriesJob
+      def perform(*args)
+        Spree::Deprecation.warn('Spree::Products::TouchTaxonsJob is deprecated and will be removed in Spree 6.1. Use Spree::Products::TouchCategoriesJob instead.')
+        super
       end
     end
   end

data/app/jobs/spree/seller_payouts/sweep_due_job.rb

@@ -0,0 +1,57 @@
+module Spree
+  module SellerPayouts
+    # Hands every approved seller to a job of their own.
+    #
+    # Scheduled daily by the host app (`spree/spree-starter`'s recurring.yml
+    # ships the entry). Daily is right whatever a seller's own interval is,
+    # since {SweepSellerJob} decides who is actually due: a scheduler cannot
+    # express "weekly, but per seller, from whenever that seller was last
+    # paid", so the interval logic lives there rather than in a cron
+    # expression.
+    #
+    # This job only fans out. Settling talks to a payment provider, so doing it
+    # inline would hold one worker for the whole marketplace and let a single
+    # slow provider call delay every seller behind it. Enqueued in batches with
+    # plain `ActiveJob.perform_all_later`, which every queue adapter supports —
+    # core must not require a particular one.
+    #
+    # Continuable, because a marketplace with many sellers takes long enough to
+    # fan out that a deploy can land mid-run. Without it a restart would begin
+    # again at the first store and re-enqueue every seller already handed off;
+    # {SweepSellerJob} would mostly no-op on the duplicates, but a marketplace
+    # would still pay for the whole fan-out twice and the sweep it does reach
+    # is the one that moves money.
+    class SweepDueJob < ::Spree::BaseJob
+      include ActiveJob::Continuable
+
+      queue_as Spree.queues.payouts
+
+      # How many jobs are handed to the adapter at a time. Enough to make the
+      # round trip worth it, small enough that a marketplace with a hundred
+      # thousand sellers never builds one enormous array.
+      BATCH_SIZE = 1_000
+
+      def perform
+        step :fan_out do |step|
+          # Store by store, so each seller is reached through the store that
+          # owns them — which is what makes the (store_id, status) index
+          # usable. The cursor is the last store handed off rather than the
+          # last seller: resuming mid-store would need a second cursor, and
+          # re-running one store's fan-out is cheap next to losing the index.
+          Spree::Store.where(id: step.cursor..).order(:id).find_each do |store|
+            enqueue_sellers_of(store)
+            step.advance! from: store.id
+          end
+        end
+      end
+
+      private
+
+      def enqueue_sellers_of(store)
+        store.sellers.approved.in_batches(of: BATCH_SIZE) do |sellers|
+          ActiveJob.perform_all_later(sellers.ids.map { |id| SweepSellerJob.new(id) })
+        end
+      end
+    end
+  end
+end