spree_core 6.0.0.rc5 → 6.0.0.rc7

data/app/models/spree/order_routing/strategy/rules.rb

@@ -59,8 +59,11 @@ module Spree
         # rank order so the Prioritizer's first-package-wins-on-hand logic
         # honors the routing decision.
         def build_packages(locations)
+          stock_levels = Spree::Stock::Packer.stock_levels_by_location(locations, requested_variant_ids)
+
           locations.flat_map do |location|
-            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters, owner: order).packages
+            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters, owner: order,
+                                     stock_levels: stock_levels.fetch(location.id, {})).packages
           end
         end
 

data/app/models/spree/price_list.rb

@@ -38,6 +38,21 @@ module Spree
     # flip or a catalog attach/detach changes which lists match generically.
     after_commit -> { Spree::Current.price_lists = nil }
 
+    # Distinct products per list for a page of lists, in one grouped query.
+    # @param price_list_ids [Array<Integer>]
+    # @return [Hash{Integer => Integer}] keyed by price list id; lists with no products are absent
+    def self.products_count_by_list(price_list_ids)
+      where(id: price_list_ids).joins(:variants).group(arel_table[:id]).
+        distinct.count(Spree::Variant.arel_table[:product_id])
+    end
+
+    # Prices per list for a page of lists, in one grouped query.
+    # @param price_list_ids [Array<Integer>]
+    # @return [Hash{Integer => Integer}] keyed by price list id; lists with no prices are absent
+    def self.prices_count_by_list(price_list_ids)
+      Spree::Price.where(price_list_id: price_list_ids).group(:price_list_id).count
+    end
+
     # Flat-payload writer for `rules`. See
     # {Spree::TypedAssociations#assign_typed_association}.
     def rules=(rows)

data/app/models/spree/product/channels.rb

@@ -64,8 +64,8 @@ module Spree
       def publication_for(channel)
         return nil unless channel
 
-        if product_publications.loaded?
-          product_publications.find { |p| p.channel_id == channel.id }
+        if read_association_in_memory?(:product_publications)
+          product_publications.find { |publication| publication.channel_id == channel.id }
         else
           product_publications.find_by(channel_id: channel.id)
         end
@@ -122,10 +122,16 @@ module Spree
       end
 
       def apply_product_publications(publications_params)
+        rows = publications_params.map { |publication_data| publication_data.to_h.with_indifferent_access }
         publication_ids_in_payload = []
 
-        publications_params.each do |publication_data|
-          publication_data = publication_data.to_h.with_indifferent_access
+        # The product's publications and every channel the payload names are
+        # read once, rather than a lookup per row.
+        named_channel_ids = rows.filter_map { |row| decode_publication_channel_id(row[:channel_id]) if row[:id].blank? }
+        channels_by_id = named_channel_ids.empty? ? {} : publishable_channels.where(id: named_channel_ids).index_by { |channel| channel.id.to_s }
+        product_publications.load
+
+        rows.each do |publication_data|
           publication_id = publication_data.delete(:id)
           channel_id = decode_publication_channel_id(publication_data[:channel_id])
 
@@ -133,7 +139,7 @@ module Spree
             decoded_id = Spree::PrefixedId.prefixed_id?(publication_id) ?
                            Spree::PrefixedId.decode_prefixed_id(publication_id) :
                            publication_id
-            publication = product_publications.find_by(id: decoded_id)
+            publication = product_publications.detect { |existing| existing.id.to_s == decoded_id.to_s }
             next unless publication
 
             # Channel is immutable; ignore any rebind attempt.
@@ -142,19 +148,21 @@ module Spree
           elsif channel_id.present?
             # Only publish to channels owned by the product's store; ignore
             # ids referencing another store's channel.
-            channel = publishable_channels.find_by(id: channel_id)
+            channel = channels_by_id[channel_id.to_s]
             next unless channel
 
             # Upsert by channel_id so repeat submissions are idempotent
             # against the unique (product_id, channel_id) index.
-            publication = product_publications.find_or_initialize_by(channel_id: channel.id)
+            publication = product_publications.detect { |existing| existing.channel_id == channel.id } ||
+                          product_publications.build(channel: channel)
             publication.assign_attributes(publication_data.slice(:published_at, :unpublished_at))
             publication.save!
             publication_ids_in_payload << publication.id
           end
         end
 
-        product_publications.where.not(id: publication_ids_in_payload).destroy_all
+        removed = product_publications.reject { |publication| publication_ids_in_payload.include?(publication.id) }
+        product_publications.destroy(*removed) if removed.any?
       end
 
       def decode_publication_channel_id(value)

data/app/models/spree/product.rb

@@ -277,7 +277,9 @@ module Spree
     #   the search. Definitions are store-owned, so the caller says which store
     #   is searching; `Spree::Current.store` is the request's answer and a
     #   background caller (an export, say) passes its own.
-    scope :search, ->(query, store = Spree::Current.store) {
+    # @param audience [Symbol, nil] `:store` keeps a shopper's search off the
+    #   custom fields hidden from the storefront; `nil` is the back office
+    scope :search, ->(query, store = Spree::Current.store, audience: nil) {
       next none if query.blank?
 
       product_ids = Spree::Variant.search_by_product_name_or_sku(query).pluck(:product_id)
@@ -285,6 +287,7 @@ module Spree
       searchable_definitions = store.custom_field_definitions.
                                for_resource_type('Spree::Product').
                                searchable
+      searchable_definitions = searchable_definitions.storefront_visible if audience == :store
 
       # Only pay for the custom_field scan when some definition opts into search;
       # the leading-wildcard LIKE over spree_custom_fields can't use an index.
@@ -494,7 +497,9 @@ module Spree
     def purchasable?
       return @purchasable unless @purchasable.nil?
 
-      @purchasable = sellable_variants.any?(&:purchasable?)
+      variants_to_check = sellable_variants
+      Spree::Stock::Quantifier.preload(variants_to_check)
+      @purchasable = variants_to_check.any?(&:purchasable?)
     end
 
     def in_stock?

data/app/models/spree/return.rb

@@ -165,7 +165,7 @@ module Spree
     # more than one step (part to store credit, part to the card), and store
     # credit is its own ledger rather than a Spree::Refund row.
     def refunded_total
-      refunds.sum(:amount) + store_credits.sum(:amount)
+      ledger_total(:refunds) + ledger_total(:store_credits)
     end
 
     def refundable_total
@@ -187,5 +187,12 @@ module Spree
     def taxed_lines
       return_line_items
     end
+
+    private
+
+    def ledger_total(association_name)
+      rows = public_send(association_name)
+      read_association_in_memory?(association_name) ? rows.sum(0.to_d, &:amount) : rows.sum(:amount)
+    end
   end
 end

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

@@ -5,7 +5,7 @@ module Spree
       # attributes. `price` also sorts descending as `-price`.
       SORT_FIELDS = %w[price best_selling manual].freeze
 
-      attr_reader :store
+      attr_reader :store, :audience
 
       # Whether this provider requires background indexing jobs.
       # Override in subclasses. Database provider returns false.
@@ -13,13 +13,18 @@ module Spree
         false
       end
 
-      def initialize(store)
+      # @param store [Spree::Store]
+      # @param audience [Symbol, nil] who searches: `:store` (shoppers) limits
+      #   filters and sorts to what the storefront may see; `nil` is the back
+      #   office
+      def initialize(store, audience: :store)
         @store = store
+        @audience = audience
       end
 
       # @return [CustomFieldSchema]
       def custom_field_schema
-        @custom_field_schema ||= CustomFieldSchema.new(store)
+        @custom_field_schema ||= CustomFieldSchema.new(store, audience: audience)
       end
 
       # Deprecated 6.0 name, removed in 6.1.

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