spree_core 6.0.0.beta4 → 6.0.0.rc2

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/seeds/stores.rb

@@ -14,7 +14,7 @@ module Spree
           s.customer_support_email       = 'support@example.com'
           s.default_currency             = 'USD'
           s.default_country_code          = 'US'
-          s.default_locale               = I18n.locale
+          s.default_locale               = Spree::Locales.listed(I18n.locale) || 'en'
         end.save!
       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

@@ -18,8 +18,9 @@ module Spree
 
       # @param store [Spree::Store] the store to provision, already persisted
       # @param country [Spree::Country] where the shop ships from
-      # @param locale [String, nil] storefront locale; defaults to the
-      #   country's own language when Spree translates it, then English
+      # @param locale [String, nil] storefront locale, a code from
+      #   `Spree::Locales::ALL` (another spelling or region moves to the listed
+      #   one); defaults to the country's own language, then English
       # @param currency [String, nil] ISO 4217 code; defaults to the country's
       #   own currency. Merchants who ship from one country and price in
       #   another currency pass it explicitly.
@@ -55,22 +56,17 @@ module Spree
         found&.iso_code || country.default_currency.presence || 'USD'
       end
 
-      # An explicit locale is honored as given — a host app may ship its own
-      # 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.
+      # A store's locale is a content locale, so it comes from
+      # `Spree::Locales::ALL` whether or not Spree ships translations for it:
+      # the storefront and dashboard carry their own. An explicit locale is
+      # kept when it is listed, or moved to its listed language (`en-IE`
+      # becomes `en`); one Spree cannot place, or none, gives the country's
+      # first official language Spree lists.
       def resolve_locale(requested, country)
-        return requested if requested.present?
+        listed = Spree::Locales.listed(requested)
+        return listed if listed
 
-        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'
+        [country.default_locale, *country.official_locales].lazy.filter_map { |language| Spree::Locales.for_language(language) }.first || 'en'
       end
 
       # The store's own country/currency/locale columns are not the source of
@@ -118,12 +114,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 +202,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 +233,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!
@@ -259,7 +257,7 @@ module Spree
           calculator = delivery_method.calculator
           next unless calculator.respond_to?(:preferred_currency)
           next if calculator.preferred_currency == currency
-          next unless calculator.preferences[:amount].to_f.zero?
+          next unless Spree::Money::Rounding.blank_or_zero?(calculator.preferences[:amount])
 
           calculator.update!(preferences: calculator.preferences.merge(currency: currency))
         end

data/app/services/spree/update_check.rb

@@ -0,0 +1,160 @@
+require 'net/http'
+
+module Spree
+  # Asks spreecloud.io which Spree releases are newer than the running one,
+  # and reports usage with the same request. The answer is cached for a day,
+  # so at most one admin request a day waits on it, for no more than the two
+  # one-second timeouts. A failed check is cached for an hour, so a passing
+  # outage costs one slow request an hour and never hides a release for long.
+  #
+  # The +version+, +environment+, +url+ and +install_id+ query keys are what
+  # Spree 5 sent, and the endpoint still serves 5.x installs with them. They
+  # are never renamed; new keys only ever go beside them.
+  class UpdateCheck
+    ENDPOINT = 'https://spreecloud.io/updates.json'.freeze
+    RELEASES_URL = 'https://github.com/spree/spree/releases/tag/'.freeze
+    RELEASE_TAG = /\Av\d+(\.[0-9a-z]+)*\z/
+    CACHE_TTL = 1.day
+    FAILURE_TTL = 1.hour
+    OPEN_TIMEOUT = 1
+    READ_TIMEOUT = 1
+    # The read timeout applies to each read, not the whole response, so a
+    # slowly trickling answer needs an overall deadline as well.
+    TOTAL_TIMEOUT = 2
+    # Order-of-magnitude buckets: enough to tell a hobby install from a large
+    # merchant, never an exact figure.
+    BUCKETS = {
+      0..0 => '0',
+      1..9 => '1-9',
+      10..99 => '10-99',
+      100..999 => '100-999',
+      1_000..9_999 => '1k-9k',
+      10_000..99_999 => '10k-99k'
+    }.freeze
+    LARGEST_BUCKET = '100k+'.freeze
+
+    class << self
+      # @return [Boolean] false when the operator turned the check off
+      def enabled?
+        Spree::Config.update_check_enabled && !env_flag?('SPREE_UPDATE_CHECK_DISABLED')
+      end
+
+      # When false, the check still runs but sends the running version only.
+      #
+      # @return [Boolean]
+      def telemetry_enabled?
+        Spree::Config.telemetry_enabled &&
+          !env_flag?('SPREE_TELEMETRY_DISABLED') &&
+          !env_flag?('DO_NOT_TRACK')
+      end
+
+      # The cached answer, fetched from the endpoint when there is none.
+      #
+      # @return [Spree::UpdateStatus]
+      def status
+        return Spree::UpdateStatus.new(current_version: Spree.version, enabled: false) unless enabled?
+
+        result = Rails.cache.read(cache_key) || refresh
+
+        Spree::UpdateStatus.new(current_version: Spree.version, checked_at: result[:checked_at], releases: result[:releases])
+      end
+
+      # @return [Hash] the query string the endpoint receives
+      def query
+        return { version: Spree.version } unless telemetry_enabled?
+
+        {
+          version: Spree.version,
+          environment: Rails.env,
+          url: Spree::Store.default&.storefront_url,
+          install_id: Spree.install_id,
+          ruby: RUBY_VERSION,
+          rails: Rails.version,
+          database: ActiveRecord::Base.connection_db_config.adapter,
+          gems: Gem.loaded_specs.keys.grep(/\Aspree_/).sort.join(','),
+          dashboard: dashboard_served?,
+          stores: bucket(Spree::Store.count),
+          products: bucket(Spree::Product.count),
+          orders: bucket(Spree::Order.complete.count),
+          sellers: seller_bucket
+        }.compact
+      end
+
+      private
+
+      def refresh
+        releases = fetch_releases
+        result = { releases: releases || [], checked_at: Time.current }
+        Rails.cache.write(cache_key, result, expires_in: releases ? CACHE_TTL : FAILURE_TTL)
+        result
+      end
+
+      # Nil when the check failed, for whatever reason: an update notice is
+      # never worth failing the admin's request over, including a database
+      # error while counting for the usage fields.
+      def fetch_releases
+        uri = URI(ENDPOINT)
+        uri.query = URI.encode_www_form(query)
+
+        response = Timeout.timeout(TOTAL_TIMEOUT) do
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true, max_retries: 0,
+                                              open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT) do |http|
+            http.get(uri.request_uri)
+          end
+        end
+        return unless response.is_a?(Net::HTTPSuccess)
+
+        newer_releases(JSON.parse(response.body))
+      rescue StandardError => e
+        Rails.error.report(e, handled: true, severity: :warning, source: 'spree.update_check')
+        nil
+      end
+
+      # The endpoint already filters by version; this does it again and
+      # builds each link from the tag, so whatever comes back over the wire
+      # never reaches the dashboard as a URL. Release candidates are only
+      # offered to installs already running one.
+      def newer_releases(payload)
+        current = Gem::Version.new(Spree.version)
+
+        Array(payload).filter_map { |release|
+          tag = release.is_a?(Hash) ? release['tag_name'].to_s : ''
+          next unless tag.match?(RELEASE_TAG)
+
+          version = Gem::Version.new(tag.delete_prefix('v'))
+          next unless version > current
+          next if version.prerelease? && !current.prerelease?
+
+          { version: version.to_s, url: "#{RELEASES_URL}#{tag}", published_at: parse_time(release['published_at']) }
+        }.sort_by { |release| Gem::Version.new(release[:version]) }.reverse
+      end
+
+      def parse_time(value)
+        Time.iso8601(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def bucket(count)
+        BUCKETS.find { |range, _| range.cover?(count) }&.last || LARGEST_BUCKET
+      end
+
+      def seller_bucket
+        count = Spree::Seller.count
+        bucket(count) if count.positive?
+      end
+
+      def dashboard_served?
+        (defined?(Spree::Dashboard) && Spree::Dashboard.dist_path.present?) || Spree::Config.dashboard_url.present?
+      end
+
+      def env_flag?(name)
+        ActiveModel::Type::Boolean.new.cast(ENV[name].presence) == true
+      end
+
+      def cache_key
+        "spree/update_check/#{Spree.version}"
+      end
+    end
+  end
+end

data/app/services/spree/uploads/assign_stores.rb

@@ -0,0 +1,92 @@
+module Spree
+  module Uploads
+    # Gives every attached file that has no store the store of the record it
+    # is attached to (the 6.0 upgrade, `spree:uploads:assign_stores`).
+    #
+    # Owners with a `store_id` column are handled with one set-based update per
+    # attachment type; the rest (a variant's digital file, a seller's
+    # submission) ask {Spree::Uploads.store_id_for} record by record. Files
+    # attached nowhere keep no store, and the daily purge leaves them alone.
+    #
+    # Safe to re-run: only files without a store are touched.
+    class AssignStores
+      prepend Spree::ServiceModule::Base
+
+      BATCH_SIZE = 1_000
+
+      # @return [Spree::ServiceModule::Result] a hash with `assigned`, the
+      #   number of files given a store, and `conflicts`, the ids of files
+      #   attached to records of more than one store, which are reported and
+      #   left for a person to resolve
+      def call
+        assigned = record_types.sum do |record_type|
+          owner_class = record_type.safe_constantize
+          next 0 if owner_class.nil?
+
+          # Renditions and previews are blobs themselves: a set-based update
+          # would join the table it updates, which MySQL refuses.
+          if owner_class.column_names.include?('store_id') && !record_type.start_with?('ActiveStorage::')
+            assign_from_store_column(record_type, owner_class)
+          else
+            assign_record_by_record(record_type)
+          end
+        end
+
+        success(assigned: assigned, conflicts: conflicting_blob_ids)
+      end
+
+      private
+
+      # Renditions and previews take their store from their original file, so
+      # they go last, once the originals have one.
+      def record_types
+        ActiveStorage::Attachment.distinct.pluck(:record_type).
+          sort_by { |record_type| [record_type.start_with?('ActiveStorage::') ? 1 : 0, record_type] }
+      end
+
+      # Correlated subqueries rather than UPDATE … FROM, which MySQL and SQLite
+      # spell differently. Several attachments of one file in different stores
+      # pick one; {#conflicting_blob_ids} reports them.
+      def assign_from_store_column(record_type, owner_class)
+        attachments_table = ActiveStorage::Attachment.table_name
+        owners_table = owner_class.table_name
+        owner_store = ActiveStorage::Attachment.
+                      joins("INNER JOIN #{owners_table} ON #{owners_table}.id = #{attachments_table}.record_id").
+                      where(record_type: record_type).
+                      where("#{attachments_table}.blob_id = #{ActiveStorage::Blob.table_name}.id").
+                      where.not(owners_table => { store_id: nil })
+
+        ActiveStorage::Blob.where(store_id: nil).
+          where(id: ActiveStorage::Attachment.where(record_type: record_type).select(:blob_id)).
+          where(owner_store.arel.exists).
+          update_all(["store_id = (#{owner_store.select("#{owners_table}.store_id").limit(1).to_sql})"])
+      end
+
+      # One update per store and batch rather than per file.
+      def assign_record_by_record(record_type)
+        unassigned = ActiveStorage::Attachment.joins(:blob).
+                     where(record_type: record_type, ActiveStorage::Blob.table_name => { store_id: nil })
+
+        unassigned.preload(:record).in_batches(of: BATCH_SIZE).sum do |batch|
+          batch.select(&:record).group_by { |attachment| Spree::Uploads.store_id_for(attachment.record) }.sum do |store_id, owned|
+            next 0 if store_id.nil?
+
+            ActiveStorage::Blob.where(id: owned.map(&:blob_id), store_id: nil).update_all(store_id: store_id)
+          end
+        end
+      end
+
+      def conflicting_blob_ids
+        resolvable_types = record_types.select(&:safe_constantize)
+        shared_blob_ids = ActiveStorage::Attachment.where(record_type: resolvable_types).group(:blob_id).having('COUNT(*) > 1').pluck(:blob_id)
+
+        shared_blob_ids.each_slice(BATCH_SIZE).flat_map do |blob_ids|
+          ActiveStorage::Attachment.where(blob_id: blob_ids, record_type: resolvable_types).includes(:record).group_by(&:blob_id).filter_map do |blob_id, blob_attachments|
+            store_ids = blob_attachments.filter_map { |attachment| attachment.record && Spree::Uploads.store_id_for(attachment.record) }
+            blob_id if store_ids.map(&:to_s).uniq.size > 1
+          end
+        end
+      end
+    end
+  end
+end

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

data/app/validators/spree/attachment_content_type_validator.rb

@@ -44,6 +44,16 @@ module Spree
     # identified outright and never reaches the tie-break at all.
     CONTAINER_CONTENT_TYPES = %w[application/zip application/x-ole-storage].freeze
 
+    # Plain-text formats carry no signature at all, so the bytes can only prove
+    # what they are not. Marcel names anything it recognises — HTML, XML, SVG,
+    # scripts with a shebang, executables — and those never reach this
+    # tie-break. What is left is accepted under a text extension only when it
+    # is free of the control bytes every binary format carries. No particular
+    # encoding is required, since spreadsheet tools still export in legacy ones.
+    TEXT_CONTENT_TYPES = %w[text/csv].freeze
+    UNIDENTIFIED_CONTENT_TYPES = %w[application/octet-stream text/plain].freeze
+    BINARY_BYTES = /[\x00-\x08\x0B\x0E-\x1F\x7F]/n
+
     # A misspelled or forgotten option would otherwise leave this validator
     # silently accepting everything, on the one path whose whole purpose is
     # refusing hostile files. An allowlist that resolves to empty at runtime is
@@ -116,9 +126,16 @@ module Spree
       # read, which would hand the decision back to whoever uploaded the file.
       detected = Marcel::MimeType.for(StringIO.new(head))
       return true if permitted.include?(detected)
+      return permitted_plain_text?(blob, head, permitted) if UNIDENTIFIED_CONTENT_TYPES.include?(detected)
       return false unless CONTAINER_CONTENT_TYPES.include?(detected)
 
-      permitted.include?(office_type_from_extension(blob))
+      permitted.include?(type_from_extension(blob))
+    end
+
+    def permitted_plain_text?(blob, head, permitted)
+      text_type = type_from_extension(blob)
+
+      TEXT_CONTENT_TYPES.include?(text_type) && permitted.include?(text_type) && !head.b.match?(BINARY_BYTES)
     end
 
     # Asks the extension alone, rather than re-reading the bytes with a filename
@@ -129,7 +146,7 @@ module Spree
     # bytes we read.
     #
     # @return [String, nil]
-    def office_type_from_extension(blob)
+    def type_from_extension(blob)
       filename = blob.filename.to_s
       return if File.extname(filename).blank?
 

data/app/validators/spree/locale_codes_validator.rb

@@ -0,0 +1,22 @@
+module Spree
+  # Rejects locale codes `Spree::Locales::ALL` does not list, in a single code
+  # or a comma-separated list, naming the ones it refuses. Reads the stored
+  # column, since a store answers `default_locale` from its default market,
+  # and checks only an attribute that is changing, so a record saved before
+  # the list was enforced can still be edited.
+  #
+  # @example
+  #   validates_with Spree::LocaleCodesValidator, attributes: %i[default_locale supported_locales]
+  class LocaleCodesValidator < ActiveModel::Validator
+    def validate(record)
+      Array(options[:attributes]).each do |attribute|
+        next unless record.will_save_change_to_attribute?(attribute)
+
+        unlisted = Spree::Locales.unlisted(record.read_attribute(attribute))
+        next if unlisted.empty?
+
+        record.errors.add(attribute, I18n.t('spree.locales_not_listed', codes: unlisted.join(', ')))
+      end
+    end
+  end
+end