spree_core 6.0.0.beta4 → 6.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed64967de26da96d2727829b206b0b6b46e36dd52a6a9b54f51f61d571de5415
-  data.tar.gz: 91298d5cadb8ea19904b9b4b3704075b06106fa68f42ac34436e6da0df00b85b
+  metadata.gz: 2b2f1ca5c6b7f00a17f11bd7c7f34eac185b07acfbc58ee5cb177b0ddc804f05
+  data.tar.gz: 521bffafb8eb7ea97c31c9e71206bb65ee5f46c453516a8365e9875b965780f7
 SHA512:
-  metadata.gz: 43e098f9562a1ad458455bb83c0bafa9f0eab01836084bb6053bd56459ef2d67c903eff8f5b3faccd052dff9a220e2c6b6edb1b90e489539e40ee93a8fa8d1e7
-  data.tar.gz: f544e4360b2bcecec6b2e8694a596c4136f9842908cc86a58d4914d8150561ba413ce2e2d4701205e8c799d11236333c5ec6611e35d187e26da039b79de86298
+  metadata.gz: 49c46ec423a04b65729afe6ed2f560f49927947f615551fdf35ff5b4edeab841e689a778321c1311310125237cde58007bd0ecd56b6554b0fec2756833da8fde
+  data.tar.gz: a8cc2d507005043e8e92e01398321e70d7af4cf687c4d9dd5bb46064c52743a42026eb5131aca5ed72735ae6389cd31423199041e13754a3a0d0a5edc3550c85

data/README.md

@@ -28,8 +28,8 @@ All models are namespaced under `Spree::` and include:
 - `Spree::Product` / `Spree::Variant` - Product catalog
 - `Spree::Order` / `Spree::LineItem` - Order management
 - `Spree::Payment` / `Spree::PaymentMethod` - Payment processing
-- `Spree::Shipment` / `Spree::ShippingMethod` - Shipping and fulfillment
-- `Spree::Taxon` / `Spree::Taxonomy` - Product categorization
+- `Spree::Fulfillment` / `Spree::DeliveryMethod` - Shipping and fulfillment
+- `Spree::Category` / `Spree::Collection` - Product categorization
 - `Spree::Store` - Multi-store support
 - `Spree::Promotion` - Promotions and discounts
 - `Spree::GiftCard` - Gift card functionality
@@ -40,8 +40,8 @@ Services follow a consistent interface pattern and are located in `app/services/
 
 ```ruby
 # Add item to cart
-Spree.cart_add_item_service.call(
-  order: order,
+Spree.cart_add_item_workflow.call(
+  cart: cart,
   variant: variant,
   quantity: 1
 )
@@ -76,7 +76,7 @@ Swap out default implementations with custom services:
 
 ```ruby
 # config/initializers/spree.rb
-Spree::Dependencies.cart_add_item_service = 'MyCustom::CartAddItem'
+Spree::Dependencies.cart_add_item_workflow = 'MyCustom::CartAddItem'
 ```
 
 ## Configuration

data/app/helpers/spree/images_helper.rb

@@ -1,30 +1,5 @@
 module Spree
   module ImagesHelper
-    # render an image tag with a spree image variant
-    # it also automatically scales the width and height by 2x to look great on retina screens
-    #
-    # @param image [ActiveStorage::Attachment] the image to render
-    # @param options [Hash] options for the image tag
-    # @option options [Integer] :width the width of the image
-    # @option options [Integer] :height the height of the image
-    # @option options [Symbol] :variant use a preprocessed named variant (e.g., :mini, :small, :medium, :large, :xlarge)
-    def spree_image_tag(image, options = {})
-      return unless image
-      return unless image.variable?
-      return if image.respond_to?(:attached?) && !image.attached?
-
-      url_options = if options[:variant].present?
-                      { variant: options[:variant] }
-                    else
-                      { width: options[:width], height: options[:height], format: options[:format] }
-                    end
-
-      image_tag(
-        spree_image_url(image, url_options),
-        options.except(:variant, :format)
-      )
-    end
-
     def spree_image_url(image, options = {})
       return unless image
       return unless image.variable?
@@ -56,38 +31,6 @@ module Spree
       end
     end
 
-    def spree_asset_aspect_ratio(attachment)
-      return unless attachment.present?
-      return unless attachment.analyzed?
-
-      metadata = attachment.metadata
-      aspect_ratio = metadata['aspect_ratio'].presence
-
-      return aspect_ratio if aspect_ratio
-
-      width = metadata['width']&.to_f
-      return unless width
-
-      height = metadata['height']&.to_f
-      return unless height
-      return if height.zero?
-
-      w = width.to_f
-      h = height.to_f
-
-      # Always return width / height, flipping if needed
-      ratio = if h > w
-                h / w
-              elsif h < w
-                w / h
-              else
-                # h == w, square image
-                1.0
-              end
-
-      ratio.round(3)
-    end
-
     # convert images to webp with some sane optimization defaults
     # it also automatically scales the width and height by 2x to look great on retina screens
     #

data/app/jobs/spree/base_job.rb

@@ -19,5 +19,26 @@ module Spree
     retry_on ActiveRecord::RecordNotFound, wait: 2.seconds, attempts: 3
 
     discard_on ActiveJob::DeserializationError
+
+    private
+
+    # Runs the block once per store owning a record in +records+, inside that
+    # store and with +records+ narrowed to it.
+    #
+    # For installation-wide sweeps. A job has no store of its own, so the work
+    # done for a record — its emails, events, store settings — would otherwise
+    # run in the default store whichever store the record belongs to.
+    # Narrowing the relation keeps each query store-scoped once the store
+    # context arms Spree::StoreScopeGuard.
+    #
+    # @param records [ActiveRecord::Relation] records of a store-owned model
+    # @yieldparam store_records [ActiveRecord::Relation] +records+ of one store
+    # @return [void]
+    def each_store_of(records)
+      # Deleted stores too — their records were swept before this was per store.
+      Spree::Store.with_deleted.where(id: records.select(:store_id)).find_each do |store|
+        Spree::Current.with_store(store) { yield records.where(store_id: store.id) }
+      end
+    end
   end
 end

data/app/jobs/spree/carts/reap_expired_job.rb

@@ -20,7 +20,7 @@ module Spree
       def base_scope
         Spree::Cart.incomplete.
           where.not(id: Spree::PaymentSession.where(status: %w[pending processing]).select(:cart_id)).
-          where.not(id: Spree::Payment.where.not(state: Spree::Payment::INVALID_STATES).where.not(cart_id: nil).select(:cart_id))
+          where.not(id: Spree::Payment.valid.where.not(cart_id: nil).select(:cart_id))
       end
 
       def empty_scope
@@ -36,7 +36,7 @@ module Spree
       end
 
       def reap(scope)
-        scope.in_batches(of: 200, &:destroy_all)
+        each_store_of(scope) { |carts| carts.in_batches(of: 200, &:destroy_all) }
       end
     end
   end

data/app/jobs/spree/collections/regenerate_time_based_job.rb

@@ -9,9 +9,12 @@ module Spree
       def perform
         types = Rails.application.config.spree.time_based_collection_rules.map(&:to_s)
 
-        Spree::Collection.automatic.
-          where(id: Spree::CollectionRule.where(type: types).select(:collection_id)).
-          find_each { |collection| Spree::Collections::RegenerateProducts.call(collection: collection) }
+        time_based = Spree::Collection.automatic.
+                     where(id: Spree::CollectionRule.where(type: types).select(:collection_id))
+
+        each_store_of(time_based) do |collections|
+          collections.find_each { |collection| Spree::Collections::RegenerateProducts.call(collection: collection) }
+        end
       end
     end
   end

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

@@ -10,11 +10,13 @@ module Spree
       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|
+        stale_drafts = Spree::Order.drafts.
+                       where.not(cart_id: nil).
+                       where(completed_at: nil).
+                       where(created_at: ...STALE_AFTER.ago)
+
+        each_store_of(stale_drafts) do |orders|
+          orders.find_each do |order|
             cart = order.cart
             next if cart.nil? || cart.completed?
 
@@ -23,6 +25,7 @@ module Spree
           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/cancel_unused_sessions_job.rb

@@ -0,0 +1,61 @@
+module Spree
+  module Payments
+    # Cancels the payment sessions an order was placed without, so none of
+    # them can still be paid. The cursor is the last session handled. A
+    # refusal is handled: asking again cannot change it. A session the
+    # provider could not be reached about is not, so a later run asks
+    # again. The buyer already holds that session's client secret.
+    class CancelUnusedSessionsJob < Spree::BaseJob
+      include ActiveJob::Continuable
+
+      # Continuable resumes only after a cursor is saved. The first session
+      # has none, so an outage there would drop the job and leave the intent
+      # payable. A refusal never reaches this retry: #cancel reports it.
+      retry_on StandardError, wait: :polynomially_longer, attempts: 5
+      # Must come after `retry_on StandardError` so DeserializationError lands in discard.
+      discard_on ActiveJob::DeserializationError
+
+      # Placement can run inside a webhook's transaction; enqueued before it
+      # commits, the job could read the order before its sessions moved onto it.
+      self.enqueue_after_transaction_commit = true
+
+      def perform(order_id)
+        # Outside the step on purpose: runs on every execution, resumes included.
+        @order = Spree::Order.find_by(id: order_id)
+        return if @order.nil?
+
+        Spree::Current.store = @order.store
+
+        step :cancel_sessions
+      end
+
+      private
+
+      def cancel_sessions(step)
+        payment_sessions = @order.payment_sessions.unused.order(:id)
+        payment_sessions = payment_sessions.where(Spree::PaymentSession.arel_table[:id].gt(step.cursor)) if step.cursor
+
+        payment_sessions.each do |payment_session|
+          cancel(payment_session)
+          step.set!(payment_session.id)
+        end
+      end
+
+      def cancel(payment_session)
+        payment_session.payment_method.cancel_payment_session(payment_session: payment_session)
+      rescue Spree::Core::GatewayError => error
+        # An unknown outcome is not a refusal. Cancel can be asked again;
+        # counting it handled leaves the intent payable.
+        raise if error.is_a?(Spree::Core::AmbiguousGatewayError)
+
+        # A refusal means the session was paid after all; retrying
+        # cannot change that, and the order is placed either way.
+        Rails.error.report(
+          error,
+          context: { payment_session_id: payment_session.id, order_id: @order.id },
+          source: 'spree.payments.cancel_unused_sessions'
+        )
+      end
+    end
+  end
+end

data/app/jobs/spree/search_provider/index_job.rb

@@ -10,6 +10,10 @@ module Spree
       # (ActiveJob handler lookup is reverse-declaration-order).
       discard_on ActiveJob::DeserializationError
 
+      # Bulk writers enqueue this inside their transaction; run before it
+      # commits, the job would index the product's previous prices.
+      self.enqueue_after_transaction_commit = true
+
       # @param resource_class [String] e.g. 'Spree::Product'
       # @param resource_id [String] always pass as string for UUID support
       # @param store_id [String] always pass as string for UUID support

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

@@ -17,6 +17,8 @@ module Spree
       def perform(seller_id)
         seller = Spree::Seller.find_by(id: seller_id)
         return if seller.nil?
+
+        Spree::Current.store = seller.store
         return if seller.resolved_payouts_schedule_interval == 'manual'
 
         currencies_owed(seller).each do |currency|

data/app/jobs/spree/uploads/purge_unattached_job.rb

@@ -0,0 +1,49 @@
+module Spree
+  module Uploads
+    # Deletes uploaded files that were never attached to anything, once they
+    # are older than `Spree::Config.unattached_upload_retention_days`.
+    #
+    # Rails deletes nothing on its own, so an upload abandoned halfway (a
+    # closed tab, a failed form) would otherwise stay in storage forever. The
+    # retention outlasts an upload reference, which expires after a day, so no
+    # file a client can still attach is deleted.
+    #
+    # Scheduled daily by the host app (`spree/spree-starter`'s recurring.yml
+    # ships the entry). Continuable: the cursor is the last file handled, so a
+    # deploy mid-run resumes rather than starting over.
+    class PurgeUnattachedJob < Spree::BaseJob
+      include ActiveJob::Continuable
+
+      def perform
+        step :purge
+      end
+
+      private
+
+      def purge(step)
+        # Only files that belong to a store: a host app may keep blobs of its
+        # own outside attachments, and those are not Spree's to delete.
+        blobs = ActiveStorage::Blob.unattached.where.not(store_id: nil).
+                where(created_at: ...Spree::Config.unattached_upload_retention_days.days.ago)
+        blobs = blobs.where(ActiveStorage::Blob.arel_table[:id].gt(step.cursor)) if step.cursor
+
+        blobs.find_each(order: :asc) do |blob|
+          purge_blob(blob)
+          step.set!(blob.id)
+        end
+      end
+
+      # A file attached between the query and the purge is kept. The check
+      # covers databases that do not enforce the attachments foreign key; the
+      # rescue covers the moment between the check and the delete on those
+      # that do.
+      def purge_blob(blob)
+        return if blob.attachments.exists?
+
+        blob.purge
+      rescue ActiveRecord::InvalidForeignKey
+        nil
+      end
+    end
+  end
+end

data/app/mailers/spree/admin_user_mailer.rb

@@ -8,31 +8,16 @@ module Spree
       @current_store = store
       @reset_url = password_reset_url(token, store, redirect_url)
 
-      with_store_locale(store, preferred_locale(admin_user, store)) do
-        mail(
-          to: admin_user.email,
-          subject: "#{store.name} #{Spree.t('admin_user_mailer.password_reset_email.subject')}",
-          store_url: store.formatted_url
+      with_store_locale(store, staff_locale(admin_user, store)) do
+        mail_template(
+          { user: email_data(admin_user, Spree::Emails::UserSerializer), reset_url: @reset_url },
+          to: admin_user.email, store_url: store.formatted_url
         )
       end
     end
 
     private
 
-    # Locale chain for admin auth emails:
-    # the admin's own dashboard language (persisted by the profile/language
-    # switcher via `PATCH /api/v3/admin/me`) → the store's configured admin
-    # locale → nil, which lets with_store_locale fall back to the store's
-    # default (storefront) locale. Blank or unavailable values fall through.
-    def preferred_locale(admin_user, store)
-      [admin_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 dashboard SPA passes a validated redirect URL; the token is appended as
     # a query param, falling back to the dashboard's own reset page.
     def password_reset_url(token, store, redirect_url)

data/app/mailers/spree/base_mailer.rb

@@ -41,7 +41,7 @@ module Spree
     end
 
     def reply_to_address
-      current_store.customer_support_email.presence || current_store.mail_from_address
+      current_store.support_email_address
     end
 
     def money(amount, currency = nil)
@@ -50,25 +50,73 @@ module Spree
     end
     helper_method :money
 
+    # Wraps HTML a mailer rendered from its own ERB views in the Liquid email
+    # layout, so every email a Spree mailer sends carries the store's logo,
+    # header and footer. Called by `layouts/spree/base_mailer.html.erb`.
+    #
+    # @param html [String] the rendered view
+    # @return [ActiveSupport::SafeBuffer]
+    def render_in_email_layout(html)
+      email_renderer.wrap(html, subject: message.subject).html_safe
+    end
+    helper_method :render_in_email_layout
+
     def mail(headers = {}, &block)
       ensure_default_action_mailer_url_host(headers[:store_url])
+      # Mailers that don't wrap their action in `with_store_locale` still get
+      # the store's default locale, as `mail` applied before Spree 5.6.
+      in_store_locale { super }
+    end
+
+    protected
 
-      if @_store_locale_active
-        super
-      else
-        # Subclasses that call `mail` without wrapping their action in
-        # `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 }
+    # Locale for an email to a staff member or seller: their own dashboard
+    # language, then the store's admin locale, then nil — which lets
+    # with_store_locale fall back to the store's default. Blank values, and
+    # languages Spree ships no translations for, fall through.
+    def staff_locale(user, store)
+      shipped = Spree.available_locales.map(&:to_s)
+      [user.try(:selected_locale), store&.preferred_admin_locale].find { |locale| shipped.include?(locale.to_s) }
+    end
+
+    # Renders the current action's email from its Liquid template and builds
+    # the message. The template's front matter supplies the subject, and the
+    # plain-text part is generated from the HTML unless a `.text.liquid` sits
+    # next to the template.
+    #
+    # @param assigns [Hash] the template's variables — serializer output and
+    #   mailer-built values such as token-carrying URLs, never models
+    # @param template [String] the template key, defaults to the action's view path
+    # @param headers [Hash] mail headers (`to:`, `store_url:`, ...)
+    # @return [Mail::Message]
+    def mail_template(assigns = {}, template: "#{mailer_name}/#{action_name}", **headers)
+      in_store_locale do
+        email = render_email_template(template, assigns)
+
+        mail(headers.merge(subject: email.subject)) do |format|
+          format.text { render plain: email.text, layout: false }
+          format.html { render html: email.html.html_safe, layout: false }
+        end
       end
     end
 
-    protected
+    # The currency an email's amounts are in: its order's, else the store's.
+    #
+    # @return [String]
+    def email_currency
+      (@order || @order_group)&.currency || current_store.default_currency
+    end
 
-    # The "<store> <subject> #<number>" subject line shared by customer-facing
-    # order emails, with the optional [RESEND] prefix.
-    def order_email_subject(store, subject, number, resend: false)
-      "#{resend ? "[#{Spree.t(:resend).upcase}] " : ''}#{store.name} #{subject} ##{number}"
+    # A record as its template reads it: the serializer's JSON, the same data
+    # a renderer outside Ruby would receive. Download links and other bearer
+    # tokens stay out; the mailer builds any URL that carries one.
+    #
+    # @param object [Object, nil] the record
+    # @param serializer [Class] an email serializer
+    # @param params [Hash] serializer params, over the email's store, currency and locale
+    # @return [Hash, nil]
+    def email_data(object, serializer, **params)
+      Spree::Emails::TemplateData.call(object, serializer, store: current_store, currency: email_currency, **params)
     end
 
     # URI-based merge preserves existing query params and fragments so the token
@@ -86,6 +134,42 @@ module Spree
 
     private
 
+    # A store's published template passed its checks with sample data, but a
+    # real record can still trip it. The customer then gets the email from the
+    # files rather than none, and the error is reported.
+    def render_email_template(template, assigns)
+      resolver = email_resolver(template)
+      email_renderer(resolver).render(find_email_template(resolver, template), assigns)
+    rescue Liquid::Error, MRML::Error => e
+      raise unless resolver&.stored_templates_used?
+
+      Rails.error.report(e, context: { email_template: template, store_id: current_store&.id })
+      fallback = email_resolver
+      email_renderer(fallback).render(find_email_template(fallback, template), assigns)
+    end
+
+    def find_email_template(resolver, template)
+      resolver.find(template) || raise(ArgumentError, "Missing email template #{template}.liquid")
+    end
+
+    # The store's published templates apply only to the emails merchants may
+    # edit; every other email, and the layout and partials it uses, comes
+    # from files.
+    def email_resolver(template = nil)
+      view_paths = self.class.view_paths.paths.map(&:path)
+      return Spree::Emails::TemplateResolver.new(view_paths) unless Spree.editable_email_templates.include?(template)
+
+      Spree::Emails::TemplateResolver.new(view_paths, store: current_store, locale: I18n.locale)
+    end
+
+    def email_renderer(resolver = email_resolver)
+      Spree::Emails::Renderer.new(resolver: resolver, store: current_store, currency: email_currency)
+    end
+
+    def in_store_locale(&block)
+      @_store_locale_active ? yield : with_store_locale(current_store, &block)
+    end
+
     # this ensures that ActionMailer::Base.default_url_options[:host] is always set
     # this is only a fail-safe solution if developer didn't set this in environment files
     # http://guides.rubyonrails.org/action_mailer_basics.html#generating-urls-in-action-mailer-views

data/app/mailers/spree/email_template_mailer.rb

@@ -0,0 +1,27 @@
+module Spree
+  # Sends an editable email template, rendered with sample data as the editor
+  # previews it, so a merchant can see it in a real inbox before publishing.
+  class EmailTemplateMailer < BaseMailer
+    # @param store [Spree::Store]
+    # @param recipient [String] the email address of the admin who asked for it
+    # @param key [String] the editable template
+    # @param locale [String] a language code, or "any"
+    # @param subject [String, nil] an unsaved subject
+    # @param body [String, nil] an unsaved body
+    # @param record_id [String, nil] the record to build sample data from
+    # @param email_key [String, nil] for the layout or a partial, the email to show it in
+    # @param branding [Hash] unsaved branding values
+    def test_email(store, recipient, key, locale: nil, subject: nil, body: nil, record_id: nil, email_key: nil, branding: {})
+      @current_store = store
+      email = Spree::EmailTemplates::Preview.new(
+        store: store, key: key, locale: locale, subject: subject, body: body, record_id: record_id, email_key: email_key,
+        branding: branding
+      ).call
+
+      mail(to: recipient, subject: I18n.t('spree.email_templates.test_email_subject', subject: email.subject)) do |format|
+        format.text { render plain: email.text, layout: false }
+        format.html { render html: email.html.html_safe, layout: false }
+      end
+    end
+  end
+end

data/app/mailers/spree/export_mailer.rb

@@ -4,10 +4,9 @@ module Spree
       @export = export
 
       with_store_locale(@export.store) do
-        mail(
-          to: @export.user.email,
-          subject: Spree.t('export_mailer.export_done.subject', export_number: @export.number).to_s,
-          store_url: current_store.url
+        mail_template(
+          { export: email_data(@export, Spree::Emails::ExportSerializer) },
+          to: @export.user.email, store_url: current_store.url
         )
       end
     end

data/app/mailers/spree/import_mailer.rb

@@ -4,10 +4,9 @@ module Spree
       @import = import
 
       with_store_locale(@import.store) do
-        mail(
-          to: @import.user.email,
-          subject: Spree.t('import_mailer.import_done.subject', import_number: @import.number).to_s,
-          store_url: current_store.url
+        mail_template(
+          { import: email_data(@import, Spree::Emails::ImportSerializer) },
+          to: @import.user.email, store_url: current_store.url
         )
       end
     end

data/app/mailers/spree/invitation_mailer.rb

@@ -8,9 +8,10 @@ module Spree
       # default store's branding on multi-store installs.
       @current_store = invitation.store
       with_store_locale(invitation.store) do
-        mail(to: invitation.email,
-             subject: Spree.t('invitation_mailer.invitation_email.subject',
-                              resource_name: invitation.resource&.name))
+        mail_template(
+          { invitation: email_data(invitation, Spree::Emails::InvitationSerializer), accept_url: accept_url(invitation) },
+          to: invitation.email
+        )
       end
     end
 
@@ -19,10 +20,26 @@ module Spree
       @invitation = invitation
       @current_store = invitation.store
       with_store_locale(invitation.store) do
-        mail(to: invitation.inviter.email,
-             subject: Spree.t('invitation_mailer.invitation_accepted.subject',
-                              invitee_name: invitation.invitee&.name,
-                              resource_name: invitation.resource&.name))
+        mail_template(
+          { invitation: email_data(invitation, Spree::Emails::InvitationSerializer) },
+          to: invitation.inviter.email
+        )
+      end
+    end
+
+    private
+
+    # The legacy `spree_admin` gem's own acceptance page when it is installed,
+    # otherwise the dashboard's.
+    def accept_url(invitation)
+      spree_routes = Spree::Core::Engine.routes.url_helpers
+
+      if spree_routes.respond_to?(:admin_invitation_url)
+        spree_routes.admin_invitation_url(invitation, token: invitation.token, host: invitation.store.formatted_url)
+      else
+        # Built with the mailer's own URL options, as the view built it before.
+        ensure_default_action_mailer_url_host
+        main_app.admin_invitation_acceptance_url(invitation)
       end
     end
   end

data/app/mailers/spree/seller_user_mailer.rb

@@ -12,28 +12,16 @@ module Spree
       @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
+      with_store_locale(store, staff_locale(seller_user, store)) do
+        mail_template(
+          { user: email_data(seller_user, Spree::Emails::UserSerializer), reset_url: @reset_url },
+          to: seller_user.email, 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

data/app/mailers/spree/webhook_mailer.rb

@@ -7,9 +7,9 @@ module Spree
       @current_store = webhook_endpoint.store
 
       with_store_locale(webhook_endpoint.store) do
-        mail(
+        mail_template(
+          { endpoint: email_data(@endpoint, Spree::Emails::WebhookEndpointSerializer) },
           to: @current_store.new_order_notifications_email.presence || @current_store.mail_from_address,
-          subject: Spree.t('webhook_mailer.endpoint_disabled.subject', endpoint_name: @endpoint.name || @endpoint.url),
           store_url: @current_store.formatted_url
         )
       end