spree_core 6.0.0.rc4 → 6.0.0.rc6

data/app/models/spree/search_provider/database.rb

@@ -7,14 +7,6 @@ module Spree
         'best_selling' => :by_best_selling
       }.freeze
 
-      # @param store [Spree::Store]
-      # @param audience [Symbol, nil] who filters: `:store` (shoppers) limits
-      #   filters to what the storefront may query; `nil` is the back office
-      def initialize(store, audience: :store)
-        super(store)
-        @audience = audience
-      end
-
       def search_and_filter(scope:, query: nil, filters: {}, sort: nil, page: 1, limit: 25)
         filters = filters.is_a?(Hash) ? filters.dup : {}
         option_value_ids = filters.delete('with_option_value_ids') || filters.delete(:with_option_value_ids)
@@ -73,14 +65,14 @@ module Spree
       private
 
       def apply_search_and_filters(scope, query: nil, filters: {})
-        scope = scope.search(query, store) if query.present?
+        scope = scope.search(query, store, audience: audience) if query.present?
 
         filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
         scope, filters = scope.with_custom_field_filters(filters, schema: custom_field_schema)
 
         ransack_filters = sanitize_filters(filters)
         if ransack_filters.present?
-          search = scope.ransack(ransack_filters, auth_object: @audience)
+          search = scope.ransack(ransack_filters, auth_object: audience)
           scope = search.result(distinct: true)
         end
 

data/app/models/spree/seller.rb

@@ -310,10 +310,7 @@ module Spree
     #
     # @return [Array<Spree::SellerBalance>]
     def balances
-      pairs = seller_transfers.where.not(status: 'failed').
-              distinct.pluck(:currency, :settled_currency)
-
-      pairs.sort.map { |currency, settlement| Spree::SellerBalance.for(self, currency, settlement) }
+      Spree::SellerBalance.all_for(self)
     end
 
     # The seller's account with whichever provider pays them — a Stripe Connect
@@ -399,6 +396,10 @@ module Spree
     # returns; falls back to any active one, since a seller with none marked
     # still has to receive what customers send back.
     def returns_location
+      if stock_locations.loaded? || lazy_preload_context
+        return @returns_location ||= returns_location_from_loaded
+      end
+
       @returns_location ||= stock_locations.active.returns_enabled.order_default.first ||
                             stock_locations.active.order_default.first
     end
@@ -417,9 +418,24 @@ module Spree
       location.address
     end
 
+    # A team is small, so on a list its members are loaded for every seller
+    # at once rather than counted one seller at a time.
+    #
+    # @return [Integer] how many people are on this seller's team
+    def users_count
+      users.loaded? || lazy_preload_context ? users.to_a.size : users.count
+    end
+
     # @return [Integer] how many products this seller lists
     def products_count
-      @products_count ||= products.count
+      return @products_count if @products_count
+
+      siblings = lazy_preload_context&.records&.grep(self.class)
+      return @products_count = products.count if siblings.blank?
+
+      counts = Spree::Product.where(seller_id: siblings.map(&:id)).group(:seller_id).count
+      siblings.each { |seller| seller.preloaded_products_count = counts.fetch(seller.id, 0) }
+      @products_count
     end
 
     # Where this seller stands against the marketplace's checklist
@@ -465,8 +481,22 @@ module Spree
       onboarding_requirements.none?(&:blocking?)
     end
 
+    protected
+
+    def preloaded_products_count=(count)
+      @products_count = count
+    end
+
     private
 
+    # The same choice as the query in {#returns_location}, made over the
+    # preloaded locations.
+    def returns_location_from_loaded
+      active_locations = stock_locations.select(&:active?).sort_by { |location| [location.default? ? 0 : 1, location.name.to_s] }
+
+      active_locations.find(&:returns_enabled?) || active_locations.first
+    end
+
 
     def normalize_slug
       self.slug = (slug.presence || name).to_s.parameterize.presence

data/app/models/spree/seller_balance.rb

@@ -57,6 +57,34 @@ module Spree
       )
     end
 
+    # Every position the seller holds, read with one grouped query per figure
+    # rather than four per position. See {Spree::Seller#balances}.
+    #
+    # @param seller [Spree::Seller]
+    # @return [Array<Spree::SellerBalance>]
+    def self.all_for(seller)
+      transfers = seller.seller_transfers.where.not(status: 'failed')
+      amounts = transfers.group(:currency, :settled_currency, :status).sum(:amount)
+      payable = transfers.completed.group(:currency, :settled_currency).sum(:settled_amount)
+      paid = transfers.completed.joins(:payout).merge(Spree::SellerPayout.completed).
+             group(:currency, :settled_currency).sum(:settled_amount)
+
+      pairs = amounts.keys.map { |currency, settlement_currency, _status| [currency, settlement_currency] }.uniq.sort
+      pairs.map do |pair|
+        amount_in = ->(*statuses) { statuses.sum(BigDecimal('0')) { |status| amounts.fetch([*pair, status], 0) } }
+
+        new(
+          seller: seller,
+          currency: pair.first,
+          settlement_currency: pair.last,
+          earned: amount_in.call('completed'),
+          pending: amount_in.call('pending', 'processing', 'unresolved'),
+          payable: payable.fetch(pair, 0),
+          paid: paid.fetch(pair, 0)
+        )
+      end
+    end
+
     # What the marketplace still owes, in the currency it can actually be sent
     # in.
     #

data/app/models/spree/seller_requirements/delivery_method.rb

@@ -11,9 +11,27 @@ module Spree
     # has shared at least one of theirs.
     class DeliveryMethod < Spree::SellerRequirement
       def met_by_seller?(seller)
-        return true if seller.delivery_methods.storefront_visible.exists?
+        return true if ships_own_methods?(seller)
 
-        store.delivery_methods.shared_with_sellers.storefront_visible.exists?
+        operator_shares_methods?
+      end
+
+      private
+
+      def ships_own_methods?(seller)
+        if seller.read_association_in_memory?(:delivery_methods)
+          seller.delivery_methods.any?(&:storefront_visible?)
+        else
+          seller.delivery_methods.storefront_visible.exists?
+        end
+      end
+
+      # The same answer for every seller of the store, so a list of them
+      # asks once.
+      def operator_shares_methods?
+        return @operator_shares_methods if defined?(@operator_shares_methods)
+
+        @operator_shares_methods = store.delivery_methods.shared_with_sellers.storefront_visible.exists?
       end
     end
   end

data/app/models/spree/stock/coordinator.rb

@@ -28,11 +28,14 @@ module Spree
       end
 
       def build_packages(packages = [])
-        stock_locations_with_requested_variants.each do |stock_location|
+        stock_locations = stock_locations_with_requested_variants.to_a
+        stock_levels = Packer.stock_levels_by_location(stock_locations, requested_variant_ids)
+
+        stock_locations.each do |stock_location|
           units = allocatable_units_for(stock_location)
           next if units.empty?
 
-          packer = build_packer(stock_location, units)
+          packer = build_packer(stock_location, units, stock_levels: stock_levels.fetch(stock_location.id, {}))
           packages += packer.packages
         end
 
@@ -114,8 +117,8 @@ module Spree
         @estimator ||= Estimator.new(order)
       end
 
-      def build_packer(stock_location, inventory_units)
-        Packer.new(stock_location, inventory_units, splitters(stock_location), owner: order)
+      def build_packer(stock_location, inventory_units, stock_levels: nil)
+        Packer.new(stock_location, inventory_units, splitters(stock_location), owner: order, stock_levels: stock_levels)
       end
 
       def splitters(_stock_location)

data/app/models/spree/stock/estimator.rb

@@ -162,6 +162,12 @@ module Spree
         methods = package.eligible_delivery_methods
         # Storeless orders exist only in specs; real orders always carry one.
         methods = methods.merge(order.store.delivery_methods) if order.store
+        # Read for every method below and when its rates are built. Through the
+        # preloader because an overridden package may hand back an Array.
+        methods = methods.to_a
+        ActiveRecord::Associations::Preloader.new(
+          records: methods, associations: %i[delivery_method_rules calculator services delivery_zone]
+        ).call
 
         # On a marketplace, a package's seller is its stock location's, and it
         # is quoted by that seller's own methods plus whatever the operator

data/app/models/spree/stock/inventory_unit_builder.rb

@@ -11,16 +11,28 @@ module Spree
         # rather than pointing at whatever order happens to share the cart's
         # id — a stranger's order whose currency and ship address would then
         # stand in for the customer's.
-        @order.line_items.map do |line_item|
+        line_items = @order.line_items.to_a
+        # Allocation asks each variant how it ships, so the variants and their
+        # delivery profiles are read once for the whole cart.
+        ActiveRecord::Associations::Preloader.new(
+          records: line_items, associations: { variant: [:delivery_profile, { product: :delivery_profile }] }
+        ).call
+
+        line_items.map do |line_item|
           # They go through multiple splits, avoid loading the
           # association to order until needed.
-          Spree::FulfillmentItem.new(
+          unit = Spree::FulfillmentItem.new(
             pending: true,
             line_item_id: line_item.id,
             variant_id: line_item.variant_id,
             quantity: line_item.quantity,
             order_id: @order.is_a?(Spree::Order) ? @order.id : nil
           )
+          # Set as targets rather than assigned, so the proposed unit is not
+          # added to the line item's own fulfillment_items.
+          unit.association(:line_item).target = line_item
+          unit.association(:variant).target = line_item.variant
+          unit
         end
       end
     end

data/app/models/spree/stock/packer.rb

@@ -9,9 +9,25 @@ module Spree
       #   belong to no order yet — so anything reading the buyer through the
       #   package (the packaging tare, the channel and company eligibility
       #   rules) would otherwise see nothing.
-      def initialize(stock_location, inventory_units, splitters = [Splitter::Base], owner: nil)
+      # Every candidate location's levels for the given variants in one query,
+      # lowest id first as StockLocation#stock_level reads, for packing several
+      # locations without a read per location.
+      #
+      # @param stock_locations [Array<Spree::StockLocation>]
+      # @param variant_ids [Array]
+      # @return [Hash{Integer => Hash{Integer => Spree::StockLevel}}] by location, then variant
+      def self.stock_levels_by_location(stock_locations, variant_ids)
+        Spree::StockLevel.where(stock_location_id: stock_locations.map(&:id), variant_id: variant_ids).
+          order(:id).group_by(&:stock_location_id).
+          transform_values { |levels| levels.group_by(&:variant_id).transform_values(&:first) }
+      end
+
+      # @param stock_levels [Hash{Integer => Spree::StockLevel}, nil] this
+      #   location's levels by variant id, when the caller read them already
+      def initialize(stock_location, inventory_units, splitters = [Splitter::Base], owner: nil, stock_levels: nil)
         @stock_location = stock_location
         @inventory_units = inventory_units
+        @stock_levels = stock_levels
         @splitters = splitters
         @owner = owner
       end
@@ -28,13 +44,21 @@ module Spree
         package = build_package
 
         # Group by variant_id as grouping by variant fires cached query.
-        inventory_units.index_by(&:variant_id).each do |variant_id, inventory_unit|
-          variant = Spree::Variant.find(variant_id)
+        units_by_variant_id = inventory_units.index_by(&:variant_id)
+        # The package's variants and their levels here, each in one query
+        # rather than one per variant. Lowest id first, as StockLocation#stock_level reads.
+        variants = variants_for(units_by_variant_id)
+        stock_levels = @stock_levels || stock_location.stock_levels.where(variant_id: units_by_variant_id.keys).order(:id).
+                       group_by(&:variant_id).transform_values(&:first)
+
+        units_by_variant_id.each do |variant_id, inventory_unit|
+          variant = variants[variant_id] || Spree::Variant.find(variant_id)
           unit = inventory_unit.dup # Can be used by others, do not use directly
           if variant.should_track_inventory?
-            next unless stock_location.stocks? variant
+            stock_level = stock_levels[variant_id]
+            next if stock_level.nil?
 
-            on_hand, backordered = stock_location.fill_status(variant, unit.quantity)
+            on_hand, backordered = stock_location.fill_status(variant, unit.quantity, stock_level: stock_level)
             package.add(FulfillmentItem.split(unit, backordered), :backordered) if backordered.positive?
             package.add(FulfillmentItem.split(unit, on_hand), :on_hand) if on_hand.positive?
           else
@@ -57,6 +81,16 @@ module Spree
 
       private
 
+      # The units' own variants when they carry them, so a cart's variants are
+      # read once however many locations are packed.
+      def variants_for(units_by_variant_id)
+        variants = units_by_variant_id.each_with_object({}) do |(variant_id, unit), loaded|
+          loaded[variant_id] = unit.variant if unit.association(:variant).loaded?
+        end
+        missing_ids = units_by_variant_id.keys - variants.keys
+        missing_ids.empty? ? variants : variants.merge(Spree::Variant.where(id: missing_ids).index_by(&:id))
+      end
+
       def build_splitter
         splitter = nil
         splitters.reverse_each do |klass|

data/app/models/spree/stock/quantifier.rb

@@ -3,6 +3,22 @@ module Spree
     class Quantifier
       attr_reader :variant, :stock_location, :excluded_order, :provided_stock_levels
 
+      # What a quantifier reads, preloaded for many variants at once, so
+      # quantifying each of them reads memory instead of querying per variant.
+      # Variants whose levels are loaded already are left as they are.
+      #
+      # @param variants [Enumerable<Spree::Variant>]
+      # @return [void]
+      def self.preload(variants)
+        unloaded = variants.compact.reject { |variant| variant.association(:stock_levels).loaded? }
+        return if unloaded.empty?
+
+        ActiveRecord::Associations::Preloader.new(
+          records: unloaded,
+          associations: { stock_levels: [:stock_location, :active_stock_reservations] }
+        ).call
+      end
+
       # @param excluded_order [Spree::Cart, Spree::Order, nil] when given,
       #   reservations belonging to this cart/order are not counted against
       #   availability. Used when checking a cart's own line items so the

data/app/models/spree/stock_location.rb

@@ -182,8 +182,10 @@ module Spree
     #
     # @param fulfillment [Spree::Fulfillment]
     # @return [Spree::StockMovement]
-    def allocate(variant, quantity, fulfillment)
-      move(variant, quantity, kind: 'allocated', cause: fulfillment)
+    # @param stock_level [Spree::StockLevel, nil] the variant's level here, when
+    #   the caller loaded it already
+    def allocate(variant, quantity, fulfillment, stock_level: nil)
+      move(variant, quantity, kind: 'allocated', cause: fulfillment, stock_level: stock_level)
     end
 
     # Withdraws a promise — a canceled, relocated or shrunk fulfillment.
@@ -199,21 +201,26 @@ module Spree
     # a negative quantity writes stock off.
     #
     # @param reason [String] audit text, required
+    # @param stock_level [Spree::StockLevel, nil] the variant's level here, when
+    #   the caller holds it already (locked, say), so the movement updates that
+    #   instance rather than one looked up again
     # @return [Spree::StockMovement]
-    def adjust(variant, quantity, reason:)
-      move(variant, quantity, kind: 'adjusted', reason: reason)
+    def adjust(variant, quantity, reason:, stock_level: nil)
+      move(variant, quantity, kind: 'adjusted', reason: reason, stock_level: stock_level)
     end
 
-    def move(variant, quantity, kind:, cause: nil, reason: nil, force: false, unit_cost: nil)
-      stock_level = stock_level_or_create(variant)
+    def move(variant, quantity, kind:, cause: nil, reason: nil, force: false, unit_cost: nil, stock_level: nil)
+      stock_level ||= stock_level_or_create(variant)
       attributes = { quantity: quantity, kind: kind, reason: reason, unit_cost: unit_cost,
                      **cause_attributes(cause) }
 
       stock_level.stock_movements.create!(attributes) { |movement| movement.force = force }
     end
 
-    def fill_status(variant, quantity)
-      if item = stock_level_or_create(variant)
+    # @param stock_level [Spree::StockLevel, nil] the variant's level here, when
+    #   the caller loaded it already
+    def fill_status(variant, quantity, stock_level: nil)
+      if item = stock_level || stock_level_or_create(variant)
         if item.available_count >= quantity
           on_hand = quantity
           backordered = 0

data/app/models/spree/store.rb

@@ -78,6 +78,22 @@ module Spree
     # same reason as auto_approve_sellers: what the marketplace lists is what
     # it vouches for.
     preference :auto_approve_seller_products, :boolean, default: false
+    # Let sellers attach downloadable files to their own products. Off for the
+    # same reason again: a file a buyer downloads under the marketplace's name
+    # is something the marketplace vouches for, and that should be a choice.
+    preference :seller_digital_assets_enabled, :boolean, default: false
+    # What a seller's file may be, checked against the file's own signature
+    # rather than its name. An entry names one type or, with `*` as the
+    # subtype, a whole family. The operator's own uploads are not restricted.
+    preference :seller_digital_asset_content_types, :array, of: :string,
+                                                            default: Spree::DigitalAsset::DEFAULT_SELLER_CONTENT_TYPES
+    # A typo here would refuse every seller upload with a message about the
+    # file, so the list is checked for the type/subtype shape when written.
+    validate :seller_digital_asset_content_types_are_media_types
+    # A file added to or replaced on a seller's product already on sale sends
+    # the product back to review, so an approved listing cannot change what it
+    # delivers without anyone looking. Moot when seller products auto-approve.
+    preference :review_seller_digital_asset_changes, :boolean, default: true
     # Who pays this store's sellers. Blank means core's record-only provider,
     # so a marketplace that has connected nothing still keeps a correct ledger
     # and settles by hand.
@@ -157,6 +173,8 @@ module Spree
     # B2B store collects it from everyone, a mixed store only offers it.
     preference :address_requires_company, :boolean, default: false
     preference :address_requires_phone, :boolean, default: false
+    MEDIA_TYPE_FORMAT = %r{\A[a-z0-9][a-z0-9!#$&^_.+-]*/[a-z0-9][a-z0-9!#$&^_.+*-]*\z}i
+
     # digital assets preferences
     preference :limit_digital_download_count, :boolean, default: true
     preference :limit_digital_download_days, :boolean, default: true
@@ -186,7 +204,8 @@ module Spree
                         :pricing_provider, :inventory_provider, :pricing_provider_failure_policy,
                         :inventory_provider_failure_policy, :payout_provider, :default_payouts_schedule_interval,
                         :default_minimum_payout_amount, :auto_approve_sellers, :auto_approve_seller_products,
-                        :send_seller_transactional_emails, :default_commission_tax_rate, :document_number_format,
+                        :seller_digital_assets_enabled, :seller_digital_asset_content_types,
+                        :review_seller_digital_asset_changes, :send_seller_transactional_emails, :default_commission_tax_rate, :document_number_format,
                         :order_number_prefix, :order_number_suffix, :order_number_sequence_start,
                         :limit_digital_download_count, :digital_asset_authorized_clicks,
                         :limit_digital_download_days, :digital_asset_authorized_days,
@@ -729,7 +748,9 @@ module Spree
     # Products without a profile fall back to this one, so it must exist
     # from the store's first moment.
     def create_default_delivery_profile
-      Spree::DeliveryProfiles::Shipping.create!(store: self, name: 'General', default: true)
+      Spree::Events.disable do
+        Spree::DeliveryProfiles::Shipping.create!(store: self, name: 'General', default: true)
+      end
     end
 
     def create_default_policies
@@ -831,5 +852,13 @@ module Spree
 
       errors.add(:preferred_order_number_sequence_start, :locked_after_first_number)
     end
+
+    def seller_digital_asset_content_types_are_media_types
+      bad = Array(preferred_seller_digital_asset_content_types).reject { |type| type.to_s.match?(MEDIA_TYPE_FORMAT) }
+      return if bad.empty?
+
+      errors.add(:preferred_seller_digital_asset_content_types, :invalid,
+                 message: I18n.t('spree.digital_assets_content_type_list_invalid', types: bad.join(', ')))
+    end
   end
 end

data/app/models/spree/store_credit.rb

@@ -3,6 +3,7 @@ module Spree
     has_prefix_id :credit
 
     include Spree::SingleStoreResource
+    include Spree::ActedBy
     include Spree::HasCustomFields
     include Spree::Metadata
     include Spree::CanonicalDecimals
@@ -25,7 +26,7 @@ module Spree
     # to attach it to.
     belongs_to :customer, class_name: "::#{Spree.customer_class}", optional: true
     include Spree::DeprecatedCustomerAlias
-    belongs_to :created_by, class_name: Spree.admin_user_class.to_s, foreign_key: 'created_by_id', optional: true
+    acted_by :created_by
     belongs_to :originator, polymorphic: true, optional: true
     belongs_to :refunded_order, class_name: 'Spree::Order', optional: true,
                                 inverse_of: :store_credit_refunds
@@ -40,8 +41,6 @@ module Spree
     validate :amount_used_less_than_or_equal_to_amount
     validate :amount_authorized_less_than_or_equal_to_amount
 
-    delegate :email, to: :created_by, prefix: true, allow_nil: true
-
     # Redemption order: the oldest credit is spent first.
     scope :oldest_first, -> { order(:created_at, :id) }
     # @deprecated Removed in Spree 6.1 — store credit types are gone; use {.oldest_first}.
@@ -110,7 +109,7 @@ module Spree
 
     self.whitelisted_ransackable_attributes = %w[customer_id created_by_id amount currency memo]
     search_by :memo
-    self.whitelisted_ransackable_associations = %w[customer created_by]
+    self.whitelisted_ransackable_associations = %w[customer]
     self.whitelisted_ransackable_scopes = %w[outstanding from_gift_card]
     self.ransackable_scope_types = %w[outstanding from_gift_card].index_with('boolean')
     # Staff notes and who issued the credit are back-office data.
@@ -283,6 +282,7 @@ module Spree
         amount: amount,
         customer_id: customer_id,
         created_by_id: created_by_id,
+        created_by_type: created_by_type,
         currency: currency,
         memo: credit_allocation_memo,
         store: store

data/app/models/spree/tax_line.rb

@@ -22,10 +22,11 @@ module Spree
     # core doesn't know about registers its reason here. The bar for a new
     # value: it distinguishes a treatment that reporting or invoicing has to
     # tell apart, not merely a different amount.
-    class_attribute :taxability_reasons,
-                    default: %w[standard_rated reduced_rated zero_rated reverse_charge
-                                intra_community_supply export customer_exempt product_exempt
-                                not_collecting not_subject_to_tax]
+    BUILT_IN_TAXABILITY_REASONS = %w[standard_rated reduced_rated zero_rated reverse_charge
+                                     intra_community_supply export customer_exempt product_exempt
+                                     not_collecting not_subject_to_tax].freeze
+
+    class_attribute :taxability_reasons, default: BUILT_IN_TAXABILITY_REASONS.dup
 
     # Provider payloads (jurisdiction breakdowns, external ids) read nil-safe.
     attribute :data, default: -> { {} }

data/app/models/spree/variant.rb

@@ -393,7 +393,11 @@ module Spree
       @tax_category ||= if self[:tax_category_id].nil?
                           product.tax_category
                         else
-                          Spree::TaxCategory.find_by(id: self[:tax_category_id]) || product.tax_category
+                          # The association, so a page of variants loads its
+                          # categories together; one deleted since it was
+                          # assigned no longer counts.
+                          own = super
+                          own.nil? || own.destroyed? || own.try(:deleted?) ? product.tax_category : own
                         end
     end
 
@@ -466,7 +470,7 @@ module Spree
     # Returns the options text of the variant.
     # @return [String] the options text of the variant
     def options_text
-      @options_text ||= if option_values.loaded?
+      @options_text ||= if read_association_in_memory?(:option_values)
                           option_values.sort_by do |ov|
                             ov.option_type.position
                           end.map { |ov| "#{ov.option_type.label}: #{ov.label}" }.to_sentence(words_connector: ', ', two_words_connector: ', ')
@@ -663,7 +667,7 @@ module Spree
     def price_in(currency)
       currency = currency&.upcase
 
-      price = if read_association_in_memory?(:prices) && prices.any?
+      price = if read_association_in_memory?(:prices)
                 prices.detect { |p| p.currency == currency && p.price_list_id.nil? }
               else
                 prices.base_prices.find_by(currency: currency)
@@ -864,7 +868,12 @@ module Spree
     # @return [void]
     def set_stock(count_on_hand, backorderable = nil, stock_location = nil)
       stock_location ||= default_stock_location
-      stock_level = stock_levels.find_or_initialize_by(stock_location: stock_location)
+      stock_level = if stock_levels.loaded?
+                      stock_levels.detect { |level| level.stock_location_id == stock_location.id } ||
+                        stock_levels.build(stock_location: stock_location)
+                    else
+                      stock_levels.find_or_initialize_by(stock_location: stock_location)
+                    end
       # `unless nil?`, not `if present?` — a caller passing false means it.
       stock_level.backorderable = backorderable unless backorderable.nil?
 
@@ -880,7 +889,10 @@ module Spree
       delta = count_on_hand.to_i - stock_level.count_on_hand.to_i
       return if delta.zero?
 
-      stock_location.adjust(self, delta, reason: Spree::StockMovement.default_adjustment_reason)
+      # Through the level already in hand rather than StockLocation#adjust,
+      # which would look the same row up again.
+      stock_level.stock_movements.create!(quantity: delta, kind: 'adjusted',
+                                          reason: Spree::StockMovement.default_adjustment_reason)
     end
 
     def default_stock_location
@@ -967,6 +979,11 @@ module Spree
     # Variants carry no store of their own; the product owns it.
     # @return [Spree::Store, nil]
     def preference_store
+      # The request's store instance when it is this one, so a page of
+      # variants reads its settings from one record rather than a copy each.
+      current_store = Spree::Current.store
+      return current_store if current_store && product&.store_id == current_store.id
+
       product&.store
     end
 
@@ -1188,7 +1205,7 @@ module Spree
     end
 
     def set_cost_currency
-      self.cost_currency = Spree::Store.default.default_currency if cost_currency.blank?
+      self.cost_currency = (product&.store || Spree::Store.default).default_currency if cost_currency.blank?
     end
 
     # Only the product's own store's locations — a new variant must not grow