spree_core 6.0.0.beta1 → 6.0.0.beta2

data/app/models/spree/line_item.rb

@@ -17,7 +17,7 @@ module Spree
       belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant'
     end
     belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory', optional: true
-    belongs_to :price_list, class_name: 'Spree::PriceList', optional: true
+    belongs_to :price_list, -> { with_deleted }, class_name: 'Spree::PriceList', optional: true
     # Snapshotted from the variant when the line is added — see copy_seller.
     # Nil is the operator's own first-party item.
     belongs_to :seller, class_name: 'Spree::Seller', optional: true

data/app/models/spree/order.rb

@@ -23,6 +23,7 @@ module Spree
 
     extend Spree::DisplayMoney
 
+    include Spree::ActedBy
     include Spree::SingleStoreResource
     include Spree::SanitizableRichText
     include Spree::Purchase::Channel
@@ -91,6 +92,54 @@ module Spree
       order
     end
 
+    # Checkout-step introspection belongs to Spree::Cart
+    # ({Spree::Purchase::CheckoutSteps}) since 6.0 — an order is past checkout
+    # by definition. These bridges answer for an upgrader reaching for the
+    # Spree 5 API on an order, rather than raising NoMethodError.
+    #
+    # The step list is data-driven, so it stays accurate here: the registry
+    # computes it from the record's own predicates, all of which Order carries.
+    # Where the checkout stands within that list is not, which is why the
+    # readers below report a finished checkout.
+
+    # @deprecated Checkout steps belong to Spree::Cart; removed in 6.1.
+    def checkout_steps
+      Spree::Deprecation.warn('Spree::Order#checkout_steps is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      Spree::Checkout::Registry.step_names_for(self)
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1.
+    def has_checkout_step?(step)
+      Spree::Deprecation.warn('Spree::Order#has_checkout_step? is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      step.present? && Spree::Checkout::Registry.step_names_for(self).include?(step.to_s)
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1.
+    def checkout_step_index(step)
+      Spree::Deprecation.warn('Spree::Order#checkout_step_index is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      Spree::Checkout::Registry.step_names_for(self).index(step).to_i
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1. An order has no
+    #   outstanding step, so this is always 'complete'.
+    def current_checkout_step
+      Spree::Deprecation.warn("Spree::Order#current_checkout_step is deprecated and will be removed in Spree 6.1. An order is past checkout, so this is always 'complete'.")
+      'complete'
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1.
+    def final_checkout_step
+      Spree::Deprecation.warn('Spree::Order#final_checkout_step is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      Spree::Checkout::Registry.step_names_for(self).reject { |step| step == 'complete' }.last || 'address'
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1. Every step is behind
+    #   an order, so this is the whole list bar 'complete'.
+    def completed_checkout_steps
+      Spree::Deprecation.warn("Spree::Order#completed_checkout_steps is deprecated and will be removed in Spree 6.1. An order is past checkout, so every step bar 'complete' is behind it.")
+      Spree::Checkout::Registry.step_names_for(self).reject { |step| step == 'complete' }
+    end
+
     # Standardized column names (renamed in 6.0); legacy readers stay as
     # aliases one release.
     alias_attribute :promo_total, :discount_total
@@ -169,9 +218,7 @@ module Spree
     # Whose sale this is. Nil on the operator's own goods, including the
     # first-party child of a mixed marketplace checkout.
     belongs_to :seller, class_name: 'Spree::Seller', optional: true
-    belongs_to :created_by, class_name: "::#{Spree.admin_user_class}", optional: true
-    belongs_to :approver, class_name: "::#{Spree.admin_user_class}", optional: true
-    belongs_to :canceler, class_name: "::#{Spree.admin_user_class}", optional: true
+    acted_by :created_by, :approver, :canceler
     belongs_to :cancel_reason, class_name: 'Spree::OrderCancellationReason', optional: true, inverse_of: :orders
 
     belongs_to :preferred_stock_location, class_name: 'Spree::StockLocation', optional: true
@@ -1089,10 +1136,11 @@ module Spree
     # Approves the order and records the approver.
     # Delegates to {Spree::Orders::Approve} service.
     #
-    # @param user [Spree.customer_class, nil] the user who approved the order
+    # @param actor [Object, nil] who approved it — an admin user or an API
+    #   key (see Spree.actor_classes)
     # @return [Spree::ServiceModule::Result]
-    def approved_by(user = nil)
-      Spree.order_approve_service.call(order: self, approver: user)
+    def approved_by(actor = nil)
+      Spree.order_approve_service.call(order: self, approver: actor)
     end
 
     def approved?

data/app/models/spree/pricing_provider/internal.rb

@@ -45,7 +45,12 @@ module Spree
         # back to base.
         # @return [Spree::Price]
         def find_price_from_lists
-          (catalog_price_lists + applicable_price_lists).each do |price_list|
+          catalog_price_list_groups.each do |price_lists|
+            price = best_price_among(price_lists)
+            return price if price
+          end
+
+          applicable_price_lists.each do |price_list|
             price = find_price_for_list(price_list)
             return price if price
           end
@@ -53,12 +58,25 @@ module Spree
           nil
         end
 
-        # Price lists reached through the buyer's effective catalogs, in
-        # catalog resolution order — the company subtree, or failing that the
-        # customer's groups, or failing that the channel's default catalog.
-        # The same chain visibility uses, and its steps are alternatives: a
-        # company buyer is priced by their company's agreement and never
-        # also by their customer group's ({Spree::Catalog.for_context}).
+        # The cheapest price one node's lists give, nil when none prices this
+        # variant. Catalogs sharing a node rank equally, so taking the first to
+        # answer charged a company from whichever sorted first rather than the
+        # cheaper (docs/plans/6.0-b2b-companies-and-catalogs.md). Equal amounts
+        # keep list order, so the answer is stable.
+        #
+        # @param price_lists [Array<Spree::PriceList>]
+        # @return [Spree::Price, nil]
+        def best_price_among(price_lists)
+          price_lists.filter_map { |price_list| find_price_for_list(price_list) }.min_by(&:amount)
+        end
+
+        # Price lists reached through the buyer's effective catalogs, grouped
+        # by the node that assigns them and ordered nearest node first — the
+        # company subtree, or failing that the customer's groups, or failing
+        # that the channel's default catalog. The same chain visibility uses,
+        # and its steps are alternatives: a company buyer is priced by their
+        # company's agreement and never also by their customer group's
+        # ({Spree::Catalog.groups_for_context}).
         #
         # A catalog-attached list applies because the catalog applies: its
         # audience rules are not consulted, since the assignment already
@@ -68,10 +86,13 @@ module Spree
         # volume pricing is (docs/plans/6.0-price-list-automatic-pricing.md).
         # Status and dates gate the list as before.
         #
-        # @return [Array<Spree::PriceList>]
-        def catalog_price_lists
-          @catalog_price_lists ||= catalogs_for_context.filter_map(&:price_list).uniq.select do |price_list|
-            price_list.currently_active? && price_list.contextual_rules_applicable?(context)
+        # @return [Array<Array<Spree::PriceList>>]
+        def catalog_price_list_groups
+          @catalog_price_list_groups ||= catalog_groups_for_context.filter_map do |catalogs|
+            lists = catalogs.filter_map(&:price_list).select do |price_list|
+              price_list.currently_active? && price_list.contextual_rules_applicable?(context)
+            end
+            lists.presence
           end
         end
 
@@ -89,11 +110,12 @@ module Spree
         # Catalogs that apply to this buyer, through the one entry point
         # visibility and quantity terms also use — what a buyer is shown, what
         # they pay and how much they must take have to come from the same
-        # agreement. Reuses the request-scoped set for the current store, so a
+        # agreement. Grouped by assigning node, since that is where precedence
+        # lives. Reuses the request-scoped set for the current store, so a
         # listing does not re-resolve the same buyer per variant.
-        # @return [Array<Spree::Catalog>]
-        def catalogs_for_context
-          Spree::Catalog.for_buyer(
+        # @return [Array<Array<Spree::Catalog>>]
+        def catalog_groups_for_context
+          Spree::Catalog.groups_for_buyer(
             store: context.store, customer: context.user,
             company: context.company, channel: context.channel
           )

data/app/models/spree/refund.rb

@@ -2,6 +2,7 @@ module Spree
   class Refund < Spree.base_class
     has_prefix_id :re  # Stripe: re_
 
+    include Spree::ActedBy
     include Spree::HasCustomFields
     include Spree::Metadata
     include Spree::InstrumentsGatewayCalls
@@ -18,7 +19,7 @@ module Spree
     # payment covers several and only one of them is being refunded.
     belongs_to :order, class_name: 'Spree::Order', optional: true, inverse_of: :refunds
     belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
-    belongs_to :refunder, class_name: Spree.admin_user_class.to_s, optional: true
+    acted_by :refunder
     # What triggered this refund — a Spree::Return today, later an Exchange
     # or Claim; nil for a manual refund. Deliberately polymorphic: the set is
     # small and closed, and refunds are never bulk-queried in a hot path.

data/app/models/spree/return.rb

@@ -14,6 +14,7 @@ module Spree
     has_prefix_id :ret
 
     has_spree_number prefix: 'RET'
+    include Spree::ActedBy
     include Spree::NumberIdentifier
     include Spree::SingleStoreResource
     include Spree::HasStatus
@@ -31,7 +32,7 @@ module Spree
     belongs_to :reason, class_name: 'Spree::ReturnReason', optional: true, inverse_of: :returns
     # Staff only. Customer-initiated returns leave this nil — the requester
     # is always order.customer, so no second association is needed.
-    belongs_to :created_by, class_name: Spree.admin_user_class.to_s, optional: true
+    acted_by :created_by
 
     has_many :return_line_items, class_name: 'Spree::ReturnLineItem',
                                  dependent: :destroy, inverse_of: :return

data/app/models/spree/stock_receipt.rb

@@ -9,6 +9,7 @@ module Spree
   class StockReceipt < Spree.base_class
     has_prefix_id :sr
 
+    include Spree::ActedBy
     include Spree::SingleStoreResource
     has_spree_number prefix: 'SR'
     include Spree::NumberIdentifier
@@ -17,7 +18,7 @@ module Spree
     publishes_lifecycle_events
 
     belongs_to :receivable, polymorphic: true, inverse_of: :stock_receipts
-    belongs_to :received_by, class_name: Spree.admin_user_class.to_s, optional: true
+    acted_by :received_by
 
     has_many :items, class_name: 'Spree::StockReceiptItem', inverse_of: :stock_receipt,
                      dependent: :destroy
@@ -29,8 +30,12 @@ module Spree
 
     normalizes :reference, with: ->(value) { value.strip.presence }
 
+    # `received_by_type` sits beside its id because ids are per-table: filtering
+    # on the id alone would match the admin user and the API key that happen to
+    # share that number.
     self.whitelisted_ransackable_attributes = %w[number reference received_at receivable_type
-                                                 receivable_id received_by_id created_at]
+                                                 receivable_id received_by_id received_by_type
+                                                 created_at]
 
     # @return [Integer] units this delivery put on the shelf
     def quantity_accepted_total

data/app/models/spree/store.rb

@@ -95,6 +95,10 @@ module Spree
     # e.g. "https://myshop.com" — see #storefront_url for the fallback chain.
     preference :storefront_url, :string
     preference :special_instructions_enabled, :boolean, default: false
+    # Advertises a confirm/review step for every checkout, even when no
+    # payment method asks for one. Payment methods that require confirmation
+    # get it regardless of this setting.
+    preference :always_include_confirm_step, :boolean, default: false
     preference :stock_reservation_ttl_minutes, :integer, default: 10
     # Store-wide default for when a customer is charged rather than only
     # authorized. A payment method's own capture_method wins when set.

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

@@ -6,7 +6,8 @@ module Spree
       # Approves an order: clears the risk flag and records who approved it and when.
       #
       # @param order [Spree::Order]
-      # @param approver [Object, nil] the user/admin who approved
+      # @param approver [Object, nil] who approved it — an admin user or an
+      #   API key (see Spree.actor_classes)
       # @param level [String, nil] deprecated and ignored — removed in Spree 6.1
       # @param note [String, nil] deprecated and ignored — removed in Spree 6.1
       # @return [Spree::ServiceModule::Result]
@@ -16,7 +17,7 @@ module Spree
         end
 
         changes = { considered_risky: false, approved_at: Time.current }
-        changes[:approver_id] = approver.id if approver.present?
+        changes.merge!(Spree::ActedBy.columns_for(:approver, approver)) if approver.present?
         order.update_columns(changes)
 
         order.publish_event('order.approved')

data/app/workflows/spree/orders/cancel.rb

@@ -11,7 +11,8 @@ module Spree
       hooks :before_cancel, :after_cancel
 
       # @param order [Spree::Order]
-      # @param canceler [Object, nil] the user/admin who initiated the cancellation
+      # @param canceler [Object, nil] who initiated it — an admin user or an
+      #   API key (see Spree.actor_classes)
       # @param canceled_at [Time, nil] timestamp (defaults to Time.current)
       # @param reason [Spree::OrderCancellationReason, nil] the merchant's own
       #   vocabulary; must belong to the order's store
@@ -102,7 +103,7 @@ module Spree
 
       def mark_canceled
         changes = { status: 'canceled', canceled_at: @decided_at, cancel_reason_id: reason&.id, cancel_note: note }
-        changes[:canceler_id] = canceler.id if canceler.present?
+        changes.merge!(Spree::ActedBy.columns_for(:canceler, canceler)) if canceler.present?
         order.update_columns(changes)
       end
 

data/app/workflows/spree/refunds/create.rb

@@ -19,7 +19,7 @@ module Spree
       #   creditable balance
       # @param reason [Spree::RefundReason, nil] defaults to the store's
       #   return-processing reason
-      # @param refunder [Object, nil] the admin issuing the refund
+      # @param refunder [Object, nil] who is issuing it (see Spree.actor_classes)
       # @param originator [Object, nil] what triggered the refund — a
       #   Spree::Return, Exchange or Claim; nil for a manual refund
       # @param order [Spree::Order, nil] which order is being put right.

data/app/workflows/spree/returns/approve.rb

@@ -13,7 +13,7 @@ module Spree
       hooks :validate, :after_approve
 
       # @param return_record [Spree::Return]
-      # @param approver [Object, nil] the admin approving it
+      # @param approver [Object, nil] who is approving it (see Spree.actor_classes)
       def perform(return_record:, approver: nil)
         super
 

data/app/workflows/spree/returns/create.rb

@@ -18,8 +18,8 @@ module Spree
       #   back to; defaults to the location that shipped them
       # @param reason [Spree::ReturnReason, nil]
       # @param memo [String, nil] customer- or staff-supplied note
-      # @param created_by [Object, nil] the admin opening it; nil for
-      #   customer self-service
+      # @param created_by [Object, nil] who is opening it (see
+      #   Spree.actor_classes); nil for customer self-service
       def perform(order:, items:, stock_location: nil, reason: nil, memo: nil, created_by: nil)
         super
 

data/app/workflows/spree/returns/refund.rb

@@ -19,7 +19,7 @@ module Spree
       # @param amount [BigDecimal, Numeric, nil] defaults to what the return
       #   is still owed
       # @param refund_method [String] 'original_payment' or 'store_credit'
-      # @param refunder [Object, nil] the admin issuing it
+      # @param refunder [Object, nil] who is issuing it (see Spree.actor_classes)
       def perform(return_record:, amount: nil, refund_method: 'original_payment', refunder: nil)
         super
 

data/config/locales/en.yml

@@ -1102,6 +1102,7 @@ en:
         store_is_already_set: Store is already set
         unknown_custom_field_type: 'is not a known custom field type (expected one of: %{types})'
         unknown_scopes: 'contains unknown scopes: %{scopes}'
+        unregistered_actor: is not a registered actor class
         variant_product_mismatch: must belong to the same product as the variant
       services:
         get_shipping_rates:

data/db/migrate/20260916000001_order_operation_actors_polymorphic.rb

@@ -0,0 +1,30 @@
+# Makes the order-operation "who did this" associations polymorphic, so a
+# write made with a secret API key records the key rather than nobody.
+# See docs/plans/6.0-action-actors.md.
+class OrderOperationActorsPolymorphic < ActiveRecord::Migration[8.1]
+  ACTORS = {
+    spree_orders: %i[created_by approver canceler],
+    spree_refunds: %i[refunder],
+    spree_returns: %i[created_by],
+    spree_exchanges: %i[created_by],
+    spree_claims: %i[created_by],
+    spree_stock_receipts: %i[received_by]
+  }.freeze
+
+  def change
+    ACTORS.each do |table, names|
+      names.each do |name|
+        # Nullable with no default: the type is data, filled by
+        # `rake spree:upgrade:backfill_actor_types`. Until it runs, the
+        # transitional reader resolves these rows through the admin user
+        # class — the only thing they could ever have pointed at.
+        add_column table, :"#{name}_type", :string
+
+        # Named for the pair so it reads apart from the `_id` index that
+        # already exists on most of these columns.
+        add_index table, [:"#{name}_type", :"#{name}_id"],
+                  name: "index_#{table}_on_#{name}_actor"
+      end
+    end
+  end
+end

data/lib/generators/spree/api_resource/api_resource_generator.rb

@@ -76,7 +76,7 @@ module Spree
     # the second run with "Spree::Brand is already used in your application".
     class_option :skip_collision_check, type: :boolean, default: true, desc: false
 
-    desc 'Scaffold a complete v3-conformant API resource (model + migration + controllers + serializers + routes + factory + specs)'
+    desc 'Creates a new Spree API resource'
 
     # --- Owned-once gating ---
     #
@@ -171,8 +171,10 @@ module Spree
 
       routes_file = api_routes_path
 
+      # An installed gem is read-only, which is the normal case: a host app
+      # declares its own routes instead, through the engine's route hook.
       unless File.exist?(routes_file) && File.writable?(routes_file)
-        say_status :skip, "routes.rb at #{routes_file} (not writable — only edge installs can modify gem source)", :yellow
+        draw_app_routes
         return
       end
 
@@ -180,11 +182,67 @@ module Spree
       inject_route_for(:admin, admin_route_line) if options[:admin]
     end
 
+    no_tasks do
+    # A host app declares its API routes in config/routes.rb, inside the
+    # engine's route hook that spree-starter ships ready to fill in. The
+    # block must be registered before the engine draws its routes, which is
+    # why it lives in routes.rb rather than an initializer.
+    def draw_app_routes
+      path = 'config/routes.rb'
+      full = File.join(destination_root, path)
+
+      unless File.exist?(full)
+        say_status :skip, "#{path} not found — add the routes by hand", :yellow
+        return
+      end
+
+      unless File.read(full).include?('Spree::Core::Engine.add_routes')
+        say_status :skip, "#{path} has no `Spree::Core::Engine.add_routes` block — add the routes by hand", :yellow
+        return
+      end
+
+      append_app_route(path, :store, store_route_line.strip) if options[:store]
+      append_app_route(path, :admin, admin_route_line.strip) if options[:admin]
+    end
+
+    # Inserts one `resources` line into the named namespace. Idempotent: a
+    # resource already declared there is left alone, so re-runs are safe.
+    def append_app_route(path, namespace, route_line)
+      full = File.join(destination_root, path)
+      content = File.read(full)
+
+      # Confined to the engine's route hook: an application may well have its
+      # own `namespace :admin` earlier in the file, and a route inserted there
+      # would never be drawn on the engine.
+      hook = content[/^(\s*)Spree::Core::Engine\.add_routes do\n.*?^\1end\n/m]
+      unless hook
+        say_status :skip, "#{path} (no `Spree::Core::Engine.add_routes` block — add `#{route_line}` by hand)", :yellow
+        return
+      end
+
+      match = hook.match(/^(\s*)namespace :#{namespace} do\n/)
+      unless match
+        say_status :skip, "#{path} (no :#{namespace} namespace — add `#{route_line}` by hand)", :yellow
+        return
+      end
+
+      block = hook[match.end(0)..].to_s[/\A.*?^#{match[1]}end$/m].to_s
+      if block.include?(route_line)
+        say_status :identical, "#{path} (#{namespace}: #{route_line})", :blue
+        return
+      end
+
+      updated_hook = hook.sub(match[0], "#{match[0]}#{match[1]}  #{route_line}\n")
+      File.write(full, content.sub(hook, updated_hook))
+      say_status :route, "#{path} (#{namespace}: #{route_line})", :green
+    end
+    end
+
     def print_summary
       say ''
       say "✓ Generated Spree::#{bare_class_name} API resource", :green
       say ''
-      say "  Prefixed ID:  #{id_prefix}_xxxxxxxxxx  (edit `has_prefix_id` in the model to change)"
+      say "  Prefixed ID:  #{id_prefix}_xxxxxxxxxx"
       if store_external_name != bare_class_name
         say "  Store API:    /api/v3/store/#{store_external_plural}  (aliased from #{bare_class_name})"
       elsif options[:store]
@@ -196,9 +254,9 @@ module Spree
       say '    1. Review the generated model — add validations, scopes, callbacks'
       say '    2. Apply the migration:  pnpm exec spree migrate'
       say '    3. Set up authorization (CanCanCan ability) for the resource'
-      say '    4. Decide whether this resource is store-scoped (add `has_many` on Store)'
+      say "    4. Add `has_many :#{plural_name}` to Spree::Store" if store_scoped?
       if options[:store] || options[:admin]
-        say '    5. Run the specs:  pnpm exec spree exec bundle exec rspec spec/controllers/spree/api/v3/'
+        say "    #{store_scoped? ? 5 : 4}. Run the specs:  pnpm exec spree rspec spec/controllers/spree/api/v3/"
       end
       say ''
     end

data/lib/generators/spree/api_resource/templates/admin_controller.rb.tt

@@ -3,6 +3,11 @@ module Spree
     module V3
       module Admin
         class <%= plural_name.camelize %>Controller < ResourceController
+          # Which API key scope authorizes this endpoint — `read_<%= plural_name %>`
+          # and `write_<%= plural_name %>`. Point it at an existing resource name
+          # instead if this endpoint belongs under one.
+          scoped_resource :<%= plural_name %>
+
           protected
 
           def model_class

data/lib/generators/spree/api_resource/templates/admin_controller_spec.rb.tt

@@ -2,6 +2,9 @@ require 'spec_helper'
 
 RSpec.describe Spree::Api::V3::Admin::<%= plural_name.camelize %>Controller, type: :controller do
   render_views
+  # The controller is mounted by the engine, so its paths resolve
+  # through the engine's router rather than the application's.
+  routes { Spree::Core::Engine.routes }
 
   include_context 'API v3 Admin authenticated'
 

data/lib/generators/spree/api_resource/templates/store_controller_spec.rb.tt

@@ -2,8 +2,11 @@ require 'spec_helper'
 
 RSpec.describe Spree::Api::V3::Store::<%= plural_name.camelize %>Controller, type: :controller do
   render_views
+  # The controller is mounted by the engine, so its paths resolve
+  # through the engine's router rather than the application's.
+  routes { Spree::Core::Engine.routes }
 
-  include_context 'API v3 Store'
+  include_context 'API v3 Store guest'
 
   let!(:<%= singular_name %>) { create(:<%= singular_name %>) }
 

data/lib/generators/spree/model/model_generator.rb

@@ -25,7 +25,24 @@ module Spree
                  default: false,
                  desc: 'Include Spree::HasCustomFields and Spree::Metadata concerns'
 
-    desc 'Creates a new Spree model with prefixed IDs and Spree.base_class parent'
+    # On by default so every new resource is observable from the moment it
+    # exists — subscribers and webhooks both hang off these events, and a
+    # model that publishes nothing is invisible to integrations.
+    class_option :lifecycle_events,
+                 type: :boolean,
+                 default: true,
+                 desc: 'Publish created/updated/deleted events'
+
+    # Store scoping is the default because commerce records belong to a store:
+    # catalog, configuration and orders are all per-store. Opt out with
+    # --no-store-scoped only for genuinely global reference data (countries,
+    # states, roles), which is rare enough to be the explicit case.
+    class_option :store_scoped,
+                 type: :boolean,
+                 default: true,
+                 desc: 'Scope the model to a store'
+
+    desc 'Creates a new Spree model'
 
     def create_module_file
       return
@@ -44,6 +61,28 @@ module Spree
         options[:custom_fields]
       end
 
+      def lifecycle_events?
+        options[:lifecycle_events]
+      end
+
+      # Whether the record belongs to a store, however that reference got
+      # there: the concern below, or a `store:references` the caller passed.
+      # Uniqueness and indexes key off this, so a value stays unique within a
+      # store rather than across the whole installation.
+      def store_scoped?
+        options[:store_scoped] || declares_store_reference?
+      end
+
+      # The concern is what adds `belongs_to :store`, so a model that already
+      # declares one must not include it as well.
+      def includes_store_concern?
+        options[:store_scoped] && !declares_store_reference?
+      end
+
+      def declares_store_reference?
+        attributes.any? { |attribute| attribute.name == 'store' }
+      end
+
       def class_path
         ['spree']
       end

data/lib/generators/spree/model/templates/create_table_migration.rb.tt

@@ -1,6 +1,10 @@
 class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
     create_table :<%= table_name %><%= primary_key_type %> do |t|
+<% if includes_store_concern? -%>
+      t.references :store, null: false, index: true, foreign_key: false
+
+<% end -%>
 <% attributes.reject(&:reference?).reject(&:virtual?).each do |attribute| -%>
 <% if attribute.password_digest? -%>
       t.string :password_digest, null: false
@@ -27,9 +31,14 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
               name: 'index_<%= table_name %>_on_<%= attribute.name %>'
 <% end -%>
 <% attributes.select(&:has_uniq_index?).reject(&:token?).each do |attribute| -%>
+<% if store_scoped? -%>
+    add_index :<%= table_name %>, [:store_id, :<%= attribute.name %>], unique: true,
+              name: 'index_<%= table_name %>_on_store_id_and_<%= attribute.name %>'
+<% else -%>
     add_index :<%= table_name %>, :<%= attribute.name %>, unique: true,
               name: 'index_<%= table_name %>_on_<%= attribute.name %>'
 <% end -%>
+<% end -%>
 <% attributes.select { |a| a.has_index? && !a.has_uniq_index? && !a.reference? && !a.token? }.each do |attribute| -%>
     add_index :<%= table_name %>, :<%= attribute.name %>
 <% end -%>

data/lib/generators/spree/model/templates/model.rb.tt

@@ -1,5 +1,9 @@
 module Spree
   class <%= class_name.demodulize %> < <%= parent_class_name %>
+<% if includes_store_concern? -%>
+    include Spree::SingleStoreResource
+
+<% end -%>
 <% if custom_fields? -%>
     include Spree::HasCustomFields
     include Spree::Metadata
@@ -10,7 +14,9 @@ module Spree
 
 <% end -%>
     has_prefix_id :<%= id_prefix %>
-
+<% if lifecycle_events? -%>
+    publishes_lifecycle_events
+<% end -%>
 <% attributes.select(&:reference?).each do |attribute| -%>
 <% if attribute.polymorphic? -%>
     belongs_to :<%= attribute.name %>, polymorphic: true
@@ -38,10 +44,10 @@ module Spree
     has_secure_password
 <% end -%>
 <% required_attrs = attributes.reject { |a| a.reference? || a.type == :boolean || a.token? || a.attachment? || a.attachments? || a.rich_text? || a.password_digest? } -%>
-<% if required_attrs.any? %>
-<% required_attrs.each do |attr| -%>
-    validates :<%= attr.name %>, presence: true<% if attr.has_uniq_index? %>, uniqueness: { scope: spree_base_uniqueness_scope }<% end %>
+<% if required_attrs.any? -%>
 
+<% required_attrs.each do |attr| -%>
+    validates :<%= attr.name %>, presence: true<% if attr.has_uniq_index? %>, uniqueness: { scope: [<%= ':store_id, ' if store_scoped? %>*spree_base_uniqueness_scope] }<% end %>
 <% end -%>
 <% end -%>
 <% ransackable = attributes.reject { |a| a.reference? || a.attachment? || a.attachments? || a.rich_text? || a.token? || a.password_digest? }.map(&:name) -%>