spree_core 6.0.0.rc7 → 6.0.1

data/app/maintenance_tasks/spree/maintenance_tasks/upgrade/store_regional_settings.rb

@@ -0,0 +1,63 @@
+module Spree
+  module MaintenanceTasks
+    module Upgrade
+      # 5.6 → 6.0 conversion of the store's time zone into an IANA identifier
+      # ("Eastern Time (US & Canada)" becomes "America/New_York") and of its
+      # admin language into a listed locale code (`en_US` becomes `en-US`), the
+      # only forms the API accepts and browsers read.
+      #
+      # A time zone that names no zone falls back to the store default, which is
+      # what the store already ran on: Ruby could not read it either. An admin
+      # language Spree does not list is cleared, so the dashboard shows each
+      # staff member their own language.
+      class StoreRegionalSettings < Spree::MaintenanceTask
+        supports_dry_run
+
+        def collection
+          Spree::Store.with_deleted.order(:id)
+        end
+
+        # Locks the store's row, so a settings save made meanwhile is read
+        # rather than overwritten, and counts each change once it is written.
+        #
+        # @param store [Spree::Store]
+        # @return [void]
+        def process(store)
+          store.with_lock do
+            changes = time_zone_change(store).merge(admin_locale_change(store))
+            next if changes.empty?
+
+            if dry_run?
+              changes.each_value { |outcome, _value| tally(:"would_#{outcome}") }
+              next
+            end
+
+            changes.each { |name, (_outcome, value)| store.set_preference(name, value) }
+            store.update_columns(preferences: store.preferences, updated_at: Time.current)
+            changes.each_value { |outcome, _value| tally(outcome) }
+          end
+        end
+
+        private
+
+        def time_zone_change(store)
+          stored = store.preferred_timezone
+          return {} if Spree::TimeZones.valid?(stored)
+
+          converted = Spree::TimeZones.normalize(stored)
+          return { timezone: [:time_zone_converted, converted] } if Spree::TimeZones.valid?(converted)
+
+          { timezone: [:time_zone_reset_to_default, store.preference_default(:timezone)] }
+        end
+
+        def admin_locale_change(store)
+          stored = store.preferred_admin_locale
+          return {} if stored.blank? || Spree::Locales::ALL.include?(stored)
+
+          listed = Spree::Locales.listed(stored)
+          { admin_locale: listed ? [:admin_locale_converted, listed] : [:admin_locale_cleared, nil] }
+        end
+      end
+    end
+  end
+end

data/app/maintenance_tasks/spree/maintenance_tasks/upgrade/users_to_customers.rb

@@ -0,0 +1,28 @@
+module Spree
+  module MaintenanceTasks
+    module Upgrade
+      # Copies the legacy Devise user table onto the gem-owned customer model
+      # and re-points every polymorphic reference that named the old class.
+      #
+      # Two of its parameters are questions only an operator can answer: whether
+      # a Devise pepper was ever configured (an encrypted password cannot be
+      # read without knowing, and Devise is gone by the time this runs), and
+      # what to do with source rows that cannot be copied.
+      class UsersToCustomers < RakeStep
+        runs_rake_task 'spree:upgrade:migrate_users_to_customers'
+
+        attribute :confirm_no_pepper, :boolean, default: false
+        attribute :skip_invalid_rows, :boolean, default: false
+        attribute :source_user_table, :string
+        attribute :source_user_type, :string
+        attribute :batch_size, :integer, default: 1_000
+
+        passes_to_environment :confirm_no_pepper, as: 'CONFIRM_NO_PEPPER'
+        passes_to_environment :skip_invalid_rows, as: 'SKIP_INVALID_ROWS'
+        passes_to_environment :source_user_table, as: 'SOURCE_USER_TABLE'
+        passes_to_environment :source_user_type, as: 'SOURCE_USER_TYPE'
+        passes_to_environment :batch_size, as: 'BATCH_SIZE'
+      end
+    end
+  end
+end

data/app/maintenance_tasks/spree/maintenance_tasks/upgrade_step.rb

@@ -0,0 +1,44 @@
+module Spree
+  module MaintenanceTasks
+    # Runs one rake-backed step of an upgrade manifest, so a shell walk and a
+    # dashboard run leave the same audit record
+    # (docs/plans/6.0-maintenance-tasks.md).
+    #
+    # Every one-pass step names its rake task in the manifest and runs here, so
+    # the rake body stays the only implementation. A step gets a task class of
+    # its own only when it walks rows (progress, resume, dry run) or asks the
+    # operator for parameters.
+    class UpgradeStep < Spree::MaintenanceTask
+      no_collection
+
+      attribute :step_id, :string
+      validates :step_id, presence: true
+
+      validate :step_must_exist
+
+      def process
+        invoke_rake_task(manifest_step.fetch('task'))
+      end
+
+      # The manifest entry this run is executing, resolved across every
+      # manifest rather than a fixed one — the walker may be part way through a
+      # multi-release upgrade.
+      #
+      # @return [Hash, nil]
+      def manifest_step
+        @manifest_step ||= Spree::Upgrade.find_step(step_id)
+      end
+
+      private
+
+      # A step with a task class of its own runs as that class, so only a
+      # step that names a rake task can be run here.
+      def step_must_exist
+        return if step_id.blank?
+        return if manifest_step&.dig('task').present?
+
+        errors.add(:step_id, "no upgrade step with id #{step_id} runs a rake task")
+      end
+    end
+  end
+end

data/app/models/concerns/spree/translatable_resource.rb

@@ -5,6 +5,9 @@ module Spree
     included do
       extend Mobility
       default_scope { i18n }
+
+      # Before the translations are autosaved, so it has to run first.
+      after_update :discard_blank_new_translations, prepend: true
     end
 
     class_methods do
@@ -178,6 +181,22 @@ module Spree
 
     private
 
+    # Clearing a translation's last value deletes its row, and Mobility then
+    # rebuilds a blank one for that locale while it finalizes dirty tracking.
+    # Saved, that blank row is either junk or, where translation rows are soft
+    # deleted (stores), a duplicate of the deleted row.
+    def discard_blank_new_translations
+      return unless association(:translations).loaded?
+
+      columns = self.class.translatable_fields.map(&:to_s)
+      translations.each do |translation|
+        next unless translation.new_record?
+        next if columns.any? { |column| translation[column].present? }
+
+        translation.mark_for_destruction
+      end
+    end
+
     # @raise [ActiveRecord::RecordInvalid] if any locale isn't supported by the store
     def validate_translation_locales!(locales)
       supported = translatable_store&.supported_locales_list || []

data/app/models/spree/ability.rb

@@ -95,6 +95,15 @@ module Spree
         apply_staff_baseline
         grantable_keys_for(roles).each { |key| activate_permission(key) }
       end
+
+      withhold_maintenance_tasks unless Spree::Config.maintenance_tasks_dashboard_enabled
+    end
+
+    # Applied last so it overrides the full-access grant, and travels to the
+    # dashboard with the other rules, which then hides the page.
+    def withhold_maintenance_tasks
+      cannot :manage, [Spree::MaintenanceTaskRun, :maintenance_task]
+      @permission_keys -= %w[read_maintenance_tasks write_maintenance_tasks]
     end
 
     # Every key the roles ask for, bounded at activation by what each role's

data/app/models/spree/invitation.rb

@@ -116,6 +116,15 @@ module Spree
       publish_event('invitation.resent')
     end
 
+    # The staff account holding the invited address, if one exists. Matched
+    # the way the account's email uniqueness is, case-insensitively, so an
+    # address typed in another case still finds the one account it can belong
+    # to. Resolved by record rather than by comparing strings in Ruby, whose
+    # case folding is wider than the database's.
+    def invitee_account
+      Spree.admin_user_class.where('LOWER(email) = LOWER(?)', email).first
+    end
+
     private
 
     def publish_invitation_created_event
@@ -161,7 +170,7 @@ module Spree
       return if resource.blank?
 
       # Check role_users directly for better performance and to avoid potential source_type issues
-      user_to_check = invitee || Spree.admin_user_class.find_by(email: email)
+      user_to_check = invitee || invitee_account
       return if user_to_check.blank?
 
       if resource.role_users.exists?(user: user_to_check)
@@ -172,7 +181,7 @@ module Spree
     def set_invitee_from_email
       return if invitee.present?
 
-      self.invitee = Spree.admin_user_class.find_by(email: email)
+      self.invitee = invitee_account
     end
   end
 end

data/app/models/spree/maintenance_task.rb

@@ -0,0 +1,221 @@
+module Spree
+  # Base class for the data work an upgrade runs: one step of an upgrade
+  # manifest (docs/plans/6.0-maintenance-tasks.md).
+  #
+  # A task walks a stable-ordered collection and processes one record at a
+  # time. The runner (Spree::MaintenanceTasks::RunJob) supplies batching,
+  # checkpointing, cancelling and the audit row, so a task body says
+  # only what it does.
+  #
+  #   class Spree::MaintenanceTasks::Upgrade::BackfillOrderMarkets < Spree::MaintenanceTask
+  #     supports_dry_run
+  #
+  #     def collection
+  #       Spree::Order.where(market_id: nil).order(:id)
+  #     end
+  #
+  #     def process(order)
+  #       return tally(:would_update) if dry_run?
+  #
+  #       order.update_columns(market_id: order.store.default_market.id)
+  #       tally(:updated)
+  #     end
+  #   end
+  #
+  # A manifest step names its task class, which registers it in
+  # `Spree.maintenance_tasks`; nothing else is runnable.
+  class MaintenanceTask
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    extend Spree::ApiTyped
+
+    # A rake body that stopped itself with `abort`.
+    class RakeTaskAborted < StandardError; end
+
+    # Two threads of one worker must not both find a task undefined and both
+    # load its file — the second load would make the task run twice.
+    RAKE_LOAD_LOCK = Mutex.new
+
+    DEFAULT_BATCH_SIZE = 100
+
+    # How long one execution may run before the runner checkpoints and
+    # re-enqueues itself, so a long step cannot hold a worker indefinitely.
+    MAX_RUN_TIME = 5.minutes
+
+    class_attribute :dry_run_supported, instance_writer: false, default: false
+    class_attribute :collection_kind, instance_writer: false, default: :relation
+    class_attribute :batch_size, instance_writer: false, default: DEFAULT_BATCH_SIZE
+
+    attr_accessor :run
+
+    class << self
+      # Declares that `process` honors `dry_run?`. The runner never fakes a
+      # dry run by rolling a transaction back, which would silently lie about
+      # external calls, enqueued jobs and cache writes.
+      def supports_dry_run
+        self.dry_run_supported = true
+      end
+
+      # The task performs a single operation instead of iterating; `process`
+      # is called once with no argument.
+      def no_collection
+        self.collection_kind = :none
+      end
+
+      def collection_batch_size(size)
+        self.batch_size = size
+      end
+
+      # @return [Array<Class>] registered task classes, sorted by name
+      def registered_classes
+        Spree.maintenance_tasks.filter_map do |entry|
+          entry.is_a?(Class) ? entry : entry.to_s.safe_constantize
+        end.uniq.sort_by(&:name)
+      end
+
+      # @param name [String] a task class name
+      # @return [Class, nil] nil when the name is not registered — an
+      #   unregistered task is never runnable, so the runner and the API can
+      #   treat nil as "no such task" without a second check
+      def find_registered(name)
+        return nil if name.blank?
+
+        registered_classes.find { |klass| klass.name == name.to_s }
+      end
+
+      # A task class name as the API shows it. A task that is no longer
+      # registered is shortened the same way rather than loaded by name.
+      #
+      # @param class_name [String]
+      # @return [String]
+      def api_type_for(class_name)
+        find_registered(class_name)&.api_type || class_name.to_s.demodulize.underscore
+      end
+
+      # The registered task an API caller names. Matches the short name only,
+      # so a Ruby class name arriving over the API is an unknown task.
+      #
+      # @param api_type [String] e.g. "capture_methods"
+      # @return [Class, nil]
+      def find_by_api_type(api_type)
+        Spree::ApiTyped.find(Spree.maintenance_tasks, api_type)
+      end
+    end
+
+    # The records to walk, ordered by primary key — the cursor is the last id
+    # processed, so any other order would resume in the wrong place.
+    #
+    # @return [ActiveRecord::Relation]
+    def collection
+      raise NotImplementedError, "#{self.class.name} must implement #collection or declare `no_collection`"
+    end
+
+    # @param item [Object] one record from the collection; omitted for
+    #   `no_collection` tasks
+    def process(item = nil)
+      raise NotImplementedError, "#{self.class.name} must implement #process"
+    end
+
+    # Total records, for the progress bar. Return nil when counting is more
+    # expensive than the work itself — the run then reports ticks only.
+    #
+    # @return [Integer, nil]
+    def count
+      collection.count unless no_collection?
+    end
+
+    def no_collection?
+      self.class.collection_kind == :none
+    end
+
+    def dry_run?
+      run&.dry_run? || false
+    end
+
+    # Records a counter shown on the run page: what was updated, skipped, or
+    # would have changed in a dry run.
+    def tally(key, by = 1)
+      @tallies ||= Hash.new(0)
+      @tallies[key.to_s] += by
+    end
+
+    def tallies
+      @tallies ||= Hash.new(0)
+    end
+
+    # Runs an engine rake task as part of this task.
+    #
+    # Rake bodies stop themselves with `abort`, which raises SystemExit — not
+    # an error the runner records. Left alone it would end the whole process
+    # from the command line and, in a worker, leave the run marked running
+    # with nothing to finish it.
+    #
+    # @param task_name [String]
+    # @raise [RakeTaskAborted] carrying the body's own message
+    def invoke_rake_task(task_name)
+      load_engine_rake_tasks(task_name)
+
+      task = ::Rake::Task[task_name]
+      task.reenable
+      task.invoke
+    rescue SystemExit => e
+      raise RakeTaskAborted, e.message
+    end
+
+    # Finds the file that defines a task by reading the files rather than
+    # loading them: loading a .rake file to discover whether it is the right
+    # one would append its blocks to every task it defines, which is the very
+    # duplication this avoids.
+    #
+    # Searches every engine and the host application, since a step may ship in
+    # an extension gem. When two files define the same task name, the one
+    # that also declares the task's namespaces wins.
+    #
+    # @return [String, nil]
+    def rake_file_defining(task_name)
+      *namespaces, leaf = task_name.split(':')
+      candidates = rake_files.select do |path|
+        File.read(path).match?(/^\s*(?:desc\s.*\n\s*)?task\s+:?["']?#{Regexp.escape(leaf)}["']?\b/)
+      end
+
+      candidates.find do |path|
+        source = File.read(path)
+        namespaces.all? { |name| source.match?(/namespace\s+:?["']?#{Regexp.escape(name)}["']?\b/) }
+      end || candidates.first
+    end
+
+    # Called once the last record has been processed, before the run is
+    # marked succeeded — for a summary tally of what the walk left alone.
+    def after_complete; end
+
+    private
+
+    # Rake tasks are defined by the Rakefile, which a web process never loads —
+    # a task fired from the dashboard has to load the engine's tasks itself.
+    #
+    # Loads the one file that defines the task, and only when it is not already
+    # defined. Both halves matter: re-loading a .rake file APPENDS its block to
+    # a task that already exists, so a second load makes that task run twice,
+    # and loading every file would do that to every task in the engine. The
+    # symptom is invisible until something counts what it did.
+    #
+    # @param task_name [String] the rake task about to be invoked
+    def load_engine_rake_tasks(task_name)
+      require 'rake'
+
+      RAKE_LOAD_LOCK.synchronize do
+        next if ::Rake::Task.task_defined?(task_name)
+
+        ::Rake::Task.define_task(:environment) unless ::Rake::Task.task_defined?(:environment)
+
+        path = rake_file_defining(task_name)
+        load(path) if path
+      end
+    end
+
+    def rake_files
+      roots = Rails.application.railties.grep(Rails::Engine).map(&:root) + [Rails.root]
+      roots.uniq.flat_map { |root| Dir.glob(File.join(root, 'lib/tasks/**/*.rake')).sort }
+    end
+  end
+end

data/app/models/spree/maintenance_task_run.rb

@@ -0,0 +1,78 @@
+module Spree
+  # One execution of a Spree::MaintenanceTask — the durable record of what was
+  # run, by whom, with which arguments, and how far it got
+  # (docs/plans/6.0-maintenance-tasks.md).
+  #
+  # The row is both the checkpoint and the audit trail. Its `cursor` is the
+  # authoritative resume point: Active Job serializes its own continuation
+  # into the job data, but that copy is lost whenever the job is dropped by
+  # the backend, so the runner writes both in the same checkpoint and always
+  # seeds from this column.
+  #
+  # Runs are installation-wide: an upgrade step converts every store's data,
+  # so a run belongs to no store.
+  class MaintenanceTaskRun < Spree.base_class
+    has_prefix_id :mtr
+
+    include Spree::HasStatus
+
+    publishes_lifecycle_events
+    publishes_events :started, :succeeded, :cancelled, :interrupted, :errored
+
+    # Terminal statuses end a run for good; a failed run is started again
+    # rather than resumed. `cancelling` is the operator's request, written by
+    # the Cancel service and observed by the runner at its next checkpoint —
+    # the runner alone moves a running run into `cancelled`, so a stopped
+    # worker can never leave a lie in the column.
+    has_status :enqueued, :running, :interrupted, :cancelling, :cancelled,
+               :succeeded, :errored,
+               default: :enqueued
+
+    ACTIVE_STATUSES = %w[enqueued running interrupted cancelling].freeze
+    INITIATED_VIA = %w[dashboard api cli].freeze
+
+    belongs_to :admin_user, class_name: Spree.admin_user_class.to_s, optional: true
+    belongs_to :api_key, class_name: 'Spree::ApiKey', optional: true
+
+    validates :task_name, presence: true
+    validates :initiated_via, presence: true, inclusion: { in: INITIATED_VIA }
+
+    scope :active, -> { where(status: ACTIVE_STATUSES) }
+
+    self.whitelisted_ransackable_attributes = %w[task_name status created_at]
+
+    # Filtered by the task's short name, which is what responses carry; the
+    # column holds its class name. A partial value (`task_name_cont=capture`)
+    # is camelized so a search still matches part of the stored name.
+    ransacker :task_name, formatter: ->(value) {
+      Spree::MaintenanceTask.find_by_api_type(value)&.name || value.to_s.camelize
+    } do |parent|
+      parent.table[:task_name]
+    end
+
+    # @return [Class, nil] the registered task class, or nil when the task has
+    #   been removed from the registry since the run was created
+    def task_class
+      Spree::MaintenanceTask.find_registered(task_name)
+    end
+
+    # The task's short name, as the API and the dashboard identify it.
+    #
+    # @return [String]
+    def task_api_type
+      Spree::MaintenanceTask.api_type_for(task_name)
+    end
+
+    def active?
+      ACTIVE_STATUSES.include?(status)
+    end
+
+    # Seconds of work. Time since the last checkpoint counts only while a
+    # worker holds the run — a queued run is not working.
+    def duration
+      return time_running unless status.in?(%w[running cancelling]) && started_at.present?
+
+      time_running + (Time.current - (updated_at || started_at))
+    end
+  end
+end

data/app/models/spree/order_routing/strategy/rules.rb

@@ -10,7 +10,7 @@ module Spree
       # See docs/plans/6.0-order-routing.md.
       class Rules < Base
         def for_allocation
-          locations = eligible_locations
+          locations = coordinator.candidate_stock_locations
           return [] if locations.empty?
 
           ordered = Spree::OrderRouting::Strategy::Reducer
@@ -18,9 +18,11 @@ module Spree
             .rank_all(locations)
           return [] if ordered.empty?
 
-          packages = build_packages(ordered)
-          packages = prioritize_packages(packages)
-          estimate_rates(packages)
+          # Packed in rank order through the Coordinator, so an order allocates
+          # under the same delivery profile and channel coverage as its cart,
+          # and the Prioritizer's first-package-wins-on-hand logic honors the
+          # routing decision between origins that can reach the destination.
+          coordinator.estimate_packages(coordinator.allocated_packages(ordered))
         end
 
         # Stock decrement / restock today happens via Spree::Fulfillment's state
@@ -39,50 +41,8 @@ module Spree
           order.channel.order_routing_rules.active.ordered
         end
 
-        def eligible_locations
-          order.store.stock_locations.active
-            .joins(:stock_levels)
-            .where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids })
-            .distinct
-            .to_a
-        end
-
-        def requested_variant_ids
-          inventory_units.map(&:variant_id).uniq
-        end
-
-        def inventory_units
-          @inventory_units ||= Spree::Stock::InventoryUnitBuilder.new(order).units
-        end
-
-        # Pack each ranked location independently. Packages are emitted in
-        # rank order so the Prioritizer's first-package-wins-on-hand logic
-        # honors the routing decision.
-        def build_packages(locations)
-          stock_levels = Spree::Stock::Packer.stock_levels_by_location(locations, requested_variant_ids)
-
-          locations.flat_map do |location|
-            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters, owner: order,
-                                     stock_levels: stock_levels.fetch(location.id, {})).packages
-          end
-        end
-
-        # Prioritizer's Adjuster distributes each inventory_unit across
-        # packages: the first package with on-hand stock fulfills the unit,
-        # and downstream packages have that unit removed. Packages whose
-        # items all get stripped are pruned. Rank only decides between origins
-        # that can reach the destination — the Prioritizer demotes the rest.
-        def prioritize_packages(packages)
-          Spree::Stock::Prioritizer.new(packages, estimator: estimator).prioritized_packages
-        end
-
-        def estimate_rates(packages)
-          packages.each { |pkg| pkg.delivery_rates = estimator.delivery_rates(pkg) }
-          packages
-        end
-
-        def estimator
-          @estimator ||= Spree::Stock::Estimator.new(order)
+        def coordinator
+          @coordinator ||= Spree::Stock::Coordinator.new(order)
         end
       end
     end

data/app/models/spree/seller_transfer.rb

@@ -89,6 +89,16 @@ module Spree
     # amount is negative, and sending one as a transfer pays the seller the
     # money it exists to take back.
     scope :awaiting_provider, -> { earnings.retryable.where(payout_id: nil) }
+    # Reversals still owing the provider a call: refused, or waiting for their
+    # earning to reach the provider first. Kept apart from `awaiting_provider`
+    # so a caller has to choose `reverse!` for these by name.
+    #
+    # A reversal of an earning nobody can account for waits with it: there is
+    # nothing to take back from until a person settles what happened.
+    scope :reversals_awaiting_provider, lambda {
+      reversals_only.retryable.where(payout_id: nil).
+        where.not(reversed_from_id: Spree::SellerTransfer.with_status('unresolved').select(:id))
+    }
     # Earned and confirmed, but not yet swept into a settlement — what the next
     # payout will pick up.
     scope :unsettled, -> { completed.where(payout_id: nil) }
@@ -138,6 +148,47 @@ module Spree
       [amount - reversals.sum(:amount).abs, 0].max
     end
 
+    # The provider that moved this row's money, not whichever one the store
+    # uses now. A marketplace that changes provider still has money sitting
+    # with the old one, and asking the new one to reverse a transfer it never
+    # made leaves the original standing.
+    #
+    # No silent fallback when that provider is no longer installed: handing
+    # the row to a different one would mark it done while the money stayed
+    # where it was. An operator has to know.
+    #
+    # @return [Spree::PayoutProvider::Base]
+    # @raise [Spree::Core::GatewayError] when the provider is not registered
+    def payout_provider_instance
+      configured = Spree::ApiTyped.registered_class(Spree.payout_providers, provider)
+      raise Spree::Core::GatewayError, "Payout provider #{provider} is not registered" if configured.nil?
+
+      configured.new
+    end
+
+    # The settlement a reversal of part of this earning records.
+    #
+    # A clawback has to settle where its earning settled. Payouts are swept by
+    # settlement currency, so a reversal left in the sale's currency would
+    # never join the batch that pays the earning it cancels — the seller would
+    # be paid in full for goods that came back.
+    #
+    # Prorated from this earning's settled figure rather than converted at
+    # today's rate, so the money comes back at the rate it went out at.
+    #
+    # @param part [BigDecimal] how much of this earning is reversed, positive
+    # @return [Hash] negative `settled_amount` and `settled_currency`
+    def reversal_settlement(part)
+      return {} if settled_amount.blank? || amount.zero?
+
+      share = settled_amount * (part / amount)
+
+      {
+        settled_amount: -Spree::Money::Rounding.quantize(share, Spree::Money::Rounding.precision(settlement_currency)),
+        settled_currency: settled_currency
+      }
+    end
+
     # @return [Boolean]
     def earning?
       kind == 'earning'