spree_core 6.0.0.beta1 → 6.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d404e43490b356a04bf850e09a644143d8f399c7f39c147301184fd11c2cfed5
-  data.tar.gz: 2b1a720b211b09a061c26b5bf1761510fdde20bf2d50ee9451fbab4a67939b0c
+  metadata.gz: 0c2e491640b87a7c66d80915167c1b3e0e342ebc527f98ab6be473494850ed8c
+  data.tar.gz: 9507987225c9b98ea0676417742b9c22e338796d9d155f309f3d0f5262617f4d
 SHA512:
-  metadata.gz: 62dd3e3663ddf4b540127ae6bd526027adc294004e05f6069bf9041f36f5542c7daead8f747937094ddd73d8e19da153ff6ae214cc0c98ca6d7b80a6a8d2b8e8
-  data.tar.gz: b8c49e3df74336ea44676d186c1b376979541c85610baf04b575f82d80886c2850ab4245d4274eb887535c4081e028631766a1b2fa31788c302116de4aca596e
+  metadata.gz: 25b1c9003b48955d08e1d26f0f64d630ae4eafb07043cd49bfb70b22736255b0315f85b6e6f22ab873fc2e24b64cb0a3a7c715ac77b522d58afe1190939f4b78
+  data.tar.gz: b7379fef995f651f02229b55260b8685a8e4318e7748be5f2a64aa0476a40577d877f1e32897a3d6542f47beee847e18a431bb027cc1237c189f2bde8e0c0493

data/app/jobs/spree/sample_data/load_job.rb

@@ -0,0 +1,13 @@
+module Spree
+  module SampleData
+    # Loads the demo catalog, customers and orders in the background. Enqueued
+    # by first-run setup when the merchant ticks "load sample data": the
+    # loader needs an admin to own its imports and downloads product images,
+    # so it can neither run before setup nor inside the setup request.
+    class LoadJob < Spree::BaseJob
+      def perform
+        Spree::SampleData::Loader.call
+      end
+    end
+  end
+end

data/app/models/concerns/spree/acted_by.rb

@@ -0,0 +1,210 @@
+module Spree
+  # Declares a "who performed this action" association — the canceler of an
+  # order, the receiver of a stock delivery, the opener of a return.
+  #
+  #   class Spree::Order < Spree.base_class
+  #     include Spree::ActedBy
+  #     acted_by :created_by, :approver, :canceler
+  #   end
+  #
+  # Each name becomes an optional polymorphic `belongs_to` whose type column is
+  # validated against `Spree.actor_classes`, so a row can only ever name a
+  # registered actor — an admin user, an API key, or a class an extension
+  # registered. See docs/plans/6.0-action-actors.md.
+  #
+  # Association names, readers and writers are the ones a plain `belongs_to`
+  # would give, so the workflows that assign these (`order.canceler = canceler`)
+  # are untouched by the conversion.
+  module ActedBy
+    extend ActiveSupport::Concern
+
+    # Every model that declares at least one `acted_by` association, so a
+    # caller sweeping actor columns — the backfill task, a user's erasure —
+    # walks all of them without being handed a list.
+    #
+    # The registry fills as models load, so it eager-loads first: in
+    # development nothing is loaded until something references it, and a
+    # caller that silently skipped an unloaded model would leave a deleted
+    # person's id behind or half-finish an upgrade.
+    #
+    # Names are held rather than classes, and resolved on read, so a code
+    # reload does not leave the registry pointing at superseded copies of the
+    # same model.
+    #
+    # @return [Array<Class>]
+    def self.models
+      Rails.application&.eager_load! unless Rails.application&.config&.eager_load
+
+      registered_model_names.filter_map(&:safe_constantize)
+    end
+
+    # @api private
+    # @return [Set<String>]
+    def self.registered_model_names
+      @registered_model_names ||= Set.new
+    end
+
+    included do
+      # The names declared on this class, so the backfill task can ask a model
+      # what it records without being told. Inherited and extended per class,
+      # never assigned, so a subclass adding one does not blank its parent's.
+      class_attribute :acted_by_associations, default: [], instance_writer: false
+    end
+
+    # The class an actor column names, answering what the reader would resolve
+    # rather than what the column literally holds: a row the backfill has not
+    # reached carries an id and no type, and the reader resolves it through
+    # the admin user class. Serializers read this so `<name>_id` and
+    # `<name>_type` never disagree about the same row.
+    #
+    # @param name [Symbol, String] the acted_by association
+    # @return [String, nil]
+    def acted_by_type(name)
+      stored = self[:"#{name}_type"]
+      return stored if stored.present?
+
+      Spree.admin_user_class.to_s if self[:"#{name}_id"].present?
+    end
+
+    # The actor's prefixed id, encoded from the columns without loading the
+    # row — so a page of orders costs no query per actor it names. Paired with
+    # {#acted_by_type} so the id and the kind always describe the same row,
+    # including one the backfill has not reached.
+    #
+    # @param name [Symbol, String] the acted_by association
+    # @return [String, nil]
+    def acted_by_prefixed_id(name)
+      Spree::Base.polymorphic_prefixed_id(acted_by_type(name), self[:"#{name}_id"])
+    end
+
+    # Names the admin user class on every un-backfilled row of `record`'s
+    # lazily-preloaded group, so the association preloads as one query rather
+    # than one per row. Writes the in-memory attribute only; nothing is saved.
+    #
+    # @api private
+    # @param record [ActiveRecord::Base]
+    # @param name [Symbol] the acted_by association
+    # @return [void]
+    def self.assume_admin_actor_type(record, name)
+      type_column = :"#{name}_type"
+      admin_type = Spree.admin_user_class.to_s
+      group = record.try(:lazy_preload_context)&.records.presence || [record]
+
+      group.each do |sibling|
+        next unless sibling.instance_of?(record.class)
+        next if sibling[type_column].present? || sibling[:"#{name}_id"].blank?
+
+        sibling[type_column] = admin_type
+      end
+    end
+
+    # Both halves of an actor column, for a caller writing through
+    # `update_columns` or `update_all` rather than through the association —
+    # an id without its type names nothing, so the pair is produced together
+    # and never by hand.
+    #
+    #   changes.merge!(Spree::ActedBy.columns_for(:canceler, canceler))
+    #
+    # The actor is checked against the registry here because these writes go
+    # through `update_columns` / `update_all`, which skip validation — without
+    # it an unregistered actor persists as a row the model itself calls
+    # invalid.
+    #
+    # @param name [Symbol, String] the acted_by association
+    # @param actor [Object, nil]
+    # @raise [ArgumentError] when the actor's class is not registered
+    # @return [Hash{Symbol => Object, nil}]
+    def self.columns_for(name, actor)
+      type = actor && actor.class.polymorphic_name
+
+      if type.present? && Spree.actor_classes.exclude?(type)
+        raise ArgumentError, "#{type} is not a registered actor class — add it to Spree.actor_classes"
+      end
+
+      { :"#{name}_id" => actor&.id, :"#{name}_type" => type }
+    end
+
+    class_methods do
+      # @param names [Array<Symbol>] the association names to declare
+      # @return [void]
+      def acted_by(*names)
+        names = names.map(&:to_sym)
+        self.acted_by_associations = acted_by_associations + names
+        # An anonymous class — one built in a spec or a console — has no name
+        # to register, and a nil in the registry would break every later read.
+        Spree::ActedBy.registered_model_names << name_for_actor_registry if name_for_actor_registry
+
+        names.each do |name|
+          belongs_to name, polymorphic: true, optional: true
+
+          validate_actor_type(name)
+          define_transitional_actor_reader(name)
+        end
+      end
+
+      private
+
+      # STI subclasses register under the base class, whose table the backfill
+      # updates; an anonymous class registers nothing.
+      def name_for_actor_registry
+        base_class.name
+      end
+
+      def validate_actor_type(name)
+        type_column = :"#{name}_type"
+
+        validate do
+          value = self[type_column]
+          next if value.blank? || Spree.actor_classes.include?(value)
+
+          errors.add(type_column, :unregistered_actor,
+                     message: Spree.t('errors.messages.unregistered_actor'))
+        end
+      end
+
+      # Rows written before the type column existed carry an id and no type,
+      # which a polymorphic association reads as nil. Until the backfill task
+      # has run they resolve through the admin user class, the only thing they
+      # could ever have pointed at.
+      #
+      # The type is filled in on the in-memory attribute and the ordinary
+      # association reader does the rest, so the fallback keeps every benefit
+      # the association has — preloading included. Resolving it with a direct
+      # `find_by` instead would sidestep `ar_lazy_preload`, turning a page of
+      # 25 orders into 75 queries while the backfill is outstanding.
+      #
+      # Nothing is saved: `[]=` writes the attribute, and a record whose only
+      # change is this would still need an explicit save to persist it.
+      # Prepended rather than defined outright, so `super` reaches the
+      # generated reader.
+      #
+      # Removed in 6.1, once the backfill is a release behind.
+      def define_transitional_actor_reader(name)
+        transitional_actor_readers.module_eval do
+          define_method(name) do
+            return super() if self[:"#{name}_type"].present?
+            return super() if self[:"#{name}_id"].blank?
+
+            Spree::Deprecation.warn(
+              "#{self.class.name}##{name} resolved through #{Spree.admin_user_class} because " \
+              "#{name}_type is blank. Run `rake spree:upgrade:backfill_actor_types`; the fallback " \
+              'is removed in Spree 6.1.'
+            )
+
+            # Fill the type across the whole lazily-preloaded group, not just
+            # this record: the preloader batches on the type it finds, and
+            # filling one row at a time as each is read produces a query per
+            # row instead of one for the page.
+            Spree::ActedBy.assume_admin_actor_type(self, name)
+            super()
+          end
+        end
+      end
+
+      # The per-class module the transitional readers live in, prepended once.
+      def transitional_actor_readers
+        @transitional_actor_readers ||= Module.new.tap { |mod| prepend(mod) }
+      end
+    end
+  end
+end

data/app/models/concerns/spree/actor.rb

@@ -0,0 +1,51 @@
+module Spree
+  # What a model must answer to be recorded as the performer of an action.
+  #
+  # Included in the admin user class and in {Spree::ApiKey}; an extension's App
+  # or bot class includes it too and registers itself in
+  # `Spree.actor_classes` (see docs/plans/6.0-action-actors.md).
+  #
+  # Both methods have defaults that read whatever the including class already
+  # offers, so a class that names itself in one of the usual ways needs no
+  # override.
+  module Actor
+    extend ActiveSupport::Concern
+
+    # The kinds core itself registers, for the generated `ActorKind` type.
+    #
+    # A literal list rather than one derived from `Spree.actor_classes`: that
+    # registry is filled after serializer classes load, so deriving it would
+    # make the generated types depend on boot order and on which extensions
+    # are installed. The union stays open on the wire, so an extension's kind
+    # is still a valid value — it just does not autocomplete.
+    BUILT_IN_KINDS = %w[admin_user api_key].freeze
+
+    # How a timeline names this actor: a person's full name or email, an API
+    # key's name, an app's title.
+    #
+    # @return [String, nil]
+    def actor_label
+      %i[full_name name email].each do |method|
+        next unless respond_to?(method)
+
+        value = public_send(method)
+        value = value.to_s if value.present?
+        return value if value.present?
+      end
+
+      nil
+    end
+
+    # The wire shorthand for this actor's kind — `admin_user`, `api_key`, …
+    # The same derivation every polymorphic type column on the Admin API uses.
+    #
+    # Read from `polymorphic_name`, which is what the `*_type` column stores,
+    # so an STI subclass of an actor answers the same kind on the expansion
+    # as it does in the column beside it.
+    #
+    # @return [String]
+    def actor_kind
+      Spree::Base.polymorphic_api_type(self.class.polymorphic_name)
+    end
+  end
+end

data/app/models/concerns/spree/admin_user_methods.rb

@@ -2,6 +2,7 @@ module Spree
   module AdminUserMethods
     extend ActiveSupport::Concern
 
+    include Spree::Actor
     include Spree::PrefixedId
     include Spree::UserRoles
     include Spree::RansackableAttributes
@@ -33,15 +34,20 @@ module Spree
 
       # Associations
       has_many :identities, class_name: 'Spree::UserIdentity', as: :user, dependent: :destroy
-      has_many :canceled_orders, class_name: 'Spree::Order', foreign_key: :canceler_id
-      has_many :created_orders, class_name: 'Spree::Order', foreign_key: :created_by_id
-      has_many :approved_orders, class_name: 'Spree::Order', foreign_key: :approver_id
+      # The order operations became polymorphic in 6.0, so these read through
+      # the association rather than a bare foreign key: matching on the id
+      # alone would hand this user the rows an API key with the same numeric
+      # id performed. The rest still point at admin users only and convert in
+      # 6.1 (see docs/plans/6.0-action-actors.md).
+      has_many :canceled_orders, class_name: 'Spree::Order', as: :canceler
+      has_many :created_orders, class_name: 'Spree::Order', as: :created_by
+      has_many :approved_orders, class_name: 'Spree::Order', as: :approver
+      has_many :refunded_refunds, class_name: 'Spree::Refund', as: :refunder
+      has_many :created_returns, class_name: 'Spree::Return', as: :created_by
+      has_many :created_exchanges, class_name: 'Spree::Exchange', as: :created_by
+      has_many :created_claims, class_name: 'Spree::Claim', as: :created_by
       has_many :created_gift_cards, class_name: 'Spree::GiftCard', foreign_key: :created_by_id
       has_many :created_gift_card_batches, class_name: 'Spree::GiftCardBatch', foreign_key: :created_by_id
-      has_many :refunded_refunds, class_name: 'Spree::Refund', foreign_key: :refunder_id
-      has_many :created_returns, class_name: 'Spree::Return', foreign_key: :created_by_id
-      has_many :created_exchanges, class_name: 'Spree::Exchange', foreign_key: :created_by_id
-      has_many :created_claims, class_name: 'Spree::Claim', foreign_key: :created_by_id
       has_many :created_store_credits, class_name: 'Spree::StoreCredit', foreign_key: :created_by_id
       has_many :exports, class_name: 'Spree::Export', foreign_key: :user_id
       has_many :saved_reports, class_name: 'Spree::SavedReport', foreign_key: :user_id
@@ -79,28 +85,53 @@ module Spree
     def nullify_approver_id_in_approved_orders
       return if self.class != Spree.admin_user_class
 
-      approved_orders.update_all(approver_id: nil, updated_at: Time.current)
+      clear_actor(Spree::Order, :approver)
     end
 
     def cleanup_admin_user_resources
       return if self.class != Spree.admin_user_class
 
-      # resources to nullify
-      # TODO: we should change these associations to polymorphic and resolve this via standard rails association
-      # declarations with dependent: :nullify
-      canceled_orders.update_all(canceler_id: nil, updated_at: Time.current)
-      created_orders.update_all(created_by_id: nil, updated_at: Time.current)
+      # Every actor column that names this user, derived from the `acted_by`
+      # declarations rather than listed here, so the 6.1 conversion of the
+      # remaining associations needs no edit in this file.
+      clear_every_actor
+
+      # The plain foreign keys that are still admin-user-only. They join the
+      # loop above once they convert in 6.1.
       created_gift_cards.update_all(created_by_id: nil, updated_at: Time.current)
       created_gift_card_batches.update_all(created_by_id: nil, updated_at: Time.current)
-      refunded_refunds.update_all(refunder_id: nil, updated_at: Time.current)
-      created_returns.update_all(created_by_id: nil, updated_at: Time.current)
-      created_exchanges.update_all(created_by_id: nil, updated_at: Time.current)
-      created_claims.update_all(created_by_id: nil, updated_at: Time.current)
       created_store_credits.update_all(created_by_id: nil, updated_at: Time.current)
       saved_reports.update_all(user_id: nil, updated_at: Time.current)
 
       # resources to destroy
       exports.destroy_all
     end
+
+    # Erases this user from every actor column any model declares with
+    # `acted_by`.
+    def clear_every_actor
+      Spree::ActedBy.models.each do |model|
+        model.acted_by_associations.each { |name| clear_actor(model, name) }
+      end
+    end
+
+    # Erases this user from one polymorphic actor column, clearing both halves
+    # together — a type left behind names a class no id points at.
+    #
+    # Matched on the id with either this class or no class at all, because a
+    # row written before the type column existed carries only the id until
+    # `spree:upgrade:backfill_actor_types` runs. Skipping those would leave a
+    # deleted person's id on the record through exactly the upgrade window the
+    # backfill exists for. The id alone cannot collide here: it is paired with
+    # a type that is ours or absent, and absent meant an admin user.
+    #
+    # @param model [Class]
+    # @param name [Symbol] the acted_by association
+    def clear_actor(model, name)
+      model.
+        where(:"#{name}_id" => id).
+        where(:"#{name}_type" => [self.class.polymorphic_name, nil]).
+        update_all(Spree::ActedBy.columns_for(name, nil).merge(updated_at: Time.current))
+    end
   end
 end

data/app/models/concerns/spree/purchase/payment_processing.rb

@@ -50,7 +50,7 @@ module Spree
       #
       # @return [Boolean]
       def confirmation_required?
-        Spree::Config[:always_include_confirm_step] ||
+        Spree::StorePreferences.read(store, :always_include_confirm_step) ||
           payments.valid.map(&:payment_method).compact.any?(&:confirmation_required?)
       end
 

data/app/models/spree/api_key.rb

@@ -2,6 +2,7 @@ module Spree
   class ApiKey < Spree.base_class
     has_prefix_id :key  # Spree-specific: api key
 
+    include Spree::Actor
     include Spree::SingleStoreResource
 
     KEY_TYPES = %w[publishable secret].freeze
@@ -124,10 +125,11 @@ module Spree
 
     # Revokes this API key by setting +revoked_at+ to the current time.
     #
-    # @param user [Object, nil] the user who performed the revocation
+    # @param actor [Object, nil] who performed the revocation — an admin user
+    #   or another API key (see Spree.actor_classes)
     # @return [Boolean] true if the update succeeded
-    def revoke!(user = nil)
-      update!(revoked_at: Time.current, revoked_by: user)
+    def revoke!(actor = nil)
+      update!(revoked_at: Time.current, revoked_by: actor)
     end
 
     # Whether this key carries the given scope. `write_*` implies the matching

data/app/models/spree/catalog.rb

@@ -14,8 +14,9 @@ module Spree
   # catalog to those companies or divisions rather than to a group.
   #
   # Within whichever audience answered, visibility is the union of its
-  # catalogs' assortments and pricing takes the price list of the nearest
-  # assignment first (docs/plans/6.0-b2b-companies-and-catalogs.md).
+  # catalogs' assortments; pricing walks the assigning nodes nearest first and
+  # within one node charges the best price any of its catalogs gives
+  # (docs/plans/6.0-b2b-companies-and-catalogs.md).
   class Catalog < Spree.base_class
     has_prefix_id :cat
 
@@ -97,6 +98,17 @@ module Spree
     # @param company [Spree::Company, nil]
     # @return [Array<Spree::Catalog>]
     def self.for_company(company)
+      groups_for_company(company).flatten
+    end
+
+    # The same catalogs, grouped by the node that assigns them, nearest first.
+    # Only pricing needs the boundaries: catalogs sharing a node rank equally
+    # and the best price among them wins, while a nearer node outranks a
+    # further one. Everything else takes the flat {.for_company}.
+    #
+    # @param company [Spree::Company, nil]
+    # @return [Array<Array<Spree::Catalog>>]
+    def self.groups_for_company(company)
       return [] if company.nil?
 
       nodes = company.self_and_ancestors
@@ -110,9 +122,15 @@ module Spree
                     includes(:catalog).
                     group_by(&:assignable_id)
 
-      nodes.flat_map do |node|
-        Array(assignments[node.id]).map(&:catalog).select(&:active?).sort_by { |catalog| catalog.position.to_i }
-      end.uniq
+      # A catalog assigned to a node and to an ancestor answers from the nearer.
+      seen = Set.new
+
+      nodes.filter_map do |node|
+        group = Array(assignments[node.id]).map(&:catalog).
+                select { |catalog| catalog.active? && seen.add?(catalog.id) }.
+                sort_by { |catalog| catalog.position.to_i }
+        group.presence
+      end
     end
 
     # The catalogs assigned to any of the given customer groups, by position.
@@ -151,18 +169,30 @@ module Spree
     # @param channel [Spree::Channel, nil]
     # @return [Array<Spree::Catalog>]
     def self.for_context(store:, company: nil, user: nil, channel: nil)
+      groups_for_context(store: store, company: company, user: user, channel: channel).flatten
+    end
+
+    # The same resolution, grouped by precedence rank ({.groups_for_company}).
+    # Only the company axis has more than one rank.
+    #
+    # @return [Array<Array<Spree::Catalog>>]
+    def self.groups_for_context(store:, company: nil, user: nil, channel: nil)
       return [] if store.nil?
 
-      catalogs = store.catalogs.for_company(company)
+      groups = store.catalogs.groups_for_company(company)
+
       # Only when the company axis found nothing: a buyer purchasing for a
       # company is on that company's agreement, and adding their personal
       # segment's catalogs on top would price one buyer under two agreements
       # at once.
-      if catalogs.empty? && user
-        groups = user.try(:customer_groups)&.where(store_id: store.id) || []
-        catalogs = store.catalogs.for_customer_groups(groups)
+      if groups.empty? && user
+        customer_groups = user.try(:customer_groups)&.where(store_id: store.id) || []
+        groups = [store.catalogs.for_customer_groups(customer_groups).presence].compact
       end
-      catalogs = [channel&.default_catalog].compact.select(&:active?) if catalogs.empty?
+
+      groups = [[channel&.default_catalog].compact.select(&:active?).presence].compact if groups.empty?
+
+      catalogs = groups.flatten
       # Pricing reads each catalog's price list, and the list's contextual
       # rules decide whether it applies to the quantity being bought; without
       # this the walk is one query per catalog again, plus one per list.
@@ -171,7 +201,7 @@ module Spree
           records: catalogs, associations: { price_list: [:price_rules, :price_adjustment_tiers] }
         ).call
       end
-      catalogs
+      groups
     end
 
     # The catalogs applying to a buyer, resolving the company for them when
@@ -190,15 +220,22 @@ module Spree
     # @param channel [Spree::Channel, nil]
     # @return [Array<Spree::Catalog>]
     def self.for_buyer(store:, customer: nil, company: nil, channel: nil)
+      groups_for_buyer(store: store, customer: customer, company: company, channel: channel).flatten
+    end
+
+    # {.for_buyer}, grouped by precedence rank. What pricing walks.
+    #
+    # @return [Array<Array<Spree::Catalog>>]
+    def self.groups_for_buyer(store:, customer: nil, company: nil, channel: nil)
       return [] if store.nil?
 
       if store == Spree::Current.store
         company ||= Spree::Current.standing_company_for(customer)
         channel ||= Spree::Current.channel
-        Spree::Current.catalogs_for(company: company, user: customer, channel: channel)
+        Spree::Current.catalog_groups_for(company: company, user: customer, channel: channel)
       else
         company ||= Spree::Company.sole_standing_for(store: store, customer: customer)
-        for_context(store: store, company: company, user: customer, channel: channel)
+        groups_for_context(store: store, company: company, user: customer, channel: channel)
       end
     end
 

data/app/models/spree/claim.rb

@@ -10,6 +10,7 @@ module Spree
     has_prefix_id :claim
 
     has_spree_number prefix: 'CLM'
+    include Spree::ActedBy
     include Spree::NumberIdentifier
     include Spree::SingleStoreResource
     include Spree::HasStatus
@@ -27,7 +28,7 @@ module Spree
     belongs_to :store, class_name: 'Spree::Store'
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :claims
     belongs_to :reason, class_name: 'Spree::ClaimReason', optional: true, inverse_of: :claims
-    belongs_to :created_by, class_name: Spree.admin_user_class.to_s, optional: true
+    acted_by :created_by
 
     has_many :claim_line_items, class_name: 'Spree::ClaimLineItem',
                                 dependent: :destroy, inverse_of: :claim

data/app/models/spree/current.rb

@@ -4,7 +4,7 @@ module Spree
   # All attributes are automatically reset between requests by Rails.
   # Fallback chains ensure sensible defaults when attributes are not explicitly set.
   class Current < ::ActiveSupport::CurrentAttributes
-    attribute :store, :channel, :market, :currency, :locale, :content_locale, :tax_country, :price_lists, :applicable_catalogs, :quantity_rules_resolvers, :standing_companies, :global_pricing_context, :provider_cache, :integrations
+    attribute :store, :channel, :market, :currency, :locale, :content_locale, :tax_country, :price_lists, :applicable_catalogs, :applicable_catalog_groups, :quantity_rules_resolvers, :standing_companies, :global_pricing_context, :provider_cache, :integrations
 
     # Scratch space for provider strategies to memoize a call across the
     # request — part of the delivery rate provider contract (nothing in core
@@ -103,16 +103,22 @@ module Spree
     # @param channel [Spree::Channel, nil]
     # @return [Array<Spree::Catalog>]
     def catalogs_for(company: nil, user: nil, channel: nil)
-      channel ||= self.channel
-      # Normalized before the key is built, not just before the query: the
-      # key is an id, so an admin and a customer sharing one would otherwise
-      # share an entry and whichever resolved first would decide for both.
-      # Only a customer has customer-group catalogs to resolve.
-      user = nil unless user.is_a?(Spree.customer_class)
-
-      key = [store&.id, company&.id, user&.id, channel&.id]
-      applicable_catalogs[key] ||= Spree::Catalog.for_context(
-        store: store, company: company, user: user, channel: channel
+      key = catalog_memo_key(company: company, user: user, channel: channel)
+      applicable_catalogs[key] ||= catalog_groups_for(company: company, user: user, channel: channel).flatten
+    end
+
+    # The same catalogs grouped by precedence rank, which is what pricing
+    # walks ({Spree::Catalog.groups_for_company}). The resolved form — the
+    # flat set above is a cached flattening of it, never a second resolution.
+    #
+    # @param company [Spree::Company, nil]
+    # @param user [Object, nil]
+    # @param channel [Spree::Channel, nil]
+    # @return [Array<Array<Spree::Catalog>>]
+    def catalog_groups_for(company: nil, user: nil, channel: nil)
+      key = catalog_memo_key(company: company, user: user, channel: channel)
+      applicable_catalog_groups[key] ||= Spree::Catalog.groups_for_context(
+        store: store, company: company, user: normalized_catalog_user(user), channel: channel || self.channel
       )
     end
 
@@ -121,6 +127,11 @@ module Spree
       super || (self.applicable_catalogs = {})
     end
 
+    # @return [Hash]
+    def applicable_catalog_groups
+      super || (self.applicable_catalog_groups = {})
+    end
+
     # The quantity-rule resolver for a buyer in this request, keyed the same
     # way their catalogs are.
     #
@@ -133,8 +144,7 @@ module Spree
     # @param channel [Spree::Channel, nil]
     # @return [Spree::Catalogs::ResolveQuantityRules]
     def quantity_rules_resolver_for(company: nil, user: nil, channel: nil)
-      channel ||= self.channel
-      key = [store&.id, company&.id, user&.id, channel&.id]
+      key = catalog_memo_key(company: company, user: user, channel: channel)
       quantity_rules_resolvers[key] ||= Spree::Catalogs::ResolveQuantityRules.new(
         catalogs_for(company: company, user: user, channel: channel)
       )
@@ -176,6 +186,7 @@ module Spree
     # @return [void]
     def reset_catalog_memos
       self.applicable_catalogs = nil
+      self.applicable_catalog_groups = nil
       self.quantity_rules_resolvers = nil
       self.standing_companies = nil
       self.price_lists = nil
@@ -194,5 +205,22 @@ module Spree
         )
       end
     end
+
+    private
+
+    # One key for every buyer-derived memo, so they cannot drift apart.
+    #
+    # @return [Array]
+    def catalog_memo_key(company: nil, user: nil, channel: nil)
+      [store&.id, company&.id, normalized_catalog_user(user)&.id, (channel || self.channel)&.id]
+    end
+
+    # Normalized before the key is built, not just before the query: the key
+    # is an id, so an admin and a customer sharing one would share an entry.
+    #
+    # @return [Object, nil]
+    def normalized_catalog_user(user)
+      user if user.is_a?(Spree.customer_class)
+    end
   end
 end

data/app/models/spree/exchange.rb

@@ -11,6 +11,7 @@ module Spree
     has_prefix_id :exch
 
     has_spree_number prefix: 'EX'
+    include Spree::ActedBy
     include Spree::NumberIdentifier
     include Spree::SingleStoreResource
     include Spree::HasStatus
@@ -26,7 +27,7 @@ module Spree
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :exchanges
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
     belongs_to :reason, class_name: 'Spree::ReturnReason', optional: true, inverse_of: :exchanges
-    belongs_to :created_by, class_name: Spree.admin_user_class.to_s, optional: true
+    acted_by :created_by
 
     has_many :exchange_line_items, class_name: 'Spree::ExchangeLineItem',
                                    dependent: :destroy, inverse_of: :exchange