spree_core 5.5.2 → 5.6.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c50d137ef2f51b5fbdb5c343c360d805fe8839978386c08902ff3f29873c7e56
-  data.tar.gz: f495c858e04f2c469323c744c5bcdff4c3d23891b85771f44082dc104922de21
+  metadata.gz: c8058b9d81b22cf12abe2193023f52faa57b5d757b99e0359e4592415b00a434
+  data.tar.gz: 13d6653cb85ab1364290621d668ed291aecbff9442ce205803595fe316ed4ea7
 SHA512:
-  metadata.gz: 96e1c8a7b981d143e5aab043ce6d236cd55627ddc28f1e29e573c873440e7515787e0f64f016409b54001c4313eca64b9f71f9f4641ddf3e021741c80300717d
-  data.tar.gz: 6810ea91184c9646922ba3dba4973fd337dfc4068513ead2cc3d198bb5f316798f4f1810eb51b08b50381eecb8603c378d56c3ef5b162c38f6d0f1cb62caf519
+  metadata.gz: ecbab7dc49344e7c228237344ff01b7addacb6309e0e70cc6a42510823265cfd97827c2a00fb9c990a90b6ace535529b2d60e11c0b45bce745d3185a8422851a
+  data.tar.gz: a2657923c327254ee18b0b222aff4b6b7c3075b26d4c9ff001f66d3b2ad5b35f7daf6d36b5d16161cfaf62613707722ae8dcf55549c2a5c811c3333638240bab

data/app/helpers/spree/base_helper.rb

@@ -8,7 +8,7 @@ module Spree
       countries = current_store.countries_available_for_checkout
 
       countries.collect do |country|
-        country.name = Spree.t(country.iso, scope: 'country_names', default: country.name)
+        country.name = localized_country_name(country)
         country
       end.sort_by { |c| c.name.parameterize }
     end
@@ -17,7 +17,7 @@ module Spree
       countries = Spree::Country.all
 
       countries.collect do |country|
-        country.name = Spree.t(country.iso, scope: 'country_names', default: country.name)
+        country.name = localized_country_name(country)
         country
       end.sort_by { |c| c.name.parameterize }
     end
@@ -112,6 +112,16 @@ module Spree
       inline_svg "payment_icons/#{payment_method}.svg", opts
     end
 
+    # @param country [Spree::Country]
+    # @return [String]
+    def localized_country_name(country)
+      Spree.t(
+        country.iso,
+        scope: 'country_names',
+        default: country.localized_name
+      )
+    end
+
     private
 
     I18N_PLURAL_MANY_COUNT = 2.1

data/app/helpers/spree/currency_helper.rb

@@ -36,10 +36,7 @@ module Spree
     # @param currency [String] the currency ISO code
     # @return [Array] the currency presentation and ISO code
     def currency_presentation(currency)
-      currency_money = currency_money(currency)
-      label = "#{currency_money.name} (#{currency_money.iso_code})"
-
-      [label, currency]
+      [Spree::Currency.new(code: currency).label, currency]
     end
 
     def currency_money(currency = current_currency)

data/app/helpers/spree/locale_helper.rb

@@ -4,10 +4,27 @@ module Spree
       supported_locales_for_all_stores.map { |locale| locale_presentation(locale) }
     end
 
+    # Locales the admin UI is translated into, as [name, code] pairs for a
+    # select. Self-contained (reads Spree.available_locales directly) so it
+    # works outside the storefront/admin controller stack — e.g. the pre-auth
+    # login screen, which has no current store.
+    def admin_locales_options
+      Spree.available_locales.map { |locale| locale_presentation(locale) }
+    end
+
     def available_locales_options
       available_locales.map { |locale| locale_presentation(locale) }
     end
 
+    # Locales a merchant may translate **content** into, as [name, code] pairs
+    # for a select. Backed by `Spree::Locales::ALL` (the canonical translation
+    # locale set) rather than the installed UI-translation bundles, so a
+    # market/store can adopt any supported locale instead of only ones already
+    # in use.
+    def translation_locales_options
+      Spree::Locales::ALL.map { |locale| locale_presentation(locale) }
+    end
+
     def supported_locales_options
       return if current_store.nil?
 
@@ -15,19 +32,7 @@ module Spree
     end
 
     def locale_presentation(locale)
-      if I18n.exists?('spree.i18n.this_file_language', locale: locale, fallback: false)
-        [locale_full_name(locale), locale.to_s]
-      elsif defined?(SpreeI18n::Locale) && (language_name = SpreeI18n::Locale.local_language_name(locale))
-        ["#{language_name} (#{locale})", locale.to_s]
-      elsif locale.to_s == 'en'
-        ['English (US)', 'en']
-      else
-        [locale, locale.to_s]
-      end
-    end
-
-    def locale_full_name(locale)
-      Spree.t('i18n.this_file_language', locale: locale)
+      [Spree::Locale.new(code: locale).label, locale.to_s]
     end
 
     def should_render_locale_dropdown?

data/app/helpers/spree/localized_names_helper.rb

@@ -0,0 +1,25 @@
+module Spree
+  module LocalizedNamesHelper
+    # @param code [String, Symbol]
+    # @return [String]
+    def locale_display_label(code)
+      return if code.blank?
+
+      content_tag(
+        :span,
+        Spree::Locale.new(code: code).label,
+        data: {
+          controller: 'display-name',
+          display_name_type_value: 'language',
+          display_name_code_value: code
+        }
+      )
+    end
+
+    # @param countries [Enumerable<Spree::Country>]
+    # @return [Array<Array>]
+    def country_select_options(countries)
+      countries.map { |country| [country.option_label, country.id] }
+    end
+  end
+end

data/app/jobs/spree/imports/process_group_job.rb

@@ -1,6 +1,10 @@
 module Spree
   module Imports
     class ProcessGroupJob < Spree::Imports::BaseJob
+      # Rows are loaded in slices so a large group never holds every ImportRow
+      # (and its raw CSV data) in memory for the whole job.
+      ROWS_BATCH_SIZE = 100
+
       def perform(import_id, row_ids)
         import = Spree::Import.find(import_id)
         Spree::Current.store = import.store
@@ -8,16 +12,23 @@ module Spree
         mappings = import.mappings.mapped.to_a
         schema_fields = import.schema_fields
         large = import.large_import?
-        # Skip rows already completed on a prior attempt so retries don't double-process them.
-        rows = import.rows.where(id: row_ids).pending_and_failed.order(:row_number)
 
-        if large
-          Spree::Events.disable do
-            rows.each { |row| row.bulk_process!(mappings: mappings, schema_fields: schema_fields) }
-          end
-        else
-          rows.each do |row|
-            row.process!(mappings: mappings, schema_fields: schema_fields)
+        row_ids.each_slice(ROWS_BATCH_SIZE) do |ids|
+          # Skip rows already completed on a prior attempt so retries don't double-process them.
+          rows = import.rows.where(id: ids).pending_and_failed.order(:row_number).to_a
+          # Share the already-loaded import across rows: each row's processor reads
+          # `row.import` (store, ability, lookup cache), and without this every row
+          # lazily loads its own Import instance and rebuilds all of that per row.
+          rows.each { |row| row.association(:import).target = import }
+
+          if large
+            Spree::Events.disable do
+              rows.each { |row| row.bulk_process!(mappings: mappings, schema_fields: schema_fields) }
+            end
+          else
+            rows.each do |row|
+              row.process!(mappings: mappings, schema_fields: schema_fields)
+            end
           end
         end
 

data/app/jobs/spree/imports/process_rows_job.rb

@@ -2,6 +2,7 @@ module Spree
   module Imports
     class ProcessRowsJob < Spree::Imports::BaseJob
       BATCH_SIZE = 100
+      UNGROUPED_KEY = '__ungrouped__'.freeze
 
       def perform(import_id)
         import = Spree::Import.find(import_id)
@@ -27,20 +28,27 @@ module Spree
 
         import.rows.pending_and_failed.order(:row_number).pluck(:id, :data).each do |id, data|
           parsed = JSON.parse(data)
-          key = parsed[file_column].to_s.strip.downcase.presence || '__ungrouped__'
+          key = parsed[file_column].to_s.strip.downcase.presence || UNGROUPED_KEY
           groups[key] << id
         rescue JSON::ParserError
-          groups['__ungrouped__'] << id
+          groups[UNGROUPED_KEY] << id
         end
 
+        # Rows without a group value don't depend on each other, so they don't have
+        # to share a single job — split them into bounded batches. Real groups stay
+        # intact: their rows must run sequentially (product row before variant rows).
+        ungrouped = groups.delete(UNGROUPED_KEY)
+        batches = groups.values
+        ungrouped&.each_slice(BATCH_SIZE) { |row_ids| batches << row_ids }
+
         # Set count before enqueuing so workers can't complete prematurely
         import.update_columns(
-          processing_groups_count: groups.size,
+          processing_groups_count: batches.size,
           completed_groups_count: 0,
           updated_at: Time.current
         )
 
-        groups.each_value { |row_ids| ProcessGroupJob.perform_later(import.id, row_ids) }
+        batches.each { |row_ids| ProcessGroupJob.perform_later(import.id, row_ids) }
       end
 
       def dispatch_batched(import)

data/app/mailers/spree/admin_user_mailer.rb

@@ -0,0 +1,71 @@
+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).
+  class AdminUserMailer < BaseMailer
+    def password_reset_email(admin_user, token, store, redirect_url: nil)
+      @user = admin_user
+      @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
+        )
+      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:
+    # 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 (token appended as a
+    # query param); the legacy Devise flow links to its own edit-password route
+    # when the host app installed it.
+    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
+    end
+  end
+end

data/app/mailers/spree/base_mailer.rb

@@ -2,18 +2,46 @@ module Spree
   class BaseMailer < ActionMailer::Base
     helper Spree::ImagesHelper
 
+    default from: -> { from_address }, reply_to: -> { reply_to_address }
+
     def current_store
       @current_store ||= @order&.store.presence || Spree::Store.current || Spree::Store.default
     end
 
     helper_method :current_store
 
+    # Render an email in the given locale, with the store's translation fallbacks
+    # active, and restore both afterwards. Controllers set these fallbacks per
+    # request via `set_fallback_locale`, but mailers run in background jobs where
+    # that never happens — so without this, translatable attributes (store name,
+    # product names, taxon names, …) return nil under a non-default locale and
+    # leave e.g. the footer blank. Setting the fallbacks here mirrors a request,
+    # so reads fall back to the store's default-locale value.
+    #
+    # @param store [Spree::Store]
+    # @param locale [String, Symbol, nil] defaults to the store's default locale
+    def with_store_locale(store, locale = nil, &block)
+      locale = locale.presence || store&.default_locale
+      return yield if locale.blank?
+
+      previous_fallbacks = Mobility.store_based_fallbacks
+      previously_active = @_store_locale_active
+      @_store_locale_active = true
+      begin
+        Spree::Locales::SetFallbackLocaleForStore.new.call(store: store) if store
+        I18n.with_locale(locale, &block)
+      ensure
+        @_store_locale_active = previously_active
+        Mobility.store_based_fallbacks = previous_fallbacks
+      end
+    end
+
     def from_address
       current_store.mail_from_address
     end
 
     def reply_to_address
-      current_store.mail_from_address
+      current_store.customer_support_email.presence || current_store.mail_from_address
     end
 
     def money(amount, currency = nil)
@@ -29,8 +57,50 @@ module Spree
 
     def mail(headers = {}, &block)
       ensure_default_action_mailer_url_host(headers[:store_url])
-      set_email_locale
-      super if Spree::Config[:send_core_emails]
+      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
+        # 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
+    # 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}"
+    end
+
+    # URI-based merge preserves existing query params and fragments so the token
+    # doesn't get swallowed by a `#section` or clobber an existing `?source=`.
+    def append_token(url, token)
+      uri = URI.parse(url.to_s)
+      params = URI.decode_www_form(uri.query || '')
+      params << ['token', token.to_s]
+      uri.query = URI.encode_www_form(params)
+      uri.to_s
+    rescue URI::InvalidURIError
+      separator = url.include?('?') ? '&' : '?'
+      "#{url}#{separator}token=#{CGI.escape(token.to_s)}"
     end
 
     private
@@ -46,13 +116,5 @@ module Spree
       ActionMailer::Base.default_url_options ||= {}
       ActionMailer::Base.default_url_options[:host] = host_url
     end
-
-    # Sets the I18n locale for the email.
-    # Prefers the order's locale (the language the customer used),
-    # falls back to the store's default locale.
-    def set_email_locale
-      locale = @order&.locale.presence || @order&.store&.default_locale || current_store&.default_locale
-      I18n.locale = locale if locale.present?
-    end
   end
 end

data/app/mailers/spree/export_mailer.rb

@@ -3,13 +3,13 @@ module Spree
     def export_done(export)
       @export = export
 
-      mail(
-        to: @export.user.email,
-        subject: Spree.t('export_mailer.export_done.subject', export_number: @export.number).to_s,
-        from: from_address,
-        reply_to: reply_to_address,
-        store_url: current_store.url
-      )
+      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
+        )
+      end
     end
 
     def current_store

data/app/mailers/spree/import_mailer.rb

@@ -0,0 +1,19 @@
+module Spree
+  class ImportMailer < Spree::BaseMailer
+    def import_done(import)
+      @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
+        )
+      end
+    end
+
+    def current_store
+      @current_store ||= @import.store
+    end
+  end
+end

data/app/mailers/spree/invitation_mailer.rb

@@ -3,22 +3,27 @@ module Spree
     # invitation email, sending email to the invited to let them know they have been invited to join a store/account/vendor
     def invitation_email(invitation)
       @invitation = invitation
-      mail(to: invitation.email,
-           from: from_address,
-           reply_to: reply_to_address,
-           subject: Spree.t('invitation_mailer.invitation_email.subject',
-                            resource_name: invitation.resource&.name))
+      # The shared header/footer and from/reply-to addresses read
+      # current_store — without this, background delivery falls back to the
+      # 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))
+      end
     end
 
     # sending email to the inviter to let them know the invitee has accepted the invitation
     def invitation_accepted(invitation)
       @invitation = invitation
-      mail(to: invitation.inviter.email,
-           from: from_address,
-           reply_to: reply_to_address,
-           subject: Spree.t('invitation_mailer.invitation_accepted.subject',
-                            invitee_name: invitation.invitee&.name,
-                            resource_name: invitation.resource&.name))
+      @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))
+      end
     end
   end
 end

data/app/mailers/spree/report_mailer.rb

@@ -3,12 +3,12 @@ module Spree
     def report_done(report)
       @report = report
 
-      mail(
-        to: @report.user.email,
-        subject: Spree.t('report_mailer.report_done.subject', report_name: @report.human_name).to_s,
-        from: from_address,
-        reply_to: reply_to_address
-      )
+      with_store_locale(@report.store) do
+        mail(
+          to: @report.user.email,
+          subject: Spree.t('report_mailer.report_done.subject', report_name: @report.human_name).to_s
+        )
+      end
     end
 
     private

data/app/mailers/spree/webhook_mailer.rb

@@ -6,12 +6,13 @@ module Spree
       @endpoint = webhook_endpoint
       @current_store = webhook_endpoint.store
 
-      mail(
-        to: @current_store.new_order_notifications_email.presence || @current_store.mail_from_address,
-        from: from_address,
-        subject: Spree.t('webhook_mailer.endpoint_disabled.subject', endpoint_name: @endpoint.name || @endpoint.url),
-        store_url: @current_store.formatted_url
-      )
+      with_store_locale(webhook_endpoint.store) do
+        mail(
+          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
     end
   end
 end

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

@@ -7,12 +7,34 @@ 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_person_name
 
       normalizes :email, :first_name, :last_name, with: ->(value) { value&.to_s&.squish&.presence }
 
+      # 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)
+      end
+
+      def self.find_by_password_reset_token(token)
+        find_by_token_for(:password_reset, token)
+      end
+
+      def self.find_by_password_reset_token!(token)
+        find_by_token_for!(:password_reset, token)
+      end
+
       # Associations
       has_many :identities, class_name: 'Spree::UserIdentity', as: :user, dependent: :destroy
       has_many :canceled_orders, class_name: 'Spree::Order', foreign_key: :canceler_id
@@ -33,6 +55,8 @@ module Spree
       # Attachments
       has_one_attached :avatar, service: Spree.public_storage_service_name
 
+      validates :avatar, content_type: Rails.application.config.active_storage.web_image_content_types
+
       #
       # Attributes
       #
@@ -78,5 +102,25 @@ module Spree
       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/legacy_multi_store_support.rb

@@ -0,0 +1,48 @@
+module Spree
+  # Backwards-compatible shim for resources migrated from a many-to-many store
+  # relationship to a single-store +belongs_to :store+ FK (Spree::Product in 5.5,
+  # Spree::Promotion and Spree::PaymentMethod in 5.6). Maps the historic
+  # +stores+/+store_ids+ accessors onto the singular +store+/+store_id+, warning
+  # on use. The +spree_multi_store+ extension defines +SpreeMultiStore+ to
+  # suppress the include and restore the real +has_many :stores+ association.
+  module LegacyMultiStoreSupport
+    extend ActiveSupport::Concern
+
+    included do
+      # Legacy accessors for the many-to-many store relationship. These are deprecated
+      # and will be removed in Spree 6.0 once the models finish migrating to single-store ownership.
+      # @return [ActiveRecord::Relation<Spree::Store>] the single store wrapped in a relation, or an empty relation if no store is set
+      def stores
+        Spree::Deprecation.warn(
+          "#{self.class.base_class}#stores is deprecated. Please use #{self.class.base_class}#store instead. " \
+          'If you want to continue using multiple stores please install spree_multi_store gem'
+        )
+        store ? Spree::Store.where(id: store.id) : Spree::Store.none
+      end
+
+      def store_ids
+        Spree::Deprecation.warn(
+          "#{self.class.base_class}#store_ids is deprecated. Please use #{self.class.base_class}#store_id instead. " \
+          'If you want to continue using multiple stores please install spree_multi_store gem'
+        )
+        store_id ? [store_id] : []
+      end
+
+      def stores=(stores)
+        Spree::Deprecation.warn(
+          "#{self.class.base_class}#stores= is deprecated. Please use #{self.class.base_class}#store= instead. " \
+          'If you want to continue using multiple stores please install spree_multi_store gem'
+        )
+        self.store = Array(stores).compact.first
+      end
+
+      def store_ids=(store_ids)
+        Spree::Deprecation.warn(
+          "#{self.class.base_class}#store_ids= is deprecated. Please use #{self.class.base_class}#store_id= instead. " \
+          'If you want to continue using multiple stores please install spree_multi_store gem'
+        )
+        self.store_id = Array(store_ids).compact_blank.first
+      end
+    end
+  end
+end