spree_core 6.0.0.rc5 → 6.0.0.rc7

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/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

data/app/models/spree/webhook_endpoint.rb

@@ -20,6 +20,10 @@ module Spree
     validates :url, format: { with: URI::DEFAULT_PARSER.make_regexp(%w[http https]), message: :invalid_url }
     validates :active, inclusion: { in: [true, false] }
     validate :url_must_not_resolve_to_private_ip, if: -> { !Rails.env.development? && url.present? && url_changed? }
+    validate :subscriptions_must_be_event_patterns, if: :will_save_change_to_subscriptions?
+
+    attribute :subscriptions, default: -> { [] }
+    normalizes :subscriptions, apply_to_nil: true, with: ->(value) { Array(value).map { |entry| entry.to_s.strip }.reject(&:empty?).uniq }
 
     before_create :generate_secret_key
     after_create  { @reveal_secret_in_response = true }
@@ -83,6 +87,23 @@ module Spree
     # Number of consecutive failed deliveries before auto-disabling
     AUTO_DISABLE_THRESHOLD = 15
 
+    MAX_SUBSCRIPTIONS = 200
+    MAX_SUBSCRIPTION_LENGTH = 100
+    SUBSCRIPTION_SEGMENT = /\A[a-zA-Z0-9_-]+\z/
+
+    # Whether +value+ is a shape `subscriptions` accepts: `*`, an event name,
+    # or a name with `*` in place of whole segments (`order.*`, `*.created`).
+    # Anything else — regexp syntax above all — is refused before it is
+    # stored, so the matcher only ever sees names and segment wildcards.
+    #
+    # @param value [Object]
+    # @return [Boolean]
+    def self.event_pattern?(value)
+      return false unless value.is_a?(String) && value.length.between?(1, MAX_SUBSCRIPTION_LENGTH)
+
+      value.split('.', -1).all? { |segment| segment == '*' || segment.match?(SUBSCRIPTION_SEGMENT) }
+    end
+
     # Check if this endpoint is subscribed to a specific event.
     #
     # Events whose payload carries a live credential (a password reset token)
@@ -93,16 +114,9 @@ module Spree
     # @return [Boolean]
     def subscribed_to?(event_name)
       return subscriptions.to_a.include?(event_name) if Spree::Events.catalog.credential?(event_name)
-      return true if subscriptions.blank? || subscriptions.include?('*')
-
-      subscriptions.any? do |subscription|
-        if subscription.include?('*')
-          pattern = Regexp.escape(subscription).gsub('\*', '.*')
-          event_name.match?(Regexp.new("^#{pattern}$"))
-        else
-          subscription == event_name
-        end
-      end
+      return true if subscriptions.blank?
+
+      subscriptions.any? { |subscription| Spree::Event.matches?(event_name, subscription) }
     end
 
     # The credential-carrying events this endpoint names.
@@ -191,6 +205,16 @@ module Spree
       self.secret_key ||= SecureRandom.hex(32)
     end
 
+    def subscriptions_must_be_event_patterns
+      entries = subscriptions.to_a
+      errors.add(:subscriptions, :too_many, count: MAX_SUBSCRIPTIONS) if entries.size > MAX_SUBSCRIPTIONS
+
+      rejected = entries.reject { |entry| self.class.event_pattern?(entry) }
+      return if rejected.empty?
+
+      errors.add(:subscriptions, :invalid_pattern, entries: rejected.first(5).map { |entry| entry.truncate(40) }.join(', '))
+    end
+
     def clear_disabled_state_when_reactivated
       return unless will_save_change_to_active? && active
 
@@ -203,12 +227,22 @@ module Spree
 
       uri = URI.parse(url)
       blacklist = SsrfFilter::IPV4_BLACKLIST + SsrfFilter::IPV6_BLACKLIST
-      addresses = Resolv.getaddresses(uri.host)
+      addresses = host_addresses(uri.host)
       if addresses.any? { |addr| blacklist.any? { |range| range.include?(IPAddr.new(addr)) } }
         errors.add(:url, :internal_address_not_allowed)
       end
     rescue URI::InvalidURIError, Resolv::ResolvError, IPAddr::InvalidAddressError, ArgumentError
       # URI format validation handles invalid URLs; DNS failures are not SSRF
     end
+
+    # A literal address first — including the forms a resolver answers
+    # nothing for, such as a bracketed IPv6 address, `127.1`, or a decimal or
+    # hex IPv4 — then DNS for a hostname.
+    def host_addresses(host)
+      literal = host.to_s.delete_prefix('[').delete_suffix(']')
+      Socket.getaddrinfo(literal, nil, nil, Socket::SOCK_STREAM, nil, Socket::AI_NUMERICHOST).map { |entry| entry[3] }.uniq
+    rescue SocketError
+      Resolv.getaddresses(host)
+    end
   end
 end

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

@@ -31,6 +31,9 @@ module Spree
         items = items.reject(&:manual_price?)
         return success([]) if items.empty?
 
+        # One read of every line's prices rather than one per variant.
+        ActiveRecord::Associations::Preloader.new(records: items.filter_map(&:variant).uniq, associations: :prices).call
+
         resolutions = items.filter_map do |line_item|
           price = resolve_price(line_item, cart)
           next if price.blank?

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

@@ -270,8 +270,10 @@ module Spree
       # describe what they held before the split, and the new one holds nothing
       # at all.
       def restate_freight_summaries(*fulfillments)
+        selected_rates = Spree::DeliveryRate.where(fulfillment_id: fulfillments.map(&:id), selected: true).order(:cost).to_a
+
         fulfillments.each do |fulfillment|
-          rate = fulfillment.reload.selected_delivery_rate
+          rate = selected_rates.find { |selected_rate| selected_rate.fulfillment_id == fulfillment.id }
           next if rate.nil?
 
           metadata = rate.metadata

data/app/services/spree/catalogs/set_product_terms.rb

@@ -50,7 +50,8 @@ module Spree
       def apply(catalog, product, values)
         minimum = normalize(values[:minimum_order_quantity])
         multiple = normalize(values[:order_multiple])
-        variant_ids = product.variants.ids
+        variants = product.variants.to_a
+        variant_ids = variants.map(&:id)
 
         # Both blank is a deletion: the product falls back to the catalog's
         # own default, which is what an empty pair means on the row.
@@ -59,8 +60,12 @@ module Spree
           return nil
         end
 
-        variant_ids.each do |variant_id|
-          rule = catalog.quantity_rules.find_or_initialize_by(variant_id: variant_id)
+        existing_rules = catalog.quantity_rules.where(variant_id: variant_ids).index_by(&:variant_id)
+
+        variants.each do |variant|
+          rule = existing_rules[variant.id] || catalog.quantity_rules.build
+          # The loaded variant, so the store check reads its product in memory.
+          rule.variant = variant
           rule.assign_attributes(minimum_order_quantity: minimum, order_multiple: multiple)
           return rule unless rule.save
         end

data/app/services/spree/collections/add_products.rb

@@ -22,7 +22,7 @@ module Spree
       def group_class = Spree::Collection
 
       def refresh_group_counters(collection_ids)
-        collection_ids.each { |id| Spree::Collection.reset_counters(id, :product_collections) }
+        Spree::Collection.reset_counters_in_bulk(collection_ids, :product_collections)
       end
     end
   end

data/app/services/spree/collections/regenerate_products.rb

@@ -44,9 +44,7 @@ module Spree
 
         # counter caches — bulk insert/delete bypass the ProductCollection counter_cache callbacks
         Spree::Collection.reset_counters(collection.id, :product_collections)
-        all_product_ids = (previous_products_ids + product_ids_to_insert).uniq
-        existing_product_ids = Spree::Product.where(id: all_product_ids).pluck(:id)
-        existing_product_ids.each { |id| Spree::Product.reset_counters(id, :product_collections) }
+        Spree::Product.reset_counters_in_bulk(previous_products_ids + product_ids_to_insert, :product_collections)
 
         success(collection)
       end

data/app/services/spree/collections/remove_products.rb

@@ -22,7 +22,7 @@ module Spree
       def group_class = Spree::Collection
 
       def refresh_group_counters(collection_ids)
-        collection_ids.each { |id| Spree::Collection.reset_counters(id, :product_collections) }
+        Spree::Collection.reset_counters_in_bulk(collection_ids, :product_collections)
       end
     end
   end

data/app/services/spree/newsletter/subscribe.rb

@@ -54,8 +54,16 @@ module Spree
         @existed_subscription ||= Spree::NewsletterSubscriber.verified.find_by(email: email, store: current_store)
       end
 
+      # The account the subscription belongs to: the signed-in customer only
+      # when the address is theirs. Linking it to whoever is signed in would
+      # hand them another person's subscription — and with it the right to
+      # cancel it.
       def known_user
-        @known_user ||= current_user || Spree.customer_class.find_by(email: email)
+        @known_user ||= if current_user&.email.to_s.casecmp?(email.to_s)
+                          current_user
+                        else
+                          Spree.customer_class.find_by(email: email)
+                        end
       end
     end
   end

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

@@ -82,14 +82,16 @@ module Spree
         )
         captured = payment.completed?
 
+        allocated_order_ids = Spree::PaymentSplit.where(payment_id: payment.id, order_id: orders.map(&:id)).pluck(:order_id).to_set
+
         orders.each_with_index do |order, index|
-          split = Spree::PaymentSplit.find_or_initialize_by(payment_id: payment.id, order_id: order.id)
-          next if split.persisted?
+          next if allocated_order_ids.include?(order.id)
 
           share = Spree::Money::Rounding.from_minor_units(shares[index], currency)
-          # So re-summing its payment total on save reuses this instance rather
-          # than loading a second copy of the row per share.
-          split.order = order
+          # The payment and order are handed over rather than looked up, so
+          # validating and re-summing each share reuses these instances
+          # instead of loading a copy per share.
+          split = Spree::PaymentSplit.new(payment: payment, order: order)
           split.currency = payment.currency
           split.authorized_amount = share
           split.captured_amount = captured ? share : 0

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

@@ -14,6 +14,7 @@ module Spree
 
         items_param = @params.delete(:items)
         address_params = extract_address_params
+        scope_store_references
 
         # requires_new: the rescue below sits outside the block, so joining a
         # caller's open transaction (the API's order lock) would let it commit
@@ -63,6 +64,24 @@ module Spree
         end.compact_blank
       end
 
+      # Named by id in the payload and read through the order's own store, as
+      # Orders::Create does: the model only checks that the record exists, so
+      # another store's market, channel or warehouse would otherwise be
+      # accepted.
+      STORE_REFERENCES = {
+        market_id: :markets,
+        channel_id: :channels,
+        preferred_stock_location_id: :stock_locations
+      }.freeze
+
+      def scope_store_references
+        STORE_REFERENCES.each do |key, association|
+          next if @params[key].blank?
+
+          @params[key] = @order.store.public_send(association).find_by_param!(@params[key]).id
+        end
+      end
+
       def assign_addresses(address_params)
         address_params.each do |association, attributes|
           @order.public_send(:"#{association}_attributes=", attributes)

data/app/services/spree/product_memberships.rb

@@ -7,9 +7,15 @@ module Spree
     private
 
     def add_memberships(groups, products)
-      rows = groups.pluck(:id).flat_map do |group_id|
-        position = membership_class.where(group_key => group_id).count
-        products.pluck(:id).map do |product_id|
+      group_ids = groups.pluck(:id)
+      product_ids = products.pluck(:id)
+      # Every group's current size in one grouped count, rather than a probe
+      # per group for the position to append at.
+      sizes = membership_class.where(group_key => group_ids).group(group_key).count
+
+      rows = group_ids.flat_map do |group_id|
+        position = sizes.fetch(group_id, 0)
+        product_ids.map do |product_id|
           {
             group_key => group_id, product_id: product_id, position: (position += 1),
             created_at: Time.current, updated_at: Time.current
@@ -18,7 +24,7 @@ module Spree
       end
       membership_class.insert_all(rows)
 
-      refresh_after_membership_change(groups.pluck(:id), products)
+      refresh_after_membership_change(group_ids, products)
     end
 
     # Removes the products, then re-packs the remaining positions from 1.
@@ -28,8 +34,12 @@ module Spree
       ApplicationRecord.transaction do
         membership_class.where(group_key => group_ids, product_id: products.pluck(:id)).delete_all
 
+        # What survived the delete, for every group in one read.
+        remaining = membership_class.where(group_key => group_ids).order(:position).pluck(group_key, :product_id).
+                    group_by(&:first).transform_values { |pairs| pairs.map(&:last) }
+
         rows = group_ids.flat_map do |group_id|
-          membership_class.where(group_key => group_id).order(:position).pluck(:product_id).map.with_index(1) do |product_id, position|
+          remaining.fetch(group_id, []).map.with_index(1) do |product_id, position|
             {
               group_key => group_id, product_id: product_id, position: position,
               created_at: Time.current, updated_at: Time.current
@@ -46,7 +56,7 @@ module Spree
     # search index are refreshed here.
     def refresh_after_membership_change(group_ids, products)
       product_ids = products.pluck(:id)
-      product_ids.each { |id| Spree::Product.reset_counters(id, membership_class.model_name.element.pluralize.to_sym) }
+      Spree::Product.reset_counters_in_bulk(product_ids, membership_class.model_name.element.pluralize.to_sym)
       refresh_group_counters(group_ids)
 
       Spree::Product.where(id: product_ids).touch_all

data/app/services/spree/products/duplicator.rb

@@ -42,7 +42,7 @@ module Spree
 
       def duplicate_variant(variant, include_images)
         new_variant = variant.dup
-        new_variant.sku = sku_generator(new_variant.sku)
+        new_variant.sku = sku_generator(variant)
         new_variant.deleted_at = nil
         new_variant.option_values = variant.option_values.map { |option_value| option_value }
         new_variant.prices = duplicate_prices(variant.prices)
@@ -82,10 +82,18 @@ module Spree
         new_image
       end
 
-      def sku_generator(sku)
-        return '' if sku.blank?
+      def sku_generator(variant)
+        return '' if variant.sku.blank?
 
-        "COPY OF #{Variant.unscoped.where('sku like ?', "%#{sku}").order(:created_at).last.sku}"
+        store_product_ids = Product.with_deleted.where(store_id: variant.store_id).select(:id)
+        # Matched the way the SKU uniqueness check compares, without regard
+        # to case, and within the same seller scope it reads, so the name taken
+        # from the latest match is one this seller may use.
+        sku_pattern = Variant.arel_table[:sku].matches("%#{Variant.sanitize_sql_like(variant.sku)}", '\\', false)
+        latest_match = Variant.with_deleted.for_seller(variant.resolved_seller_id).
+                       where(product_id: store_product_ids).where(sku_pattern).order(:created_at, :id).last
+
+        "COPY OF #{(latest_match || variant).sku}"
       end
 
       def duplicate_error_message(new_product)

data/app/services/spree/search_provider/custom_field_schema.rb

@@ -15,13 +15,16 @@ module Spree
       ORDERED_FILTER_PREDICATES = (TEXT_FILTER_PREDICATES | NUMBER_FILTER_PREDICATES).
                                   sort_by { |predicate| -predicate.length }.freeze
 
-      attr_reader :store
+      attr_reader :store, :audience
 
       # @param store [Spree::Store] the store whose custom-field schema this
       #   describes — definitions are store-owned, so two stores have their own
       #   filter vocabularies.
-      def initialize(store)
+      # @param audience [Symbol, nil] who filters: `:store` (shoppers) sees only
+      #   storefront-visible definitions; `nil` is the back office
+      def initialize(store, audience: nil)
         @store = store
+        @audience = audience
       end
 
       # @return [Hash{String => Spree::CustomFieldDefinition}]
@@ -134,8 +137,13 @@ module Spree
 
       private
 
+      # A definition hidden from the storefront stays out of its filter and
+      # sort vocabulary too: the serializer withholds the value, and a sort or
+      # a range filter on it would hand that value back one comparison at a
+      # time.
       def product_definitions
         scope = store.custom_field_definitions.for_resource_type('Spree::Product')
+        scope = scope.storefront_visible if audience == :store
         scope.where(searchable: true).or(scope.where(sortable: true))
       end
 

data/app/services/spree/stock_levels/correct.rb

@@ -32,6 +32,11 @@ module Spree
         return failure(stock_level, I18n.t('spree.stock_level.errors.count_on_hand_not_an_integer')) if count_on_hand.present? && target.nil?
         return failure(stock_level, I18n.t('spree.stock_level.errors.adjustment_not_an_integer')) if adjustment.present? && delta.nil?
 
+        # Read before locking, which reloads the level and with it drops the
+        # variant and location a bulk caller loaded for every row at once.
+        stock_location = stock_level.stock_location
+        variant = stock_level.variant
+
         # Locked around the read: the delta is worked out from the count this
         # caller first saw, so two admins correcting the same level at once
         # would otherwise each measure against a shelf the other had already
@@ -42,12 +47,14 @@ module Spree
 
           # Through the location's own mover rather than building a movement
           # by hand: it types the row as an adjustment and records the reason,
-          # so a correction reads like every other change in the history.
-          stock_level.stock_location.adjust(stock_level.variant, move,
-                                            reason: Spree::StockMovement.adjustment_reason_text(reason))
+          # so a correction reads like every other change in the history. The
+          # movement writes through this locked instance, which leaves it
+          # current without another reload.
+          stock_location.adjust(variant, move, reason: Spree::StockMovement.adjustment_reason_text(reason),
+                                               stock_level: stock_level)
         end
 
-        success(stock_level.reload)
+        success(stock_level)
       end
 
       private

data/app/services/spree/stock_reservations/reserve.rb

@@ -69,7 +69,7 @@ module Spree
       private
 
       def build_targets(cart)
-        cart.line_items.includes(variant: { stock_levels: :stock_location }).filter_map do |line_item|
+        cart.line_items.includes(variant: [:product, { stock_levels: :stock_location }]).filter_map do |line_item|
           variant = line_item.variant
           next unless variant&.should_track_inventory?
 

data/app/services/spree/stores/provision_defaults.rb

@@ -31,13 +31,17 @@ module Spree
         @currency = resolve_currency(currency, country)
         @locale = resolve_locale(locale, country)
 
-        ApplicationRecord.transaction do
-          update_default_market
-          provision_stock_location
-          provision_delivery_zones
-          provision_package_type
-          provision_pickup
-          restate_seeded_calculators
+        # Defaults are bookkeeping, not merchant actions — webhooks and
+        # subscribers should not hear about each zone and method created here.
+        Spree::Events.disable do
+          ApplicationRecord.transaction do
+            update_default_market
+            provision_stock_location
+            provision_delivery_zones
+            provision_package_type
+            provision_pickup
+            restate_seeded_calculators
+          end
         end
 
         store.reload

data/app/services/spree/tags/bulk_add.rb

@@ -10,8 +10,15 @@ module Spree
       # @param context [String] default: 'tags'
       # @return [Spree::ServiceModule::Base::Result]
       def call(tag_names: [], records: [], context: 'tags')
-        tags = tag_names.map do |tag_name|
-          ActsAsTaggableOn::Tag.find_or_create_by(name: tag_name.strip)
+        names = tag_names.map(&:strip).reject(&:blank?).uniq
+        return if names.empty?
+
+        # One read for the names that already exist, then a create only for
+        # the ones that do not. `find_or_create_by` per name is a query per
+        # tag, which a bulk tagging pays on every name in the payload.
+        existing = ActsAsTaggableOn::Tag.where(name: names).index_by(&:name)
+        tags = names.map do |name|
+          existing[name] || ActsAsTaggableOn::Tag.create_or_find_by(name: name)
         end
 
         record_class = records.first.class
@@ -27,17 +34,20 @@ module Spree
 
       private
 
+      # Mirrors the gem's own tagging save, which stores the taggable's tenant
+      # (its `store_id` for store-owned records) as a string on each tagging.
       def taggings_attributes(tags, records, context:, record_class:)
-        records.pluck(:id).map do |record_id|
+        records.flat_map do |record|
           tags.map do |tag|
             {
-              taggable_id: record_id,
+              taggable_id: record.id,
               taggable_type: record_class.to_s,
               context: context,
-              tag_id: tag.id
+              tag_id: tag.id,
+              tenant: record.taggable_tenant&.to_s
             }
           end
-        end.flatten.compact
+        end
       end
     end
   end