spree_core 5.5.3 → 5.6.0.rc2

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

@@ -5,7 +5,7 @@ FactoryBot.define do
     state         { 'checkout' }
     response_code { "BGS-#{SecureRandom.hex(6)}" }
 
-    payment_method { create(:credit_card_payment_method, stores: [order.store]) }
+    payment_method { create(:credit_card_payment_method, store: order.store) }
     association(:source, factory: :credit_card)
 
     factory :payment_with_refund do
@@ -16,7 +16,7 @@ FactoryBot.define do
     end
 
     factory :custom_payment, class: Spree::Payment do
-      payment_method { create(:custom_payment_method, stores: [order.store]) }
+      payment_method { create(:custom_payment_method, store: order.store) }
       source { create(:payment_source, user: order.user, payment_method: payment_method) }
     end
   end
@@ -29,7 +29,7 @@ FactoryBot.define do
   end
 
   factory :store_credit_payment, class: Spree::Payment, parent: :payment do
-    payment_method { create(:store_credit_payment_method, stores: [order.store]) }
+    payment_method { create(:store_credit_payment_method, store: order.store) }
     source { create(:store_credit, store: order.store, user: order.user) }
   end
 end

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

@@ -2,15 +2,7 @@ FactoryBot.define do
   factory :payment_method, class: Spree::PaymentMethod do
     type { 'Spree::PaymentMethod' }
     name { 'Test' }
-
-    before(:create) do |payment_method|
-      if payment_method.stores.empty?
-        default_store = Spree::Store.default.persisted? ? Spree::Store.default : nil
-        store = default_store || create(:store)
-
-        payment_method.stores << store
-      end
-    end
+    store { Spree::Store.find_by(default: true) || association(:store) }
   end
 
   factory :check_payment_method, parent: :payment_method, class: Spree::PaymentMethod::Check do

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

@@ -1,7 +1,7 @@
 FactoryBot.define do
   factory :payment_session, class: 'Spree::PaymentSession' do
     order
-    payment_method { create(:credit_card_payment_method, stores: [order.store]) }
+    payment_method { create(:credit_card_payment_method, store: order.store) }
     amount { order.total }
     currency { order.currency }
     status { 'pending' }
@@ -39,7 +39,7 @@ FactoryBot.define do
 
     factory :bogus_payment_session, class: 'Spree::PaymentSessions::Bogus' do
       type { 'Spree::PaymentSessions::Bogus' }
-      payment_method { create(:bogus_payment_method, stores: [order.store]) }
+      payment_method { create(:bogus_payment_method, store: order.store) }
       external_id { "bogus_#{SecureRandom.hex(12)}" }
       external_data { { 'client_secret' => "bogus_secret_#{SecureRandom.hex(8)}" } }
     end

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

@@ -17,19 +17,11 @@ FactoryBot.define do
 
   factory :promotion, class: Spree::Promotion do
     name { 'Promo' }
+    store { Spree::Store.find_by(default: true) || association(:store) }
     sequence :code do |n|
       "CODE-#{n}"
     end
 
-    before(:create) do |promotion, _evaluator|
-      if promotion.stores.empty?
-        default_store = Spree::Store.default.persisted? ? Spree::Store.default : nil
-        store = default_store || create(:store)
-
-        promotion.stores << [store]
-      end
-    end
-
     trait :with_line_item_adjustment do
       transient do
         adjustment_rate { 10 }

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

@@ -30,4 +30,28 @@ FactoryBot.define do
       customer_group_ids { [] }
     end
   end
+
+  factory :promotion_rule_channel, class: Spree::Promotion::Rules::Channel do
+    association :promotion
+
+    after(:build) do |rule, evaluator|
+      rule.preferred_channel_ids = evaluator.channel_ids if evaluator.respond_to?(:channel_ids)
+    end
+
+    transient do
+      channel_ids { [] }
+    end
+  end
+
+  factory :promotion_rule_market, class: Spree::Promotion::Rules::Market do
+    association :promotion
+
+    after(:build) do |rule, evaluator|
+      rule.preferred_market_ids = evaluator.market_ids if evaluator.respond_to?(:market_ids)
+    end
+
+    transient do
+      market_ids { [] }
+    end
+  end
 end

data/lib/spree/translations.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Spree
+  # Builds the admin translation matrix, field-discovery metadata, and the
+  # public translatable-resource registry for records in
+  # +Spree.translatable_resources+. Stateless helper shared by the dedicated
+  # translations endpoint, the +?expand=translations+ serializer attribute, the
+  # batch write controller, and the discovery endpoint.
+  module Translations
+    module_function
+
+    # @return [Hash{String=>Hash}] locale => { field => value, "translated_field_count" => Integer }
+    def matrix_for(record, locales: nil)
+      fields = field_keys(record)
+      locales ||= non_default_locales(record)
+
+      locales.index_with do |locale|
+        translated = field_values(record, locale, fields)
+        translated.merge('translated_field_count' => translated.count { |_k, v| v.present? })
+      end
+    end
+
+    # @return [Array<Hash>] [{ "key" => "name", "type" => "string", "source" => "Espresso Machine" }, ...]
+    def fields_for(record)
+      Mobility.with_locale(default_locale(record)) do
+        field_keys(record).map do |field|
+          { 'key' => field, 'type' => field_type(record.class, field), 'source' => record.public_send(field) }
+        end
+      end
+    end
+
+    # @return [Array<Hash>] registry made public: [{ "resource_type" => "product", "fields" => [{key,type}] }]
+    def registry
+      Spree.translatable_resources.map do |klass|
+        {
+          'resource_type' => public_resource_type(klass),
+          'fields' => klass.public_translatable_fields.map { |f| { 'key' => f.to_s, 'type' => field_type(klass, f) } }
+        }
+      end
+    end
+
+    # @return [String] underscored, demodulized model name (e.g. "option_type")
+    def resource_type(klass)
+      klass.name.demodulize.underscore
+    end
+
+    # The PUBLIC resource-type token used in read (document/registry) and
+    # write (batch) payloads. Taxon is exposed as "category" (routes use the
+    # 5.5 rename) while the model element stays "taxon"; this keeps the read
+    # and write contracts consistent.
+    #
+    # @return [String]
+    def public_resource_type(klass)
+      return 'category' if klass <= Spree::Taxon
+
+      resource_type(klass)
+    end
+
+    # Inverse of +public_resource_type+: maps a public token to its
+    # registered translatable class, or nil if not translatable.
+    #
+    # @param token [String, Symbol] e.g. "product", "option_value", "category"
+    # @return [Class, nil]
+    def resource_class(token)
+      # Recomputed per call (not memoized) so a dev-mode class reload of a
+      # registry member doesn't leave a stale class reference behind.
+      map = Spree.translatable_resources.index_by { |klass| public_resource_type(klass) }
+      map[token.to_s]
+    end
+
+    # The editor type for a translatable field: +html+ when the model declares
+    # it as rich text (drives a rich-text editor in the SPA), else +string+.
+    # @param klass [Class] a translatable model
+    # @param field [String, Symbol] public field name
+    # @return [String]
+    def field_type(klass, field)
+      klass.translatable_rich_text_fields.map(&:to_sym).include?(field.to_sym) ? 'html' : 'string'
+    end
+
+    # Public field names, so the matrix read/write keys match the serializer
+    # (e.g. OptionType exposes `label`, not the internal `presentation`).
+    def field_keys(record)
+      record.class.public_translatable_fields.map(&:to_s)
+    end
+    private_class_method :field_keys
+
+    def field_values(record, locale, fields)
+      Mobility.with_locale(locale) do
+        fields.index_with do |field|
+          # fallback: false so an absent translation reads as nil, not the source value
+          record.public_send(field, fallback: false)
+        rescue ArgumentError
+          # fields without a Mobility reader signature still respond to the bare getter
+          record.public_send(field)
+        end
+      end
+    end
+    private_class_method :field_values
+
+    def default_locale(record)
+      record.translatable_store&.default_locale || I18n.default_locale.to_s
+    end
+    private_class_method :default_locale
+
+    def non_default_locales(record)
+      store = record.translatable_store
+      return [] unless store
+
+      (store.supported_locales_list - [store.default_locale]).sort
+    end
+    private_class_method :non_default_locales
+  end
+end

data/lib/spree/upgrades/5_5_to_5_6/manifest.yml

@@ -0,0 +1,59 @@
+# Spree 5.5 → 5.6 upgrade manifest.
+#
+# Lists ONLY the version-specific rake tasks that perform data backfills.
+# Universal upgrade steps (bundle update, db:migrate, scheduling cron jobs,
+# reviewing breaking changes) are NOT in this file:
+#
+#   - `bundle update` + `db:migrate` are handled by your deploy pipeline
+#     (Heroku release phase, K8s init container, Render auto-migrate,
+#     Capistrano deploy hook, etc.) and by the @spree/cli's `spree upgrade`
+#     wrapper for local development.
+#   - Cron scheduling, optional tunings, and human-readable behavior changes
+#     live in the upgrade doc at docs/developer/upgrades/5.5-to-5.6.mdx.
+#
+# This manifest is the machine-runnable shape — what `bin/rake spree:upgrade`
+# (in production) and `spree upgrade` (in dev) execute. Every step must be a
+# rake task and must be idempotent. Re-running the full manifest is safe.
+---
+from: "5.5"
+to: "5.6"
+docs: "https://spreecommerce.org/docs/developer/upgrades/5.5-to-5.6"
+
+steps:
+  - id: role_user_store_ids
+    name: "Backfill store_id on role assignments"
+    task: "spree:role_users:backfill_store_ids"
+    notes: |
+      Sets spree_role_users.store_id from the store resource so Spree::Ability
+      resolves roles by store. Store-scoped assignments only; extensions (e.g.
+      spree_multi_vendor) backfill their own resource types. Store admins stay
+      authorized via the spree_admin? fallback until this runs.
+
+  - id: single_store_promotions_payment_methods
+    name: "Backfill store_id on promotions and payment methods"
+    task: "spree:upgrade:populate_single_store_associations"
+    notes: |
+      Sets store_id on Spree::Promotion and Spree::PaymentMethod from the legacy
+      spree_promotions_stores / spree_payment_methods_stores join tables. Until
+      this runs, migrated rows have a NULL store_id and are hidden from
+      store-scoped lookups (and unavailable at checkout), so run it right after
+      db:migrate. Records shared across stores keep one owner (promotions:
+      earliest then lowest store_id; payment methods: lowest store_id) unless
+      spree_multi_store is installed.
+
+  - id: taxon_store_id
+    name: "Backfill store_id on taxons"
+    task: "spree:taxons:backfill_store_id"
+    notes: |
+      Sets spree_taxons.store_id from each taxon's taxonomy, then resolves
+      taxonomy-less rows through their parent chain. Until this runs, existing
+      taxons keep resolving their store via the taxonomy join (Taxon.for_store
+      fallback); taxonomy-less categories (Spree::Category) rely on the direct
+      store_id, so the backfill is required for them.
+
+  - id: taxon_products_count
+    name: "Backfill products_count on taxons"
+    task: "spree:taxons:backfill_products_count"
+    notes: |
+      Recomputes the descendant-inclusive products_count counter cache on every
+      taxon in batches.

data/lib/tasks/role_users.rake

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+namespace :spree do
+  namespace :role_users do
+    desc <<~DESC
+      Backfills +spree_role_users.store_id+ for store-scoped role assignments
+      (resource_type = 'Spree::Store') by copying +resource_id+. Idempotent —
+      only rows with a null +store_id+ are touched.
+
+      Role resolution (Spree::Ability) scopes by +store_id+, so run this after
+      adding the column. Until it does, the +spree_admin?+ fallback keeps store
+      admins authorized. Role assignments on non-store resources (e.g.
+      Spree::Vendor) are backfilled by the owning extension.
+    DESC
+    task backfill_store_ids: :environment do
+      count = Spree::RoleUser.where(resource_type: Spree::Store.name, store_id: nil)
+                             .update_all('store_id = resource_id')
+      puts "  Backfilled store_id on #{count} store-scoped role assignment(s)."
+    end
+  end
+end

data/lib/tasks/single_store_associations.rake

@@ -0,0 +1,65 @@
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Populates +spree_promotions.store_id+ and +spree_payment_methods.store_id+
+      from the legacy +spree_promotions_stores+ / +spree_payment_methods_stores+
+      join tables. Idempotent — re-running skips records that already have a
+      +store_id+.
+
+      Run once after upgrading to Spree 5.6+. Multi-store merchants must install
+      +spree_multi_store+ before running; without it, a record shared across
+      several stores keeps only one owner (promotions: the earliest
+      +spree_promotions_stores+ row by +created_at+; payment methods: the lowest
+      +store_id+, since that join has no timestamps) and the other stores lose
+      the shared record. Each shared record is logged so the loss is visible.
+    DESC
+    task populate_single_store_associations: :environment do
+      shared = Hash.new(0)
+
+      if ActiveRecord::Base.connection.table_exists?(Spree::StorePromotion.table_name)
+        Spree::Promotion.where(store_id: nil).find_each do |promotion|
+          store_ids = Spree::StorePromotion.where(promotion_id: promotion.id).order(:created_at, :store_id).pluck(:store_id)
+          next if store_ids.empty?
+
+          if store_ids.size > 1
+            shared[:promotions] += 1
+            Spree::Deprecation.warn(
+              "Promotion #{promotion.id} was shared across #{store_ids.size} stores; " \
+              "assigning it to store #{store_ids.first}. Install spree_multi_store to keep sharing."
+            )
+          end
+
+          promotion.update_column(:store_id, store_ids.first)
+        end
+      else
+        puts "  #{Spree::StorePromotion.table_name} table not found — skipping promotions."
+      end
+
+      if ActiveRecord::Base.connection.table_exists?(Spree::StorePaymentMethod.table_name)
+        # +with_deleted+: PaymentMethod is paranoid, so soft-deleted rows would
+        # otherwise be skipped and keep a NULL store_id.
+        Spree::PaymentMethod.with_deleted.where(store_id: nil).find_each do |payment_method|
+          store_ids = Spree::StorePaymentMethod.where(payment_method_id: payment_method.id).order(:store_id).pluck(:store_id)
+          next if store_ids.empty?
+
+          if store_ids.size > 1
+            shared[:payment_methods] += 1
+            Spree::Deprecation.warn(
+              "PaymentMethod #{payment_method.id} was shared across #{store_ids.size} stores; " \
+              "assigning it to store #{store_ids.first}. Install spree_multi_store to keep sharing."
+            )
+          end
+
+          payment_method.update_column(:store_id, store_ids.first)
+        end
+      else
+        puts "  #{Spree::StorePaymentMethod.table_name} table not found — skipping payment methods."
+      end
+
+      if shared.values.sum.positive?
+        puts "  #{shared[:promotions]} promotion(s) and #{shared[:payment_methods]} payment method(s) " \
+             "were shared across stores — only the owner store keeps them unless spree_multi_store is installed."
+      end
+    end
+  end
+end

data/lib/tasks/taxons.rake

@@ -1,6 +1,64 @@
 namespace :spree do
   namespace :taxons do
-    desc 'Reset counter caches (children_count, classification_count) on taxons'
+    desc 'Backfill spree_taxons.store_id from each taxon\'s taxonomy (or parent)'
+    task backfill_store_id: :environment do |_t, _args|
+      puts 'Backfilling taxon store_id from taxonomy...'
+
+      # Resolve per-taxonomy and update by id — never reference a joined table in
+      # an update_all SET clause. It is not portable: on some adapter / Rails
+      # version combinations (e.g. Rails 7.2 on PostgreSQL) update_all-with-join
+      # is rewritten to `... WHERE id IN (subquery)`, leaving the joined alias out
+      # of scope in the SET and raising PG::UndefinedTable ("missing FROM-clause
+      # entry"). It fails at parse time, even when no rows need changing.
+      Spree::Taxonomy.where.not(store_id: nil).find_each do |taxonomy|
+        Spree::Taxon.unscoped.where(store_id: nil, taxonomy_id: taxonomy.id).
+          in_batches(of: 1000).update_all(store_id: taxonomy.store_id)
+        print '.'
+      end
+
+      puts "\nResolving taxonomy-less taxons through the parent chain..."
+
+      # Mirror Spree::Taxon#ensure_store: taxonomy-less rows inherit their parent's
+      # store. Loop so a chain of unbackfilled ancestors resolves top-down — each
+      # pass pushes an already-resolved parent's store onto its children.
+      loop do
+        updated = 0
+
+        # Resolved parents that still have children missing a store form the
+        # frontier; push each store down in one UPDATE per (store, id batch).
+        frontier = Spree::Taxon.unscoped.where.not(store_id: nil).
+                   where(id: Spree::Taxon.unscoped.where(store_id: nil).select(:parent_id))
+        frontier.pluck(:id, :store_id).group_by(&:last).each do |store_id, rows|
+          rows.map(&:first).each_slice(1000) do |parent_ids|
+            updated += Spree::Taxon.unscoped.where(store_id: nil, parent_id: parent_ids).
+                       update_all(store_id: store_id)
+          end
+        end
+
+        print '.'
+        break if updated.zero?
+      end
+
+      puts "\nDone!"
+    end
+
+    # Recomputes the descendant-inclusive products_count for every taxon, in
+    # batches. Shared by the dedicated task and reset_counter_caches.
+    backfill_products_count = lambda do
+      Spree::Taxon.unscoped.in_batches(of: 1000) do |batch|
+        Spree::Taxon.recalculate_products_count(batch.pluck(:id))
+        print '.'
+      end
+    end
+
+    desc 'Backfill the descendant-inclusive products_count on every taxon'
+    task backfill_products_count: :environment do |_t, _args|
+      puts 'Backfilling taxon products_count...'
+      backfill_products_count.call
+      puts "\nDone!"
+    end
+
+    desc 'Reset counter caches (children_count, classification_count, products_count) on taxons'
     task reset_counter_caches: :environment do |_t, _args|
       puts 'Resetting taxon counter caches...'
 
@@ -13,6 +71,9 @@ namespace :spree do
         print '.'
       end
 
+      puts "\nRecomputing products_count..."
+      backfill_products_count.call
+
       puts "\nDone!"
     end
   end