spree_core 5.5.3 → 5.6.0.rc1

data/app/models/spree/export.rb

@@ -43,6 +43,15 @@ module Spree
     #
     self.whitelisted_ransackable_attributes = %w[number type format vendor_id]
 
+    #
+    # Preferences
+    #
+    # Absolute URL of the admin view for this export, captured at create by
+    # the caller (legacy admin passes its export page; see the import
+    # counterpart for the dashboard mechanics) — the export-done email links
+    # back to it. No URL, no button.
+    preference :results_url, :string, default: nil
+
     #
     # Attachments
     #
@@ -205,6 +214,16 @@ module Spree
       Rails.root.join('tmp', export_file_name)
     end
 
+    # Public API name for the +results_url+ preference (read/write symmetry).
+    # String preferences round-trip nil as "" — normalize blank to nil.
+    def results_url
+      preferred_results_url.presence
+    end
+
+    def results_url=(value)
+      self.preferred_results_url = value
+    end
+
     def send_export_done_email
       return if user.blank? # App-created exports (secret API key) have no user to email.
 

data/app/models/spree/exports/coupon_codes.rb

@@ -14,8 +14,7 @@ module Spree
       end
 
       def scope
-        model_class.joins(promotion: :stores).where(spree_stores: { id: store.id })
-                   .accessible_by(current_ability)
+        model_class.where(promotion: store.promotions).accessible_by(current_ability, :show)
       end
     end
   end

data/app/models/spree/import.rb

@@ -34,7 +34,12 @@ module Spree
     #
     # Ransack configuration
     #
-    self.whitelisted_ransackable_attributes = %w[number type]
+    self.whitelisted_ransackable_attributes = %w[number type status]
+
+    #
+    # Scopes
+    #
+    scope :for_store, ->(store) { where(owner: store) }
 
     #
     # Attachments
@@ -70,12 +75,23 @@ module Spree
       event :fail do
         transition to: :failed
       end
+
+      # Re-processes rows that failed: the dispatcher targets pending_and_failed
+      # rows, so retry is just a transition + re-dispatch.
+      event :retry_failed_rows do
+        transition from: :completed, to: :processing, if: ->(import) { import.rows.failed.exists? }
+      end
+      after_transition on: :retry_failed_rows, do: :process_rows_async
     end
 
     #
     # Preferences
     #
     preference :delimiter, :string, default: ','
+    # Absolute URL of the dashboard's imports view, captured at create and
+    # validated against the store's allowed origins — the import-done email
+    # links back to it. Blank for legacy-admin or app-created imports.
+    preference :results_url, :string, default: nil
 
     # Returns true if the import has more rows than the large import threshold.
     # Large imports skip per-row UI broadcasts and use bulk processing.
@@ -110,6 +126,59 @@ module Spree
       status == 'completed'
     end
 
+    # Imports are deletable only while no processing jobs can be in flight —
+    # CreateRowsJob/ProcessGroupJob re-load the record mid-run.
+    # @return [Boolean]
+    def can_be_deleted?
+      %w[pending mapping completed failed].include?(status)
+    end
+
+    # Per-status row counts for API status payloads, memoized so one request
+    # issues a single grouped COUNT instead of one per status.
+    # @return [Hash{String => Integer}]
+    def rows_status_counts
+      @rows_status_counts ||= rows.group(:status).count
+    end
+
+    # Public API name for the +results_url+ preference (read/write symmetry).
+    # String preferences round-trip nil as "" — normalize blank to nil.
+    def results_url
+      preferred_results_url.presence
+    end
+
+    def results_url=(value)
+      self.preferred_results_url = value
+    end
+
+    # URL of the wizard/results view for this import — the caller-provided
+    # +results_url+ with the wizard's `?import=` param appended (a no-op for
+    # the legacy admin's show URL, whose path already identifies the import).
+    # Nil when the preference is absent; the mailer then renders no link.
+    # @return [String, nil]
+    def results_page_url
+      return if preferred_results_url.blank?
+
+      uri = URI.parse(preferred_results_url)
+      params = URI.decode_www_form(uri.query.to_s)
+      params << ['import', prefixed_id]
+      uri.query = URI.encode_www_form(params)
+      uri.to_s
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    # First data row as { header => value }, reading a single line of the
+    # attached CSV — used by the mapping UI to show example values.
+    # @return [Hash]
+    def sample_row
+      return {} if attachment_file_content.blank?
+
+      row = ::CSV.foreach(StringIO.new(attachment_file_content), headers: true, col_sep: preferred_delimiter).first
+      row&.to_h || {}
+    rescue ::CSV::MalformedCSVError, EncodingError
+      {}
+    end
+
     # Returns the model class for the import
     # @return [Class]
     def model_class
@@ -277,6 +346,20 @@ module Spree
         available_types.find { |type| type.model_class.to_s == model.to_s }
       end
 
+      # Admin API scope family gating this import type — an import is a bulk
+      # write, so an API key needs `write_<required_scope>` to create and
+      # manage it. Derived from the class name (Spree::Imports::Customers =>
+      # :customers); override in subclasses gated by a different scope.
+      # Returns nil on the base class, so unmapped types are only accessible
+      # to write_all keys.
+      #
+      # @return [Symbol, nil]
+      def required_scope
+        return nil if self == Spree::Import
+
+        to_s.demodulize.underscore.to_sym
+      end
+
       # eg. Spree::Imports::Orders => Spree::Order
       def model_class
         return Spree.user_class if to_s == 'Spree::Imports::Customers'

data/app/models/spree/import_row.rb

@@ -18,6 +18,11 @@ module Spree
     validates :import, :data, presence: true
     validates :row_number, uniqueness: { scope: :import_id }, numericality: { only_integer: true, greater_than: 0 }, presence: true
 
+    #
+    # Ransack configuration
+    #
+    self.whitelisted_ransackable_attributes = %w[status row_number]
+
     #
     # State machine
     #
@@ -92,6 +97,7 @@ module Spree
     def process!(mappings: nil, schema_fields: nil)
       start_processing!
       self.item = import.row_processor_class.new(self, mappings: mappings, schema_fields: schema_fields).process!
+      self.validation_errors = nil # clear a stale error when a retried row succeeds
       complete!
     rescue StandardError => e
       Rails.error.report(e, handled: true, context: { import_row_id: id }, source: 'spree.core')
@@ -105,7 +111,7 @@ module Spree
       update_columns(status: 'processing', updated_at: Time.current)
       processor = import.row_processor_class.new(self, mappings: mappings, schema_fields: schema_fields)
       self.item = processor.process!
-      update_columns(status: 'completed', item_type: item.class.name, item_id: item.id, updated_at: Time.current)
+      update_columns(status: 'completed', item_type: item.class.name, item_id: item.id, validation_errors: nil, updated_at: Time.current)
     rescue StandardError => e
       Rails.error.report(e, handled: true, context: { import_row_id: id }, source: 'spree.core')
       update_columns(status: 'failed', validation_errors: e.message, updated_at: Time.current)

data/app/models/spree/imports/product_translations.rb

@@ -16,6 +16,12 @@ module Spree
       def self.model_class
         Spree::Product
       end
+
+      # Translation imports write products, so they share the products scope
+      # (mirrors Spree::Exports::ProductTranslations.required_scope).
+      def self.required_scope
+        :products
+      end
     end
   end
 end

data/app/models/spree/locale.rb

@@ -0,0 +1,104 @@
+module Spree
+  # Virtual model for a supported locale. Wraps a locale +code+ and exposes its
+  # display name, layout direction, and whether it is a store's default — the
+  # single home for that logic (RTL list, name resolution) instead of being
+  # restated in serializers, helpers, and the admin RTL module.
+  class Locale
+    include ActiveModel::Model
+    include Comparable
+
+    # ISO 639-1 language codes that use right-to-left scripts.
+    RTL_LANGUAGE_CODES = %w[ar he fa ur yi].freeze
+
+    # @!attribute code
+    #   @return [String] the locale code, e.g. "en", "pt-BR"
+    attr_accessor :code
+
+    # Display name, e.g. "English", "Deutsch". Falls back to the code for an
+    # unknown locale.
+    # @return [String]
+    def name
+      code = self.code.to_s
+
+      if I18n.exists?('spree.i18n.this_file_language', locale: code, fallback: false)
+        return normalize_name(Spree.t('i18n.this_file_language', locale: code))
+      end
+
+      if defined?(SpreeI18n::Locale) && (name = SpreeI18n::Locale.local_language_name(code))
+        return normalize_name(name)
+      end
+
+      return 'English' if code == 'en'
+
+      code
+    end
+
+    # Select label, e.g. "EN — English".
+    # @return [String]
+    def label
+      upper = code.to_s.upcase
+      return upper if name.blank? || name.casecmp?(code.to_s)
+
+      "#{upper} — #{name}"
+    end
+
+    # @return [Spree::Store] the current store
+    def store
+      @store ||= Spree::Store.current
+    end
+
+    # @return [Boolean] whether this is the store's default (source) locale
+    def default?
+      store.present? && code.to_s == store.default_locale.to_s
+    end
+
+    # @return [Boolean] whether the locale uses a right-to-left script
+    def rtl?
+      RTL_LANGUAGE_CODES.include?(language_code)
+    end
+
+    # @return [String] "rtl" or "ltr"
+    def direction
+      rtl? ? 'rtl' : 'ltr'
+    end
+
+    # The base ISO 639-1 language code, dropping any region (e.g. "pt-BR" → "pt").
+    # @return [String]
+    def language_code
+      code.to_s.downcase.tr('_', '-').split('-').first
+    end
+
+    def to_s
+      code.to_s
+    end
+
+    # Compare/equality by code so a Locale slots into string-keyed collections
+    # (e.g. `locale == "en"`, `[locale].sort`).
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+
+    def eql?(other)
+      other.is_a?(Spree::Locale) && code.to_s == other.code.to_s
+    end
+
+    def hash
+      code.to_s.hash
+    end
+
+    private
+
+    # Strip a trailing " (CODE)" suffix from Spree I18n locale labels. Uses
+    # plain string ops rather than a regex to avoid polynomial backtracking on
+    # adversarial input (ReDoS).
+    def normalize_name(name)
+      name = name.to_s.rstrip
+      return name unless name.end_with?(')')
+
+      open_paren = name.rindex('(')
+      return name unless open_paren
+
+      name[0...open_paren].rstrip
+    end
+  end
+end

data/app/models/spree/option_type.rb

@@ -9,10 +9,16 @@ module Spree
     include Spree::UniqueName
     include Spree::Metafields
     include Spree::Metadata
-    include Spree::TranslatableResource
+    # presentation column, exposed publicly as `label` + translated via Mobility.
+    include Spree::PresentationTranslatable
 
-    TRANSLATABLE_FIELDS = %i[presentation].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
+    TRANSLATABLE_FIELDS = Spree::PresentationTranslatable::TRANSLATABLE_FIELDS
+
+    # Option values are translated alongside their type — the translations
+    # endpoint nests their matrices so the editor fetches both in one read.
+    def self.translatable_children
+      :option_values
+    end
 
     self::Translation.class_eval do
       normalizes :presentation, with: ->(value) { value&.to_s&.squish&.presence }
@@ -41,16 +47,8 @@ module Spree
     has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
     has_many :prototypes, through: :option_type_prototypes, class_name: 'Spree::Prototype'
 
-    # 5.5 API naming bridge (DB column rename in 6.0)
-    # NOTE: alias_attribute bypasses Mobility's locale-aware reader/writer,
-    # so we define explicit delegating methods instead.
-    def label(*args)
-      presentation(*args)
-    end
-
-    def label=(value)
-      self.presentation = value
-    end
+    # 5.5 API naming bridge (`label` → `presentation`) lives in
+    # Spree::PresentationTranslatable.
 
     #
     # Validations

data/app/models/spree/option_value.rb

@@ -5,14 +5,10 @@ module Spree
     include Spree::ParameterizableName
     include Spree::Metafields
     include Spree::Metadata
-    include Spree::TranslatableResource
+    # presentation column, exposed publicly as `label` + translated via Mobility.
+    include Spree::PresentationTranslatable
 
-    TRANSLATABLE_FIELDS = %i[presentation].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
-
-    self::Translation.class_eval do
-      normalizes :presentation, with: ->(value) { value&.to_s&.squish&.presence }
-    end
+    TRANSLATABLE_FIELDS = Spree::PresentationTranslatable::TRANSLATABLE_FIELDS
 
     #
     # Magic methods
@@ -33,16 +29,8 @@ module Spree
     has_many :variants, through: :option_value_variants, class_name: 'Spree::Variant'
     has_many :products, through: :variants, class_name: 'Spree::Product'
 
-    # 5.5 API naming bridge (DB column rename in 6.0)
-    # NOTE: alias_attribute bypasses Mobility's locale-aware reader/writer,
-    # so we define explicit delegating methods instead.
-    def label(*args)
-      presentation(*args)
-    end
-
-    def label=(value)
-      self.presentation = value
-    end
+    # 5.5 API naming bridge (`label` → `presentation`) lives in
+    # Spree::PresentationTranslatable.
 
     #
     # Validations

data/app/models/spree/order.rb

@@ -224,7 +224,6 @@ module Spree
     accepts_nested_attributes_for :shipments
 
     # Needs to happen before save_permalink is called
-    before_validation :ensure_store_presence
     before_validation :ensure_market_presence
     before_validation :ensure_channel_presence
     before_validation :ensure_currency_presence
@@ -500,7 +499,8 @@ module Spree
     end
 
     def ensure_store_presence
-      self.store ||= Spree::Store.default
+      Spree::Deprecation.warn('Spree::Order#ensure_store_presence is deprecated and will be removed in Spree 6.0. ensure_store instead.')
+      ensure_store
     end
 
     def ensure_market_presence
@@ -513,6 +513,23 @@ module Spree
       self.channel = store&.default_channel
     end
 
+    # @return [Boolean] true when this order has no registered user and its
+    #   channel forbids guest checkout (see Spree::Channel::Gating). Enforced by
+    #   the checkout completion service and the v3 Store API so every completion
+    #   path (controller, payment webhook) is covered.
+    #
+    #   A +prices_hidden+ channel also disallows guest completion regardless of
+    #   the +guest_checkout+ flag — prices are withheld from guests, and a buyer
+    #   who cannot see prices cannot meaningfully place an order. This dissolves
+    #   the otherwise contradictory "prices hidden but guests may buy" config.
+    def guest_checkout_disallowed?
+      return false if user_id.present?
+      return false if channel.blank?
+      return true if channel.storefront_prices_hidden?
+
+      !channel.resolved_guest_checkout
+    end
+
     def allow_cancel?
       return false if !completed? || canceled?
 

data/app/models/spree/payment_method.rb

@@ -5,13 +5,15 @@ module Spree
     acts_as_paranoid
     acts_as_list
 
-    include Spree::StoreScopedResource
+    include Spree::SingleStoreResource
     include Spree::Metafields
     include Spree::Metadata
     include Spree::DisplayOn
     if defined?(Spree::Security::PaymentMethods)
       include Spree::Security::PaymentMethods
     end
+    # Multi-store sharing moved to the spree_multi_store extension in 5.6.
+    include Spree::LegacyMultiStoreSupport unless defined?(SpreeMultiStore)
 
     scope :active,    -> { where(active: true).order(position: :asc) }
     scope :available, -> { active.where(display_on: [:front_end, :back_end, :both]) }
@@ -20,10 +22,10 @@ module Spree
     after_initialize :set_name, if: :new_record?
 
     validates :name, presence: true
+    validates :store, presence: true, unless: -> { Spree::Config[:disable_store_presence_validation] }
     normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
 
-    has_many :store_payment_methods, class_name: 'Spree::StorePaymentMethod', inverse_of: :payment_method
-    has_many :stores, class_name: 'Spree::Store', through: :store_payment_methods
+    belongs_to :store, class_name: 'Spree::Store'
 
     has_many :payments, class_name: 'Spree::Payment', inverse_of: :payment_method, dependent: :nullify
     has_many :credit_cards, class_name: 'Spree::CreditCard', dependent: :destroy # CCs are soft deleted
@@ -101,7 +103,6 @@ module Spree
     # Returns the webhook URL for this payment method.
     # @return [String, nil]
     def webhook_url
-      store = stores.first
       return nil unless store
 
       "#{store.url_or_custom_domain}/api/v3/webhooks/payments/#{prefixed_id}"
@@ -200,7 +201,7 @@ module Spree
     def available_for_store?(store)
       return true if store.blank?
 
-      store_ids.include?(store.id)
+      store_id == store.id
     end
 
     def public_preferences

data/app/models/spree/policy.rb

@@ -21,7 +21,8 @@ module Spree
     # Translations
     #
     TRANSLATABLE_FIELDS = %i[name body].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
+    RICH_TEXT_TRANSLATABLE_FIELDS = %i[body].freeze
+    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
 
     #
     # ActionText

data/app/models/spree/product.rb

@@ -34,7 +34,7 @@ module Spree
     include Spree::Product::Webhooks
     include Spree::Product::Slugs
     include Spree::Product::Channels
-    include Spree::Product::LegacyMultiStoreSupport unless defined?(SpreeMultiStore)
+    include Spree::LegacyMultiStoreSupport unless defined?(SpreeMultiStore)
     include Spree::SearchIndexable
     if defined?(Spree::VendorConcern)
       include Spree::VendorConcern
@@ -56,7 +56,8 @@ module Spree
     }.freeze
 
     TRANSLATABLE_FIELDS = %i[name description slug meta_description meta_title].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
+    RICH_TEXT_TRANSLATABLE_FIELDS = %i[description].freeze
+    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
 
     self::Translation.class_eval do
       normalizes :name, :meta_title, with: ->(value) { value&.to_s&.squish&.presence }
@@ -522,6 +523,26 @@ module Spree
       active? && !deleted? && (available_on.nil? || available_on <= Time.current)
     end
 
+    # True when the product is currently offered as a pre-order: at least one
+    # variant is sold before it is in stock (see {Variant#preorder?}).
+    # Independent of publishing — a pre-order product is live in the catalog,
+    # just flagged "buy now, ships later".
+    # @return [Boolean]
+    def preorder?
+      default_variant.preorder? || variants.any?(&:preorder?)
+    end
+
+    # The latest "ships by" date across the product's pre-order variants, so a
+    # storefront can show a single "ships by" promise for the product. Nil when
+    # the product is not a pre-order. Scans the same sellable set {#preorder?}
+    # consults (the master only counts when it is the sole, purchasable
+    # variant), reading preloaded associations to avoid an N+1.
+    # @return [ActiveSupport::TimeWithZone, nil]
+    def preorder_ships_at
+      candidates = has_variants? ? variants : [master]
+      candidates.select(&:preorder?).filter_map(&:preorder_ships_at).max
+    end
+
     def discontinue!
       self.discontinue_on = Time.current
       self.status = 'archived'

data/app/models/spree/promotion/rules/channel.rb

@@ -0,0 +1,37 @@
+# A rule to limit a promotion based on the order's channel.
+module Spree
+  class Promotion
+    module Rules
+      class Channel < PromotionRule
+        # Stored as raw IDs. Accepts prefixed IDs (`ch_…`) from API
+        # callers and decodes them on write so eligibility checks compare
+        # against the order's raw `channel_id` directly. Scope confines the
+        # existence check to the promotion's store so cross-store channel
+        # IDs can't sneak in.
+        preference :channel_ids, :array, default: [],
+                   parse_on_set: normalize_id_preference(
+                     klass: Spree::Channel,
+                     scope: ->(rule) { rule.promotion&.store&.channels || Spree::Channel.none }
+                   )
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def channels
+          return Spree::Channel.none if preferred_channel_ids.blank?
+
+          promotion.store.channels.where(id: preferred_channel_ids)
+        end
+
+        def eligible?(order, _options = {})
+          return false if preferred_channel_ids.empty?
+          return true if preferred_channel_ids.map(&:to_s).include?(order.channel_id.to_s)
+
+          eligibility_errors.add(:base, eligibility_error_message(:no_matching_channel))
+          false
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion/rules/market.rb

@@ -0,0 +1,37 @@
+# A rule to limit a promotion based on the order's market.
+module Spree
+  class Promotion
+    module Rules
+      class Market < PromotionRule
+        # Stored as raw IDs. Accepts prefixed IDs (`mkt_…`) from API
+        # callers and decodes them on write so eligibility checks compare
+        # against the order's raw `market_id` directly. Scope confines the
+        # existence check to the promotion's store so cross-store market
+        # IDs can't sneak in.
+        preference :market_ids, :array, default: [],
+                   parse_on_set: normalize_id_preference(
+                     klass: Spree::Market,
+                     scope: ->(rule) { rule.promotion&.store&.markets || Spree::Market.none }
+                   )
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def markets
+          return Spree::Market.none if preferred_market_ids.blank?
+
+          promotion.store.markets.where(id: preferred_market_ids)
+        end
+
+        def eligible?(order, _options = {})
+          return false if preferred_market_ids.empty?
+          return true if preferred_market_ids.map(&:to_s).include?(order.market_id.to_s)
+
+          eligibility_errors.add(:base, eligibility_error_message(:no_matching_market))
+          false
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion.rb

@@ -2,12 +2,14 @@ module Spree
   class Promotion < Spree.base_class
     has_prefix_id :promo  # Spree-specific: promotion
 
-    include Spree::StoreScopedResource
+    include Spree::SingleStoreResource
     include Spree::Metafields
     include Spree::Metadata
     if defined?(Spree::Security::Promotions)
       include Spree::Security::Promotions
     end
+    # Multi-store sharing moved to the spree_multi_store extension in 5.6.
+    include Spree::LegacyMultiStoreSupport unless defined?(SpreeMultiStore)
 
     publishes_lifecycle_events
 
@@ -37,8 +39,7 @@ module Spree
     has_many :coupon_codes, -> { order(created_at: :asc) }, dependent: :destroy, class_name: 'Spree::CouponCode'
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
-    has_many :store_promotions, class_name: 'Spree::StorePromotion'
-    has_many :stores, class_name: 'Spree::Store', through: :store_promotions
+    belongs_to :store, class_name: 'Spree::Store'
 
     after_save :apply_pending_rules_and_actions, if: :pending_rules_or_actions?
 
@@ -60,6 +61,7 @@ module Spree
     #
     validates_associated :rules
     validates :name, presence: true
+    validates :store, presence: true, unless: -> { Spree::Config[:disable_store_presence_validation] }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }, allow_blank: true
     validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }

data/app/models/spree/promotion_handler/promotion_duplicator.rb

@@ -11,7 +11,7 @@ module Spree
         @new_promotion.path = "#{@promotion.path}_#{@random_string}"
         @new_promotion.name = "New #{@promotion.name}"
         @new_promotion.code = "#{@promotion.code}_#{@random_string}"
-        @new_promotion.stores = @promotion.stores
+        @new_promotion.store = @promotion.store
 
         ActiveRecord::Base.transaction do
           @new_promotion.save

data/app/models/spree/role_user.rb

@@ -1,11 +1,14 @@
 module Spree
   class RoleUser < Spree.base_class
+    include Spree::SingleStoreResource
+
     #
     # Associations
     #
     belongs_to :role, class_name: 'Spree::Role', foreign_key: :role_id
     belongs_to :user, polymorphic: true
     belongs_to :resource, polymorphic: true
+    belongs_to :store, class_name: 'Spree::Store'
     belongs_to :invitation, class_name: 'Spree::Invitation', optional: true, inverse_of: :role_user
 
     #
@@ -14,6 +17,7 @@ module Spree
     validates :role, presence: true
     validates :user, presence: true
     validates :resource, presence: true
+    validates :store, presence: true
     validates :role_id, uniqueness: { scope: [:user_id, :resource_id, :user_type, :resource_type] }
 
     #