spree_core 6.0.0.rc4 → 6.0.0.rc6

data/app/models/spree/data_request.rb

@@ -20,9 +20,12 @@ module Spree
 
     publishes_lifecycle_events
     publishes_event :completed
+    publishes_event :confirmation_requested,
+                    serializer: 'Spree::Api::V3::DataRequestConfirmationRequestedEventSerializer',
+                    credential: 'write_customers'
 
     include Spree::HasStatus
-    has_status :pending, :processing, :completed, :failed, default: :pending
+    has_status :awaiting_confirmation, :pending, :processing, :completed, :failed, :lapsed, default: :pending
 
     ACCESS = 'access'.freeze
     ERASURE = 'erasure'.freeze
@@ -33,11 +36,23 @@ module Spree
     # about them is not left lying around.
     DEFAULT_EXPIRY = 7.days
 
+    # How long a request a customer raised waits for confirmation from its
+    # email address before it lapses.
+    CONFIRMATION_WINDOW = 24.hours
+
     # Addresses the finished export. Plaintext like the digital-link token:
     # the URL is the credential, it is only ever sent to the address that
     # asked, and it stops working when the request expires.
     has_secure_token :download_token
 
+    # Proves that whoever confirms reads mail at the address the request
+    # names. Bound to
+    # the download token, so an erasure, which clears it, voids every link
+    # already sent.
+    generates_token_for :confirmation do
+      download_token
+    end
+
     belongs_to :customer, class_name: Spree.customer_class.to_s
     # Null when the subject asked for it themselves; set when staff acted on a
     # request that arrived by email.
@@ -52,6 +67,8 @@ module Spree
     scope :access, -> { where(kind: ACCESS) }
     scope :erasure, -> { where(kind: ERASURE) }
     scope :in_progress, -> { with_status(:pending, :processing) }
+    scope :confirmable, -> { awaiting_confirmation.where(requested_at: CONFIRMATION_WINDOW.ago..) }
+    scope :past_confirmation_window, -> { awaiting_confirmation.where(requested_at: ...CONFIRMATION_WINDOW.ago) }
     scope :recent_first, -> { order(requested_at: :desc) }
 
     self.whitelisted_ransackable_attributes = %w[number kind status email requested_at completed_at]
@@ -89,6 +106,22 @@ module Spree
       expires_at.present? && expires_at.past?
     end
 
+    # Whether the request is still waiting for confirmation, within the window
+    # to receive it, and still names the account's address.
+    # @return [Boolean]
+    def confirmable?
+      awaiting_confirmation? && requested_at > CONFIRMATION_WINDOW.ago && addressed_to_customer?
+    end
+
+    # Whether the request names the address the account has now. The work
+    # matches guest rows by the account's address when it runs, so a request
+    # for an address the account has since left would reach rows it never
+    # named.
+    # @return [Boolean]
+    def addressed_to_customer?
+      customer.present? && email.to_s.casecmp?(customer.email.to_s)
+    end
+
     private
 
     def set_defaults

data/app/models/spree/delivery_method.rb

@@ -451,10 +451,13 @@ module Spree
         calculator.description + ': ' +
 
         if calculator.is_a?(Spree::Calculator::Shipping::FlatRate)
-          if calculator.preferred_amount == 0
+          amount = calculator.amount_for(calculator.preferred_currency)
+          if amount.nil?
+            ''
+          elsif amount.zero?
             I18n.t('spree.free')
           else
-            Spree::Money.new(calculator.preferred_amount, { currency: calculator.preferred_currency }).to_s
+            Spree::Money.new(amount, { currency: calculator.preferred_currency }).to_s
           end
         elsif calculator.is_a?(Spree::Calculator::Shipping::FlexiRate)
           Spree::Money.new(calculator.preferred_first_item, { currency: calculator.preferred_currency }).to_s
@@ -497,14 +500,21 @@ module Spree
       reconcile_services(pending)
     end
 
+    # Matched against the method's rows loaded once, rather than a lookup per
+    # row. A row created here joins that list, so a later row naming the
+    # same (carrier, service) updates it as a lookup would.
     def reconcile_services(rows)
+      existing = services.reload.to_a
       kept_ids = rows.filter_map do |row|
-        record =
-          if row[:id].present?
-            id = Spree::PrefixedId.prefixed_id?(row[:id]) ? Spree::PrefixedId.decode_prefixed_id(row[:id]) : row[:id]
-            services.find_by(id: id)
-          end
-        record ||= services.find_or_initialize_by(carrier: row[:carrier], service: row[:service])
+        if row[:id].present?
+          id = Spree::PrefixedId.prefixed_id?(row[:id]) ? Spree::PrefixedId.decode_prefixed_id(row[:id]) : row[:id]
+          record = existing.find { |service| service.id.to_s == id.to_s }
+        end
+        record ||= existing.find { |service| service.carrier == row[:carrier] && service.service == row[:service] }
+        unless record
+          record = services.build(carrier: row[:carrier], service: row[:service])
+          existing << record
+        end
         record.assign_attributes(row.slice(:carrier, :service, :label, :markup_flat, :markup_percent, :position).to_h)
         record.save!
         record.id

data/app/models/spree/delivery_profile.rb

@@ -123,6 +123,24 @@ module Spree
       delivery_origin_groups.first
     end
 
+    # How many products use this profile. Counted for every profile of a
+    # lazily preloaded list in one grouped query, since loading the products
+    # themselves to count them would fetch the whole catalog.
+    #
+    # @return [Integer]
+    def products_count
+      return @products_count if defined?(@products_count)
+
+      profiles = lazy_preload_context&.records.presence || [self]
+      counts = Spree::Product.where(delivery_profile_id: profiles.map(&:id)).group(:delivery_profile_id).count
+      profiles.each { |profile| profile.products_count = counts.fetch(profile.id, 0) }
+      @products_count
+    end
+
+    protected
+
+    attr_writer :products_count
+
     private
 
     def create_default_origin_group

data/app/models/spree/digital_asset.rb

@@ -25,6 +25,20 @@ module Spree
     # and provider-backed assets (which carry no file) are exempt.
     DEFAULT_PROVIDER = 'Spree::DigitalAssetProvider::File'.freeze
 
+    # What a seller may upload unless the marketplace says otherwise: the
+    # formats digital goods usually come in. Executables, scripts and
+    # unrecognised binaries are left out on purpose, as is SVG, which can
+    # carry scripts. A marketplace selling a niche format adds it in settings.
+    # The text formats have no signature, so they are taken at the type the
+    # upload declared.
+    DEFAULT_SELLER_CONTENT_TYPES = %w[
+      application/pdf application/epub+zip application/zip application/x-7z-compressed application/gzip
+      application/json text/plain text/csv
+      audio/mpeg audio/mp4 audio/aac audio/flac audio/ogg audio/wav audio/x-wav audio/midi
+      video/mp4 video/webm video/quicktime
+      image/jpeg image/png image/gif image/webp image/tiff
+    ].freeze
+
     # The API names a provider by its shorthand (`file`); the column keeps the
     # class name.
     normalizes :provider_type, with: ->(value) { Spree::ApiTyped.class_name_for(Spree.digital_asset_providers, value) }

data/app/models/spree/event.rb

@@ -86,14 +86,29 @@ module Spree
     # @return [Boolean]
     def self.matches?(event_name, pattern)
       return true if pattern == '*'
+      return event_name == pattern unless pattern.include?('*')
 
-      if pattern.include?('*')
-        regex = Regexp.new("^#{Regexp.escape(pattern).gsub('\*', '.*')}$")
-        event_name.match?(regex)
-      else
-        event_name == pattern
+      wildcard_match?(event_name, pattern)
+    end
+
+    # `*` stands for any run of characters, as in a shell glob. The comparison
+    # is plain string searching so a pattern taken from a merchant never
+    # reaches the regexp engine, which has had memory bugs in pattern parsing.
+    def self.wildcard_match?(event_name, pattern)
+      head, *middle, tail = pattern.split('*', -1)
+      return false unless event_name.start_with?(head) && event_name.end_with?(tail)
+      return false if event_name.length < head.length + tail.length
+
+      position = head.length
+      limit = event_name.length - tail.length
+      middle.all? do |segment|
+        found = event_name.index(segment, position)
+        next false if found.nil? || found + segment.length > limit
+
+        position = found + segment.length
       end
     end
+    private_class_method :wildcard_match?
 
     alias_method :to_h, :attributes
 

data/app/models/spree/fulfillment.rb

@@ -653,7 +653,14 @@ module Spree
     #
     # @return [Spree::DeliveryMethod]
     def delivery_method
-      selected_delivery_rate&.delivery_method || delivery_rates.first&.delivery_method
+      selected = selected_delivery_rate
+      # The same row read through the rate list, when that list is to hand,
+      # so its method loads with every other rate's instead of on its own.
+      if selected && read_association_in_memory?(:delivery_rates)
+        selected = delivery_rates.detect { |rate| rate.id == selected.id } || selected
+      end
+
+      selected&.delivery_method || delivery_rates.first&.delivery_method
     end
 
     # The fulfillment provider strategy handling this fulfillment's

data/app/models/spree/fulfillment_changer.rb

@@ -138,7 +138,9 @@ module Spree
     end
 
     def reload_shipment_inventory_units
-      [current_shipment, desired_shipment].each { |shipment| shipment.fulfillment_items.reload }
+      shipments = [current_shipment, desired_shipment]
+      shipments.each { |shipment| shipment.association(:fulfillment_items).reset }
+      ActiveRecord::Associations::Preloader.new(records: shipments, associations: :fulfillment_items).call
     end
 
     def current_quantity

data/app/models/spree/fulfillment_item.rb

@@ -107,6 +107,17 @@ module Spree
       split
     end
 
+    # `dup` copies the foreign keys but not the loaded records, so every copy
+    # made while packing and splitting would look its line item and variant
+    # up again.
+    def initialize_dup(other)
+      super
+      %i[line_item variant].each do |name|
+        association = other.association(name)
+        self.association(name).target = association.target if association.loaded?
+      end
+    end
+
     # This will fail if extract >= available_quantity
     def split_inventory!(extract_quantity)
       split = self.class.split(self, extract_quantity)

data/app/models/spree/import.rb

@@ -215,10 +215,22 @@ module Spree
     end
 
     # Per-status row counts for API status payloads, memoized so one request
-    # issues a single grouped COUNT instead of one per status.
+    # issues a single grouped COUNT instead of one per status — and, on a
+    # lazily preloaded list, one for every import of the list.
     # @return [Hash{String => Integer}]
     def rows_status_counts
-      @rows_status_counts ||= rows.group(:status).count
+      return @rows_status_counts if @rows_status_counts
+
+      siblings = lazy_preload_context&.records&.grep(Spree::Import)
+      return @rows_status_counts = rows.group(:status).count if siblings.blank?
+
+      counts = Spree::ImportRow.where(import_id: siblings.map(&:id)).group(:import_id, :status).count
+      siblings.each do |import|
+        import.preloaded_rows_status_counts = counts.each_with_object({}) do |((import_id, status), count), by_status|
+          by_status[status] = count if import_id == import.id
+        end
+      end
+      @rows_status_counts
     end
 
     # Public API name for the +results_url+ preference (read/write symmetry).
@@ -474,6 +486,12 @@ module Spree
       end
     end
 
+    protected
+
+    def preloaded_rows_status_counts=(counts)
+      @rows_status_counts = counts
+    end
+
     private
 
     # Mirrors the machine's bang events: an illegal move raised.

data/app/models/spree/order.rb

@@ -152,7 +152,7 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[
       completed_at email number status payment_status payment_state fulfillment_status shipment_state delivery_total
       total item_total total_quantity considered_risky channel_id currency coupon_code customer_id seller_id
-      order_group_id po_number
+      order_group_id po_number market_id locale
     ]
     self.whitelisted_ransackable_scopes = %w[complete incomplete refunded partially_refunded search]
     self.ransackable_scope_types = %w[complete incomplete refunded partially_refunded].index_with('boolean')

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/sales_context.rb

@@ -0,0 +1,162 @@
+module Spree
+  # Who buys, on which channel, in which market: what a buyer can be sold, and
+  # at what price, depends on all of these together. A market fixes the
+  # currency and the languages a sale may use.
+  class SalesContext
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :store
+    attribute :market
+    attribute :channel
+    attribute :customer
+    attribute :company
+    attribute :country
+    attribute :currency, :string
+    attribute :locale, :string
+    # A placed sale keeps the company it was stamped with, even none, so only
+    # a sale still being put together looks up the customer's company.
+    attribute :resolve_company, :boolean, default: true
+
+    validate :currency_sold_in_a_market
+    validate :currency_matches_market
+    validate :locale_supported_by_market
+
+    # @param order [Spree::Order]
+    # @return [Spree::SalesContext]
+    def self.from_order(order)
+      new(
+        store: order.store, market: order.market, channel: order.channel, customer: order.customer,
+        company: order.resolved_company, resolve_company: false, country: order.tax_country,
+        currency: order.currency, locale: order.locale
+      )
+    end
+
+    # The market chosen for the sale, else one selling the requested currency,
+    # else the store's default.
+    #
+    # @return [Spree::Market, nil]
+    def market
+      chosen = super
+      return chosen if chosen
+      return @resolved_market if defined?(@resolved_market)
+
+      @resolved_market = resolve_market
+    end
+
+    def channel
+      super || store&.default_channel
+    end
+
+    # @return [String] the requested currency, else the market's, else the store's
+    def currency
+      requested_currency || market&.currency || store&.default_currency
+    end
+
+    # @return [String, nil] the requested language, else the market's default
+    def locale
+      super.presence || market&.default_locale
+    end
+
+    # The company chosen for the sale, else the one the customer stands in
+    # alone — the same answer pricing and catalog visibility reach.
+    #
+    # @return [Spree::Company, nil]
+    def company
+      chosen = super
+      return chosen if chosen || !resolve_company
+      return @standing_company if defined?(@standing_company)
+
+      @standing_company =
+        if customer.is_a?(Spree.customer_class) && store
+          Spree::Company.sole_standing_for(store: store, customer: customer)
+        end
+    end
+
+    # Variants the buyer may order on the channel: published there and inside
+    # their catalogs.
+    #
+    # @return [ActiveRecord::Relation<Spree::Variant>]
+    def orderable_variants
+      @orderable_variants ||= Spree::Variant.for_products(
+        Spree.products_for_context_service.call(
+          store: store, channel: channel, customer: customer, company: company,
+          base: store.products.not_discontinued_on(channel)
+        ).value
+      )
+    end
+
+    # Orderable variants the buyer can be quoted in the sale's currency: a base
+    # price, or a price from a list that applies to them, so a product sold to
+    # a buyer only under their agreement is offered to that buyer alone.
+    #
+    # @return [ActiveRecord::Relation<Spree::Variant>]
+    def sellable_variants
+      prices = Spree::Price.where(variant_id: orderable_variants.select(:id), currency: currency)
+                           .where.not(amount: nil)
+                           .where(price_list_id: [nil, *applicable_price_list_ids])
+
+      orderable_variants.where(id: prices.select(:variant_id))
+    end
+
+    # @return [Spree::Pricing::Context] the context prices are resolved in
+    def pricing_context
+      @pricing_context ||= Spree::Pricing::Context.new(
+        currency: currency, store: store, country: country, market: market,
+        channel: channel, user: customer, company: company
+      )
+    end
+
+    private
+
+    def requested_currency
+      attributes['currency'].presence&.upcase
+    end
+
+    def resolve_market
+      return unless store
+
+      candidates = [(Spree::Current.market if Spree::Current.store == store), store.default_market].compact
+      return candidates.first unless requested_currency
+
+      candidates.find { |candidate| candidate.currency == requested_currency } ||
+        store.markets.find_by(currency: requested_currency)
+    end
+
+    # Catalog price lists the buyer's catalogs carry, and standalone lists
+    # whose rules match the sale, judged the way the internal pricing provider
+    # judges them.
+    def applicable_price_list_ids
+      @applicable_price_list_ids ||= begin
+        catalogs = Spree::Catalog.groups_for_buyer(store: store, customer: customer, company: company, channel: channel)
+        catalog_lists = catalogs.flatten.filter_map(&:price_list).select do |list|
+          list.currently_active? && list.contextual_rules_applicable?(pricing_context)
+        end
+        standalone_lists = Spree::PriceList.for_context(pricing_context).select { |list| list.applicable?(pricing_context) }
+
+        (catalog_lists + standalone_lists).map(&:id).uniq
+      end
+    end
+
+    def currency_sold_in_a_market
+      return if requested_currency.nil? || market || store.nil? || !store.markets.exists?
+
+      errors.add(:currency, :currency_not_supported_by_store, message: I18n.t('spree.currency_not_supported_by_store'))
+    end
+
+    def currency_matches_market
+      return if market.nil? || currency == market.currency
+
+      errors.add(
+        :currency, :currency_does_not_match_market,
+        message: I18n.t('spree.currency_does_not_match_market', currency: market.currency)
+      )
+    end
+
+    def locale_supported_by_market
+      return if market.nil? || locale.blank? || market.supported_locales_list.include?(locale)
+
+      errors.add(:locale, :locale_not_supported_by_market, message: I18n.t('spree.locale_not_supported_by_market'))
+    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.