spree_core 5.6.0 → 5.6.1

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Spree
+  module SearchProvider
+    # Product metafield definitions that participate in search/sort.
+    class MetafieldSchema
+      # Ransack-style predicates accepted per field type. Mirrors the operator
+      # sets the admin dashboard's filter panel offers for string/number columns
+      # (see packages/dashboard-core/src/components/table-toolbar.tsx).
+      TEXT_FILTER_PREDICATES = %w[i_cont cont eq not_eq start end present blank].freeze
+      NUMBER_FILTER_PREDICATES = %w[eq gt gteq lt lteq present blank].freeze
+
+      # Longest first so a key ending in +_i_cont+ isn't mis-split as the
+      # shorter +_cont+ against a definition keyed +..._i+.
+      ORDERED_FILTER_PREDICATES = (TEXT_FILTER_PREDICATES | NUMBER_FILTER_PREDICATES).
+                                  sort_by { |predicate| -predicate.length }.freeze
+
+      # @return [Hash{String => Spree::MetafieldDefinition}]
+      def entries
+        @entries ||= product_definitions.index_by(&:filter_key)
+      end
+
+      # @return [Array<String>]
+      def searchable_attribute_keys
+        @searchable_attribute_keys ||= entries.each_value.filter_map do |definition|
+          definition.filter_key if definition.searchable?
+        end
+      end
+
+      # @return [Array<String>]
+      def sortable_attribute_keys
+        @sortable_attribute_keys ||= entries.each_value.filter_map do |definition|
+          definition.filter_key if definition.sortable?
+        end
+      end
+
+      # @param attribute_key [String]
+      # @return [Spree::MetafieldDefinition, nil]
+      def entry_for(attribute_key)
+        entries[attribute_key.to_s]
+      end
+
+      # Every schema attribute accepts filters — values are already indexed
+      # for search/sort, so filtering rides on the same document keys.
+      #
+      # @return [Array<String>]
+      def filterable_attribute_keys
+        @filterable_attribute_keys ||= entries.keys
+      end
+
+      # @return [Array<String>]
+      def sort_ids
+        @sort_ids ||= sortable_attribute_keys.flat_map { |key| [key, "-#{key}"] }
+      end
+
+      # @return [Array<Hash>] +{ id:, label: }+
+      def sort_options
+        @sort_options ||= entries.each_value.select(&:sortable?).flat_map do |definition|
+          key = definition.filter_key
+          name = definition.name.presence || key
+
+          [
+            { id: key, label: sort_option_label(name, definition.field_type, :asc) },
+            { id: "-#{key}", label: sort_option_label(name, definition.field_type, :desc) }
+          ]
+        end
+      end
+
+      # @param sort [String, nil]
+      # @return [Hash, nil] { attribute:, direction: 'asc'|'desc' }
+      def parse_sort(sort)
+        value = sort.to_s.strip
+        return if value.blank?
+
+        attribute = value.delete_prefix('-')
+        definition = entry_for(attribute)
+        return unless definition&.sortable?
+
+        {
+          attribute: attribute,
+          direction: value.start_with?('-') ? 'desc' : 'asc'
+        }
+      end
+
+      # Splits a Ransack-style predicate key (e.g. +cf_custom_label_i_cont+)
+      # into the definition it targets and the predicate. Both search keys and
+      # predicates contain underscores, so predicates are tried longest-first —
+      # otherwise +cf_x_i_cont+ would resolve as key +x_i+ with predicate
+      # +cont+. A key that itself ends in a predicate name (+..._eq_eq+) is
+      # only reachable if the shorter split names a real definition.
+      #
+      # @param key [String, Symbol]
+      # @return [Hash, nil] +{ definition:, predicate: }+
+      def parse_filter(key)
+        value = key.to_s
+        return unless value.start_with?('cf_')
+
+        ORDERED_FILTER_PREDICATES.each do |predicate|
+          next unless value.end_with?("_#{predicate}")
+
+          definition = entries[value.delete_suffix("_#{predicate}")]
+          next unless definition && filter_predicates_for(definition.field_type).include?(predicate)
+
+          return { definition: definition, predicate: predicate }
+        end
+
+        nil
+      end
+
+      # @param field_type [String]
+      # @return [Array<String>]
+      def filter_predicates_for(field_type)
+        field_type == 'number' ? NUMBER_FILTER_PREDICATES : TEXT_FILTER_PREDICATES
+      end
+
+      # Stamp for Store API filters cache keys.
+      #
+      # @return [String]
+      def schema_version
+        @schema_version ||= [
+          entries.size,
+          entries.each_value.filter_map(&:updated_at).max&.utc&.iso8601(6)
+        ].join('-')
+      end
+
+      private
+
+      def product_definitions
+        scope = Spree::MetafieldDefinition.for_resource_type('Spree::Product')
+        scope.where(searchable: true).or(scope.where(sortable: true))
+      end
+
+      def sort_option_label(name, field_type, direction)
+        suffix =
+          if field_type == 'number'
+            direction == :asc ? Spree.t(:sort_low_to_high) : Spree.t(:sort_high_to_low)
+          else
+            direction == :asc ? Spree.t(:sort_a_to_z) : Spree.t(:sort_z_to_a)
+          end
+        "#{name} (#{suffix})"
+      end
+    end
+  end
+end

data/app/services/spree/seeds/allowed_origins.rb

@@ -4,10 +4,9 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call
-        store = Spree::Store.default
-        return unless store&.persisted?
-
-        store.allowed_origins.find_or_create_by!(origin: 'http://localhost')
+        Spree::Store.all.each do |store|
+          store.allowed_origins.find_or_create_by!(origin: 'http://localhost')
+        end
       end
     end
   end

data/app/services/spree/seeds/states.rb

@@ -10,14 +10,18 @@ module Spree
 
       def call
         Spree::Country.where(states_required: true).each do |country|
-          carmen_country = Carmen::Country.named(country.name)
+          # Match on ISO code, not name: Spree stores official ISO-3166 names
+          # ("United States of America") while Carmen uses common ones
+          # ("United States"), and `named` is an exact match — so a name lookup
+          # silently skipped the US, leaving it with no states at all.
+          carmen_country = Carmen::Country.coded(country.iso) || Carmen::Country.named(country.name)
           next unless carmen_country
 
-          carmen_country.subregions.each do |subregion|
+          states = carmen_country.subregions.flat_map do |subregion|
             if carmen_country.alpha_2_code == 'US'
               # Produces 50 states, one postal district (Washington DC)
               # and 3 APO's as you would expect to see on any good U.S. states list.
-              next if EXCLUDED_US_STATES.include?(subregion.code)
+              next [] if EXCLUDED_US_STATES.include?(subregion.code)
 
               state_level(country, subregion)
             elsif carmen_country.alpha_2_code == 'CA' || carmen_country.alpha_2_code == 'MX'
@@ -27,7 +31,7 @@ module Spree
             elsif carmen_country.alpha_2_code == 'CN'
               # Removes 3 "States" from that list that are also listed as Countries,
               # Hong Kong, Taiwan and Macao
-              next if EXCLUDED_CN_STATES.include?(subregion.code)
+              next [] if EXCLUDED_CN_STATES.include?(subregion.code)
 
               state_level(country, subregion)
             elsif subregion.subregions?
@@ -36,27 +40,42 @@ module Spree
               state_level(country, subregion)
             end
           end
+
+          # One upsert per country rather than one per subregion.
+          upsert_states(states)
         end
       end
 
       protected
 
       def state_level(country, subregion)
-        country.states.where(
-          name: subregion.name,
-          abbr: subregion.code
-        ).first_or_create!
+        [{ name: subregion.name, abbr: subregion.code, country_id: country.id }]
       end
 
       def province_level(country, subregion)
-        new_states = subregion.subregions.map do |province|
-          Hash[
-            name: province.name,
-            abbr: province.code,
-            country_id: country.id
-          ]
-        end.compact.uniq
-        Spree::State.insert_all(new_states)
+        subregion.subregions.map do |province|
+          { name: province.name, abbr: province.code, country_id: country.id }
+        end
+      end
+
+      # Seeds are re-run on every deploy, so this has to converge rather than
+      # duplicate: `[country_id, abbr]` is unique, and a name change upstream
+      # updates the existing row instead of adding a second one.
+      def upsert_states(states)
+        states = states.uniq { |state| [state[:country_id], state[:abbr]] }.reject { |state| state[:abbr].blank? }
+        return if states.empty?
+
+        now = Time.current
+        opts = { update_only: %i[name] }
+        # MySQL infers the conflict target from the table's unique constraints
+        # and rejects an explicit +unique_by+; PostgreSQL/SQLite require it.
+        opts[:unique_by] = %i[country_id abbr] unless mysql_adapter?
+
+        Spree::State.upsert_all(states.map { |state| state.merge(created_at: now, updated_at: now) }, **opts)
+      end
+
+      def mysql_adapter?
+        ActiveRecord::Base.connection.adapter_name.downcase.include?('mysql')
       end
     end
   end

data/config/locales/en.yml

@@ -71,6 +71,8 @@ en:
         quantity: Quantity
       spree/metafield_definition:
         namespace: Namespace
+        searchable: Searchable
+        sortable: Sortable
       spree/option_type:
         filterable: Filterable
         kind: Kind
@@ -1479,7 +1481,11 @@ en:
     skus: SKUs
     slug: Slug
     social: Social
+    sort_a_to_z: A-Z
     sort_by: Sort by
+    sort_high_to_low: high-low
+    sort_low_to_high: low-high
+    sort_z_to_a: Z-A
     source: Source
     special_instructions: Special Instructions
     split: Split

data/db/migrate/20260722000001_add_searchable_sortable_to_spree_metafield_definitions.rb

@@ -0,0 +1,6 @@
+class AddSearchableSortableToSpreeMetafieldDefinitions < ActiveRecord::Migration[7.2]
+  def change
+    add_column :spree_metafield_definitions, :searchable, :boolean, if_not_exists: true
+    add_column :spree_metafield_definitions, :sortable, :boolean, if_not_exists: true
+  end
+end

data/db/migrate/20260727000001_add_unique_country_abbr_index_to_spree_states.rb

@@ -0,0 +1,30 @@
+class AddUniqueCountryAbbrIndexToSpreeStates < ActiveRecord::Migration[7.2]
+  def up
+    remove_duplicate_states!
+
+    add_index :spree_states, [:country_id, :abbr],
+              unique: true,
+              name: 'index_spree_states_on_country_id_and_abbr'
+  end
+
+  def down
+    remove_index :spree_states, name: 'index_spree_states_on_country_id_and_abbr'
+  end
+
+  private
+
+  # `Spree::Seeds::States` used a plain `insert_all` for province-level
+  # countries, so re-running the seeds duplicated their states. Keep the oldest
+  # row of each group — addresses point at it — and drop the rest.
+  def remove_duplicate_states!
+    duplicated = Spree::State.group(:country_id, :abbr).having('COUNT(*) > 1').pluck(:country_id, :abbr)
+
+    duplicated.each do |country_id, abbr|
+      ids = Spree::State.where(country_id: country_id, abbr: abbr).order(:id).pluck(:id)
+      keeper = ids.shift
+
+      Spree::Address.where(state_id: ids).update_all(state_id: keeper) if ids.any?
+      Spree::State.where(id: ids).delete_all
+    end
+  end
+end

data/lib/spree/core/preferences/preferable.rb

@@ -123,7 +123,13 @@ module Spree::Preferences::Preferable
   def convert_preference_value(value, type, nullable: false)
     case type
     when :string, :text
-      value.to_s
+      # A nullable string keeps "unset" (nil / empty string) as nil so it can
+      # fall back to another value, instead of collapsing it to "".
+      if nullable && (value.nil? || (value.respond_to?(:empty?) && value.empty?))
+        nil
+      else
+        value.to_s
+      end
     when :password
       value.to_s
     when :decimal

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '5.6.0'.freeze
+  VERSION = '5.6.1'.freeze
 
   def self.version
     VERSION

data/lib/spree/permitted_attributes.rb

@@ -152,7 +152,11 @@ module Spree
 
     @@metafield_attributes = [:id, :value, :type, :metafield_definition_id, :_destroy]
 
-    @@metafield_definition_attributes = [:key, :name, :namespace, :metafield_type, :resource_type, :display_on]
+    @@metafield_definition_attributes = [
+      :key, :name, :namespace, :metafield_type, :resource_type, :display_on,
+      :searchable, :sortable
+    ]
+
 
     @@option_type_attributes = [:name, :presentation, :position, :filterable, :kind,
                                 option_values_attributes: [:id, :name, :presentation, :position, :color_code, :image, :_destroy]]

data/lib/spree/testing_support/factories/metafield_definition_factory.rb

@@ -6,6 +6,8 @@ FactoryBot.define do
     metafield_type { 'Spree::Metafields::ShortText' }
     resource_type { 'Spree::Product' }
     display_on { 'both' }
+    searchable { false }
+    sortable { false }
 
     trait :front_end_only do
       display_on { 'front_end' }
@@ -51,6 +53,14 @@ FactoryBot.define do
       name { 'Metadata' }
     end
 
+    trait :searchable do
+      searchable { true }
+    end
+
+    trait :sortable do
+      sortable { true }
+    end
+
     trait :for_variant do
       resource_type { 'Spree::Variant' }
       key { 'variant_custom' }

data/lib/tasks/product_tag_tenants.rake

@@ -14,11 +14,9 @@ namespace :spree do
     task backfill_product_tag_tenants: :environment do
       taggings = ActsAsTaggableOn::Tagging.arel_table.name
       products = Spree::Product.table_name
-
       updated = ActsAsTaggableOn::Tagging.
                 where(taggable_type: 'Spree::Product', tenant: nil).
-                joins("INNER JOIN #{products} ON #{products}.id = #{taggings}.taggable_id").
-                update_all("tenant = #{products}.store_id")
+                update_all("tenant = (SELECT store_id FROM #{products} WHERE #{products}.id = #{taggings}.taggable_id)")
 
       puts "  Backfilled tenant on #{updated} product tagging(s)."
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_core
 version: !ruby/object:Gem::Version
-  version: 5.6.0
+  version: 5.6.1
 platform: ruby
 authors:
 - Sean Schofield
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-23 00:00:00.000000000 Z
+date: 2026-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n-tasks
@@ -904,6 +904,7 @@ files:
 - app/models/concerns/spree/legacy_multi_store_support.rb
 - app/models/concerns/spree/memoized_data.rb
 - app/models/concerns/spree/metadata.rb
+- app/models/concerns/spree/metafield_filterable.rb
 - app/models/concerns/spree/metafields.rb
 - app/models/concerns/spree/multi_searchable.rb
 - app/models/concerns/spree/named_type.rb
@@ -1035,6 +1036,7 @@ files:
 - app/models/spree/market_country.rb
 - app/models/spree/metafield.rb
 - app/models/spree/metafield_definition.rb
+- app/models/spree/metafield_definition/search_capabilities.rb
 - app/models/spree/metafields/boolean.rb
 - app/models/spree/metafields/json.rb
 - app/models/spree/metafields/long_text.rb
@@ -1344,8 +1346,11 @@ files:
 - app/services/spree/prices/bulk_upsert.rb
 - app/services/spree/products/auto_match_taxons.rb
 - app/services/spree/products/duplicator.rb
+- app/services/spree/sample_data/helper.rb
+- app/services/spree/sample_data/import_builder.rb
 - app/services/spree/sample_data/import_runner.rb
 - app/services/spree/sample_data/loader.rb
+- app/services/spree/search_provider/metafield_schema.rb
 - app/services/spree/seeds/admin_user.rb
 - app/services/spree/seeds/all.rb
 - app/services/spree/seeds/allowed_origins.rb
@@ -1605,6 +1610,8 @@ files:
 - db/migrate/20260711000001_add_preferences_to_spree_exports.rb
 - db/migrate/20260719000001_add_channel_id_to_spree_api_keys.rb
 - db/migrate/20260721000001_add_unique_type_index_to_spree_order_routing_rules.rb
+- db/migrate/20260722000001_add_searchable_sortable_to_spree_metafield_definitions.rb
+- db/migrate/20260727000001_add_unique_country_abbr_index_to_spree_states.rb
 - db/sample_data/channels.rb
 - db/sample_data/customers.csv
 - db/sample_data/markets.rb
@@ -1868,9 +1875,9 @@ licenses:
 - BSD-3-Clause
 metadata:
   bug_tracker_uri: https://github.com/spree/spree/issues
-  changelog_uri: https://github.com/spree/spree/releases/tag/v5.6.0
+  changelog_uri: https://github.com/spree/spree/releases/tag/v5.6.1
   documentation_uri: https://docs.spreecommerce.org/
-  source_code_uri: https://github.com/spree/spree/tree/v5.6.0
+  source_code_uri: https://github.com/spree/spree/tree/v5.6.1
 post_install_message:
 rdoc_options: []
 require_paths: