spree_core 5.6.1 → 6.0.0.beta1

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

@@ -0,0 +1,70 @@
+module Spree
+  module SellerPayouts
+    # Settles one seller, in every currency they are owed in.
+    #
+    # Its own job rather than a loop inside {SweepDueJob}, because settling a
+    # seller talks to a payment provider: a marketplace with a few thousand of
+    # them would otherwise hold one worker for the whole run, and one slow
+    # provider call would delay every seller queued behind it.
+    #
+    # Deliberately no retry beyond the base job's infrastructure errors: a
+    # sweep that half-ran has already claimed its transfers, and re-running is
+    # safe only because of that claim, not because the work is repeatable.
+    class SweepSellerJob < ::Spree::BaseJob
+      queue_as Spree.queues.payouts
+
+      # @param seller_id [Integer]
+      def perform(seller_id)
+        seller = Spree::Seller.find_by(id: seller_id)
+        return if seller.nil?
+        return if seller.resolved_payouts_schedule_interval == 'manual'
+
+        currencies_owed(seller).each do |currency|
+          next unless due?(seller, currency)
+
+          Spree.seller_payout_sweep_workflow.call(seller: seller, currency: currency)
+        end
+      end
+
+      private
+
+      # Whether enough time has passed since this seller was last settled in
+      # this currency. A seller who has never been paid is due as soon as they
+      # have earned anything — their first settlement should not wait a whole
+      # period.
+      #
+      # Asked per currency, because settlements are made per currency. Reading
+      # the seller's most recent payout across all of them would let an
+      # out-of-band settlement in one currency reset the clock for every other
+      # — a monthly seller paid early in dollars would have their euro balance
+      # skipped for another month.
+      def due?(seller, currency)
+        # Failed payouts are excluded: one releases its earnings back to the
+        # next sweep, so counting it as a settlement would block the very
+        # retry it exists to allow — for a whole interval, with the money
+        # sitting owed and unsent.
+        settled_at = seller.seller_payouts.where(currency: currency).
+                     where.not(status: 'failed').maximum(:created_at)
+        return true if settled_at.nil?
+
+        settled_at <= interval_ago(seller.resolved_payouts_schedule_interval)
+      end
+
+      def interval_ago(interval)
+        case interval
+        when 'daily' then 1.day.ago
+        when 'weekly' then 1.week.ago
+        when 'biweekly' then 2.weeks.ago
+        else 1.month.ago
+        end
+      end
+
+      # Only the currencies this seller actually has earnings waiting in — a
+      # marketplace trading in three currencies should not run three sweeps for
+      # a seller who sold in one.
+      def currencies_owed(seller)
+        seller.payable_currencies
+      end
+    end
+  end
+end

data/app/jobs/spree/seller_transfers/execute_pending_due_job.rb

@@ -0,0 +1,56 @@
+module Spree
+  module SellerTransfers
+    # Hands every seller holding an unconfirmed earning to a job of their own.
+    #
+    # The transfer level's counterpart to {Spree::SellerPayouts::SweepDueJob},
+    # and deliberately a separate schedule rather than something the settlement
+    # run does on its way past. The two answer different questions on different
+    # clocks: a settlement waits for the seller's own interval, which a
+    # marketplace measures in weeks, while an earning the provider refused is
+    # owed *now* and the refusal is usually a passing thing — a platform
+    # balance that has not settled, a rate limit, a charge not yet usable as a
+    # funding source. Run this hourly and that earning clears within the hour;
+    # tie it to the settlement run and it waits for the next one.
+    #
+    # Only sellers who actually have something outstanding are enqueued. The
+    # awaiting set is the exception rather than the rule, so on a healthy
+    # marketplace this fans out to nobody.
+    #
+    # Scheduled by the host app, like every other recurring job in core.
+    class ExecutePendingDueJob < ::Spree::BaseJob
+      queue_as Spree.queues.payouts
+
+      # How many jobs are handed to the adapter at a time, matching the
+      # settlement enumerator.
+      BATCH_SIZE = 1_000
+
+      def perform
+        # Store by store, so each seller is reached through the store that owns
+        # them and the provider question below is asked of the right one.
+        Spree::Store.find_each do |store|
+          sellers_awaiting_provider(store).in_batches(of: BATCH_SIZE) do |sellers|
+            ActiveJob.perform_all_later(sellers.ids.map { |id| ExecutePendingJob.new(id) })
+          end
+        end
+      end
+
+      private
+
+      # @param store [Spree::Store]
+      # @return [ActiveRecord::Relation<Spree::Seller>]
+      def sellers_awaiting_provider(store)
+        scope = store.sellers.approved.
+                where(id: Spree::SellerTransfer.for_store(store).awaiting_provider.select(:seller_id))
+
+        # A seller the provider will not accept yet keeps their earnings
+        # unconfirmed, and the job would return at once. Skipped rather than
+        # enqueued, because a marketplace's half-onboarded sellers are a
+        # standing population and this runs often — and nothing is lost by it:
+        # finishing onboarding runs the job for them directly.
+        return scope unless store.payout_provider_class.requires_payout_account?
+
+        scope.where.not(payouts_enabled_at: nil)
+      end
+    end
+  end
+end

data/app/jobs/spree/seller_transfers/execute_pending_job.rb

@@ -0,0 +1,52 @@
+module Spree
+  module SellerTransfers
+    # Asks the provider again about earnings it could not be asked about before.
+    #
+    # A seller who ships while their payout account is still being verified has
+    # earned all the same, so the ledger records the row and leaves it pending.
+    # So does a seller whose provider simply refused the call. Either way the
+    # money is owed, and no settlement will find it: a sweep collects confirmed
+    # earnings, and these are not confirmed.
+    #
+    # Two callers, for the two ways a row gets here. A seller becoming payable
+    # runs it at once, because that is the moment the answer changed. Everyone
+    # else is reached by {ExecutePendingDueJob} on a schedule — without it, a
+    # seller who was payable all along would never see a refused earning tried
+    # again, since nothing about them ever changes to prompt it.
+    #
+    # It takes the retryable rows — never sent, or refused outright. A transfer
+    # whose outcome the provider could not report is left alone: asking again
+    # is precisely how the same money moves twice, and only a person can say
+    # what actually happened.
+    class ExecutePendingJob < ::Spree::BaseJob
+      queue_as Spree.queues.payouts
+
+      # @param seller_id [Integer]
+      def perform(seller_id)
+        seller = Spree::Seller.find_by(id: seller_id)
+        return if seller.nil? || !seller.payouts_enabled?
+
+        provider = seller.store.payout_provider_instance
+
+        # Earnings only — see the scope. A reversal is retryable the same way
+        # when its own provider call is refused, but sending one through
+        # `transfer!` would pay the seller the amount it exists to take back:
+        # the row is negative and the amount sent is its absolute value.
+        seller.seller_transfers.awaiting_provider.find_each do |transfer|
+          provider.transfer!(transfer)
+        rescue Spree::Core::AmbiguousGatewayError => e
+          # The money may already have moved, so this row must not be offered
+          # again: left retryable, the next run would send it a second time,
+          # and an idempotency key stops that only while the provider still
+          # holds its record.
+          transfer.update!(status: 'unresolved')
+          Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+        rescue StandardError => e
+          # A refusal — the money did not move. One seller's stuck earning must
+          # not stop the rest, and the row stays retryable for the next run.
+          Rails.error.report(e, handled: true, context: { seller_transfer_id: transfer.id }, source: 'spree.core')
+        end
+      end
+    end
+  end
+end

data/app/jobs/spree/shipping_labels/store_file_job.rb

@@ -0,0 +1,17 @@
+module Spree
+  module ShippingLabels
+    # Retries fetching a purchased label's file when the fetch right after
+    # purchase failed — the carrier's hosted copy is usually there a moment
+    # later. Idempotent: an already-attached file is left alone.
+    class StoreFileJob < Spree::BaseJob
+      retry_on StandardError, wait: :polynomially_longer, attempts: 5
+
+      # @param shipping_label_id [Integer]
+      def perform(shipping_label_id)
+        shipping_label = Spree::ShippingLabel.find(shipping_label_id)
+        result = Spree.shipping_label_store_file_service.call(shipping_label: shipping_label)
+        raise result.error.to_s if result.failure?
+      end
+    end
+  end
+end

data/app/jobs/spree/stock_locations/stock_items/create_job.rb

@@ -1,11 +1,13 @@
 module Spree
   module StockLocations
     module StockItems
-      class CreateJob < Spree::BaseJob
-        queue_as Spree.queues.stock_location_stock_items
-
-        def perform(stock_location)
-          Spree::StockLocations::StockItems::Create.call(stock_location: stock_location)
+      # @deprecated Renamed to Spree::StockLocations::StockLevels::CreateJob 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 CreateJob < StockLevels::CreateJob
+        def perform(*args)
+          Spree::Deprecation.warn('Spree::StockLocations::StockItems::CreateJob is deprecated and will be removed in Spree 6.1. Use Spree::StockLocations::StockLevels::CreateJob instead.')
+          super
         end
       end
     end

data/app/jobs/spree/stock_locations/stock_levels/create_job.rb

@@ -0,0 +1,13 @@
+module Spree
+  module StockLocations
+    module StockLevels
+      class CreateJob < Spree::BaseJob
+        queue_as Spree.queues.stock_location_stock_levels
+
+        def perform(stock_location)
+          Spree::StockLocations::StockLevels::Create.call(stock_location: stock_location)
+        end
+      end
+    end
+  end
+end

data/app/jobs/spree/stock_reservations/expire_job.rb

@@ -4,7 +4,7 @@ module Spree
       queue_as Spree.queues.stock_reservations
 
       def perform
-        Spree::StockReservation.expired.in_batches(of: 1_000).delete_all
+        Spree::StockReservation.sweep_expired
       end
     end
   end

data/app/jobs/spree/tax_identifiers/validate_job.rb

@@ -0,0 +1,14 @@
+module Spree
+  module TaxIdentifiers
+    class ValidateJob < BaseJob
+      queue_as Spree.queues.tax_identifiers
+
+      def perform(tax_identifier_id)
+        tax_identifier = Spree::TaxIdentifier.find_by(id: tax_identifier_id)
+        return if tax_identifier.nil?
+
+        Spree::TaxIdentifiers::Validate.call(tax_identifier: tax_identifier)
+      end
+    end
+  end
+end

data/app/jobs/spree/variants/remove_line_item_job.rb

@@ -4,8 +4,36 @@ module Spree
       queue_as Spree.queues.variants
 
       def perform(line_item:)
-        Spree.cart_remove_line_item_service.call(order: line_item.order, line_item: line_item)
+        owner = line_item.owner
+        return if owner.nil?
+
+        # Carts and draft orders have different contracts: the cart side turns
+        # a vetoed removal into a warning and still succeeds, the order side
+        # fails outright. Routing an order-owned line through the cart
+        # workflow would apply cart semantics to an admin edit.
+        cart_owned = owner.is_a?(Spree::Cart)
+        workflow = (cart_owned ? Spree.cart_upsert_items_workflow : Spree.order_upsert_items_workflow).new
+
+        result = workflow.call(
+          **(cart_owned ? { cart: owner } : { order: owner }),
+          items: [{ variant_id: line_item.variant_id, quantity: 0 }]
+        )
+
+        # A cart-side veto surfaces as a warning rather than a failed result,
+        # so both have to be checked — otherwise a discontinued variant stays
+        # in the cart with nothing to show for it.
+        rejection = workflow.warnings.first
+        return if result.success? && rejection.nil?
+
+        Rails.error.report(
+          RemovalRejected.new(rejection&.message || result.error.to_s),
+          context: { line_item_id: line_item.id, variant_id: line_item.variant_id },
+          source: 'spree.variants.remove_line_item',
+          handled: true
+        )
       end
+
+      class RemovalRejected < StandardError; end
     end
   end
 end

data/app/mailers/spree/admin_user_mailer.rb

@@ -1,7 +1,7 @@
 module Spree
-  # Auth emails for admin users. Reached two ways: the legacy Rails admin's
-  # Devise flow (via Spree::AdminUserMethods::DeviseNotifications) and the Admin
-  # API's `admin_user.password_reset_requested` event (dashboard SPA).
+  # Auth emails for admin users. Reached via the Admin API's
+  # `admin_user.password_reset_requested` event (dashboard SPA), delivered by
+  # Spree::AdminUserEmailSubscriber.
   class AdminUserMailer < BaseMailer
     def password_reset_email(admin_user, token, store, redirect_url: nil)
       @user = admin_user
@@ -17,20 +17,6 @@ module Spree
       end
     end
 
-    def confirmation_email(admin_user, token, store)
-      @user = admin_user
-      @current_store = store
-      @confirmation_url = confirmation_url(token, store)
-
-      with_store_locale(store, preferred_locale(admin_user, store)) do
-        mail(
-          to: admin_user.email,
-          subject: "#{store.name} #{Spree.t('admin_user_mailer.confirmation_email.subject')}",
-          store_url: store.formatted_url
-        )
-      end
-    end
-
     private
 
     # Locale chain for admin auth emails:
@@ -47,25 +33,10 @@ module Spree
       locale.present? && I18n.available_locales.map(&:to_s).include?(locale.to_s)
     end
 
-    # The dashboard SPA passes a validated redirect URL (token appended as a
-    # query param); the legacy Devise flow links to its own edit-password route
-    # when the host app installed it.
+    # The dashboard SPA passes a validated redirect URL; the token is appended as
+    # a query param, falling back to the store URL.
     def password_reset_url(token, store, redirect_url)
-      return append_token(redirect_url, token) if redirect_url.present?
-
-      if spree.respond_to?(:edit_admin_user_password_url)
-        spree.edit_admin_user_password_url(reset_password_token: token, host: store.formatted_url)
-      else
-        append_token(store.formatted_url, token)
-      end
-    end
-
-    def confirmation_url(token, store)
-      if spree.respond_to?(:admin_user_confirmation_url)
-        spree.admin_user_confirmation_url(confirmation_token: token, host: store.formatted_url)
-      else
-        append_token(store.formatted_url, token)
-      end
+      append_token(redirect_url.presence || store.formatted_url, token)
     end
   end
 end

data/app/mailers/spree/base_mailer.rb

@@ -50,38 +50,19 @@ module Spree
     end
     helper_method :money
 
-    def frontend_available?
-      Spree::Core::Engine.frontend_available?
-    end
-    helper_method :frontend_available?
-
     def mail(headers = {}, &block)
       ensure_default_action_mailer_url_host(headers[:store_url])
-      return unless Spree::Config[:send_core_emails]
 
       if @_store_locale_active
         super
       else
         # Subclasses that call `mail` without wrapping their action in
-        # `with_store_locale` (e.g. Devise mailers, extensions) still get the
+        # `with_store_locale` (e.g. extension mailers) still get the
         # store default locale, as `mail` applied before Spree 5.6.
         with_store_locale(current_store) { super }
       end
     end
 
-    # @deprecated Each mailer action now wraps its body in {#with_store_locale},
-    #   which also activates the store's translation fallbacks and restores the
-    #   previous locale afterwards. This method mutates `I18n.locale` for the rest
-    #   of the thread without restoring it. Will be removed in Spree 6.0.
-    def set_email_locale
-      Spree::Deprecation.warn(
-        'Spree::BaseMailer#set_email_locale is deprecated and will be removed in Spree 6.0. ' \
-        'Wrap the mailer action body in `with_store_locale(store, locale) { ... }` instead.'
-      )
-      locale = @order&.locale.presence || @order&.store&.default_locale || current_store&.default_locale
-      I18n.locale = locale if locale.present?
-    end
-
     protected
 
     # The "<store> <subject> #<number>" subject line shared by customer-facing

data/app/mailers/spree/invitation_mailer.rb

@@ -1,6 +1,6 @@
 module Spree
   class InvitationMailer < BaseMailer
-    # invitation email, sending email to the invited to let them know they have been invited to join a store/account/vendor
+    # invitation email, sending email to the invited to let them know they have been invited to join a store/account/seller
     def invitation_email(invitation)
       @invitation = invitation
       # The shared header/footer and from/reply-to addresses read

data/app/mailers/spree/seller_user_mailer.rb

@@ -0,0 +1,47 @@
+module Spree
+  # Auth emails for seller panel users. Reached via the Seller API's
+  # `seller_user.password_reset_requested` event, delivered by
+  # Spree::SellerUserEmailSubscriber.
+  #
+  # Separate from AdminUserMailer even though both address the same user class:
+  # what differs is which panel the link opens, and sending a seller to the
+  # staff dashboard would land them on a form they cannot submit.
+  class SellerUserMailer < BaseMailer
+    def password_reset_email(seller_user, token, store, redirect_url: nil)
+      @user = seller_user
+      @current_store = store
+      @reset_url = password_reset_url(token, store, redirect_url)
+
+      with_store_locale(store, preferred_locale(seller_user, store)) do
+        mail(
+          to: seller_user.email,
+          subject: "#{store.name} #{Spree.t('seller_user_mailer.password_reset_email.subject')}",
+          store_url: store.formatted_url
+        )
+      end
+    end
+
+    private
+
+    # The seller's own panel language, then the store's admin locale, then nil —
+    # which lets with_store_locale fall back to the store's default.
+    def preferred_locale(seller_user, store)
+      [seller_user.try(:selected_locale), store&.preferred_admin_locale]
+        .find { |locale| available_locale?(locale) }
+    end
+
+    def available_locale?(locale)
+      locale.present? && I18n.available_locales.map(&:to_s).include?(locale.to_s)
+    end
+
+    # The panel passes a validated redirect URL when it has one. Without it the
+    # panel origin is resolved server-side rather than falling back to the store
+    # URL: a storefront link cannot reset a seller password, and the marketplace
+    # may never have added the panel to its allowed origins.
+    def password_reset_url(token, store, redirect_url)
+      target = redirect_url.presence || "#{Spree::Sellers::PanelUrl.call(store: store)}/reset-password"
+
+      append_token(target, token)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Spree
+  # Failed-login tracking and temporary account lockout, shared by the default
+  # auth models (Customer, AdminUser). Thresholds are configuration-driven via
+  # +Spree::Config[:max_failed_login_attempts]+ and +Spree::Config[:lockout_duration]+
+  # (seconds). Enforcement lives in the authentication strategy — including this
+  # concern opts a model in, but nothing locks until the login flow records attempts.
+  module AccountLockout
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :failed_attempts, :integer, default: 0
+    end
+
+    # @return [Boolean] whether the account is currently within its lockout window
+    def locked?
+      locked_at.present? && locked_at > Spree::Config[:lockout_duration].seconds.ago
+    end
+
+    # Records a failed login attempt, locking the account once the configured
+    # threshold is reached. Serialized with a row lock so concurrent failures
+    # read the latest counter — otherwise a stale in-memory value could cross the
+    # threshold without ever persisting +locked_at+.
+    # @return [void]
+    def record_failed_attempt!
+      with_lock do
+        increment(:failed_attempts)
+        self.locked_at = Time.current if failed_attempts >= Spree::Config[:max_failed_login_attempts]
+        save!
+      end
+    end
+
+    # Clears the failed-attempt counter and any lockout. Call on successful login.
+    # @return [void]
+    def reset_failed_attempts!
+      with_lock { update!(failed_attempts: 0, locked_at: nil) }
+    end
+  end
+end

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

@@ -7,12 +7,7 @@ module Spree
     include Spree::RansackableAttributes
 
     included do
-      # Wins over Devise's implementation regardless of module include order, so
-      # host apps that add `devise ...` after this concern still send admin auth
-      # emails through Spree's mailer.
-      prepend Spree::AdminUserMethods::DeviseNotifications
-
-      has_prefix_id :admin
+      has_prefix_id :adm
 
       has_person_name
 
@@ -21,10 +16,11 @@ module Spree
       # Token auto-invalidates when password changes (salt changes)
       # Expiration is configurable via Spree::Config.admin_password_reset_expires_in (in minutes)
       generates_token_for :password_reset, expires_in: Spree::Config.admin_password_reset_expires_in.minutes do
-        # `try` rather than `&.`: models without a password_salt method or
-        # column at all (modern Devise) must fall through to encrypted_password
-        # — a bare call would raise NameError before the fallback.
-        try(:password_salt)&.last(10) || encrypted_password&.last(10)
+        # `try` rather than `&.`: a model that lacks the method/column entirely
+        # must fall through rather than raise NameError. `password_salt` covers
+        # has_secure_password (which derives it from password_digest);
+        # `encrypted_password` covers a legacy bcrypt column on a custom model.
+        try(:password_salt)&.last(10) || try(:encrypted_password)&.last(10)
       end
 
       def self.find_by_password_reset_token(token)
@@ -43,10 +39,12 @@ module Spree
       has_many :created_gift_cards, class_name: 'Spree::GiftCard', foreign_key: :created_by_id
       has_many :created_gift_card_batches, class_name: 'Spree::GiftCardBatch', foreign_key: :created_by_id
       has_many :refunded_refunds, class_name: 'Spree::Refund', foreign_key: :refunder_id
-      has_many :performed_reimbursements, class_name: 'Spree::Reimbursement', foreign_key: :performed_by_id
+      has_many :created_returns, class_name: 'Spree::Return', foreign_key: :created_by_id
+      has_many :created_exchanges, class_name: 'Spree::Exchange', foreign_key: :created_by_id
+      has_many :created_claims, class_name: 'Spree::Claim', foreign_key: :created_by_id
       has_many :created_store_credits, class_name: 'Spree::StoreCredit', foreign_key: :created_by_id
-      has_many :reports, class_name: 'Spree::Report', foreign_key: :user_id
       has_many :exports, class_name: 'Spree::Export', foreign_key: :user_id
+      has_many :saved_reports, class_name: 'Spree::SavedReport', foreign_key: :user_id
 
       # Callbacks
       after_destroy :nullify_approver_id_in_approved_orders
@@ -95,32 +93,14 @@ module Spree
       created_gift_cards.update_all(created_by_id: nil, updated_at: Time.current)
       created_gift_card_batches.update_all(created_by_id: nil, updated_at: Time.current)
       refunded_refunds.update_all(refunder_id: nil, updated_at: Time.current)
-      performed_reimbursements.update_all(performed_by_id: nil, updated_at: Time.current)
+      created_returns.update_all(created_by_id: nil, updated_at: Time.current)
+      created_exchanges.update_all(created_by_id: nil, updated_at: Time.current)
+      created_claims.update_all(created_by_id: nil, updated_at: Time.current)
       created_store_credits.update_all(created_by_id: nil, updated_at: Time.current)
+      saved_reports.update_all(user_id: nil, updated_at: Time.current)
 
       # resources to destroy
-      reports.destroy_all
       exports.destroy_all
     end
-
-    # Routes Devise's auth notifications through Spree's own mailer so admin
-    # password reset and account confirmation emails carry the store design and
-    # locale instead of Devise's built-in templates. Other notification kinds
-    # (e.g. unlock instructions) fall through to Devise.
-    module DeviseNotifications
-      def send_devise_notification(notification, *args)
-        token = args.first
-        store = Spree::Current.store || Spree::Store.default
-
-        case notification
-        when :reset_password_instructions
-          Spree::AdminUserMailer.password_reset_email(self, token, store).deliver_later
-        when :confirmation_instructions
-          Spree::AdminUserMailer.confirmation_email(self, token, store).deliver_later
-        else
-          super
-        end
-      end
-    end
   end
 end

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

@@ -14,26 +14,20 @@ module Spree
         spree_calculators.send model_name_without_spree_namespace
       end
 
+      # The public API shorthand (`'flat_rate'`), never the Ruby class name.
       def calculator_type
-        calculator.class.to_s if calculator
+        calculator.class.api_type if calculator
       end
 
-      # Accepts a fully-qualified class name (`'Spree::Calculator::FlatRate'`)
-      # or the public API shorthand (`'flat_rate'`). Shorthand is resolved
-      # against this parent's registered calculators so a CreateAdjustment
-      # can't be assigned a shipping-only calculator just by knowing its
-      # name.
+      # Takes the public API shorthand (`'flat_rate'`), resolved against this
+      # parent's registered calculators — so a CreateAdjustment can't be
+      # assigned a shipping-only calculator just by knowing its name, and
+      # nothing user-supplied ever reaches `constantize`.
       def calculator_type=(calculator_type)
         return if calculator_type.blank?
 
-        str = calculator_type.to_s
-        klass =
-          if str.include?('::')
-            str.safe_constantize
-          else
-            registry = self.class.respond_to?(:calculators) ? self.class.calculators : []
-            registry.find { |k| k.api_type == str }
-          end
+        registry = self.class.respond_to?(:calculators) ? self.class.calculators : []
+        klass = registry.find { |k| k.api_type == calculator_type.to_s }
         self.calculator = klass.new if klass && !calculator.instance_of?(klass)
       end
 

data/app/models/concerns/spree/calculator/currency_amounts.rb

@@ -0,0 +1,43 @@
+module Spree
+  class Calculator < Spree.base_class
+    # Per-currency amounts for amount-based delivery calculators, mirroring
+    # how product prices work: one explicit amount per currency, no FX. The
+    # `amounts` hash ({ "USD" => 5.0, "EUR" => 4.0 }) quotes the cart's
+    # currency directly, so one method serves every currency it has an
+    # amount for — no more method-per-currency duplication.
+    #
+    # The 5.x single `amount` + `currency` preferences keep working as the
+    # fallback for their own currency, so upgraded stores quote unchanged
+    # until they fill in the hash.
+    module CurrencyAmounts
+      extend ActiveSupport::Concern
+
+      included do
+        preference :amounts, :hash, default: {}
+      end
+
+      # The amount this calculator quotes for a currency: the per-currency
+      # hash first, then the legacy single amount when its currency matches.
+      #
+      # @param currency [String]
+      # @return [BigDecimal, nil] nil when the currency has no amount — the
+      #   method is not offered for that cart
+      def amount_for(currency)
+        explicit = preferred_amounts&.transform_keys { |key| key.to_s.upcase }&.dig(currency.to_s.upcase)
+        return BigDecimal(explicit.to_s) if explicit.present?
+
+        legacy_currency = respond_to?(:preferred_currency) ? preferred_currency : nil
+        return preferred_amount if legacy_currency.blank? || legacy_currency.casecmp(currency.to_s).zero?
+
+        nil
+      end
+
+      # Whether this calculator can quote the given currency at all — the
+      # Estimator's method filter, replacing the old exact-match on the
+      # single currency preference.
+      def supports_currency?(currency)
+        amount_for(currency).present?
+      end
+    end
+  end
+end