spree_core 6.0.0.beta2 → 6.0.0.beta3

data/db/sample_data/payment_methods.rb

@@ -1,19 +1,19 @@
-Spree::Store.all.find_each do |store|
-  cc_payment_method = store.payment_methods.find_or_initialize_by(
-    type: 'Spree::Gateway::Bogus',
-    name: 'Credit Card',
-    description: 'Bogus payment gateway.',
-    active: true
-  )
-  cc_payment_method.storefront_visible = false
-  cc_payment_method.save!
+store = Spree::Current.store
 
-  check_payment_method = store.payment_methods.find_or_initialize_by(
-    type: 'Spree::PaymentMethod::Check',
-    name: 'Check',
-    description: 'Pay by check.',
-    active: true
-  )
-  check_payment_method.storefront_visible = false
-  check_payment_method.save!
-end
+cc_payment_method = store.payment_methods.find_or_initialize_by(
+  type: 'Spree::Gateway::Bogus',
+  name: 'Credit Card',
+  description: 'Bogus payment gateway.',
+  active: true
+)
+cc_payment_method.storefront_visible = false
+cc_payment_method.save!
+
+check_payment_method = store.payment_methods.find_or_initialize_by(
+  type: 'Spree::PaymentMethod::Check',
+  name: 'Check',
+  description: 'Pay by check.',
+  active: true
+)
+check_payment_method.storefront_visible = false
+check_payment_method.save!

data/db/sample_data/product_type_categories.rb

@@ -5,7 +5,7 @@
 # categories — before it there is nothing to link to. Seeding is additive and
 # only applies to products created from here on, so linking after the fact
 # changes nothing about the imported catalog.
-store = Spree::Store.default
+store = Spree::Current.store
 
 categories_by_type = {
   'Kitchen Appliance' => 'Kitchen',

data/db/sample_data/product_types.rb

@@ -10,9 +10,9 @@
 #
 # Categories are attached afterwards by product_type_categories.rb — the import
 # is what creates them, so there is nothing to link to at this point.
-store = Spree::Store.default
+store = Spree::Current.store
 
-color_option_type = Spree::OptionType.find_by(name: 'color')
+color_option_type = Spree::OptionType.for_store(store).find_by(name: 'color')
 
 definitions = store.custom_field_definitions.where(
   namespace: 'custom',

data/db/sample_data/promotions.rb

@@ -1,8 +1,6 @@
-promotion = Spree::Promotion.where(
+promotion = Spree::Current.store.promotions.where(
   name: 'Free Shipping',
   code: 'FREESHIP'
-).first_or_create! do |promo|
-  promo.store = Spree::Store.default
-end
+).first_or_create!
 
 Spree::Promotion::Actions::FreeShipping.where(promotion: promotion).first_or_create!

data/db/sample_data/wholesale.rb

@@ -2,7 +2,7 @@
 # Spree::Seeds::Channels: an approved demo buyer and a customer-group price
 # list, so a fresh install can walk the whole B2B portal story — sign in as
 # the buyer, see wholesale prices, check out on the wholesale channel.
-store = Spree::Store.default
+store = Spree::Current.store
 
 wholesale_group = store.customer_groups.find_or_create_by!(name: Spree::Seeds::CustomerGroups::WHOLESALE_NAME)
 

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

@@ -17,6 +17,7 @@ module Spree
   #   - Factory                       (managed — overwrite on re-run)
   #   - Controller specs              (managed — overwrite on re-run)
   #   - Routes                        (idempotent inject between sentinels)
+  #   - Permission scope + label      (idempotent inject; locale owned-once)
   #
   # Owned-once contract: if the model file already exists, the generator
   # leaves it (and the migration) alone — domain code is yours after
@@ -59,6 +60,11 @@ module Spree
                  default: false,
                  desc: "Don't inject routes into spree/api/config/routes.rb"
 
+    class_option :permission_group,
+                 type: :string,
+                 default: 'catalog',
+                 desc: 'Permission picker group for the read_/write_ keys (orders, catalog, customers, settings, …)'
+
     class_option :skip_specs,
                  type: :boolean,
                  default: false,
@@ -182,6 +188,35 @@ module Spree
       inject_route_for(:admin, admin_route_line) if options[:admin]
     end
 
+    # The Admin controller declares `scoped_resource :<plural>`; without a
+    # matching catalog scope its keys cannot be granted to a staff role or
+    # minted on a secret API key, so only full-access principals get in.
+    def register_permission_scope
+      return unless options[:admin]
+
+      if File.exist?(File.join(destination_root, INITIALIZER_PATH))
+        if File.read(File.join(destination_root, INITIALIZER_PATH)).include?("register_scope(:#{plural_name},")
+          say_status :identical, "#{INITIALIZER_PATH} (#{plural_name} permission scope)", :blue
+        else
+          append_to_file INITIALIZER_PATH, permission_scope_block
+        end
+      else
+        create_file INITIALIZER_PATH, permission_scope_block.lstrip
+      end
+    end
+
+    def create_permission_locale
+      return unless options[:admin]
+
+      path = "config/locales/spree_#{plural_name}.en.yml"
+      if File.exist?(File.join(destination_root, path))
+        say_status :skip, "#{path} (owned-once; already exists)", :yellow
+        return
+      end
+
+      template 'permissions.en.yml.tt', path
+    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
@@ -253,7 +288,11 @@ module Spree
       say '  Next steps:', :yellow
       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'
+      if options[:admin]
+        say "    3. Grant read_#{plural_name} / write_#{plural_name} to staff roles or secret API keys"
+      else
+        say '    3. Add an Admin API resource later to manage it from the dashboard'
+      end
       say "    4. Add `has_many :#{plural_name}` to Spree::Store" if store_scoped?
       if options[:store] || options[:admin]
         say "    #{store_scoped? ? 5 : 4}. Run the specs:  pnpm exec spree rspec spec/controllers/spree/api/v3/"
@@ -295,6 +334,13 @@ module Spree
         file_name.pluralize
       end
 
+      def permission_group
+        group = options[:permission_group].to_s
+        raise Thor::Error, "--permission-group must be a lowercase identifier (got #{group.inspect})" unless group.match?(/\A[a-z][a-z0-9_]*\z/)
+
+        group
+      end
+
       # Attributes the controller permits on write. By default, every column
       # except references (FKs come through nested), attachments, rich text.
       def permitted_attribute_names
@@ -306,6 +352,17 @@ module Spree
 
     private
 
+    INITIALIZER_PATH = 'config/initializers/spree.rb'.freeze
+
+    def permission_scope_block
+      <<~RUBY
+
+        # Permissions for the #{bare_class_name} API — grants read_#{plural_name} / write_#{plural_name}
+        # to staff roles and secret API keys. Labels: config/locales/spree_#{plural_name}.en.yml
+        Spree.permissions.register_scope(:#{plural_name}, group: :#{permission_group}, resources: -> { [Spree::#{bare_class_name}] })
+      RUBY
+    end
+
     # Where the model file lands. We use parent's class_path + file_name so
     # this stays in sync with whatever Spree::ModelGenerator decides.
     def model_file_destination

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

@@ -3,9 +3,10 @@ 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.
+          # The permission that authorizes this endpoint — `read_<%= plural_name %>` and
+          # `write_<%= plural_name %>`, registered in config/initializers/spree.rb so
+          # they can be granted to staff roles and secret API keys. Point it at an
+          # existing resource name instead if this endpoint belongs under one.
           scoped_resource :<%= plural_name %>
 
           protected
@@ -18,8 +19,8 @@ module Spree
             Spree::Api::V3::Admin::<%= bare_class_name %>Serializer
           end
 
-          def permitted_params
-            params.permit(<%= permitted_attribute_names.map { |a| ":#{a}" }.join(', ') %>)
+          def resource_permitted_attributes
+            [<%= permitted_attribute_names.map { |a| ":#{a}" }.join(', ') %>]
           end
         end
       end

data/lib/generators/spree/api_resource/templates/permissions.en.yml.tt

@@ -0,0 +1,6 @@
+en:
+  spree:
+    permissions_catalog:
+      resources:
+        <%= plural_name %>:
+          label: <%= plural_name.humanize %>

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

@@ -20,8 +20,8 @@ module Spree
 <% end -%>
 <% if writable? -%>
 
-          def permitted_params
-            params.permit(<%= permitted_attribute_names.map { |a| ":#{a}" }.join(', ') %>)
+          def resource_permitted_attributes
+            [<%= permitted_attribute_names.map { |a| ":#{a}" }.join(', ') %>]
           end
 <% end -%>
         end

data/lib/generators/spree/dummy/templates/rails/test.rb

@@ -43,5 +43,12 @@ Dummy::Application.configure do
 
   config.cache_store = :null_store
 
+  # Spree encrypts secrets at rest (webhook signing keys, OAuth tokens) only when
+  # Active Record encryption is configured, so the suite configures it like a
+  # production app would.
+  config.active_record.encryption.primary_key = 'spree-test-primary-key'
+  config.active_record.encryption.deterministic_key = 'spree-test-deterministic-key'
+  config.active_record.encryption.key_derivation_salt = 'spree-test-key-derivation-salt'
+
   routes.default_url_options = { host: 'localhost', port: 3000 }
 end

data/lib/generators/spree/subscriber/subscriber_generator.rb

@@ -3,9 +3,9 @@
 module Spree
   # spree:subscriber — scaffold an event subscriber and register it.
   #
-  #   bin/rails g spree:subscriber OmsOrderSync order.completed order.canceled
+  #   bin/rails g spree:subscriber OmsOrderSync order.placed order.canceled
   #   bin/rails g spree:subscriber MyApp::BrandSync brand.created brand.updated
-  #   bin/rails g spree:subscriber CriticalSync order.completed --sync
+  #   bin/rails g spree:subscriber CriticalSync order.placed --sync
   #
   # Subscribers are not auto-discovered — they must be appended to the
   # Spree.subscribers array. Forgetting that step produces a silent no-op,
@@ -64,7 +64,7 @@ module Spree
     def warn_about_missing_events
       return if events.any?
 
-      say_status :note, "no events given — edit `subscribes_to` in the generated subscriber (e.g. 'order.completed')", :yellow
+      say_status :note, "no events given — edit `subscribes_to` in the generated subscriber (e.g. 'order.placed')", :yellow
     end
 
     private

data/lib/spree/core/engine.rb

@@ -135,6 +135,14 @@ module Spree
         app.config.spree.line_item_comparison_hooks = Set.new
       end
 
+      # The one eligibility rule core ships: a per-market return window,
+      # bypassed by staff. Registered before application initializers so a
+      # store can unregister it in its own initializer.
+      initializer 'spree.returns.register_eligibility_validator', before: :load_config_initializers do
+        Spree.hooks.register('returns.create.validate', 'Spree::Returns::EligibilityValidator')
+        Spree.hooks.register('exchanges.create.validate', 'Spree::Returns::EligibilityValidator')
+      end
+
       initializer 'spree.register.payment_methods', after: 'acts_as_list.insert_into_active_record' do |app|
       end
 
@@ -691,14 +699,6 @@ module Spree
         end
       end
 
-      # The one eligibility rule core ships: a per-market return window,
-      # bypassed by staff. Registered after application initializers so a
-      # store can unregister it in its own initializer.
-      initializer 'spree.returns.register_eligibility_validator', after: :load_config_initializers do
-        Spree.hooks.register('returns.create.validate', 'Spree::Returns::EligibilityValidator')
-        Spree.hooks.register('exchanges.create.validate', 'Spree::Returns::EligibilityValidator')
-      end
-
       # A hook registered against a key no workflow declares would never fire
       # and never say so. Checking after eager load turns that typo into a
       # boot failure. Skipped when eager loading is off (development,

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '6.0.0.beta2'.freeze
+  VERSION = '6.0.0.beta3'.freeze
 
   def self.version
     VERSION

data/lib/spree/iso_data.rb

@@ -53,6 +53,13 @@ module Spree
       }
     }.freeze
 
+    # Some gem subdivision names are a placeholder the gem falls back to when it
+    # has no proper name for the entry: the value it would have translated,
+    # tagged with the locale it belongs to — Pakistan's "Sind (en)",
+    # "Baluchistan (en)". The clean name is the locale's own translation, so a
+    # name matching this is replaced rather than shown or matched against.
+    LOCALE_TAGGED_NAME = /\s\([a-z]{2}(?:-[a-z]{2})?\)\z/i
+
     # Retired ISO codes mapped to their current equivalent. Reading an address
     # written under the old code still finds the right subdivision; writing
     # always stores the successor.
@@ -172,16 +179,28 @@ module Spree
       # English deliberately reads the canonical +name+ rather than the +en+
       # translation: the two disagree in places (the gem translates DC as
       # "Washington DC", where the canonical name is "District of Columbia"),
-      # and the canonical spelling is the one Spree has always stored.
+      # and the canonical spelling is the one Spree has always stored. The
+      # exception is a name the gem left as a locale-tagged placeholder
+      # ("Sind (en)"): that is not a spelling to preserve, so the clean English
+      # translation wins.
       #
       # Note the translation keys are symbols here, unlike +Country#translation+,
       # which takes a string.
       def subdivision_display_name(subdivision)
         locale = I18n.locale.to_s.downcase
-        return subdivision.name if locale.start_with?('en')
-
         translations = subdivision.translations || {}
-        translations[locale.to_sym].presence || subdivision.name
+        english = translations[:en].presence
+
+        if locale.start_with?('en')
+          name = subdivision.name
+          return name.match?(LOCALE_TAGGED_NAME) ? (english || name) : name
+        end
+
+        translated = translations[locale.to_sym].presence
+        return translated if translated
+
+        name = subdivision.name
+        name.match?(LOCALE_TAGGED_NAME) ? (english || name) : name
       end
     end
   end

data/lib/spree/store_scope_guard.rb

@@ -72,6 +72,19 @@ module Spree
         RequestStore.store[ACTIVE_KEY] = previous
       end
 
+      # Opens the window for whatever declared a store context — a job, a
+      # webhook, a console script — and leaves it open until Spree::Current
+      # resets, which Rails does per request and per job. Called from
+      # `Spree::Current#store=`; work that never declares a store stays
+      # unguarded, since reading the default store through the fallback is
+      # not a scoping claim.
+      def arm!
+        return unless enabled?
+
+        install!
+        Spree::Current.store_scope_guard_armed = true
+      end
+
       # Suppresses the guard for a deliberately store-less lookup.
       def skip
         previous = RequestStore.store[SKIP_KEY]
@@ -82,7 +95,9 @@ module Spree
       end
 
       def active?
-        RequestStore.store[ACTIVE_KEY] && !RequestStore.store[SKIP_KEY]
+        return false if RequestStore.store[SKIP_KEY]
+
+        RequestStore.store[ACTIVE_KEY] || Spree::Current.store_scope_guard_armed.present?
       end
 
       # Forgets memoized environment/schema state (specs, migrations).

data/lib/spree/testing_support/factories/invitation_factory.rb

@@ -2,5 +2,6 @@ FactoryBot.define do
   factory :invitation, class: Spree::Invitation do
     email { FFaker::Internet.email }
     association :inviter, factory: :admin_user
+    role { (resource || Spree::Store.current).default_user_role }
   end
 end

data/lib/spree/testing_support/factories/order_group_factory.rb

@@ -5,6 +5,55 @@ FactoryBot.define do
     currency { 'USD' }
     email { customer&.email }
 
+    # A split checkout as it actually leaves completion: each child holding a
+    # seller's item and the parcel that ships it. `:with_orders` builds bare
+    # orders, which is enough for roll-up arithmetic and not enough for
+    # anything that renders the purchase.
+    #
+    # One stock location per seller by default, so each parcel is quoted on its
+    # own delivery method and the group ships in as many parcels as it has
+    # children. Pass `shared_stock_location: true` for the marketplace-fulfilled
+    # shape instead: every child ships out of one warehouse on one method, which
+    # is what a divided parcel looks like after the split clones it.
+    trait :with_parcels do
+      transient do
+        sellers_count { 2 }
+        shared_stock_location { false }
+      end
+
+      after(:create) do |group, evaluator|
+        shared_location = create(:stock_location, name: "Shared #{group.number}") if evaluator.shared_stock_location
+        shared_method = create(:delivery_method, name: "Shared #{group.number}") if evaluator.shared_stock_location
+
+        evaluator.sellers_count.times do |index|
+          seller = create(:seller, :approved, store: group.store)
+          order = create(
+            :order_with_line_items,
+            store: group.store,
+            order_group: group,
+            seller: seller,
+            number: "#{group.number}-#{index + 1}",
+            customer: group.customer,
+            currency: group.currency,
+            line_items_count: 1
+          )
+          order.line_items.each { |line_item| line_item.update_columns(seller_id: seller.id) }
+
+          # The order factory already built the parcel; this decides where it
+          # ships from and by what, which is what the grouping reads.
+          fulfillment = order.fulfillments.first
+          fulfillment.update_columns(
+            stock_location_id: (shared_location || create(:stock_location, name: "#{seller.name} warehouse")).id
+          )
+          fulfillment.delivery_rates.destroy_all
+          fulfillment.add_delivery_method(shared_method || create(:delivery_method, name: "#{seller.name} delivery"), true)
+          order.recalculate_totals!
+        end
+
+        group.orders.reload
+      end
+    end
+
     trait :with_orders do
       transient do
         sellers_count { 2 }

data/lib/spree/testing_support/factories/payment_factory.rb

@@ -29,7 +29,12 @@ FactoryBot.define do
   end
 
   factory :store_credit_payment, class: Spree::Payment, parent: :payment do
-    payment_method { create(:store_credit_payment_method, store: (order || cart).store) }
-    source { create(:store_credit, store: (order || cart).store, customer: (order || cart).customer) }
+    # An order group owns payments like a cart or an order does, and a split
+    # checkout paid with store credit is exactly where that matters.
+    payment_method { create(:store_credit_payment_method, store: (order || cart || order_group).store) }
+    source do
+      owner = order || cart || order_group
+      create(:store_credit, store: owner.store, customer: owner.customer)
+    end
   end
 end

data/lib/spree/upgrades/5_6_to_6_0/manifest.yml

@@ -438,6 +438,22 @@ steps:
       once several stores hold tax configuration. The NOT NULL constraints land
       in 6.1. Idempotent.
 
+  - id: backfill_order_coupon_codes
+    name: "Backfill coupon codes on placed orders"
+    task: "spree:backfill_order_coupon_codes"
+    notes: |
+      spree_orders gains a coupon_code column in Spree 6, matching carts.
+      Historical placed orders applied coupons only through the promotion
+      join tables, so this fills the column from the order's coupon-code
+      record, or failing that from the code of an applied single-code
+      promotion, so admin filtering and the serializer answer consistently
+      for old orders. Reads promotion records only — no dependency on the
+      adjustments conversion — and touches completed orders only, so it is
+      independent of the cart conversion below. Tune the load size with
+      BATCH_SIZE (default 500).
+
+      Idempotent — only orders whose coupon_code is still blank are scanned.
+
   - id: backfill_order_markets
     name: "Backfill order markets"
     task: "spree:backfill_order_markets"
@@ -664,6 +680,24 @@ steps:
       stop the run. Purge the soft-deleted rows later with
       spree:upgrade:purge_migrated_external_receives.
 
+  - id: backfill_actor_types
+    name: "Name the kind of actor on past orders, returns, refunds and receipts"
+    task: "spree:upgrade:backfill_actor_types"
+    notes: |
+      Orders, refunds, returns, exchanges, claims and stock receipts remember
+      who cancelled, approved, created or received them. In 6.0 that can be a
+      member of staff or an API key, so each actor id column gained a type
+      column beside it. Rows written before the upgrade carry an id and no
+      type — they could only ever have pointed at an admin user — so this
+      fills in the admin user class. Until it runs those rows still read as
+      the staff member they always were, with a deprecation warning.
+
+      Run AFTER migrate_returns and migrate_external_receives_to_purchase_orders
+      so any actor rows those steps write are covered too. Walks
+      every model that declares acted_by, so extensions are included.
+
+      Idempotent — a row that already carries a type is skipped.
+
   - id: recount_stock_levels
     name: "Fill in the reserved and incoming counters on every stock level"
     task: "spree:stock:recount_levels"

data/lib/tasks/sample_data.rake

@@ -1,7 +1,13 @@
 namespace :spree do
-  desc 'Loads sample data (products, customers, orders, configuration)'
+  desc 'Loads sample data (products, customers, orders, configuration). Set STORE_ID (prefixed or numeric) or STORE_CODE to target a store other than the default one'
   task load_sample_data: :environment do
-    Spree::SampleData::Loader.call
+    store = if ENV['STORE_ID'].present?
+              Spree::Store.find_by_param!(ENV['STORE_ID'])
+            elsif ENV['STORE_CODE'].present?
+              Spree::Store.find_by!(code: ENV['STORE_CODE'])
+            end
+
+    Spree::SampleData::Loader.call(store: store)
   end
 end
 

data/lib/tasks/upgrade.rake

@@ -13,7 +13,7 @@
 #
 # Usage:
 #   bundle exec rake spree:upgrade                 # walk all eligible manifests
-#   bundle exec rake spree:upgrade DRY_RUN=1       # print plan, run nothing
+#   bundle exec rake spree:upgrade DRY_RUN=1       # print the steps a run would execute, run nothing
 #   bundle exec rake spree:upgrade STEP=channels   # run one step by id (any manifest)
 #   bundle exec rake spree:upgrade TO=5.4          # cap the walk at this version
 #
@@ -72,10 +72,9 @@ module Spree
     # rendering, invocation) stay separable and the plan can be inspected
     # without execution.
     class Runner
-      attr_reader :target_version, :step_id, :dry_run, :target_explicit
+      attr_reader :target_version, :step_id, :dry_run
 
       def initialize(target_version: nil, step_id: nil, dry_run: false)
-        @target_explicit = !target_version.nil?
         @target_version  = target_version || Spree::Upgrade.installed_minor_version
         @step_id         = step_id
         @dry_run         = dry_run
@@ -98,36 +97,22 @@ module Spree
 
       private
 
-      # In plan-mode without explicit TO, show manifests ahead of the installed
-      # version — the path the operator is about to walk. Otherwise filter to
-      # manifests whose `to` is ≤ target.
+      # Plan mode selects exactly what a real run executes, so a dry run after
+      # bumping the gem lists every backfill the upgrade is about to perform.
       def eligible_manifests
         Spree::Upgrade.available_manifests
-          .select { |manifest| manifest_eligible?(manifest) }
+          .select { |manifest| Spree::Upgrade.compare(manifest[:to], target_version) <= 0 }
           .map { |entry| load_manifest_yaml(entry) }
       end
 
-      def manifest_eligible?(manifest)
-        if dry_run && !target_explicit
-          Spree::Upgrade.compare(manifest[:from], Spree::Upgrade.installed_minor_version) >= 0
-        else
-          Spree::Upgrade.compare(manifest[:to], target_version) <= 0
-        end
-      end
-
       def load_manifest_yaml(entry)
         YAML.safe_load_file(File.join(entry[:dir], 'manifest.yml'))
       end
 
       def run_full_walk(manifests)
         total_steps = manifests.sum { |m| m['steps'].size }
-        reported_target = if dry_run && !target_explicit
-                            manifests.map { |m| m['to'] }.compact.max_by { |v| Spree::Upgrade.version_parts(v) } || target_version
-                          else
-                            target_version
-                          end
         puts
-        puts "  Walking #{manifests.size} manifest(s), #{total_steps} step(s) total. Target: Spree #{reported_target}."
+        puts "  Walking #{manifests.size} manifest(s), #{total_steps} step(s) total. Target: Spree #{target_version}."
 
         manifests.each do |manifest|
           print_manifest_header(manifest)