spree_core 6.0.0.beta2 → 6.0.0.beta3

data/app/presenters/spree/csv/order_line_item_presenter.rb

@@ -130,7 +130,7 @@ module Spree
           index.zero? ? order.bill_address&.company : nil,
           index.zero? ? order.bill_address&.city : nil,
           index.zero? ? order.bill_address&.postal_code : nil,
-          index.zero? ? order.bill_address&.state_name : nil,
+          index.zero? ? order.bill_address&.state_text : nil,
           index.zero? ? order.bill_address&.country&.name : nil,
           index.zero? ? order.bill_address&.phone : nil,
           index.zero? ? order.ship_address&.full_name : nil,
@@ -139,7 +139,7 @@ module Spree
           index.zero? ? order.ship_address&.company : nil,
           index.zero? ? order.ship_address&.city : nil,
           index.zero? ? order.ship_address&.postal_code : nil,
-          index.zero? ? order.ship_address&.state_name : nil,
+          index.zero? ? order.ship_address&.state_text : nil,
           index.zero? ? order.ship_address&.country&.name : nil,
           index.zero? ? order.ship_address&.phone : nil,
           index.zero? ? format_date(order.completed_at) : nil,

data/app/services/spree/carts/split_by_seller.rb

@@ -29,20 +29,26 @@ module Spree
       # blocklist would carry every future column onto siblings by default.
       # Adding a column here is a decision that it describes the checkout
       # rather than one seller's part of it.
+      #
+      # +metadata+ is here because at this point it holds what the checkout
+      # recorded about the purchase (copied from the cart), so every child gets
+      # the same hash — and so does the group. Once split, each order's
+      # metadata is its own: edits never propagate between siblings.
       CARRIED_TO_SIBLING = %w[
         email currency locale market_id channel_id company_id
         customer_id token accept_marketing preferred_stock_location_id
-        customer_note last_ip_address po_number
+        customer_note last_ip_address po_number metadata
       ].freeze
 
-      # @param cart [Spree::Cart]
       # @param order [Spree::Order] the paid draft order, adopted as the
       #   group's first child rather than replaced — it is the record the
       #   payment was taken against
       # @param partitions [Array<Spree::Carts::SellerPartition>] ordered, first
       #   party first
+      # @param cart [Spree::Cart, nil] nil for an order raised from the admin,
+      #   which never had one
       # @return [Spree::ServiceModule::Result] value is the Spree::OrderGroup
-      def call(cart:, order:, partitions:)
+      def call(order:, partitions:, cart: nil)
         group = nil
         # Every apportionment here divides money in this one currency.
         @currency = order.currency
@@ -76,20 +82,24 @@ module Spree
       # keeps the reference they saw at checkout, and the children number off
       # it: R1001-1, R1001-2. The cart_id moves up too — the group is what that
       # cart completed into, and it becomes the replay anchor.
+      #
+      # The facts come off the order rather than the cart because the order
+      # carries every one of them and an admin-raised order has no cart; the
+      # cart is only linked, as the replay anchor, when there is one.
       def build_group(cart, order)
         order.update_columns(cart_id: nil)
 
-        group = cart.store.order_groups.create!(
+        order.store.order_groups.create!(
           cart: cart,
-          customer: cart.customer,
+          customer: order.customer,
           number: order.number,
-          currency: cart.currency,
-          email: cart.email,
-          token: cart.token,
-          ship_address: cart.ship_address&.snapshot,
-          bill_address: cart.bill_address&.snapshot
+          currency: order.currency,
+          email: order.email,
+          token: order.token,
+          metadata: order.metadata.to_h.deep_dup,
+          ship_address: order.ship_address&.snapshot,
+          bill_address: order.bill_address&.snapshot
         )
-        group
       end
 
       # Files the paid order under the group as its first child. Its own
@@ -109,7 +119,7 @@ module Spree
       # settled during completion.
       def hand_off(source_order, group, partition, index)
         sibling = source_order.store.orders.create!(
-          source_order.attributes.slice(*CARRIED_TO_SIBLING).merge(
+          source_order.attributes.slice(*CARRIED_TO_SIBLING).deep_dup.merge(
             'order_group_id' => group.id,
             'seller_id' => partition.seller_id,
             'number' => "#{group.number}-#{index}",

data/app/services/spree/companies/add_member.rb

@@ -18,11 +18,17 @@ module Spree
       #   (memberships have no metadata column; a direct-membership payload is
       #   applied by the caller through the `company_membership.form_fields`
       #   contract, not stored here)
+      # @param require_acceptance [Boolean] always invite, even an existing
+      #   customer — for callers who cannot vouch that the email is the
+      #   person they mean (a storefront member typing an address). The
+      #   emailed token is what proves the invitee owns the address and
+      #   agrees to join; a direct membership would hand the company to
+      #   whoever happens to hold that email.
       # @return [Spree::ServiceModule::Result] value is the created
       #   Spree::CompanyMembership or Spree::CompanyInvitation
-      def call(company:, email:, inviter: nil, metadata: nil)
+      def call(company:, email:, inviter: nil, metadata: nil, require_acceptance: false)
         normalized_email = email.to_s.strip.downcase
-        customer = Spree.customer_class.find_by(email: normalized_email)
+        customer = Spree.customer_class.find_by(email: normalized_email) unless require_acceptance
 
         record =
           if customer

data/app/services/spree/imports/row_processors/price_list_price.rb

@@ -154,6 +154,12 @@ module Spree
             Spree.t(:price_list_import_too_many_breaks, count: Spree::Price::MAXIMUM_BREAKS_PER_VARIANT)
           elsif value[:invalid_quantities].present?
             Spree.t(:price_list_import_invalid_quantity, value: attributes['min_quantity'])
+          elsif (rising = value[:rising_ladders].presence)
+            # Named rung and floor, like the sibling branches: a file is written
+            # one rung per row, so the merchant needs to know which one and what
+            # it had to beat.
+            Spree.t(:price_list_import_price_rises_with_quantity,
+                    quantity: rising.first[:min_quantity], floor: rising.first[:floor])
           else
             result.error.to_s.presence || Spree.t(:price_list_import_failed)
           end

data/app/services/spree/imports/row_processors/product_translation.rb

@@ -37,7 +37,7 @@ module Spree
         private
 
         def product_scope
-          Spree::Product.accessible_by(import.current_ability, :manage)
+          store.products.accessible_by(import.current_ability, :manage)
         end
       end
     end

data/app/services/spree/imports/row_processors/product_variant.rb

@@ -125,15 +125,17 @@ module Spree
 
         # Which products this import may resolve an existing row onto.
         #
-        # A seller's import reaches only that seller's own products. The
-        # ability cannot answer this: it grants capability, never tenancy —
-        # a seller holding `write_products` gets `can :manage, Spree::Product`,
-        # the whole class (see Spree::Ability). On the API that is safe because
-        # the controller scope-fetches through `current_seller`; a background
-        # row processor has no controller, so the narrowing has to happen here
-        # or a CSV naming another seller's slug would edit their product.
+        # The import's own store's products, and for a seller's import only
+        # that seller's. The ability cannot answer either: it grants
+        # capability, never tenancy — a seller holding `write_products` gets
+        # `can :manage, Spree::Product`, the whole class (see Spree::Ability),
+        # and an admin of two stores reaches both. On the API that is safe because
+        # the controller scope-fetches through `current_store` and
+        # `current_seller`; a background row processor has no controller, so
+        # the narrowing has to happen here or a CSV naming another store's or
+        # seller's slug would edit their product.
         def product_scope
-          scope = Spree::Product.accessible_by(import.current_ability, :manage)
+          scope = store.products.accessible_by(import.current_ability, :manage)
           seller.present? ? scope.where(seller_id: seller.id) : scope
         end
 
@@ -237,7 +239,7 @@ module Spree
         def prepare_tax_category
           tax_category_name = attributes['tax_category'].strip
           cached_lookup(:tax_category, tax_category_name) do
-            Spree::TaxCategory.find_by(name: tax_category_name)
+            store.tax_categories.find_by(name: tax_category_name)
           end
         end
 
@@ -302,15 +304,19 @@ module Spree
         def find_or_create_option_type!(label)
           cached_lookup(:option_type, label) do
             begin
-              Spree::OptionType.search_by_name(label).first || Spree::OptionType.create!(label: label)
+              store_option_types.search_by_name(label).first || store_option_types.create!(label: label)
             rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
               raise unless uniqueness_conflict?(e, :name)
 
-              Spree::OptionType.search_by_name(label).first!
+              store_option_types.search_by_name(label).first!
             end
           end
         end
 
+        def store_option_types
+          Spree::OptionType.for_store(store)
+        end
+
         def find_or_create_option_value!(option_type, label)
           cached_lookup(:option_value, option_type.id, label) do
             begin

data/app/services/spree/order_groups/allocate_payments.rb

@@ -87,6 +87,9 @@ module Spree
           next if split.persisted?
 
           share = Spree::Money::Rounding.from_minor_units(shares[index], currency)
+          # So re-summing its payment total on save reuses this instance rather
+          # than loading a second copy of the row per share.
+          split.order = order
           split.currency = payment.currency
           split.authorized_amount = share
           split.captured_amount = captured ? share : 0

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

@@ -9,10 +9,16 @@ module Spree
     #
     # No-op when the order has no shipping address, no line items, or does
     # not require delivery (digital orders, etc.).
+    #
+    # Also a no-op once the order is placed. Its fulfillments hold the stock
+    # promised at placement, and an edit adjusts them in place through
+    # Spree::OrderInventory. Rebuilding would delete them and leave that
+    # promise on rows nothing can cancel or ship, so the stock stays held.
     class BuildFulfillments
       prepend Spree::ServiceModule::Base
 
       def call(order:)
+        return success(order) if order.completed?
         return success(order) unless order.ship_address_id.present?
         return success(order) unless order.line_items.any?
         return success(order) unless order.delivery_step_required?

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

@@ -60,14 +60,20 @@ module Spree
       # shipped and been captured while another has not, no proportion of the
       # group's totals can describe either.
       #
+      # Refunded spans both ledgers. A refund paid as store credit writes no
+      # {Spree::Refund} row, and counting only those rows left an order that
+      # had given every penny back still reading `paid`.
+      #
       # @return [Array(BigDecimal, BigDecimal, BigDecimal)] captured,
       #   authorized and refunded, in that order
       def money_for(order)
+        credited = order.store_credit_refunds.sum(:amount)
+
         unless order.order_group_id.present?
           return [
             order.payments.valid.completed.sum(:amount),
             order.payments.valid.pending.sum(:amount),
-            order.refunds.sum(:amount)
+            order.refunds.sum(:amount) + credited
           ]
         end
 
@@ -76,7 +82,7 @@ module Spree
 
         # Authorized means still to draw: what the shares allow, less what has
         # already been taken against them.
-        [captured, splits.sum(&:authorized_amount) - captured, splits.sum(&:refunded_amount)]
+        [captured, splits.sum(&:authorized_amount) - captured, splits.sum(&:refunded_amount) + credited]
       end
 
       # Rolls the fulfillments up into one word for filtering and display.

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.