spree_core 6.0.0.beta3 → 6.0.0.rc1

data/app/services/spree/locales.rb

@@ -4,11 +4,10 @@ module Spree
     # (Mobility-backed content such as product names, descriptions, taxons,
     # option values, etc.).
     #
-    # This is deliberately **independent of the admin/storefront UI translation
-    # set** (`Spree.available_locales`, which reflects which `spree_i18n` UI
-    # bundles happen to be installed). In a headless setup the storefront ships
-    # its own UI translations, so the languages a merchant can store content in
-    # must not be constrained by which admin chrome translations exist.
+    # This is deliberately **independent of the languages Spree ships
+    # translations for** (`Spree.available_locales`). In a headless setup the
+    # storefront ships its own UI translations, so the languages a merchant can
+    # store content in must not be constrained by Spree's own translations.
     #
     # Codes follow BCP-47 casing (lowercase language, uppercase region —
     # `pt-BR`, `zh-CN`) so the browser's `Intl.DisplayNames` resolves a clean

data/app/services/spree/newsletter/subscribe.rb

@@ -26,7 +26,7 @@ module Spree
           end
         end
 
-        subscriber.publish_event('newsletter_subscriber.subscription_requested', subscription_requested_payload) unless subscriber.verified?
+        publish_subscription_requested unless subscriber.verified?
         subscriber
       end
 
@@ -34,17 +34,13 @@ module Spree
 
       attr_reader :email, :current_user, :current_store, :redirect_url
 
-      def subscription_requested_payload
-        payload = {
-          id: subscriber.prefixed_id,
-          email: subscriber.email,
-          verification_token: subscriber.verification_token,
-          unsubscribe_token: subscriber.generate_token_for(:unsubscribe),
-          store_id: current_store.prefixed_id,
-          customer_id: subscriber.customer&.prefixed_id
-        }
-        payload[:redirect_url] = redirect_url if redirect_url.present?
-        payload
+      def publish_subscription_requested
+        event_name = 'newsletter_subscriber.subscription_requested'
+        payload = subscriber.event_payload_for(
+          event_name,
+          include_verification_token: true, store: current_store, redirect_url: redirect_url.presence
+        )
+        subscriber.publish_event(event_name, payload)
       end
 
       def upsert_subscriber

data/app/services/spree/orders/build_fulfillments.rb

@@ -17,13 +17,14 @@ module Spree
     class BuildFulfillments
       prepend Spree::ServiceModule::Base
 
-      def call(order:)
+      # @param keep_selection [Boolean] false when the destination changed
+      def call(order:, keep_selection: true)
         return success(order) if order.completed?
         return success(order) unless order.ship_address_id.present?
         return success(order) unless order.line_items.any?
         return success(order) unless order.delivery_step_required?
 
-        order.rebuild_fulfillments!
+        order.rebuild_fulfillments!(keep_selection: keep_selection)
         order.create_shipment_tax_charge!
         order.set_fulfillments_cost
         order.apply_free_shipping_promotions

data/app/services/spree/orders/create.rb

@@ -49,7 +49,7 @@ module Spree
         # ActiveStorage raises a message-less error for that, which would
         # otherwise be an unhandled 500 on the Admin API.
         order ||= @store.orders.new
-        order.errors.add(:po_document, :po_document_upload_incomplete, message: Spree.t(:po_document_upload_incomplete))
+        order.errors.add(:po_document, :po_document_upload_incomplete, message: I18n.t('spree.po_document_upload_incomplete'))
         failure(order, order.errors.full_messages.to_sentence)
       end
 
@@ -170,6 +170,7 @@ module Spree
             coupon_code: @params[:coupon_code]
           }
           order.coupon_code = nil
+          handler.release_stale_coupon_codes
         end
       end
     end

data/app/services/spree/orders/discounts/create.rb

@@ -18,16 +18,19 @@ module Spree
         # @return [Spree::ServiceModule::Result] value is the created rows
         def call(order:, label:, value:, value_type: 'flat', line_item: nil)
           value = BigDecimal(value.to_s)
-          return failure(nil, Spree.t('errors.messages.discount_value_must_be_positive')) unless value.positive?
-          return failure(nil, Spree.t('errors.messages.discount_value_type_invalid')) unless %w[flat percent].include?(value_type)
+          return failure(nil, I18n.t('spree.errors.messages.discount_value_must_be_positive')) unless value.positive?
+          return failure(nil, I18n.t('spree.errors.messages.discount_value_type_invalid')) unless %w[flat percent].include?(value_type)
 
           rows = order.with_lock do
             created = line_item ? [line_item_row(order, line_item, label, value, value_type)].compact : distributed_rows(order, label, value, value_type)
-            Spree.order_recalculate_totals_workflow.call(order: order) if created.any?
+            if created.any?
+              Spree.order_recalculate_totals_workflow.call(order: order)
+              order.update_statuses!
+            end
             created
           end
 
-          return failure(nil, Spree.t('errors.messages.discount_has_no_effect')) if rows.empty?
+          return failure(nil, I18n.t('spree.errors.messages.discount_has_no_effect')) if rows.empty?
 
           success(rows)
         end

data/app/services/spree/orders/discounts/destroy.rb

@@ -15,6 +15,7 @@ module Spree
           order.with_lock do
             discount.destroy!
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
           end
 
           success(discount)

data/app/services/spree/orders/discounts/update.rb

@@ -18,6 +18,7 @@ module Spree
             next false unless discount.update(attributes)
 
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
             true
           end
 

data/app/services/spree/orders/fees/create.rb

@@ -17,6 +17,7 @@ module Spree
             next false unless fee.save
 
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
             true
           end
 

data/app/services/spree/orders/fees/destroy.rb

@@ -12,6 +12,7 @@ module Spree
           order.with_lock do
             fee.destroy!
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
           end
 
           success(fee)

data/app/services/spree/orders/fees/update.rb

@@ -14,6 +14,7 @@ module Spree
             next false unless fee.update(attributes)
 
             Spree.order_recalculate_totals_workflow.call(order: order)
+            order.update_statuses!
             true
           end
 

data/app/services/spree/orders/remove_line_item.rb

@@ -1,12 +1,22 @@
 module Spree
   module Orders
-    # Draft-order twin of the cart service — order: is the canonical keyword
-    # on this side, delegating onto the shared implementation.
+    # Draft-order twin of the cart service. Removing an item is an upsert with
+    # quantity zero, so the removal passes the same 'orders.upsert_items.validate'
+    # hook every other draft-order item edit does.
     class RemoveLineItem
       prepend Spree::ServiceModule::Base
 
+      # @param order [Spree::Order]
+      # @param line_item [Spree::LineItem]
+      # @param options [Hash] accepted for signature compatibility and ignored
+      # @return [Spree::ServiceModule::Result] value is the removed line item
       def call(order:, line_item:, options: {})
-        Spree::Carts::RemoveLineItem.call(cart: order, line_item: line_item, options: options)
+        result = Spree.order_upsert_items_workflow.call(
+          order: order,
+          items: [{ variant_id: line_item.variant_id, quantity: 0 }]
+        )
+
+        result.success? ? success(line_item) : failure(line_item, result.error)
       end
     end
   end

data/app/services/spree/orders/update.rb

@@ -15,7 +15,10 @@ module Spree
         items_param = @params.delete(:items)
         address_params = extract_address_params
 
-        ApplicationRecord.transaction do
+        # requires_new: the rescue below sits outside the block, so joining a
+        # caller's open transaction (the API's order lock) would let it commit
+        # the half-applied edit.
+        ApplicationRecord.transaction(requires_new: true) do
           ship_address_id_before = @order.ship_address_id
           assign_addresses(address_params)
 
@@ -25,11 +28,12 @@ module Spree
 
           process_items(items_param) if items_param
 
-          if items_param || @order.ship_address_id != ship_address_id_before
-            build_fulfillments
-          end
+          # An address row edited in place keeps its id, so an edit to the fields a quote reads counts too.
+          destination_changed = @order.ship_address_id != ship_address_id_before || @order.ship_address&.saved_change_to_destination?
+          build_fulfillments(keep_selection: !destination_changed) if items_param || destination_changed
 
           @order.recalculate_totals!
+          @order.update_statuses!
         end
 
         success(@order.reload)
@@ -70,8 +74,8 @@ module Spree
         propagate_step_failure!(result, fallback: 'Failed to update items on order') if result.failure?
       end
 
-      def build_fulfillments
-        result = Spree::Orders::BuildFulfillments.call(order: @order)
+      def build_fulfillments(keep_selection:)
+        result = Spree::Orders::BuildFulfillments.call(order: @order, keep_selection: keep_selection)
         propagate_step_failure!(result, fallback: 'Failed to build shipments') if result.failure?
       end
 

data/app/services/spree/orders/update_item.rb

@@ -21,7 +21,7 @@ module Spree
         price_provided = !price.equal?(PRICE_NOT_PROVIDED)
 
         if price_provided && order.completed?
-          return reject_price(line_item, :price_override_not_allowed, Spree.t('cart_line_item.price_override_not_allowed'))
+          return reject_price(line_item, :price_override_not_allowed, I18n.t('spree.cart_line_item.price_override_not_allowed'))
         end
 
         attributes = {}
@@ -30,7 +30,7 @@ module Spree
 
         if price_provided && !price.nil?
           manual_price = parse_manual_price(price)
-          return reject_price(line_item, :invalid_price, Spree.t('cart_line_item.invalid_price')) if manual_price.nil?
+          return reject_price(line_item, :invalid_price, I18n.t('spree.cart_line_item.invalid_price')) if manual_price.nil?
 
           attributes[:price] = manual_price
           attributes[:price_source] = Spree::LineItem::MANUAL_PRICE_SOURCE
@@ -47,7 +47,10 @@ module Spree
         ActiveRecord::Base.transaction do
           return failure(line_item) unless line_item.update(attributes)
 
-          Spree::Orders::Recalculate.call(order: order, line_item: line_item) if quantity_changing || price_provided
+          if quantity_changing || price_provided
+            Spree::Orders::Recalculate.call(order: order, line_item: line_item)
+            order.update_statuses!
+          end
         end
 
         success(line_item)

data/app/services/spree/orders/update_statuses.rb

@@ -4,7 +4,9 @@ module Spree
     # Derive-then-persist: statuses are recomputed from payment/refund/
     # fulfillment records and stored in indexed columns so admin filtering
     # keeps working. Triggered from payment/refund/fulfillment/return event
-    # subscribers — never inline from controllers.
+    # subscribers, and by each edit service that moves an order's total
+    # (fees, discounts, items) once it has re-summed — no event announces
+    # that change. Never inline from controllers.
     class UpdateStatuses
       prepend Spree::ServiceModule::Base
 

data/app/services/spree/product_memberships.rb

@@ -0,0 +1,61 @@
+module Spree
+  # Bulk adding and removing products on categories or collections. The
+  # including service names the join model (`membership_class`), the grouping
+  # it belongs to (`group_class`, `group_key`) and refreshes the grouping's
+  # own counters in `refresh_group_counters`.
+  module ProductMemberships
+    private
+
+    def add_memberships(groups, products)
+      rows = groups.pluck(:id).flat_map do |group_id|
+        position = membership_class.where(group_key => group_id).count
+        products.pluck(:id).map do |product_id|
+          {
+            group_key => group_id, product_id: product_id, position: (position += 1),
+            created_at: Time.current, updated_at: Time.current
+          }
+        end
+      end
+      membership_class.insert_all(rows)
+
+      refresh_after_membership_change(groups.pluck(:id), products)
+    end
+
+    # Removes the products, then re-packs the remaining positions from 1.
+    def remove_memberships(groups, products)
+      group_ids = groups.pluck(:id)
+
+      ApplicationRecord.transaction do
+        membership_class.where(group_key => group_ids, product_id: products.pluck(:id)).delete_all
+
+        rows = group_ids.flat_map do |group_id|
+          membership_class.where(group_key => group_id).order(:position).pluck(:product_id).map.with_index(1) do |product_id, position|
+            {
+              group_key => group_id, product_id: product_id, position: position,
+              created_at: Time.current, updated_at: Time.current
+            }
+          end
+        end
+        membership_class.upsert_all(rows, unique_by: ([group_key, :product_id] unless Spree.mysql?)) if rows.any?
+      end
+
+      refresh_after_membership_change(group_ids, products)
+    end
+
+    # Bulk writes skip the join model's callbacks, so counters, caches and the
+    # search index are refreshed here.
+    def refresh_after_membership_change(group_ids, products)
+      product_ids = products.pluck(:id)
+      product_ids.each { |id| Spree::Product.reset_counters(id, membership_class.model_name.element.pluralize.to_sym) }
+      refresh_group_counters(group_ids)
+
+      Spree::Product.where(id: product_ids).touch_all
+      products.each(&:enqueue_search_index)
+      group_class.where(id: group_ids).touch_all
+    end
+
+    def group_key
+      group_class.model_name.element.foreign_key.to_sym
+    end
+  end
+end

data/app/services/spree/returns/eligibility_validator.rb

@@ -32,7 +32,7 @@ module Spree
         workflow.errors.add(
           :base,
           :outside_return_window,
-          message: Spree.t('return_errors.outside_window', days: window)
+          message: I18n.t('spree.return_errors.outside_window', days: window)
         )
         workflow.reject!
       end

data/app/services/spree/search_provider/custom_field_schema.rb

@@ -142,9 +142,9 @@ module Spree
       def sort_option_label(name, field_type, direction)
         suffix =
           if field_type == 'number'
-            direction == :asc ? Spree.t(:sort_low_to_high) : Spree.t(:sort_high_to_low)
+            direction == :asc ? I18n.t('spree.sort_low_to_high') : I18n.t('spree.sort_high_to_low')
           else
-            direction == :asc ? Spree.t(:sort_a_to_z) : Spree.t(:sort_z_to_a)
+            direction == :asc ? I18n.t('spree.sort_a_to_z') : I18n.t('spree.sort_z_to_a')
           end
         "#{name} (#{suffix})"
       end

data/app/services/spree/seeds/commission_rates.rb

@@ -35,7 +35,7 @@ module Spree
         return if store.commission_rates.exists?(code: DEFAULT_CODE)
 
         rate = store.commission_rates.create!(
-          name: Spree.t('seed.commission_rates.marketplace_default'),
+          name: I18n.t('spree.seed.commission_rates.marketplace_default'),
           code: DEFAULT_CODE,
           kind: 'percentage',
           value: 0,

data/app/services/spree/seeds/digital_delivery.rb

@@ -12,7 +12,7 @@ module Spree
         profile = Spree::DeliveryProfiles::Digital.find_by(store: store) ||
                   Spree::DeliveryProfiles::Digital.create!(store: store, name: I18n.t('spree.seed.delivery_profiles.digital'))
 
-        digital_delivery_method = Spree::DeliveryMethod.find_or_initialize_by(name: Spree.t('digital.digital_delivery'), store: store)
+        digital_delivery_method = Spree::DeliveryMethod.find_or_initialize_by(name: I18n.t('spree.digital.digital_delivery'), store: store)
 
         digital_delivery_method.delivery_profile = profile
         digital_delivery_method.storefront_visible = true

data/app/services/spree/seeds/payment_methods.rb

@@ -12,8 +12,8 @@ module Spree
         )
         return if payment_method.persisted?
 
-        payment_method.name = Spree.t(:store_credit_name)
-        payment_method.description = Spree.t(:store_credit_name)
+        payment_method.name = I18n.t('spree.store_credit_name')
+        payment_method.description = I18n.t('spree.store_credit_name')
         payment_method.active = true
         payment_method.save!
       end

data/app/services/spree/seeds/saved_reports.rb

@@ -86,8 +86,8 @@ module Spree
           next if known_names(report[:key]).intersect?(existing)
 
           store.saved_reports.create!(
-            name: Spree.t("reporting.seeds.#{report[:key]}.name"),
-            description: Spree.t("reporting.seeds.#{report[:key]}.description"),
+            name: I18n.t("spree.reporting.seeds.#{report[:key]}.name"),
+            description: I18n.t("spree.reporting.seeds.#{report[:key]}.description"),
             query: report[:query],
             seeded: true
           )
@@ -98,7 +98,7 @@ module Spree
       def known_names(key)
         @known_names ||= {}
         @known_names[key] ||= Spree.available_locales.filter_map do |locale|
-          Spree.t("reporting.seeds.#{key}.name", locale: locale, default: nil)&.downcase
+          I18n.t("spree.reporting.seeds.#{key}.name", locale: locale, default: nil)&.downcase
         end.to_set
       end
     end

data/app/services/spree/sellers/requirements.rb

@@ -61,8 +61,7 @@ module Spree
       def record_blocking(errors)
         blocking.each do |requirement|
           errors.add(:requirements, :incomplete,
-                     message: Spree.t('seller_requirements.incomplete', name: requirement.name,
-                                                                       default: "#{requirement.name} is not complete"))
+                     message: I18n.t('spree.seller_requirements.incomplete', name: requirement.name))
         end
       end
 

data/app/services/spree/shipping_labels/confirm_refund.rb

@@ -14,7 +14,7 @@ module Spree
         return success(shipping_label) if shipping_label.refunded?
 
         unless shipping_label.refund_requested?
-          shipping_label.errors.add(:base, :not_refund_requested, message: Spree.t('shipping_labels.errors.not_refund_requested'))
+          shipping_label.errors.add(:base, :not_refund_requested, message: I18n.t('spree.shipping_labels.errors.not_refund_requested'))
           return failure(shipping_label)
         end
 

data/app/services/spree/shipping_labels/store_file.rb

@@ -27,7 +27,7 @@ module Spree
 
         url = shipping_label.file_url
         if url.blank?
-          shipping_label.errors.add(:file, :no_file_url, message: Spree.t('shipping_labels.errors.no_file_url'))
+          shipping_label.errors.add(:file, :no_file_url, message: I18n.t('spree.shipping_labels.errors.no_file_url'))
           return failure(shipping_label)
         end
 
@@ -38,13 +38,13 @@ module Spree
           # ordinary outcome here, not an exception the caller should handle:
           # the purchase behind it is already a fact, and the job retries.
           shipping_label.errors.add(:file, :file_fetch_failed, status: e.message,
-                                    message: Spree.t('shipping_labels.errors.file_fetch_failed', status: e.message))
+                                    message: I18n.t('spree.shipping_labels.errors.file_fetch_failed', status: e.message))
           return failure(shipping_label)
         end
 
         unless response.is_a?(Net::HTTPSuccess)
           shipping_label.errors.add(:file, :file_fetch_failed, status: response.code,
-                                    message: Spree.t('shipping_labels.errors.file_fetch_failed', status: response.code))
+                                    message: I18n.t('spree.shipping_labels.errors.file_fetch_failed', status: response.code))
           return failure(shipping_label)
         end
 

data/app/services/spree/stock_levels/correct.rb

@@ -24,13 +24,13 @@ module Spree
       # @return [Spree::ServiceModule::Result] the corrected stock level
       def call(stock_level:, count_on_hand: nil, adjustment: nil, reason: nil)
         if count_on_hand.present? && adjustment.present?
-          return failure(stock_level, Spree.t('stock_level.errors.adjustment_exclusive_with_count_on_hand'))
+          return failure(stock_level, I18n.t('spree.stock_level.errors.adjustment_exclusive_with_count_on_hand'))
         end
 
         target = parse(count_on_hand)
         delta = parse(adjustment)
-        return failure(stock_level, Spree.t('stock_level.errors.count_on_hand_not_an_integer')) if count_on_hand.present? && target.nil?
-        return failure(stock_level, Spree.t('stock_level.errors.adjustment_not_an_integer')) if adjustment.present? && delta.nil?
+        return failure(stock_level, I18n.t('spree.stock_level.errors.count_on_hand_not_an_integer')) if count_on_hand.present? && target.nil?
+        return failure(stock_level, I18n.t('spree.stock_level.errors.adjustment_not_an_integer')) if adjustment.present? && delta.nil?
 
         # Locked around the read: the delta is worked out from the count this
         # caller first saw, so two admins correcting the same level at once

data/app/services/spree/stock_reservations/reserve.rb

@@ -36,9 +36,8 @@ module Spree
             if available < line_item.quantity
               raise InsufficientStockError.new(
                 line_item,
-                Spree.t(
-                  :insufficient_stock_for_reservation,
-                  default: '%{item} has only %{available} available',
+                I18n.t(
+                  'spree.insufficient_stock_for_reservation',
                   item: line_item.variant.name,
                   available: [available, 0].max
                 )

data/app/services/spree/store_credits/apply.rb

@@ -13,7 +13,10 @@ module Spree
         # credit payment for a negative amount.
         remaining_total = [amount ? [amount, @order.outstanding_balance].min : @order.outstanding_balance, 0].max
 
-        return failure(nil, Spree.t(:error_user_does_not_have_any_store_credits)) unless @order.customer&.store_credits&.any?
+        # Mirrors Spree::GiftCards::Apply, which refuses a gift card once store
+        # credit is in use: the two are never combined on one order.
+        return failure(nil, I18n.t('spree.store_credit_using_gift_card_error')) if @order.gift_card.present?
+        return failure(nil, I18n.t('spree.error_user_does_not_have_any_store_credits')) unless spendable_store_credits.exists?
 
         ApplicationRecord.transaction do
           existing = @order.payments.store_credits.where(status: :checkout)
@@ -40,12 +43,10 @@ module Spree
       # creating unnecessary invalid payment records on every recalculation.
       def update_existing_payments(payments, remaining_total)
         payments.each do |payment|
-          credit = payment.source
-          available = credit.amount_remaining + payment.amount
-          new_amount = [available, remaining_total].min
+          new_amount = store_credit_amount(payment.source, remaining_total)
 
           if new_amount.positive?
-            payment.update_column(:amount, new_amount)
+            payment.update_store_credit_amount!(new_amount)
             remaining_total -= new_amount
           else
             payment.invalidate!
@@ -53,19 +54,14 @@ module Spree
         end
 
         # If there's still remaining total, apply from additional store credits
-        apply_store_credits(remaining_total) if remaining_total.positive?
+        apply_store_credits(remaining_total, except: payments.map(&:source_id)) if remaining_total.positive?
       end
 
-      def apply_store_credits(remaining_total)
+      def apply_store_credits(remaining_total, except: [])
         payment_method = Spree::PaymentMethod::StoreCredit.available.first
         raise 'Store credit payment method could not be found' unless payment_method
 
-        # Only credits in the order's own currency: an older credit in another
-        # currency would be drawn against first and, being unusable, either
-        # overshoot the allowed amount or persist a payment that fails later
-        # at authorization. This matches what the order already counts as
-        # available (Purchase::StoreCredits#total_available_store_credit).
-        @order.customer.store_credits.for_store(@order.store).where(currency: @order.currency).oldest_first.each do |credit|
+        spendable_store_credits.where.not(id: except).oldest_first.each do |credit|
           break unless remaining_total.positive?
           next if credit.amount_remaining.zero?
 
@@ -75,6 +71,12 @@ module Spree
         end
       end
 
+      def spendable_store_credits
+        return Spree::StoreCredit.none unless @order.customer
+
+        @order.customer.store_credits.without_gift_card.for_store(@order.store).where(currency: @order.currency)
+      end
+
       def create_store_credit_payment(payment_method, credit, amount)
         @order.payments.create!(
           source: credit,

data/app/services/spree/stores/provision_defaults.rb

@@ -59,18 +59,17 @@ module Spree
       # translations. Only the *derived* default is filtered: falling back to
       # a country's official language that Spree has no strings for would set
       # a storefront to a language with nothing behind it, and it is not one
-      # the setup screen ever offers. Installs without spree_i18n know only
-      # English, so filtering there would flatten every country to it.
+      # the setup screen ever offers.
       def resolve_locale(requested, country)
         return requested if requested.present?
 
         derived = country.default_locale.presence
         return 'en' if derived.blank?
 
-        translated = Spree.available_locales.map { |locale| locale.to_s.split('-').first }.uniq
-        return derived if translated.size <= 1 || translated.include?(derived)
-
-        (country.official_locales & translated).first || 'en'
+        locales = Spree.available_locales
+        Spree.locale_for_language(derived, locales) ||
+          country.official_locales.lazy.filter_map { |language| Spree.locale_for_language(language, locales) }.first ||
+          'en'
       end
 
       # The store's own country/currency/locale columns are not the source of
@@ -118,12 +117,12 @@ module Spree
       end
 
       # Match on identity alone: folding the other attributes into the finder
-      # made re-running fail once anything edited them.
+      # made re-running fail once anything edited them. The default flag is
+      # that identity; the name is translated and may have been edited.
       def provision_stock_location
-        # first_party, so a seller who happened to name a location the same
-        # thing is never adopted as the store's own.
-        location = store.stock_locations.first_party.
-                   where(name: Spree.t(:default_stock_location_name)).first_or_initialize
+        # first_party, so a seller's location is never adopted as the store's own.
+        location = store.stock_locations.first_party.where(default: true).
+                   first_or_initialize(name: I18n.t('spree.default_stock_location_name'))
         location.propagate_all_variants = false if location.new_record?
         location.country_code = country.iso
         if location.persisted? && location.will_save_change_to_country_code?
@@ -206,7 +205,7 @@ module Spree
         weight_unit = store.preferred_weight_unit
 
         store.package_types.create!(
-          name: Spree.t('package_types.default_name'),
+          name: I18n.t('spree.package_types.default_name'),
           kind: 'box',
           default: true,
           length: metric ? 30 : 12,
@@ -237,10 +236,12 @@ module Spree
         end
         return if store.stock_locations.first_party.where(pickup_enabled: true).none?
 
-        delivery_method = store.delivery_methods.where(name: Spree.t('pickup.store_pickup')).first_or_initialize
+        # Matched by its provider, not its translated (and editable) name.
+        delivery_method = store.delivery_methods.first_party.
+                          where(fulfillment_provider: 'Spree::FulfillmentProvider::Pickup').
+                          first_or_initialize(name: I18n.t('spree.pickup.store_pickup'))
         delivery_method.delivery_profile = profile
         delivery_method.storefront_visible = true
-        delivery_method.fulfillment_provider = 'Spree::FulfillmentProvider::Pickup'
         delivery_method.calculator ||= Spree::Calculator::Shipping::FlatRate.new
         delivery_method.calculator.preferences = { amount: 0, currency: currency }
         delivery_method.save!

data/app/subscribers/spree/seller_onboarding_subscriber.rb

@@ -26,7 +26,7 @@ module Spree
       seller = invitation.resource
       return unless seller.is_a?(Spree::Seller)
 
-      Spree::Sellers::StartOnboarding.call(seller: seller)
+      Spree.seller_start_onboarding_workflow.call(seller: seller)
     end
   end
 end