spree_core 5.6.1 → 6.0.0.beta2

data/app/services/spree/fulfillments/stand_down_provider.rb

@@ -0,0 +1,47 @@
+module Spree
+  module Fulfillments
+    # The carrier half of cancelling a parcel: every active label is refunded
+    # and the provider is told to drop any non-label dispatch (a 3PL pick).
+    # Network I/O, so callers run it from an external step after their own
+    # transaction has committed — Spree::Fulfillments::Cancel directly,
+    # Spree::Orders::Cancel batched over every fulfillment on the order.
+    #
+    # Nothing here blocks the cancellation: the goods are not going out
+    # either way, and a refund the carrier refuses surfaces on the label.
+    class StandDownProvider
+      prepend Spree::ServiceModule::Base
+
+      # @param fulfillment [Spree::Fulfillment]
+      # @return [Spree::ServiceModule::Result]
+      def call(fulfillment:)
+        self.class.refund_labels(fulfillment)
+        fulfillment.provider.cancel_fulfillment(fulfillment)
+        success(fulfillment)
+      end
+
+      # Gives back the postage on anything that is no longer travelling.
+      # Owner-agnostic because a canceled return is the same problem as a
+      # canceled parcel: the label is live, the merchant has paid for it, and
+      # whoever holds it could still ship on it.
+      #
+      # @param owner [Spree::Fulfillment, Spree::Return]
+      def self.refund_labels(owner)
+        owner.shipping_labels.active.each do |shipping_label|
+          next unless shipping_label.refundable?
+
+          result = Spree.shipping_label_refund_workflow.call(shipping_label: shipping_label)
+          next if result.success?
+
+          # The goods are not moving either way, so a carrier that refuses the
+          # refund never blocks the cancellation — but the merchant is out of
+          # pocket, so it is reported rather than swallowed.
+          Rails.error.report(
+            Spree::Core::LabelRefundFailed.new(result.error.to_s),
+            context: { shipping_label_id: shipping_label.id, owner_type: owner.class.name, owner_id: owner.id },
+            source: 'spree.fulfillments.stand_down'
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/spree/imports/row_processors/customer.rb

@@ -16,7 +16,7 @@ module Spree
           email = attributes['email'].to_s.strip.downcase
           raise ArgumentError, 'Email is required' if email.blank?
 
-          Spree.user_class.find_or_initialize_by(email: email)
+          Spree.customer_class.find_or_initialize_by(email: email)
         end
 
         def assign_user_attributes(user)
@@ -34,25 +34,25 @@ module Spree
         end
 
         def assign_address(user)
-          # Save user first so the address can FK to it via user_id (has_many :addresses).
+          # Save user first so the address can point at it through the polymorphic owner.
           user.save! if user.new_record?
 
           address = user.bill_address || user.addresses.build
-          address.firstname = attributes['first_name'].presence || user.first_name
-          address.lastname = attributes['last_name'].presence || user.last_name
+          address.first_name = attributes['first_name'].presence || user.first_name
+          address.last_name = attributes['last_name'].presence || user.last_name
           address.company = attributes['company'].strip if attributes['company'].present?
           address.address1 = attributes['address1'].strip if attributes['address1'].present?
           address.address2 = attributes['address2'].strip if attributes['address2'].present?
           address.city = attributes['city'].strip if attributes['city'].present?
-          address.zipcode = attributes['zip'].strip if attributes['zip'].present?
+          address.postal_code = attributes['zip'].strip if attributes['zip'].present?
           address.phone = attributes['phone'].presence || user.phone
 
           if attributes['country_code'].present?
-            address.country = Spree::Country.find_by(iso: attributes['country_code'].strip.upcase)
+            address.country_code = attributes['country_code'].strip
           end
 
-          if attributes['province_code'].present? && address.country
-            address.state = address.country.states.find_by(abbr: attributes['province_code'].strip)
+          if attributes['province_code'].present? && address.country_code.present?
+            address.state_code = attributes['province_code'].strip
           end
 
           address.save!

data/app/services/spree/imports/row_processors/price_list_price.rb

@@ -0,0 +1,164 @@
+module Spree
+  module Imports
+    module RowProcessors
+      # Writes one rung of one variant's ladder on the import's price list.
+      #
+      # The write goes through Spree::Prices::BulkUpsert, the same path the
+      # bulk price editor uses, so a blank price means "remove this rung" in
+      # the file exactly as it does in the editor, and the break cap is judged
+      # by the same code. What the service does not check — the sign of an
+      # amount, a currency the store does not trade in — is refused here
+      # first, since the service trusts its callers.
+      class PriceListPrice < Base
+        def initialize(row, **)
+          super
+          @store = import.store
+        end
+
+        attr_reader :store
+
+        # @return [Spree::Variant] the variant whose ladder the row changed —
+        #   whether it wrote a rung or removed one, so the group job publishes
+        #   the product's update either way
+        def process!
+          price_list = cached_lookup(:price_list_import_list) { import.price_list }
+          raise ArgumentError, Spree.t(:price_list_import_no_price_list) if price_list.nil?
+
+          variant = find_variant
+          currency = currency_for(attributes['currency'])
+          quantity = attributes['min_quantity'].to_s.strip.presence
+          row = {
+            variant_id: variant.id,
+            currency: currency,
+            price_list_id: price_list.id,
+            min_quantity: quantity,
+            amount: amount_for(attributes['price'], 'price')
+          }
+          # The service writes both amounts on every upsert, so a file without
+          # the column would blank every compare-at price it touched; a rung
+          # keeps its own until a mapped column says otherwise.
+          row[:compare_at_amount] = if mapped?('compare_at_price')
+                                      amount_for(attributes['compare_at_price'], 'compare_at_price')
+                                    else
+                                      stored_compare_at(price_list, variant, currency, (quantity || 1).to_i)
+                                    end
+
+          result = Spree::Prices::BulkUpsert.call(rows: [row])
+          raise ArgumentError, failure_message(result) unless result.success?
+
+          # After the write, and only for a row that priced something: a
+          # refused row must not put its product on the list, and neither
+          # must a blank one, whose whole job is to take a rung away.
+          ensure_membership(price_list, variant) if row[:amount].present?
+          remember_compare_at(variant, currency, (quantity || 1).to_i, row)
+          variant
+        end
+
+        private
+
+        # The store's own variants only, and exactly one of them: a SKU is
+        # unique per seller, not per store, so two sellers' listings can share
+        # one and the row cannot say which it meant. Cached per SKU, since a
+        # group is one SKU's rows and every rung would otherwise repeat the join.
+        def find_variant
+          sku = attributes['sku'].to_s.strip
+          raise ArgumentError, Spree.t(:price_list_import_sku_required) if sku.blank?
+
+          variants = cached_lookup(:price_list_import_variant, sku.downcase) do
+            # Case-insensitive, as the product import matches SKUs and as the
+            # uniqueness validation compares them.
+            store.variants.where(Spree::Variant.arel_table[:sku].lower.eq(sku.downcase)).limit(2).to_a
+          end
+          raise ArgumentError, Spree.t(:price_list_import_unknown_sku, sku: sku) if variants.empty?
+          raise ArgumentError, Spree.t(:price_list_import_ambiguous_sku, sku: sku) if variants.many?
+
+          variants.first
+        end
+
+        # Blank means the store's default currency; anything else has to be
+        # one the store trades in, or the row would price the variant in a
+        # currency no shopper can be shown.
+        def currency_for(value)
+          currency = value.to_s.strip.upcase.presence || store.default_currency
+          return currency if supported_currencies.include?(currency)
+
+          raise ArgumentError, Spree.t(:price_list_import_unsupported_currency, currency: currency)
+        end
+
+        def supported_currencies
+          cached_lookup(:price_list_import_currencies) { store.supported_currencies_list.map(&:iso_code) }
+        end
+
+        # Digits with an optional dot — the shape the export writes and the one
+        # figure that reads the same under every locale. A blank stays blank
+        # (the service reads it as "remove"). Not the locale-aware parser: it
+        # answers 0 for text it cannot read, and under a comma-decimal locale
+        # it would read "16.50" as 1650.
+        AMOUNT_FORMAT = /\A\d+(\.\d+)?\z/
+
+        def amount_for(value, column)
+          text = value.to_s.strip
+          return nil if text.blank?
+          raise ArgumentError, Spree.t(:price_list_import_invalid_amount, column: column, value: text) unless text.match?(AMOUNT_FORMAT)
+
+          BigDecimal(text)
+        end
+
+        # A product added through the dashboard gets a placeholder row per
+        # store currency, which is what puts it in every currency's grid. A
+        # variant the file prices gets the same, once per product per job, so
+        # an imported product is on the list the way an added one is rather
+        # than only in the currencies the file mentioned.
+        def ensure_membership(price_list, variant)
+          cached_lookup(:price_list_import_membership, variant.product_id) do
+            price_list.add_products([variant.product_id])
+            true
+          end
+        end
+
+        def mapped?(field)
+          cached_lookup(:price_list_import_mapped_fields) { import.mappings.mapped.pluck(:schema_field) }.include?(field)
+        end
+
+        # The compare-at a rung holds now, read once per variant for the whole
+        # group and kept true by `remember_compare_at` as the group's rows
+        # write and remove rungs.
+        def stored_compare_at(price_list, variant, currency, quantity)
+          compare_at_rungs(price_list, variant)[[currency, quantity]]
+        end
+
+        def compare_at_rungs(price_list, variant)
+          cached_lookup(:price_list_import_compare_at, variant.id) do
+            price_list.prices.where(variant_id: variant.id)
+                      .pluck(:currency, :min_quantity, :compare_at_amount)
+                      .to_h { |rung_currency, rung_quantity, compare_at| [[rung_currency, rung_quantity], compare_at] }
+          end
+        end
+
+        def remember_compare_at(variant, currency, quantity, row)
+          rungs = import.row_lookup_cache[[:price_list_import_compare_at, variant.id]]
+          return if rungs.nil?
+
+          if row[:amount].nil?
+            rungs.delete([currency, quantity])
+          else
+            rungs[[currency, quantity]] = row[:compare_at_amount]
+          end
+        end
+
+        def failure_message(result)
+          value = result.error&.value
+          value = {} unless value.is_a?(Hash)
+
+          if value[:over_cap].present?
+            Spree.t(:price_list_import_too_many_breaks, count: Spree::Price::MAXIMUM_BREAKS_PER_VARIANT)
+          elsif value[:invalid_quantities].present?
+            Spree.t(:price_list_import_invalid_quantity, value: attributes['min_quantity'])
+          else
+            result.error.to_s.presence || Spree.t(:price_list_import_failed)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/spree/imports/row_processors/product_variant.rb

@@ -7,20 +7,19 @@ module Spree
         def initialize(row, **)
           super
           @store = row.store
+          @seller = import.seller
           @product = ensure_product_exists
         end
 
-        attr_reader :product, :store
+        attr_reader :product, :store, :seller
 
         def process!
-          variant_scope = options.empty? ? product.variants_including_master : product.variants
-
           variant = if attributes['sku'].present?
-                      variant_scope.where(
+                      product.variants.where(
                         Spree::Variant.arel_table[:sku].lower.eq(attributes['sku'].strip.downcase)
                       ).first || product.variants.new
                     elsif options.empty?
-                      product.master
+                      product.default_variant
                     else
                       product.variants.new
                     end
@@ -28,12 +27,25 @@ module Spree
           variant.sku = attributes['sku'] if attributes['sku'].present?
           variant.cost_price = attributes['cost_price'] if attributes['cost_price'].present?
           variant.weight = attributes['weight'] if attributes['weight'].present?
+          variant.weight_unit = attributes['weight_unit'] if attributes['weight_unit'].present?
           variant.height = attributes['height'] if attributes['height'].present?
           variant.width = attributes['width'] if attributes['width'].present?
           variant.depth = attributes['depth'] if attributes['depth'].present?
+          variant.dimensions_unit = attributes['dimensions_unit'] if attributes['dimensions_unit'].present?
           variant.track_inventory = attributes['track_inventory'] if attributes['track_inventory'].present?
+          variant.hs_code = attributes['hs_code'] if attributes['hs_code'].present?
+          variant.country_of_origin = attributes['country_of_origin'] if attributes['country_of_origin'].present?
+          variant.customs_description = attributes['customs_description'] if attributes['customs_description'].present?
+          variant.units_per_carton = attributes['units_per_carton'] if attributes['units_per_carton'].present?
+          variant.carton_weight = attributes['carton_weight'] if attributes['carton_weight'].present?
+          variant.cartons_per_pallet = attributes['cartons_per_pallet'] if attributes['cartons_per_pallet'].present?
           variant.option_value_variants = prepare_option_value_variants if options.any?
 
+          if attributes['carton'].present?
+            carton = prepare_carton
+            variant.carton_package_type = carton if carton.present?
+          end
+
           if attributes['tax_category'].present?
             tax_category = prepare_tax_category
             variant.tax_category = tax_category if tax_category.present?
@@ -47,19 +59,41 @@ module Spree
           end
 
           if attributes['inventory_count'].present?
-            variant.set_stock(attributes['inventory_count'].to_i, attributes['inventory_backorderable']&.to_b)
+            variant.set_stock(
+              attributes['inventory_count'].to_i,
+              attributes['inventory_backorderable']&.to_b,
+              import_stock_location
+            )
           end
 
           handle_images(variant)
 
-          variant
+          remove_placeholder_default_variant if options.any?
+
+          # A row that resolves to a real option variant owns that Variant; a
+          # product/header row resolves to the option-less default (a placeholder
+          # that may later be removed), so it owns the Product instead — keeping the
+          # import row linked to a record that always survives.
+          variant.option_values.any? ? variant : product
         end
 
         private
 
+        # A product-header (options-empty) row creates an option-less default
+        # variant to hold product-level attributes. Once an option-bearing
+        # variant exists, that placeholder is a leftover — remove it and
+        # re-point the default so the product has exactly its option variants.
+        def remove_placeholder_default_variant
+          placeholders = product.variants.where.missing(:option_value_variants)
+          return if placeholders.empty?
+
+          placeholders.destroy_all
+          product.update_column(:default_variant_id, product.variants.reload.first&.id)
+        end
+
         def ensure_product_exists
           if options.empty?
-            # For master variants, create or update the product
+            # For product/header rows (no options), create or update the product
             product = Spree::Product.new
             if attributes['slug'].present?
               existing_product = product_scope.find_by(slug: attributes['slug'].strip.downcase)
@@ -69,18 +103,18 @@ module Spree
             # Store is touched when the import completes
             Spree::Store.no_touching do
               product = assign_attributes_to_product(product)
-              product.save!
+              save_through_workflow!(product)
             end
 
             handle_tags(product) if attributes['tags'].present?
             if has_product_attributes?
-              handle_metafields(product)
+              handle_custom_fields(product)
               handle_categories(product)
             end
 
             product
           else
-            # For non-master variants, only look up the product
+            # For variant rows (with options), only look up the product
             if attributes['slug'].present?
               product_scope.find_by!(slug: attributes['slug'].strip.downcase)
             else
@@ -89,16 +123,57 @@ module Spree
           end
         end
 
+        # Which products this import may resolve an existing row onto.
+        #
+        # A seller's import reaches only that seller's own products. The
+        # ability cannot answer this: it grants capability, never tenancy —
+        # a seller holding `write_products` gets `can :manage, Spree::Product`,
+        # the whole class (see Spree::Ability). On the API that is safe because
+        # the controller scope-fetches through `current_seller`; a background
+        # row processor has no controller, so the narrowing has to happen here
+        # or a CSV naming another seller's slug would edit their product.
         def product_scope
-          Spree::Product.accessible_by(import.current_ability, :manage)
+          scope = Spree::Product.accessible_by(import.current_ability, :manage)
+          seller.present? ? scope.where(seller_id: seller.id) : scope
+        end
+
+        # Imported rows pass the same :validate hook dashboard edits do — one
+        # gate, so a store's product rules can't be sidestepped by uploading
+        # a CSV. Attributes are already assigned, so the workflow gets the
+        # dirty record and nothing more.
+        def save_through_workflow!(product)
+          result =
+            if product.new_record?
+              Spree.product_create_workflow.call(store: product.store, record: product)
+            else
+              Spree.product_update_workflow.call(product: product)
+            end
+
+          if result.failure?
+            # A hook rejection carries its own errors, not the product's, so
+            # copy them across — otherwise the failed row records an empty
+            # validation_errors and the merchant sees no reason.
+            rejection = result.error&.value
+            if rejection.is_a?(ActiveModel::Errors) && product.errors.empty?
+              rejection.each { |error| product.errors.add(error.attribute, error.message) }
+            end
+
+            raise ActiveRecord::RecordInvalid, product
+          end
+
+          product
         end
 
         def assign_attributes_to_product(product)
-          # setting SKU for master variant so it will be picked up in process! and won't try to create a non-master variant
+          # set the SKU on a product/header row so process! updates the default variant instead of creating a new one
           if product.new_record?
             product.slug = attributes['slug']
             product.sku = attributes['sku'] if attributes['sku'].present? && options.empty?
             product.store = store
+            # A seller's import creates the seller's products. Without this the
+            # rows would land unowned — belonging to the store, invisible in the
+            # seller's own panel and unattributable at commission time.
+            product.seller = seller if seller.present?
             # Publish to the store's default channel so imported products surface
             # in the storefront.
             product.channels << store.default_channel if store.default_channel && product.channels.empty?
@@ -109,22 +184,53 @@ module Spree
           product.meta_title = attributes['meta_title'] if attributes['meta_title'].present?
           product.meta_description = attributes['meta_description'] if attributes['meta_description'].present?
           product.meta_keywords = attributes['meta_keywords'] if attributes['meta_keywords'].present?
-          product.status = to_spree_status(attributes['status']) if attributes['status'].present?
+          # A seller never reaches `active` by their own hand, so the CSV's
+          # status column is ignored on a seller's import — otherwise
+          # `status,active` would publish to the marketplace catalog with
+          # nobody having looked at it, which is the hole the JSON endpoint
+          # already closed (docs/plans/6.0-seller-product-submission.md).
+          # Imported products land as `draft`; the seller submits each for
+          # review afterwards.
+          if attributes['status'].present? && seller.blank?
+            product.status = to_spree_status(attributes['status'])
+          end
 
           if options.empty?
-            if attributes['shipping_category'].present?
-              shipping_category = prepare_shipping_category
-              product.shipping_category = shipping_category if shipping_category.present?
+            if attributes['product_type'].present?
+              product_type = prepare_product_type
+              product.product_type = product_type if product_type.present?
             end
           end
 
           product
         end
 
-        def prepare_shipping_category
-          shipping_category_name = attributes['shipping_category'].strip
-          cached_lookup(:shipping_category, shipping_category_name) do
-            Spree::ShippingCategory.find_by(name: shipping_category_name)
+        def prepare_product_type
+          product_type_name = attributes['product_type'].strip
+          cached_lookup(:product_type, product_type_name) do
+            existing = Spree::ProductType.where(store_id: store.id).find_by(name: product_type_name)
+            # A seller fills in a type's fields; they do not define types
+            # (`product_types` is read-only for the seller audience). An
+            # unknown name is ignored rather than created, so a CSV cannot
+            # extend the marketplace's own vocabulary.
+            next existing if seller.present?
+
+            existing || Spree::ProductType.create!(name: product_type_name, store_id: store.id)
+          end
+        end
+
+        # Named rather than referenced by id, like the tax category beside it —
+        # a merchant's spreadsheet says "Large carton", not a prefixed id.
+        def prepare_carton
+          carton_name = attributes['carton'].strip
+          cached_lookup(:carton_package_type, carton_name) do
+            # A seller's import reaches their own cartons and the
+            # marketplace's, ordered so their own row wins when both owners
+            # named a carton the same way — a seller's spreadsheet means their
+            # own measurements. An operator's import sees the marketplace's.
+            store.package_types.cartons.available_to_seller(seller).
+              order(Arel.sql('CASE WHEN seller_id IS NULL THEN 1 ELSE 0 END')).
+              find_by(name: carton_name)
           end
         end
 
@@ -135,6 +241,25 @@ module Spree
           end
         end
 
+        # Where an imported row's stock lands.
+        #
+        # Nil for an operator's import, which leaves `set_stock` to pick the
+        # store's default. A seller's stock belongs in their own warehouse:
+        # `Variant#default_stock_location` answers the *store's*, so without
+        # this a seller's `inventory_count` would deposit their goods in the
+        # marketplace's location — the same mistake the seller products
+        # endpoint narrows `stock_levels` to prevent.
+        #
+        # A seller with no location of their own falls back to the store's
+        # rather than dropping the count on the floor.
+        def import_stock_location
+          return nil if seller.blank?
+
+          cached_lookup(:seller_stock_location, seller.id) do
+            seller.stock_locations.active.order_default.first
+          end
+        end
+
         def prepare_option_value_variants
           return [] if options.empty?
 
@@ -174,26 +299,26 @@ module Spree
         # Recover the losing worker by re-fetching the peer's row whether the conflict
         # surfaces via the DB unique index (RecordNotUnique) or the AR uniqueness
         # validator (RecordInvalid with a :taken error on the relevant attribute).
-        def find_or_create_option_type!(presentation)
-          cached_lookup(:option_type, presentation) do
+        def find_or_create_option_type!(label)
+          cached_lookup(:option_type, label) do
             begin
-              Spree::OptionType.search_by_name(presentation).first || Spree::OptionType.create!(presentation: presentation)
+              Spree::OptionType.search_by_name(label).first || Spree::OptionType.create!(label: label)
             rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
               raise unless uniqueness_conflict?(e, :name)
 
-              Spree::OptionType.search_by_name(presentation).first!
+              Spree::OptionType.search_by_name(label).first!
             end
           end
         end
 
-        def find_or_create_option_value!(option_type, presentation)
-          cached_lookup(:option_value, option_type.id, presentation) do
+        def find_or_create_option_value!(option_type, label)
+          cached_lookup(:option_value, option_type.id, label) do
             begin
-              option_type.option_values.search_by_name(presentation).first || option_type.option_values.create!(presentation: presentation)
+              option_type.option_values.search_by_name(label).first || option_type.option_values.create!(label: label)
             rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
               raise unless uniqueness_conflict?(e, :name)
 
-              option_type.option_values.search_by_name(presentation).first!
+              option_type.option_values.search_by_name(label).first!
             end
           end
         end
@@ -226,9 +351,10 @@ module Spree
           return if image_urls.empty?
 
           # Always attach to the product so blobs aren't duplicated across
-          # variants. For non-master rows, pass the variant id so the job links
-          # the resulting product-level asset to that variant via VariantMedia.
-          link_variant_id = variant.is_master? ? nil : variant.id
+          # variants. For option rows, pass the variant id so the job links the
+          # resulting product-level asset to that variant via VariantMedia; a
+          # simple product's default variant keeps images product-level.
+          link_variant_id = options.empty? ? nil : variant.id
 
           image_urls.each do |image_url|
             Spree::Images::SaveFromUrlJob.perform_later(
@@ -246,61 +372,71 @@ module Spree
           %w[name status description category1 category2 category3].any? { |key| attributes[key].present? }
         end
 
-        def handle_metafields(product)
-          return unless product.class.included_modules.include?(Spree::Metafields)
+        def handle_custom_fields(product)
+          return unless product.class.included_modules.include?(Spree::HasCustomFields)
 
-          metafield_attributes = attributes.select { |key, _value| key.to_s.start_with?('metafield.') }
-          return if metafield_attributes.empty?
+          custom_field_attributes = attributes.select { |key, _value| key.to_s.start_with?('custom_field.') }
+          return if custom_field_attributes.empty?
 
-          # Build nested attributes for metafields
+          # Build nested attributes for custom_fields
           nested_attrs = []
 
-          metafield_attributes.each do |attribute_key, value|
-            # Extract namespace.key from "metafield.namespace.key"
-            full_key = attribute_key.to_s.sub(/^metafield\./, '')
+          custom_field_attributes.each do |attribute_key, value|
+            # Extract namespace.key from "custom_field.namespace.key"
+            full_key = attribute_key.to_s.sub(/^custom_field\./, '')
             namespace, key = product.extract_namespace_and_key(full_key)
 
-            # Find or initialize metafield definition
-            metafield_definition = cached_lookup(:metafield_definition, namespace, key, product.class.name) do
-              Spree::MetafieldDefinition.find_by(
+            # Find or initialize custom_field definition
+            custom_field_definition = cached_lookup(:custom_field_definition, namespace, key, product.class.name) do
+              store.custom_field_definitions.find_by(
                 namespace: namespace,
                 key: key,
                 resource_type: product.class.name
               )
             end
 
-            next unless metafield_definition
+            next unless custom_field_definition
 
-            # Find existing metafield if product is persisted
-            existing_metafield = product.persisted? ? product.metafields.find_by(metafield_definition: metafield_definition) : nil
+            # Find existing custom_field if product is persisted
+            existing_custom_field = product.persisted? ? product.custom_fields.find_by(custom_field_definition: custom_field_definition) : nil
 
-            # Skip blank values for new metafields
-            next if value.blank? && existing_metafield.nil?
+            # Skip blank values for new custom_fields
+            next if value.blank? && existing_custom_field.nil?
 
-            # For existing metafields with blank values, we'll mark them for destruction
-            # For new metafields, we skip them (handled above)
-            # For existing or new metafields with values, we create/update them
-            metafield_attrs = {
-              metafield_definition_id: metafield_definition.id,
+            # For existing custom_fields with blank values, we'll mark them for destruction
+            # For new custom_fields, we skip them (handled above)
+            # For existing or new custom_fields with values, we create/update them
+            custom_field_attrs = {
+              custom_field_definition_id: custom_field_definition.id,
               value: value.to_s.strip,
-              type: metafield_definition.metafield_type
+              type: custom_field_definition.field_type_class_name
             }
 
-            metafield_attrs[:id] = existing_metafield.id if existing_metafield
+            custom_field_attrs[:id] = existing_custom_field.id if existing_custom_field
 
-            nested_attrs << metafield_attrs
+            nested_attrs << custom_field_attrs
           end
 
-          product.update(metafields_attributes: nested_attrs) unless nested_attrs.empty?
+          product.update!(custom_fields_attributes: nested_attrs) unless nested_attrs.empty?
         end
 
+        # Tags are tenanted to the store (`acts_as_taggable_tenant :store_id`),
+        # so a seller typing one adds a term to the marketplace's shared
+        # vocabulary rather than labelling their own product — which is why the
+        # seller products endpoint does not permit them either.
         def handle_tags(product)
+          return if seller.present?
           return Spree::Imports::AssignTagsJob.perform_now(product.id, attributes['tags']) if import.preferred_inline
 
           Spree::Imports::AssignTagsJob.perform_later(product.id, attributes['tags'])
         end
 
+        # How a product is filed is the marketplace's own merchandising, and
+        # this job *creates* the categories it cannot find. `categories` has no
+        # seller audience in the permission catalog at all.
         def handle_categories(product)
+          return if seller.present?
+
           names = prepare_taxon_pretty_names
           return Spree::Imports::CreateCategoriesJob.perform_now(product.id, store.id, names) if import.preferred_inline