spree_core 5.6.0 → 5.6.1

data/app/models/spree/metafields/long_text.rb

@@ -2,6 +2,10 @@ module Spree
   module Metafields
     class LongText < Spree::Metafield
       normalizes :value, with: ->(value) { value.to_s.strip }
+
+      def self.searchable?
+        true
+      end
     end
   end
 end

data/app/models/spree/metafields/number.rb

@@ -3,6 +3,14 @@ module Spree
     class Number < Spree::Metafield
       validates :value, numericality: true
 
+      def self.searchable?
+        true
+      end
+
+      def self.sortable?
+        true
+      end
+
       def serialize_value
         value.to_d
       end

data/app/models/spree/metafields/short_text.rb

@@ -2,6 +2,14 @@ module Spree
   module Metafields
     class ShortText < Spree::Metafield
       normalizes :value, with: ->(value) { value.to_s.strip }
+
+      def self.searchable?
+        true
+      end
+
+      def self.sortable?
+        true
+      end
     end
   end
 end

data/app/models/spree/product.rb

@@ -31,7 +31,9 @@ module Spree
     include Spree::TranslatableResource
     include Spree::MemoizedData
     include Spree::Metafields
+    include Spree::MetafieldFilterable
     include Spree::Metadata
+    include Spree::Searchable
     include Spree::Product::Webhooks
     include Spree::Product::Slugs
     include Spree::Product::Channels
@@ -171,7 +173,23 @@ module Spree
       next none if query.blank?
 
       product_ids = Spree::Variant.search_by_product_name_or_sku(query).pluck(:product_id)
-      where(id: product_ids.uniq.compact)
+
+      searchable_definitions = Spree::MetafieldDefinition.
+                               for_resource_type('Spree::Product').
+                               searchable
+
+      # Only pay for the metafield scan when some definition opts into search;
+      # the leading-wildcard LIKE over spree_metafields can't use an index.
+      metafield_ids = if searchable_definitions.exists?
+                        joins(metafields: :metafield_definition).
+                          merge(searchable_definitions).
+                          where(search_condition(Spree::Metafield, :value, query)).
+                          unscope(:order).distinct.pluck(:id)
+                      else
+                        []
+                      end
+
+      where(id: (product_ids + metafield_ids).uniq.compact)
     }
 
     # Backward compatibility alias — remove in Spree 6.0

data/app/models/spree/report.rb

@@ -37,8 +37,18 @@ module Spree
       'Spree::Api::V3::ReportSerializer'.safe_constantize
     end
 
+    # Registered report subclasses, mirroring Spree::Export/Spree::Import so
+    # `api_type_for` can resolve an STI column value without constantizing it.
+    #
+    # @return [Array<Class>]
+    def self.available_types
+      Spree.reports
+    end
+
+    # @deprecated Use `.api_type` — identical derivation, consistent with the
+    #   rest of the API's `type` fields.
     def self.report_type
-      name.demodulize.underscore
+      api_type
     end
 
     # Returns a scope of records to be used for generating report lines

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

@@ -13,6 +13,11 @@ module Spree
         @store = store
       end
 
+      # @return [MetafieldSchema]
+      def metafield_schema
+        @metafield_schema ||= MetafieldSchema.new
+      end
+
       # Search and paginate products. Does NOT compute filter facets — use #filters for that.
       #
       # @param scope [ActiveRecord::Relation] base scope (store-scoped, visibility-filtered, authorized)

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

@@ -46,6 +46,7 @@ module Spree
                              end
 
         filter_facets = build_facets(scope_with_options, category: category, option_value_ids: option_value_ids, scope_before_options: scope_before_options)
+        filter_facets[:sort_options] = filter_facets[:sort_options] + metafield_sort_options
 
         FiltersResult.new(
           filters: filter_facets[:filters],
@@ -60,6 +61,9 @@ module Spree
       def apply_search_and_filters(scope, query: nil, filters: {})
         scope = scope.search(query) if query.present?
 
+        filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
+        scope, filters = scope.with_metafield_filters(filters, schema: metafield_schema)
+
         ransack_filters = sanitize_filters(filters)
         if ransack_filters.present?
           search = scope.ransack(ransack_filters)
@@ -74,7 +78,7 @@ module Spree
       end
 
       def build_facets(scope, category: nil, option_value_ids: [], scope_before_options: nil)
-        return { filters: [], sort_options: available_sort_options, default_sort: 'manual', total_count: scope.distinct.count } unless defined?(Spree::Api::V3::FiltersAggregator)
+        return { filters: [], sort_options: built_in_sort_options, default_sort: 'manual', total_count: scope.distinct.count } unless defined?(Spree::Api::V3::FiltersAggregator)
 
         Spree::Api::V3::FiltersAggregator.new(
           scope: scope,
@@ -98,6 +102,8 @@ module Spree
         scope_method = CUSTOM_SORT_SCOPES[sort]
         if scope_method
           scope.reorder(nil).send(scope_method)
+        elsif (parsed = metafield_schema.parse_sort(sort))
+          apply_metafield_sort(scope, parsed)
         else
           # Standard Ransack sort: 'name' → 'name asc', '-name' → 'name desc'
           ransack_sort = sort.split(',').map { |field|
@@ -112,8 +118,48 @@ module Spree
         end
       end
 
-      def available_sort_options
-        %w[price -price best_selling name -name -available_on available_on].map { |id| { id: id } }
+      # Project the ORDER BY expression into the SELECT list so PostgreSQL
+      # accepts it when DISTINCT is applied. Null-rank keeps products without
+      # the metafield last for both ASC and DESC.
+      def apply_metafield_sort(scope, parsed)
+        definition = metafield_schema.entry_for(parsed[:attribute])
+        return scope unless definition
+
+        products = Spree::Product.arel_table
+        # Aliased so this join can't collide with the `filter_cf` correlated
+        # subquery when a cf_* filter and a cf_* sort are combined.
+        metafields = Spree::Metafield.arel_table.alias('sort_cf')
+
+        sort_expr = Spree::Product.metafield_value_expression(metafields[:value], definition.field_type)
+        # NULL-rank so products missing the metafield sort last (Meilisearch parity).
+        # Projected as cf_sort_missing because PostgreSQL rejects (alias IS NULL) in ORDER BY.
+        null_rank = sort_expr.eq(nil)
+
+        direction = parsed[:direction] == 'desc' ? :desc : :asc
+
+        join = products.
+               outer_join(metafields).
+               on(
+                 metafields[:resource_type].eq('Spree::Product').
+                 and(metafields[:resource_id].eq(products[:id])).
+                 and(metafields[:metafield_definition_id].eq(definition.id))
+               ).
+               join_sources
+
+        scope.
+          joins(join).
+          select(products[Arel.star]).
+          select(Arel::Nodes::As.new(sort_expr, Arel.sql('cf_sort_value'))).
+          select(Arel::Nodes::As.new(null_rank, Arel.sql('cf_sort_missing'))).
+          reorder(Arel.sql('cf_sort_missing').asc, sort_expr.public_send(direction))
+      end
+
+      def built_in_sort_options
+        %w[price -price best_selling name -name -available_on available_on].map { |id| { id: id, label: nil } }
+      end
+
+      def metafield_sort_options
+        metafield_schema.sort_options
       end
     end
   end

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

@@ -5,6 +5,8 @@ module Spree
     class Meilisearch < Base
       PREFIXED_ID_PATTERN = /\A[a-z]+_[A-Za-z0-9]+\z/
       ALLOWED_STATUSES = %w[active draft archived paused].freeze
+      BUILT_IN_FILTERABLE_ATTRIBUTES = %w[product_id status in_stock preorder store_ids channel_ids locale currency available_on discontinue_on price category_ids tags option_value_ids].freeze
+      METAFIELD_RANGE_OPERATORS = { 'gt' => '>', 'gteq' => '>=', 'lt' => '<', 'lteq' => '<=' }.freeze
 
       def self.indexing_required?
         true
@@ -51,7 +53,7 @@ module Spree
         unless ms_result
           return FiltersResult.new(
             filters: [],
-            sort_options: available_sort_options.map { |id| { id: id } },
+            sort_options: built_in_and_metafield_sort_options,
             default_sort: 'manual',
             total_count: 0
           )
@@ -59,7 +61,7 @@ module Spree
 
         FiltersResult.new(
           filters: build_facet_response(facet_distribution),
-          sort_options: available_sort_options.map { |id| { id: id } },
+          sort_options: built_in_and_metafield_sort_options,
           default_sort: 'manual',
           total_count: ms_result['estimatedTotalHits'] || 0
         )
@@ -91,6 +93,7 @@ module Spree
 
       def reindex(scope = nil)
         scope ||= store.products
+        @metafield_schema = MetafieldSchema.new
         ensure_index_settings!
 
         indexed = 0
@@ -180,7 +183,7 @@ module Spree
           # is referenced before the index settings were refreshed — otherwise
           # every search on an upgraded store returns empty until a reindex or
           # the next product write.
-          if e.code == 'invalid_search_filter' && !settings_refreshed
+          if %w[invalid_search_filter invalid_search_sort].include?(e.code) && !settings_refreshed
             settings_refreshed = true
             ensure_index_settings!
             retry
@@ -240,23 +243,30 @@ module Spree
       end
 
       def searchable_attributes
-        %w[name description sku option_values category_names tags]
+        %w[name description sku option_values category_names tags] + metafield_schema.searchable_attribute_keys
       end
 
       def filterable_attributes
-        %w[product_id status in_stock preorder store_ids channel_ids locale currency available_on discontinue_on price category_ids tags option_value_ids]
+        BUILT_IN_FILTERABLE_ATTRIBUTES + metafield_schema.filterable_attribute_keys
       end
 
       def sortable_attributes
-        %w[name price created_at available_on units_sold_count]
+        %w[name price created_at available_on units_sold_count] + metafield_schema.sortable_attribute_keys
       end
 
+      # Facets stay built-in only — cf_* distributions aren't consumed by
+      # +build_facet_response+, so requesting them would be wasted work.
       def facet_attributes
-        filterable_attributes
+        BUILT_IN_FILTERABLE_ATTRIBUTES
       end
 
       def available_sort_options
-        %w[price -price name -name -available_on available_on best_selling]
+        %w[price -price name -name -available_on available_on best_selling] + metafield_schema.sort_ids
+      end
+
+      def built_in_and_metafield_sort_options
+        %w[price -price name -name -available_on available_on best_selling].map { |id| { id: id, label: nil } } +
+          metafield_schema.sort_options
       end
 
       # Build Meilisearch filter conditions from API params.
@@ -331,9 +341,51 @@ module Spree
         when 'with_option_value_ids'
           # Handled by grouped option conditions in search_and_filter — skip here
           nil
+        else
+          metafield_filter_condition(key, value)
+        end
+      end
+
+      # Meilisearch has stable filter operators for equality, ranges, and
+      # EXISTS — but no string contains/starts/ends (CONTAINS is still
+      # experimental), so those predicates are ignored here. The Database
+      # provider supports the full predicate set.
+      def metafield_filter_condition(key, value)
+        parsed = metafield_schema.parse_filter(key)
+        return nil unless parsed
+
+        attribute = parsed[:definition].filter_key
+        numeric = parsed[:definition].field_type == 'number'
+
+        case parsed[:predicate]
+        when 'present'
+          "#{attribute} EXISTS"
+        when 'blank'
+          "#{attribute} NOT EXISTS"
+        when 'eq', 'not_eq'
+          operator = parsed[:predicate] == 'eq' ? '=' : '!='
+          formatted = format_metafield_filter_value(value, numeric)
+          formatted && "#{attribute} #{operator} #{formatted}"
+        when *METAFIELD_RANGE_OPERATORS.keys
+          return nil unless numeric
+
+          formatted = format_metafield_filter_value(value, numeric)
+          formatted && "#{attribute} #{METAFIELD_RANGE_OPERATORS[parsed[:predicate]]} #{formatted}"
         end
       end
 
+      def format_metafield_filter_value(value, numeric)
+        if numeric
+          Float(value.to_s, exception: false)&.to_s
+        else
+          "'#{escape_filter_string(value)}'"
+        end
+      end
+
+      def escape_filter_string(value)
+        value.to_s.gsub('\\') { '\\\\' }.gsub("'") { "\\'" }
+      end
+
       # Group prefixed option value IDs by option type (single DB query).
       # Returns { option_type_id => ['optval_abc', 'optval_def'], ... }
       def group_option_values_by_type(prefixed_ids)
@@ -380,6 +432,9 @@ module Spree
         when '-available_on' then ['available_on:desc']
         when 'available_on'  then ['available_on:asc']
         when 'best_selling'  then ['units_sold_count:desc']
+        else
+          parsed = metafield_schema.parse_sort(sort)
+          parsed && ["#{parsed[:attribute]}:#{parsed[:direction]}"]
         end
       end
 

data/app/presenters/spree/search_provider/product_presenter.rb

@@ -75,7 +75,27 @@ module Spree
           available_on: product.available_on&.iso8601,
           created_at: product.created_at&.iso8601,
           updated_at: product.updated_at&.iso8601
-        }
+        }.merge(metafield_document_attributes)
+      end
+
+      # Flat cf_* hash for searchable ∪ sortable metafields (Meilisearch docs).
+      def metafield_document_attributes
+        @metafield_document_attributes ||= product.metafields.filter_map do |metafield|
+          definition = metafield.metafield_definition
+          next unless definition&.searchable? || definition&.sortable?
+
+          [definition.filter_key, metafield_index_value(metafield, definition.field_type)]
+        end.to_h
+      end
+
+      def metafield_index_value(metafield, field_type)
+        serialized = metafield.serialize_value
+        case field_type
+        when 'number'
+          serialized.to_f
+        else
+          serialized.to_s
+        end
       end
 
       # Returns all market × locale pairs for this store

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

@@ -295,11 +295,16 @@ module Spree
         end
 
         def handle_tags(product)
+          return Spree::Imports::AssignTagsJob.perform_now(product.id, attributes['tags']) if import.preferred_inline
+
           Spree::Imports::AssignTagsJob.perform_later(product.id, attributes['tags'])
         end
 
         def handle_categories(product)
-          Spree::Imports::CreateCategoriesJob.perform_later(product.id, store.id, prepare_taxon_pretty_names)
+          names = prepare_taxon_pretty_names
+          return Spree::Imports::CreateCategoriesJob.perform_now(product.id, store.id, names) if import.preferred_inline
+
+          Spree::Imports::CreateCategoriesJob.perform_later(product.id, store.id, names)
         end
 
         def prepare_taxon_pretty_names

data/app/services/spree/sample_data/helper.rb

@@ -0,0 +1,55 @@
+module Spree
+  module SampleData
+    # Shared by the sample-data drivers: `Spree::SampleData::Loader` (the
+    # synchronous, rake-facing one) and any app that loads a subset itself —
+    # e.g. running the configuration files inline and handing the CSVs to the
+    # import pipeline. Keeping the file locations and catalog-publishing rules
+    # here means they don't have to be kept in sync by hand.
+    module Helper
+      private
+
+      def sample_data_path
+        @sample_data_path ||= Spree::Core::Engine.root.join('db', 'sample_data')
+      end
+
+      def load_ruby_file(name)
+        file = sample_data_path.join("#{name}.rb")
+        load file.to_s if file.exist?
+      end
+
+      # Publishes the catalog to every channel the store has. The import only
+      # adds a product to the default channel, and only when it has none, so
+      # anything else the store defines (wholesale, a locale-specific storefront,
+      # whatever an app has seeded) would otherwise be left empty. Catalog parity
+      # is the point — channels differentiate through their own gates and price
+      # lists, not through a narrower catalog. `add_products` upserts in bulk and
+      # skips rows that already exist.
+      def publish_sample_products(store)
+        product_ids = store.product_ids
+        return if product_ids.empty?
+
+        store.channels.each { |channel| channel.add_products(product_ids) }
+      end
+
+      # Cheap proxy for "the base seeds have run": the US states are seeded
+      # alongside everything else, and products/addresses depend on them.
+      def seeds_loaded?
+        Spree::State.joins(:country).where(spree_countries: { iso: 'US' }).exists?
+      end
+
+      def ensure_seeds_loaded
+        return if seeds_loaded?
+
+        Spree::Seeds::All.call
+      end
+
+      def without_geocoding
+        previous = Spree::Config[:geocode_addresses]
+        Spree::Config[:geocode_addresses] = false
+        yield
+      ensure
+        Spree::Config[:geocode_addresses] = previous
+      end
+    end
+  end
+end

data/app/services/spree/sample_data/import_builder.rb

@@ -0,0 +1,32 @@
+module Spree
+  module SampleData
+    # Creates the `Spree::Import` record for a sample CSV, attaching the file
+    # but processing nothing — the two runners differ only in what they do next.
+    class ImportBuilder
+      # @return [Spree::Import] persisted, unprocessed
+      def self.call(csv_path:, import_class:, store: nil, user: nil, inline: false, skip_events: false)
+        store ||= Spree::Store.default
+        # An admin of the target store, not `admin_user_class.first` — in a
+        # multi-store or multi-tenant app that global first can belong to a
+        # different store entirely.
+        user ||= store.users.first
+
+        raise 'No admin user found. Please run seeds first.' unless user
+
+        import = import_class.new(owner: store, user: user)
+        # Persisted before save: the processing jobs reload the record, so these
+        # have to travel with it rather than live on the instance.
+        import.preferred_inline = inline
+        import.preferred_skip_events = skip_events
+        import.number = import.generate_permalink(import_class)
+        import.attachment.attach(
+          io: File.open(csv_path),
+          filename: File.basename(csv_path),
+          content_type: 'text/csv'
+        )
+        import.save!(validate: false)
+        import
+      end
+    end
+  end
+end

data/app/services/spree/sample_data/import_runner.rb

@@ -1,53 +1,34 @@
-require 'csv'
-
 module Spree
   module SampleData
+    # Runs a sample CSV through the regular import pipeline: `start_mapping`
+    # auto-assigns the column mappings from the CSV headers (the sample files
+    # use the canonical schema names, so every column maps) and
+    # `complete_mapping` kicks off row creation and processing.
+    #
+    # Enqueues by default, so row creation, batching and the per-import
+    # concurrency cap behave exactly as they do for a merchant-uploaded CSV.
+    # Pass `inline: true` for rake tasks, seeds and the console — where the data
+    # has to exist when the call returns and there may be no worker attached.
+    # Never inline from a request: `products.csv` alone is 211 rows, each
+    # downloading a remote image.
     class ImportRunner
       prepend Spree::ServiceModule::Base
 
-      def call(csv_path:, import_class:)
-        store = Spree::Store.default
-        admin = Spree.admin_user_class.first
-
-        raise 'No admin user found. Please run seeds first.' unless admin
-
-        import = import_class.new(
-          owner: store,
-          user: admin
-        )
-        import.number = import.generate_permalink(import_class)
-        import.attachment.attach(
-          io: File.open(csv_path),
-          filename: File.basename(csv_path),
-          content_type: 'text/csv'
+      # Pass `skip_events: true` when seeding demo data — subscribers would
+      # otherwise deliver webhooks and analytics for a catalog nobody created.
+      #
+      # @return [Spree::ServiceModule::Result] wrapping the import — completed
+      #   when inline, queued otherwise
+      def call(csv_path:, import_class:, store: nil, user: nil, inline: false, skip_events: false)
+        import = Spree::SampleData::ImportBuilder.call(
+          csv_path: csv_path, import_class: import_class, store: store, user: user,
+          inline: inline, skip_events: skip_events
         )
-        import.save!(validate: false)
-        import.update_columns(status: 'processing')
-        import.create_mappings
-
-        row_number = 0
-        failed = 0
-
-        ::CSV.foreach(csv_path, headers: true) do |csv_row|
-          row_number += 1
-          import_row = import.rows.create!(
-            row_number: row_number,
-            data: csv_row.to_h.to_json,
-            status: 'pending'
-          )
-
-          begin
-            import_row.process!
-          rescue StandardError => e
-            failed += 1
-            puts "\n  Warning: Row #{row_number} failed: #{e.message}"
-          end
 
-          print '.' if (row_number % 10).zero?
-        end
+        import.start_mapping
+        import.complete_mapping
 
-        import.update!(status: 'completed')
-        puts "\n  Processed #{row_number} rows (#{failed} failed)"
+        success(import.reload)
       end
     end
   end

data/app/services/spree/sample_data/loader.rb

@@ -2,11 +2,13 @@ module Spree
   module SampleData
     class Loader
       prepend Spree::ServiceModule::Base
+      include Spree::SampleData::Helper
 
       def call
         Spree::Events.disable do
           without_geocoding do
             ActiveRecord::Base.no_touching do
+              puts 'Running seeds first...' unless seeds_loaded?
               ensure_seeds_loaded
 
               puts 'Loading sample configuration data...'
@@ -28,10 +30,7 @@ module Spree
               load_products
 
               puts 'Publishing sample products on the default channel...'
-              publish_sample_products
-
-              puts 'Loading sample categories...'
-              load_categories
+              publish_sample_products(Spree::Store.default)
 
               puts 'Loading sample product translations...'
               load_product_translations
@@ -56,18 +55,6 @@ module Spree
 
       private
 
-      def ensure_seeds_loaded
-        us = Spree::Country.find_by(iso: 'US')
-        return if us&.states&.any? && Spree::Store.default&.persisted?
-
-        puts 'Running seeds first...'
-        Spree::Seeds::All.call
-      end
-
-      def sample_data_path
-        @sample_data_path ||= Spree::Core::Engine.root.join('db', 'sample_data')
-      end
-
       def load_configuration_data
         load_ruby_file('shipping_methods')
         load_ruby_file('payment_methods')
@@ -76,57 +63,19 @@ module Spree
 
       def load_products
         csv_path = sample_data_path.join('products.csv')
-        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Products)
-      end
-
-      # Publishes the catalog to both surfaces: the public default channel and
-      # the gated wholesale channel (catalog parity; wholesale differentiation
-      # comes from the price list in +wholesale.rb+ and the channel's gate).
-      def publish_sample_products
-        store = Spree::Store.default
-        store.default_channel.add_products(store.product_ids)
-        store.channels.find_by(code: Spree::Seeds::Channels::WHOLESALE_CODE)&.add_products(store.product_ids)
-      end
-
-      def load_categories
-        store = Spree::Store.default
-        csv_path = sample_data_path.join('products.csv')
-
-        require 'csv'
-        ::CSV.foreach(csv_path, headers: true) do |row|
-          product = store.products.find_by(slug: row['slug'])
-          next unless product
-
-          categories = [row['category1'], row['category2'], row['category3']].compact_blank
-          next if categories.empty?
-
-          Spree::Imports::CreateCategoriesJob.perform_now(product.id, store.id, categories)
-        end
+        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Products, inline: true)
       end
 
       def load_product_translations
         csv_path = sample_data_path.join('product_translations.csv')
         return unless csv_path.exist?
 
-        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::ProductTranslations)
+        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::ProductTranslations, inline: true)
       end
 
       def load_customers
         csv_path = sample_data_path.join('customers.csv')
-        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Customers)
-      end
-
-      def load_ruby_file(name)
-        file = sample_data_path.join("#{name}.rb")
-        load file.to_s if file.exist?
-      end
-
-      def without_geocoding
-        previous = Spree::Config[:geocode_addresses]
-        Spree::Config[:geocode_addresses] = false
-        yield
-      ensure
-        Spree::Config[:geocode_addresses] = previous
+        Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Customers, inline: true)
       end
     end
   end