spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/services/spree/emails/template.rb

@@ -0,0 +1,51 @@
+module Spree
+  module Emails
+    # One Liquid email template: a file on disk, with optional front matter
+    # holding its subject, or a store's saved version with the subject in its
+    # own field.
+    class Template
+      FRONT_MATTER = /\A---\s*\n(.*?)\n---\s*(?:\n|\z)/m
+
+      attr_reader :key, :path
+
+      # @param key [String] the template key, e.g. "spree/order_mailer/confirm_email"
+      # @param path [String, nil] the file on disk
+      # @param subject [String, nil] the subject, for a template not read from a file
+      # @param body [String, nil] the body, for a template not read from a file
+      def initialize(key:, path: nil, subject: nil, body: nil)
+        @key = key
+        @path = path
+        @subject = subject
+        @body = body
+      end
+
+      # @return [Boolean] whether this is a store's saved template or a draft, rather than a file
+      def stored?
+        path.nil?
+      end
+
+      # @return [String, nil] the subject line as Liquid
+      def subject
+        stored? ? @subject : front_matter['subject']
+      end
+
+      # @return [String] the template without its front matter
+      def body
+        stored? ? @body.to_s : source.sub(FRONT_MATTER, '')
+      end
+
+      private
+
+      def source
+        @source ||= File.read(path)
+      end
+
+      def front_matter
+        @front_matter ||= begin
+          match = source.match(FRONT_MATTER)
+          match ? YAML.safe_load(match[1]).to_h : {}
+        end
+      end
+    end
+  end
+end

data/app/services/spree/emails/template_data.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Emails
+    # Turns a record into the JSON an email template reads: the serializer's
+    # output, the same data a renderer outside Ruby would receive. Shared by
+    # mailers and by the sample data the template editor previews with.
+    # Download links and other bearer tokens stay out of it.
+    module TemplateData
+      # @param object [Object, nil] the record
+      # @param serializer [Class] an email serializer
+      # @param store [Spree::Store]
+      # @param currency [String, nil] defaults to the store's
+      # @param params [Hash] serializer params over the defaults
+      # @return [Hash, nil]
+      def self.call(object, serializer, store:, currency: nil, **params)
+        return if object.nil?
+
+        params = { store: store, currency: currency || store.default_currency, locale: I18n.locale.to_s,
+                   storefront_url: store.storefront_url.to_s.chomp('/'), hide_credentials: true }.merge(params)
+        JSON.parse(serializer.new(object, params: params).serialize)
+      end
+    end
+  end
+end

data/app/services/spree/emails/template_resolver.rb

@@ -0,0 +1,109 @@
+module Spree
+  module Emails
+    # Finds the Liquid template behind an email key.
+    #
+    # With a store, an editable template (see Spree.editable_email_templates)
+    # is looked up in the store first: its published version in the email's
+    # language, then its version for every language. Otherwise, and for every
+    # other template, the app's own file wins over the one a gem ships.
+    # `drafts` puts unsaved templates in front of everything, for previews and
+    # for checking a draft before it is published.
+    class TemplateResolver
+      KEY_FORMAT = %r{\A[a-z0-9_]+(?:/[a-z0-9_]+)*\z}
+
+      # @return [Spree::Store, nil] the store whose published templates apply
+      attr_reader :store
+
+      class InvalidKey < ArgumentError; end
+
+      # @param options [Hash] see {#initialize}
+      # @return [Spree::Emails::TemplateResolver] searching the directories Spree's mailers render from
+      def self.for_mailers(**options)
+        new(Spree::BaseMailer.view_paths.paths.map(&:path), **options)
+      end
+
+      # @param view_paths [Array<String, Pathname>] directories to search, highest precedence first
+      # @param store [Spree::Store, nil] the store whose published templates apply
+      # @param locale [String, Symbol, nil] the email's language
+      # @param drafts [Hash{String => Spree::Emails::Template}] unsaved templates by key
+      def initialize(view_paths, store: nil, locale: nil, drafts: {})
+        @view_paths = view_paths.map(&:to_s).uniq
+        @store = store
+        @locale = locale.to_s
+        @drafts = drafts
+        @stored = {}
+      end
+
+      # @param key [String] e.g. "spree/order_mailer/confirm_email"
+      # @return [Spree::Emails::Template, nil]
+      def find(key)
+        validate!(key)
+        @drafts[key] || stored(key) || find_file(key, '.liquid')
+      end
+
+      # The default: what answers for the key without the store's templates or drafts.
+      #
+      # @param key [String]
+      # @return [Spree::Emails::Template, nil]
+      def find_default(key)
+        validate!(key)
+        Spree.editable_email_templates[key]&.kind == :partial ? partial_file(key) : find_file(key, '.liquid')
+      end
+
+      # A hand-written plain-text part. A store's saved template has none, so
+      # its text is always generated from its HTML.
+      #
+      # @param key [String]
+      # @return [Spree::Emails::Template, nil]
+      def find_text(key)
+        validate!(key)
+        return if @drafts[key] || stored(key)
+
+        find_file(key, '.text.liquid')
+      end
+
+      # @param name [String] a partial name, e.g. "spree/shared/line_item"
+      # @return [Spree::Emails::Template, nil] the store's version, or "spree/shared/_line_item.liquid"
+      def find_partial(name)
+        validate!(name)
+        @drafts[name] || stored(name) || partial_file(name)
+      end
+
+      # @return [Boolean] whether a store's published template answered any lookup so far
+      def stored_templates_used?
+        @stored.values.any?
+      end
+
+      private
+
+      attr_reader :view_paths
+
+      def stored(key)
+        return unless @store && Spree.editable_email_templates.include?(key)
+        return @stored[key] if @stored.key?(key)
+
+        record = @store.email_templates.published.where(key: key, locale: [@locale, Spree::EmailTemplate::ANY_LOCALE]).
+                 min_by { |template| template.locale == Spree::EmailTemplate::ANY_LOCALE ? 1 : 0 }
+        @stored[key] = record && Template.new(key: key, subject: record.subject, body: record.body)
+      end
+
+      def partial_file(name)
+        *folders, file = name.split('/')
+        find_file([*folders, "_#{file}"].join('/'), '.liquid')
+      end
+
+      def find_file(key, extension)
+        view_paths.each do |view_path|
+          path = File.join(view_path, "#{key}#{extension}")
+          return Template.new(key: key, path: path) if File.file?(path)
+        end
+
+        nil
+      end
+
+      def validate!(key)
+        raise InvalidKey, "Invalid email template name: #{key.inspect}" unless key.to_s.match?(KEY_FORMAT)
+      end
+    end
+  end
+end

data/app/services/spree/emails/text_converter.rb

@@ -0,0 +1,72 @@
+module Spree
+  module Emails
+    # Turns a rendered email's HTML into its plain-text part, keeping each
+    # link as "label (url)". Generating the text rather than writing it by
+    # hand means it can never drift from the HTML.
+    class TextConverter
+      BLOCK_ELEMENTS = %w[p div h1 h2 h3 h4 h5 h6 table tr ul ol li section blockquote].freeze
+      SKIPPED_ELEMENTS = %w[head style script title img].freeze
+      HIDDEN_STYLE = /display\s*:\s*none/i
+
+      # @param html [String]
+      # @return [String]
+      def self.call(html)
+        new(html).call
+      end
+
+      def initialize(html)
+        @document = Nokogiri::HTML(html)
+      end
+
+      # @return [String]
+      def call
+        output = +''
+        walk(@document.at('body') || @document, output)
+
+        output.lines.map { |line| line.squeeze(' ').strip }.join("\n").gsub(/\n{3,}/, "\n\n").strip + "\n"
+      end
+
+      private
+
+      def walk(node, output)
+        node.children.each do |child|
+          if child.text?
+            output << child.text.gsub(/\s+/, ' ')
+          elsif child.element?
+            element(child, output)
+          end
+        end
+      end
+
+      def element(node, output)
+        name = node.name.downcase
+        return if SKIPPED_ELEMENTS.include?(name) || node['style'].to_s.match?(HIDDEN_STYLE)
+
+        case name
+        when 'br' then output << "\n"
+        when 'a' then link(node, output)
+        when 'td', 'th'
+          walk(node, output)
+          output << ' '
+        else
+          block = BLOCK_ELEMENTS.include?(name)
+          output << "\n" if block
+          walk(node, output)
+          output << "\n" if block
+        end
+      end
+
+      def link(node, output)
+        label = +''
+        walk(node, label)
+        label = label.squeeze(' ').strip
+        href = node['href'].to_s.strip.delete_prefix('mailto:')
+
+        # A link with no text is a linked image, which has nothing to say in text.
+        return if label.blank?
+
+        output << (href.blank? || href == label ? label : "#{label} (#{href})")
+      end
+    end
+  end
+end

data/app/services/spree/emails/translation_inliner.rb

@@ -0,0 +1,134 @@
+module Spree
+  module Emails
+    # Turns Spree's translation keys in a template into readable text in one
+    # language, for a merchant who starts editing it:
+    #
+    #   {{ 'order_mailer.confirm_email.dear_customer' | t: name: order.customer_name }}
+    #   # => Dear {{ order.customer_name }},
+    #
+    #   {% assign heading = 'order_mailer.confirm_email.order_summary' | t: number: order.number %}
+    #   # => {% capture heading %}Order {{ order.number }} Summary{% endcapture %}
+    #
+    # A use it cannot turn into text exactly (a plural form, a missing
+    # translation, a value it does not recognize) is left as it was, so the
+    # template still renders the same.
+    class TranslationInliner
+      # Tags are found with simple patterns and read with string handling, so
+      # matching stays linear on any input a merchant pastes in.
+      OUTPUT_TAG = /\{\{([^{}]*)\}\}/
+      ASSIGN_TAG = /\{%([^{}%]*)%\}/
+      TRANSLATED = /\A'([a-z0-9_.]+)'\s*\|\s*t\b/
+      ASSIGNED = /\Aassign\s+(\w+)\s*=\s*/
+      INTERPOLATION = /%\{(\w+)\}/
+
+      # @param source [String, nil] a template's subject or body
+      # @param locale [String, Symbol] the language to write the text in
+      # @param escape [Boolean] whether the text is HTML: false for a subject,
+      #   which renders unescaped as a mail header
+      # @return [String, nil]
+      def self.call(source, locale:, escape: true)
+        new(locale, escape).call(source)
+      end
+
+      def initialize(locale, escape = true)
+        @locale = locale
+        @escape = escape
+      end
+
+      def call(source)
+        return source if source.blank?
+
+        source.
+          gsub(ASSIGN_TAG) { |tag| inline_assign(markup(Regexp.last_match[1])) || tag }.
+          gsub(OUTPUT_TAG) { |tag| inline_output(markup(Regexp.last_match[1])) || tag }
+      end
+
+      private
+
+      # A tag's content without whitespace control dashes or padding.
+      def markup(content)
+        content.delete_prefix('-').delete_suffix('-').strip
+      end
+
+      # `'key' | t`, `'key' | t: name: value` and `'key' | t | filter`, split into
+      # the key, its arguments and the filters after it.
+      def translation_call(markup)
+        match = TRANSLATED.match(markup)
+        return unless match
+
+        rest = match.post_match.strip
+        if rest.start_with?(':')
+          arguments, filters = rest.delete_prefix(':').split('|', 2)
+          [match[1], arguments.strip, filters&.strip]
+        elsif rest.start_with?('|')
+          [match[1], nil, rest.delete_prefix('|').strip]
+        elsif rest.empty?
+          [match[1], nil, nil]
+        end
+      end
+
+      def inline_output(markup)
+        key, arguments, filters = translation_call(markup)
+        text = key && translation(key)
+        return unless text
+
+        if filters.present?
+          return if arguments.present? || text.include?("'")
+
+          "{{ '#{text}' | #{filters} }}"
+        else
+          interpolate(text, arguments) { |literal| literal_text(literal) }
+        end
+      end
+
+      def inline_assign(markup)
+        assigned = ASSIGNED.match(markup)
+        return unless assigned
+
+        variable = assigned[1]
+        key, arguments, filters = translation_call(assigned.post_match)
+        text = key && filters.nil? && translation(key)
+        return unless text
+
+        if arguments.blank? && text.exclude?("'") && text !~ INTERPOLATION
+          "{% assign #{variable} = '#{text}' %}"
+        else
+          body = interpolate(text, arguments) { |literal| literal_text(literal) }
+          body && "{% capture #{variable} %}#{body}{% endcapture %}"
+        end
+      end
+
+      # Literal text is escaped by the caller's block; each `%{name}` becomes
+      # the Liquid expression the template passed for it.
+      def interpolate(text, arguments)
+        values = parse_arguments(arguments)
+        return unless values
+        return if text.scan(INTERPOLATION).flatten.any? { |name| !values.key?(name) }
+
+        text.split(INTERPOLATION).each_with_index.map do |part, index|
+          index.odd? ? "{{ #{values[part]} }}" : yield(part)
+        end.join
+      end
+
+      def literal_text(literal)
+        @escape ? ERB::Util.html_escape(literal) : literal
+      end
+
+      def parse_arguments(arguments)
+        return {} if arguments.blank?
+
+        arguments.split(/,\s*(?=\w+\s*:)/).to_h do |pair|
+          name, expression = pair.split(':', 2).map(&:strip)
+          return nil if name.blank? || expression.blank?
+
+          [name, expression]
+        end
+      end
+
+      def translation(key)
+        text = I18n.t(key, scope: :spree, locale: @locale, default: nil)
+        text if text.is_a?(String) && !text.include?('{{') && !text.include?('{%')
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module Spree
         #   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?
+          raise ArgumentError, I18n.t('spree.price_list_import_no_price_list') if price_list.nil?
 
           variant = find_variant
           currency = currency_for(attributes['currency'])
@@ -62,15 +62,15 @@ module Spree
         # 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?
+          raise ArgumentError, I18n.t('spree.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?
+          raise ArgumentError, I18n.t('spree.price_list_import_unknown_sku', sku: sku) if variants.empty?
+          raise ArgumentError, I18n.t('spree.price_list_import_ambiguous_sku', sku: sku) if variants.many?
 
           variants.first
         end
@@ -82,7 +82,7 @@ module Spree
           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)
+          raise ArgumentError, I18n.t('spree.price_list_import_unsupported_currency', currency: currency)
         end
 
         def supported_currencies
@@ -99,7 +99,7 @@ module Spree
         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)
+          raise ArgumentError, I18n.t('spree.price_list_import_invalid_amount', column: column, value: text) unless text.match?(AMOUNT_FORMAT)
 
           BigDecimal(text)
         end
@@ -151,17 +151,17 @@ module Spree
           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)
+            I18n.t('spree.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'])
+            I18n.t('spree.price_list_import_invalid_quantity', value: attributes['min_quantity'])
           elsif (rising = value[:rising_ladders].presence)
             # Named rung and floor, like the sibling branches: a file is written
             # one rung per row, so the merchant needs to know which one and what
             # it had to beat.
-            Spree.t(:price_list_import_price_rises_with_quantity,
+            I18n.t('spree.price_list_import_price_rises_with_quantity',
                     quantity: rising.first[:min_quantity], floor: rising.first[:floor])
           else
-            result.error.to_s.presence || Spree.t(:price_list_import_failed)
+            result.error.to_s.presence || I18n.t('spree.price_list_import_failed')
           end
         end
       end

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

@@ -3,15 +3,23 @@ module Spree
     module RowProcessors
       class ProductVariant < Base
         OPTION_TYPES_COUNT = 3
+        CATEGORY_FIELDS = %w[category1 category2 category3].freeze
+        # Written as plain decimals ("16.50"): the models store text as sent,
+        # and "1,599.99" or "16,50" would otherwise be saved as 1 or 16.
+        DECIMAL_FIELDS = %w[price compare_at_price cost_price weight height width depth carton_weight].freeze
 
         def initialize(row, **)
           super
+          ensure_decimals!
           @store = row.store
           @seller = import.seller
+          # Before the product is saved: rows are not wrapped in a transaction,
+          # so an unknown location must fail the row with nothing written.
+          @stock_location = import_stock_location if attributes['inventory_count'].present?
           @product = ensure_product_exists
         end
 
-        attr_reader :product, :store, :seller
+        attr_reader :product, :store, :seller, :stock_location
 
         def process!
           variant = if attributes['sku'].present?
@@ -62,7 +70,7 @@ module Spree
             variant.set_stock(
               attributes['inventory_count'].to_i,
               attributes['inventory_backorderable']&.to_b,
-              import_stock_location
+              stock_location
             )
           end
 
@@ -79,6 +87,14 @@ module Spree
 
         private
 
+        def ensure_decimals!
+          DECIMAL_FIELDS.each do |column|
+            Spree::Money::Rounding.parse_decimal(attributes[column])
+          rescue Spree::Money::InvalidFormat
+            raise ArgumentError, I18n.t('spree.import_invalid_number', column: column, value: attributes[column].to_s.strip)
+          end
+        end
+
         # 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
@@ -91,9 +107,17 @@ module Spree
           product.update_column(:default_variant_id, product.variants.reload.first&.id)
         end
 
+        # Whether this row carries the product itself, as opposed to only one of
+        # its variants. A row is a product row when it has no options at all, or
+        # when it names the product alongside them — an export (and Shopify's
+        # own CSV) writes the product's attributes on its first variant's row,
+        # so that row has to both create the product and create a variant.
+        def product_row?
+          options.empty? || has_product_attributes?
+        end
+
         def ensure_product_exists
-          if options.empty?
-            # For product/header rows (no options), create or update the product
+          if product_row?
             product = Spree::Product.new
             if attributes['slug'].present?
               existing_product = product_scope.find_by(slug: attributes['slug'].strip.downcase)
@@ -167,9 +191,12 @@ module Spree
         end
 
         def assign_attributes_to_product(product)
-          # 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']
+            # Only an option-less row's SKU belongs to the product's own variant,
+            # so process! updates that variant instead of creating a second one.
+            # On a row that also carries options the SKU identifies that option
+            # variant, which process! creates for itself.
             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
@@ -197,11 +224,9 @@ module Spree
             product.status = to_spree_status(attributes['status'])
           end
 
-          if options.empty?
-            if attributes['product_type'].present?
-              product_type = prepare_product_type
-              product.product_type = product_type if product_type.present?
-            end
+          if attributes['product_type'].present?
+            product_type = prepare_product_type
+            product.product_type = product_type if product_type.present?
           end
 
           product
@@ -243,23 +268,32 @@ 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?
+          name = attributes['stock_location'].to_s.squish
 
-          cached_lookup(:seller_stock_location, seller.id) do
-            seller.stock_locations.active.order_default.first
+          if name.blank?
+            return cached_lookup(:default_stock_location) do
+              Spree::StockLocation.owned_by(store_id: store.id, seller_id: seller&.id).active.order_default.first ||
+                store.default_stock_location
+            end
           end
+
+          owner_ids = stock_location_owner_ids
+          name_column = Spree::StockLocation.arel_table[:name]
+          cached_lookup(:stock_location, owner_ids, name.downcase) do
+            store.stock_locations.where(seller_id: owner_ids).
+              order(Arel.sql('CASE WHEN seller_id IS NULL THEN 1 ELSE 0 END')).
+              find_by(name_column.lower.eq(Arel::Nodes::NamedFunction.new('LOWER', [Arel::Nodes.build_quoted(name)])))
+          end || raise(ArgumentError, I18n.t('spree.product_import_unknown_stock_location', name: name))
+        end
+
+        # A seller reaches only their own locations — never the marketplace's
+        # shelf. An operator reaches the marketplace's and, for a seller's
+        # product, that seller's, whose own wins on a shared name as with cartons.
+        def stock_location_owner_ids
+          return [seller.id] if seller.present?
+
+          [nil, product_scope.where(slug: attributes['slug'].to_s.strip.downcase).pick(:seller_id)].uniq
         end
 
         def prepare_option_value_variants
@@ -304,11 +338,11 @@ module Spree
         def find_or_create_option_type!(label)
           cached_lookup(:option_type, label) do
             begin
-              store_option_types.search_by_name(label).first || store_option_types.create!(label: label)
+              store_option_types.with_name(label).first || store_option_types.create!(label: label)
             rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
               raise unless uniqueness_conflict?(e, :name)
 
-              store_option_types.search_by_name(label).first!
+              store_option_types.with_name(label).first!
             end
           end
         end
@@ -320,11 +354,11 @@ module Spree
         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(label).first || option_type.option_values.create!(label: label)
+              option_type.option_values.with_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(label).first!
+              option_type.option_values.with_name(label).first!
             end
           end
         end
@@ -375,7 +409,7 @@ module Spree
         end
 
         def has_product_attributes?
-          %w[name status description category1 category2 category3].any? { |key| attributes[key].present? }
+          (%w[name status description] + CATEGORY_FIELDS).any? { |key| attributes[key].present? }
         end
 
         def handle_custom_fields(product)
@@ -442,6 +476,7 @@ module Spree
         # seller audience in the permission catalog at all.
         def handle_categories(product)
           return if seller.present?
+          return unless category_columns_mapped?
 
           names = prepare_taxon_pretty_names
           return Spree::Imports::CreateCategoriesJob.perform_now(product.id, store.id, names) if import.preferred_inline
@@ -450,11 +485,19 @@ module Spree
         end
 
         def prepare_taxon_pretty_names
-          [
-            attributes['category1'],
-            attributes['category2'],
-            attributes['category3']
-          ].compact_blank.map(&:strip).uniq
+          CATEGORY_FIELDS.map { |field| attributes[field] }.compact_blank.map(&:strip).uniq
+        end
+
+        # A blank category cell means "file this product under nothing", and
+        # CreateCategoriesJob assigns the list wholesale to honour that. A file
+        # that carries no category columns at all means something different —
+        # it simply doesn't speak about categories — so without this a Shopify
+        # export, or any spreadsheet that omits them, would unfile every
+        # product it touched.
+        def category_columns_mapped?
+          cached_lookup(:category_columns_mapped) do
+            import.mappings.mapped.any? { |mapping| CATEGORY_FIELDS.include?(mapping.schema_field) }
+          end
         end
 
         def to_spree_status(status)