spree_core 6.0.0.beta1 → 6.0.0.beta3

data/app/services/spree/prices/bulk_upsert.rb

@@ -35,11 +35,13 @@ module Spree
       # @return [Spree::ServiceModule::Result] success carries
       #   `{ price_count: N }` — the number of rows passed to `upsert_all`.
       #   Fails with the offending rows when a batch carries an unusable
-      #   `min_quantity`, or would take a variant past
-      #   {Spree::Price::MAXIMUM_BREAKS_PER_VARIANT} breaks on one list. This
-      #   path writes in SQL and runs no model validations, so both checks
-      #   live here rather than in each of the three controllers that reach
-      #   it (docs/plans/6.0-volume-pricing.md).
+      #   `min_quantity`, puts a quantity on a base price, names one rung twice,
+      #   would take a variant past
+      #   {Spree::Price::MAXIMUM_BREAKS_PER_VARIANT} breaks on one list, or
+      #   would leave a ladder charging more for a bigger order. This path
+      #   writes in SQL and runs no model validations, so the checks live here
+      #   rather than in each of the three writers that reach it
+      #   (docs/plans/6.0-volume-pricing.md).
       def call(rows:)
         rows = Array(rows).map { |r| r.with_indifferent_access }
         # Amounts are parsed once, here; everything below reads numbers.
@@ -54,20 +56,35 @@ module Spree
         negative = rows_with_negative_amount(keyed)
         return failure(nil, invalid_amounts: negative) if negative.any?
 
-        # PG rejects an upsert with two rows hitting the same unique key in one
-        # statement ("ON CONFLICT DO UPDATE command cannot affect row a second
-        # time"). Last-write-wins: keep the last occurrence of each key.
-        deduped = keyed.reverse.uniq { |r| row_key(r) }.reverse
-        upsert_rows, clear_rows = deduped.partition { |r| r[:amount].present? }
+        # A base price is one row per (variant, currency) whatever quantity it
+        # names, so a quantity here would upsert onto a key it does not
+        # describe. The model refuses it in `break_requires_price_list`, which
+        # this SQL path never runs.
+        misplaced = base_rows_with_quantity(keyed)
+        return failure(nil, quantities_on_base_prices: misplaced) if misplaced.any?
+
+        duplicates = rows_with_duplicate_quantity(keyed)
+        return failure(nil, duplicate_quantities: duplicates) if duplicates.any?
+
+        upsert_rows, clear_rows = keyed.partition { |r| r[:amount].present? }
+        # A clear at a quantity the batch also prices is a rung moving onto
+        # it, so the amount wins.
+        claimed = upsert_rows.map { |r| row_key(r) }.to_set
+        clear_rows = clear_rows.reject { |r| claimed.include?(row_key(r)) }
 
         payload = build_payload(upsert_rows)
-        affected_keys = deduped.map { |r| row_key(r) }
+        affected_keys = (upsert_rows + clear_rows).map { |r| row_key(r) }
 
         return success(price_count: 0) if affected_keys.empty?
 
-        over_cap = ladders_over_cap(upsert_rows, clear_rows)
+        stored = stored_rungs(upsert_rows + clear_rows)
+
+        over_cap = ladders_over_cap(upsert_rows, clear_rows, stored)
         return failure(nil, over_cap: over_cap) if over_cap.any?
 
+        rising = rising_ladders(upsert_rows, clear_rows, stored)
+        return failure(nil, rising_ladders: rising) if rising.any?
+
         base_rows, override_rows = payload.partition { |r| r[:price_list_id].nil? }
 
         Spree::Price.transaction do
@@ -129,7 +146,7 @@ module Spree
       # quantity address the bottom rung, which is every row written before
       # breaks existed (docs/plans/6.0-volume-pricing.md).
       def row_key(row)
-        [row[:variant_id], row[:currency], row[:price_list_id], quantity_of(row)]
+        [row[:variant_id].to_s, row[:currency], row[:price_list_id].presence&.to_s, quantity_of(row)]
       end
 
       # Absent means the ladder's bottom rung. Anything present must be a
@@ -182,55 +199,177 @@ module Spree
       # constant is named: breaks *above* the bottom rung, so a variant priced
       # at one figure plus ten breaks is exactly at the limit.
       #
-      # Only ladders the batch actually adds a break to are checked, so an
-      # ordinary spreadsheet save — one quantity-1 row per variant — costs no
-      # extra queries at all.
-      #
       # @param rows [Array<Hash>] the rows carrying an amount
       # @param cleared_rows [Array<Hash>] the rows whose blank amount removes a rung
+      # @param stored [Hash] `{ ladder_key => { quantity => amount } }` as stored
       # @return [Array<Hash>] `[{ variant_id:, currency:, price_list_id: }, ...]`
-      def ladders_over_cap(rows, cleared_rows = [])
-        touched = rows.
-                  reject { |row| row[:price_list_id].blank? || quantity_of(row) == 1 }.
-                  group_by { |row| [row[:variant_id].to_s, row[:currency], row[:price_list_id].to_s] }.
-                  transform_values { |group| group.map { |row| quantity_of(row) }.to_set }
+      def ladders_over_cap(rows, cleared_rows, stored)
+        touched = breaks_by_ladder(rows)
         return [] if touched.empty?
 
-        cleared = cleared_rows.
-                  reject { |row| row[:price_list_id].blank? || quantity_of(row) == 1 }.
-                  group_by { |row| [row[:variant_id].to_s, row[:currency], row[:price_list_id].to_s] }.
-                  transform_values { |group| group.map { |row| quantity_of(row) }.to_set }
-
-        # One query for every ladder in the batch rather than one each: an
-        # import writing a ladder across two hundred variants would otherwise
-        # issue two hundred round trips inside the request. Cross-pairs the
-        # `IN` clauses pull in are dropped by the lookup below, the same way
-        # #sweep handles them.
-        # Placeholder rows charge nothing, so they do not fill a ladder — the
-        # model's own guard counts the same way, and a cap two writers
-        # disagree about is one that refuses what it just allowed.
-        stored = Spree::Price.
-                 where(variant_id: touched.keys.map { |key| key[0] },
-                       currency: touched.keys.map { |key| key[1] },
-                       price_list_id: touched.keys.map { |key| key[2] }).
-                 breaks.
-                 where.not(amount: nil).
-                 pluck(:variant_id, :currency, :price_list_id, :min_quantity).
-                 group_by { |variant_id, currency, price_list_id, _| [variant_id.to_s, currency, price_list_id.to_s] }
+        cleared = breaks_by_ladder(cleared_rows)
 
         touched.filter_map do |key, incoming|
           # Stored rungs this batch does not name are the ones that survive it;
           # counting the rest as well would refuse a merchant who deleted two
           # rungs and added two others, whose ladder ends the size it began.
-          # The deletions ride in `clear_rows` and the sweep applies them, so
-          # what is left after this batch is (survivors + incoming).
-          survivors = stored.fetch(key, []).map(&:last).to_set - cleared.fetch(key, Set.new)
+          survivors = stored.fetch(key, {}).keys.reject { |quantity| quantity == 1 }.to_set - cleared.fetch(key, Set.new)
           next if (survivors | incoming).size <= Spree::Price::MAXIMUM_BREAKS_PER_VARIANT
 
           { variant_id: key[0], currency: key[1], price_list_id: key[2] }
         end
       end
 
+      # The break quantities each ladder in these rows carries.
+      def breaks_by_ladder(rows)
+        rows.
+          reject { |row| row[:price_list_id].blank? || quantity_of(row) == 1 }.
+          group_by { |row| ladder_key(row) }.
+          transform_values { |group| group.map { |row| quantity_of(row) }.to_set }
+      end
+
+      # Base-price rows naming a quantity. A base price is one row per
+      # (variant, currency), so the quantity describes nothing and the row
+      # would upsert onto a key it does not match.
+      #
+      # @return [Array<Hash>] `[{ index: }, ...]`
+      def base_rows_with_quantity(rows)
+        rows.each_with_index.filter_map do |row, index|
+          { index: index } if row[:price_list_id].blank? && quantity_of(row) != 1
+        end
+      end
+
+      # Rows repeating a rung the batch has already priced. Only amounts
+      # collide: a clear at the same key is a rung moving onto it, which #call
+      # resolves in favour of the amount.
+      #
+      # @param rows [Array<Hash>]
+      # @return [Array<Hash>] `[{ index:, min_quantity: }, ...]`
+      def rows_with_duplicate_quantity(rows)
+        seen = Set.new
+
+        rows.each_with_index.filter_map do |row, index|
+          next if row[:amount].blank?
+
+          { index: index, min_quantity: quantity_of(row) } unless seen.add?(row_key(row))
+        end
+      end
+
+      # Ladders this batch would leave charging more for a bigger order. A rung
+      # must not cost more than the rung beneath it, or than the base price for
+      # a ladder starting above one unit; a bottom rung above base is a dearer
+      # agreement, which is allowed. Judged on the state the batch leaves, not
+      # on what it changed: no write path can produce a rising ladder, so one
+      # found rising came from outside them and must be repaired rather than
+      # built on. Base is the floor even where another list would undercut it
+      # below the threshold — the write path cannot know which list wins for
+      # which buyer (docs/plans/6.0-volume-pricing.md).
+      #
+      # @param rows [Array<Hash>] the rows carrying an amount
+      # @param cleared_rows [Array<Hash>] the rows whose blank amount removes a rung
+      # @param stored [Hash] `{ ladder_key => { quantity => amount } }` as stored
+      # @return [Array<Hash>] the offending rung and the price it must not exceed
+      def rising_ladders(rows, cleared_rows, stored)
+        keys = ladder_keys_to_check(rows + cleared_rows, stored)
+        return [] if keys.empty?
+
+        incoming = rungs_by_ladder(rows)
+        cleared = breaks_and_bottom_by_ladder(cleared_rows)
+        floors = base_floors(rows, cleared_rows, keys)
+
+        keys.filter_map do |key|
+          dropped = cleared.fetch(key, Set.new)
+          now = stored.fetch(key, {}).reject { |quantity, _| dropped.include?(quantity) }.
+                merge(incoming.fetch(key, {}))
+
+          breach = Spree::Price.rising_rung(now.sort_by(&:first), floors[key.first(2)])
+          next if breach.nil?
+
+          { variant_id: key[0], currency: key[1], price_list_id: key[2],
+            min_quantity: breach[0], amount: breach[1], floor: breach[2] }
+        end
+      end
+
+      # The ladders whose shape or floor this batch could change: those it
+      # writes rows on, plus every stored ladder of a variant whose base price
+      # it moves — lowering the shop price under a break raises the bill at the
+      # threshold just as surely as mispricing the break.
+      def ladder_keys_to_check(rows, stored)
+        own = rows.reject { |row| row[:price_list_id].blank? }.map { |row| ladder_key(row) }
+        rebased = rows.select { |row| row[:price_list_id].blank? }.
+                  map { |row| [row[:variant_id].to_s, row[:currency]] }.to_set
+        return own.uniq if rebased.empty?
+
+        (own + stored.keys.select { |key| rebased.include?(key.first(2)) }).uniq
+      end
+
+      # `{ ladder_key => { quantity => amount } }` for these rows.
+      def rungs_by_ladder(rows)
+        rows.
+          reject { |row| row[:price_list_id].blank? }.
+          group_by { |row| ladder_key(row) }.
+          transform_values { |group| group.to_h { |row| [quantity_of(row), row[:amount]] } }
+      end
+
+      # Every quantity these rows remove, bottom rung included — unlike the cap
+      # check, which only counts breaks.
+      def breaks_and_bottom_by_ladder(rows)
+        rows.
+          reject { |row| row[:price_list_id].blank? }.
+          group_by { |row| ladder_key(row) }.
+          transform_values { |group| group.map { |row| quantity_of(row) }.to_set }
+      end
+
+      # The stored rungs of every ladder this batch touches, and of every
+      # ladder whose base price it moves. Placeholder rows charge nothing, so a
+      # ladder whose quantity-1 row is a placeholder starts at its first real
+      # break. Cross-pairs the `IN` clauses pull in are dropped by the lookup,
+      # as in #sweep.
+      #
+      # @param rows [Array<Hash>]
+      # @return [Hash] `{ ladder_key => { quantity => amount } }`
+      def stored_rungs(rows)
+        variant_ids = rows.map { |row| row[:variant_id] }.uniq
+        currencies = rows.map { |row| row[:currency] }.uniq
+        return {} if variant_ids.empty?
+
+        Spree::Price.
+          where(variant_id: variant_ids, currency: currencies).
+          where.not(price_list_id: nil).
+          where.not(amount: nil).
+          pluck(:variant_id, :currency, :price_list_id, :min_quantity, :amount).
+          group_by { |variant_id, currency, price_list_id, _, _| [variant_id.to_s, currency, price_list_id.to_s] }.
+          transform_values { |rungs| rungs.to_h { |rung| [rung[3], rung[4]] } }
+      end
+
+      # The base price each ladder falls through to, as this batch would leave
+      # it, so a save that moves both the shop price and a break is judged on
+      # the pair it sent.
+      #
+      # @return [Hash] `{ [variant_id, currency] => amount }`
+      def base_floors(rows, cleared_rows, keys)
+        pairs = keys.map { |key| key.first(2) }.uniq
+        return {} if pairs.empty?
+
+        stored = Spree::Price.
+                 where(variant_id: pairs.map(&:first), currency: pairs.map(&:last), price_list_id: nil).
+                 where.not(amount: nil).
+                 pluck(:variant_id, :currency, :amount).
+                 to_h { |variant_id, currency, amount| [[variant_id.to_s, currency], amount] }
+
+        written = rows.select { |row| row[:price_list_id].blank? }.
+                  to_h { |row| [[row[:variant_id].to_s, row[:currency]], row[:amount]] }
+        removed = cleared_rows.select { |row| row[:price_list_id].blank? }.
+                  map { |row| [row[:variant_id].to_s, row[:currency]] }
+
+        stored.merge(written).except(*removed)
+      end
+
+      # A ladder is one variant's rungs, in one currency, on one list.
+      def ladder_key(row)
+        [row[:variant_id].to_s, row[:currency], row[:price_list_id].to_s]
+      end
+
       # Parses locale-aware decimal input ("1.234,56" in DE, "1,234.56"
       # in en-US). Numeric values pass through; blank values become nil.
       def parse_amount(value)
@@ -254,7 +393,7 @@ module Spree
           .pluck(:id, :variant_id, :currency, :price_list_id, :min_quantity, :amount)
 
         doomed_ids = candidates.filter_map do |id, variant_id, currency, price_list_id, min_quantity, amount|
-          key = [variant_id, currency, price_list_id, min_quantity]
+          key = [variant_id.to_s, currency, price_list_id&.to_s, min_quantity]
           next unless affected_set.include?(key)
           next id if amount.nil?
           next id if cleared_keys.include?(key)

data/app/services/spree/sample_data/import_builder.rb

@@ -7,7 +7,7 @@ module Spree
       #   runs — a price-list import's `preferred_price_list_id`, say
       # @return [Spree::Import] persisted, unprocessed
       def self.call(csv_path:, import_class:, store: nil, user: nil, inline: false, skip_events: false, attributes: {})
-        store ||= Spree::Store.default
+        store ||= Spree::Current.store
         # An admin of the target store, not `admin_user_class.first` — in a
         # multi-store or multi-tenant app that global first can belong to a
         # different store entirely.

data/app/services/spree/sample_data/loader.rb

@@ -4,65 +4,79 @@ module Spree
       prepend Spree::ServiceModule::Base
       include Spree::SampleData::Helper
 
-      def call
+      # Loads the demo data into one store. The sample files and the imports
+      # they run read `Spree::Current.store`, so it is set for the whole run
+      # and restored afterwards.
+      #
+      # @param store [Spree::Store, nil] the store to load into; defaults to
+      #   the default store, resolved after the seeds so a bare install works
+      # @return [Spree::ServiceModule::Result]
+      def call(store: nil)
         Spree::Events.disable do
           without_geocoding do
             ActiveRecord::Base.no_touching do
               puts 'Running seeds first...' unless seeds_loaded?
               ensure_seeds_loaded
 
-              puts 'Loading sample configuration data...'
-              load_configuration_data
+              @store = store || Spree::Store.default
+              Spree::Current.set(store: @store) { load_sample_data }
+            end
+          end
+        end
+      end
 
-              puts 'Loading sample channels...'
-              load_ruby_file('channels')
+      private
 
-              puts 'Loading sample custom_field definitions...'
-              load_ruby_file('custom_field_definitions')
+      attr_reader :store
 
-              puts 'Loading sample options...'
-              load_ruby_file('options')
+      def load_sample_data
+        puts 'Loading sample configuration data...'
+        load_configuration_data
 
-              puts 'Loading sample product types...'
-              load_ruby_file('product_types')
+        puts 'Loading sample channels...'
+        load_ruby_file('channels')
 
-              puts 'Loading sample products...'
-              load_products
+        puts 'Loading sample custom_field definitions...'
+        load_ruby_file('custom_field_definitions')
 
-              puts 'Attaching the sample digital product file...'
-              load_ruby_file('digital_products')
+        puts 'Loading sample options...'
+        load_ruby_file('options')
 
-              puts 'Publishing sample products on the default channel...'
-              publish_sample_products(Spree::Store.default)
+        puts 'Loading sample product types...'
+        load_ruby_file('product_types')
 
-              puts 'Loading sample product translations...'
-              load_product_translations
+        puts 'Loading sample products...'
+        load_products
 
-              puts 'Linking product types to categories...'
-              load_ruby_file('product_type_categories')
+        puts 'Attaching the sample digital product file...'
+        load_ruby_file('digital_products')
 
-              puts 'Loading sample collections...'
-              load_ruby_file('collections')
+        puts 'Publishing sample products on every channel...'
+        publish_sample_products(store)
 
-              puts 'Loading sample customers...'
-              load_customers
+        puts 'Loading sample product translations...'
+        load_product_translations
 
-              puts 'Loading wholesale demo data...'
-              load_ruby_file('wholesale')
+        puts 'Linking product types to categories...'
+        load_ruby_file('product_type_categories')
 
-              puts 'Loading sample orders...'
-              load_ruby_file('orders')
+        puts 'Loading sample collections...'
+        load_ruby_file('collections')
 
-              puts 'Loading sample posts...'
-              load_ruby_file('posts')
+        puts 'Loading sample customers...'
+        load_customers
 
-              puts 'Sample data loaded successfully!'
-            end
-          end
-        end
-      end
+        puts 'Loading wholesale demo data...'
+        load_ruby_file('wholesale')
 
-      private
+        puts 'Loading sample orders...'
+        load_ruby_file('orders')
+
+        puts 'Loading sample posts...'
+        load_ruby_file('posts')
+
+        puts 'Sample data loaded successfully!'
+      end
 
       def load_configuration_data
         load_ruby_file('fulfillment')
@@ -72,19 +86,19 @@ module Spree
 
       def load_products
         csv_path = sample_data_path.join('products.csv')
-        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Products, inline: true)
+        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Products, store: store, inline: true)
       end
 
       def load_product_translations
         csv_path = sample_data_path.join('product_translations.csv')
         return unless csv_path.exist?
 
-        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::ProductTranslations, inline: true)
+        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::ProductTranslations, store: store, inline: true)
       end
 
       def load_customers
         csv_path = sample_data_path.join('customers.csv')
-        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Customers, inline: true)
+        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Customers, store: store, inline: true)
       end
     end
   end

data/app/services/spree/seeds/all.rb

@@ -10,39 +10,14 @@ module Spree
             # countries gem, and zones are migration-only, so none of them
             # are seeded.
 
-            # additional data
-            TaxCategories.call
-
-            # store & channels
             Stores.call
-            Channels.call
-            # Roles are store-owned, so they can only be seeded once a store
-            # exists — every store gets its own immutable admin role.
-            Roles.call
-            # Store-scoped, so it can only run once a store exists.
-            DigitalDelivery.call
+            Spree::Store.find_each { |store| StoreResources.call(store: store) }
             # The warehouse, delivery zones and pickup are not seeded: their
             # shape depends on which country the shop sells from, and nobody
             # has answered that yet. Spree::Stores::ProvisionDefaults builds
             # them from the merchant's answer — at first-run setup, or here
             # when ADMIN_EMAIL/ADMIN_PASSWORD name an install that skips it.
             AdminUser.call
-
-            # add store resources
-            PaymentMethods.call
-            TaxCategories.call
-            ProductTypes.call
-            CustomerGroups.call
-            ReturnsEnvironment.call
-            # The marketplace's catch-all rate, at the bottom of the list so
-            # narrower rates added later resolve ahead of it.
-            CommissionRates.call
-            # What a new seller has to do before this marketplace will let
-            # them trade. Runs after stores for the same reason roles do.
-            SellerRequirements.call
-            ApiKeys.call
-            SavedReports.call
-            AllowedOrigins.call
           end
         end
       end

data/app/services/spree/seeds/allowed_origins.rb

@@ -2,11 +2,12 @@ module Spree
   module Seeds
     class AllowedOrigins
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
-      def call
-        Spree::Store.all.each do |store|
-          store.allowed_origins.find_or_create_by!(origin: 'http://localhost')
-        end
+      private
+
+      def seed(store)
+        store.allowed_origins.find_or_create_by!(origin: 'http://localhost')
       end
     end
   end

data/app/services/spree/seeds/api_keys.rb

@@ -2,17 +2,18 @@ module Spree
   module Seeds
     class ApiKeys
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
-      def call
-        Spree::Store.find_each do |store|
-          unless store.api_keys.active.publishable.where(channel_id: nil).exists?
-            store.api_keys.create!(name: 'Default', key_type: 'publishable')
-          end
+      private
 
-          wholesale = store.channels.find_by(code: Channels::WHOLESALE_CODE)
-          if wholesale && !store.api_keys.active.publishable.where(channel: wholesale).exists?
-            store.api_keys.create!(name: 'Storefront (Wholesale)', key_type: 'publishable', channel: wholesale)
-          end
+      def seed(store)
+        unless store.api_keys.active.publishable.where(channel_id: nil).exists?
+          store.api_keys.create!(name: 'Default', key_type: 'publishable')
+        end
+
+        wholesale = store.channels.find_by(code: Channels::WHOLESALE_CODE)
+        if wholesale && !store.api_keys.active.publishable.where(channel: wholesale).exists?
+          store.api_keys.create!(name: 'Storefront (Wholesale)', key_type: 'publishable', channel: wholesale)
         end
       end
     end

data/app/services/spree/seeds/channels.rb

@@ -6,18 +6,19 @@ module Spree
     # See docs/plans/5.6-store-channel-context-and-key-binding.md.
     class Channels
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
       WHOLESALE_CODE = 'wholesale'.freeze
 
-      def call
-        Spree::Store.find_each do |store|
-          store.ensure_default_channel
+      private
 
-          store.channels.find_or_create_by!(code: WHOLESALE_CODE) do |channel|
-            channel.name = 'Wholesale'
-            channel.preferred_storefront_access = 'login_required'
-            channel.preferred_guest_checkout = false
-          end
+      def seed(store)
+        store.ensure_default_channel
+
+        store.channels.find_or_create_by!(code: WHOLESALE_CODE) do |channel|
+          channel.name = 'Wholesale'
+          channel.preferred_storefront_access = 'login_required'
+          channel.preferred_guest_checkout = false
         end
       end
     end

data/app/services/spree/seeds/commission_rates.rb

@@ -22,31 +22,32 @@ module Spree
     # setting the value is the operator's first commission decision.
     class CommissionRates
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
       DEFAULT_CODE = 'marketplace-default'.freeze
 
-      def call
-        Spree::Store.find_each do |store|
-          # Live rows only, matching the partial unique index: an operator who
-          # deleted the seeded fallback gets it back on the next run rather
-          # than being left with no bottom-of-list catch-all forever.
-          next if store.commission_rates.exists?(code: DEFAULT_CODE)
+      private
 
-          rate = store.commission_rates.create!(
-            name: Spree.t('seed.commission_rates.marketplace_default'),
-            code: DEFAULT_CODE,
-            kind: 'percentage',
-            value: 0,
-            enabled: false
-          )
+      def seed(store)
+        # Live rows only, matching the partial unique index: an operator who
+        # deleted the seeded fallback gets it back on the next run rather
+        # than being left with no bottom-of-list catch-all forever.
+        return if store.commission_rates.exists?(code: DEFAULT_CODE)
 
-          # New rates are born at the top, which is right for one an operator
-          # adds and wrong for this one: it matches every sale, so anywhere but
-          # the bottom leaves the rates below it unreachable. A store seeded
-          # after it already has rates would otherwise have them all shadowed
-          # the moment this was enabled.
-          rate.move_to_bottom
-        end
+        rate = store.commission_rates.create!(
+          name: Spree.t('seed.commission_rates.marketplace_default'),
+          code: DEFAULT_CODE,
+          kind: 'percentage',
+          value: 0,
+          enabled: false
+        )
+
+        # New rates are born at the top, which is right for one an operator
+        # adds and wrong for this one: it matches every sale, so anywhere but
+        # the bottom leaves the rates below it unreachable. A store seeded
+        # after it already has rates would otherwise have them all shadowed
+        # the moment this was enabled.
+        rate.move_to_bottom
       end
     end
   end

data/app/services/spree/seeds/customer_groups.rb

@@ -5,13 +5,14 @@ module Spree
     # wholesale price lists key off.
     class CustomerGroups
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
       WHOLESALE_NAME = 'Wholesale'.freeze
 
-      def call
-        Spree::Store.find_each do |store|
-          store.customer_groups.find_or_create_by!(name: WHOLESALE_NAME)
-        end
+      private
+
+      def seed(store)
+        store.customer_groups.find_or_create_by!(name: WHOLESALE_NAME)
       end
     end
   end