spree_core 5.4.3 → 5.5.0.rc2

data/lib/tasks/core.rake

@@ -43,6 +43,7 @@ namespace :core do
           user_id: id,
           verified_at: updated_at,
           verification_token: nil,
+          store_id: Spree::Store.default&.id,
           updated_at: DateTime.current,
           created_at: DateTime.current
         }

data/lib/tasks/media.rake

@@ -16,5 +16,32 @@ namespace :spree do
 
       puts 'Done!'
     end
+
+    # Enqueues Spree::Media::MigrateProductAssetsJob for every product that
+    # still has at least one variant-pinned asset. The job is idempotent, so
+    # re-running this task is safe.
+    #
+    # ENV vars:
+    #   BATCH_SIZE — products fetched per scope batch (default: 500)
+    desc 'Enqueue jobs to migrate legacy variant-pinned images to product-level media (opt-in, 5.5)'
+    task migrate_master_images_to_product_media: :environment do
+      batch_size = ENV.fetch('BATCH_SIZE', 500).to_i
+      batch_size = 500 if batch_size < 1
+
+      # Subquery (not pluck) so the product set doesn't materialize in Ruby —
+      # important for catalogs with millions of products.
+      variant_product_ids = Spree::Variant
+                              .joins("INNER JOIN #{Spree::Asset.table_name} ON " \
+                                     "#{Spree::Asset.table_name}.viewable_id = #{Spree::Variant.table_name}.id " \
+                                     "AND #{Spree::Asset.table_name}.viewable_type = 'Spree::Variant'")
+                              .select(:product_id)
+
+      relation = Spree::Product.where(id: variant_product_ids)
+      relation.find_each(batch_size: batch_size) do |product|
+        Spree::Media::MigrateProductAssetsJob.perform_later(product.id)
+      end
+
+      puts "Enqueued migration jobs for #{relation.count} products on the #{Spree.queues.images} queue."
+    end
   end
 end

data/lib/tasks/products.rake

@@ -19,21 +19,19 @@ namespace :spree do
       puts "\nDone!"
     end
 
-    desc 'Enqueue background jobs to populate product metrics for all store products'
+    desc 'Enqueue background jobs to populate product metrics for every product'
     task populate_metrics: :environment do
       total_count = 0
 
-      Spree::StoreProduct.in_batches(of: 100) do |batch|
-        jobs = batch.pluck(:product_id, :store_id).map do |product_id, store_id|
-          Spree::Products::RefreshMetricsJob.new(product_id, store_id)
-        end
+      Spree::Product.in_batches(of: 100) do |batch|
+        jobs = batch.pluck(:id).map { |product_id| Spree::Products::RefreshMetricsJob.new(product_id) }
         ActiveJob.perform_all_later(jobs)
         total_count += jobs.size
         print '.'
       end
 
       if total_count.zero?
-        puts 'No store products found.'
+        puts 'No products found.'
       else
         puts "\nEnqueued #{total_count} jobs to refresh product metrics."
       end

data/lib/tasks/publications.rake

@@ -0,0 +1,60 @@
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Populates +spree_products.store_id+ and +spree_product_publications+ from the legacy
+      +spree_products_stores+ join. Idempotent — re-running skips products that
+      already have a +store_id+ and channels that already have a publication for
+      the product.
+
+      Run once after upgrading to Spree 5.5+. Multi-store merchants must install
+      +spree_multi_store+ before running; running on a multi-store catalog without
+      the extension picks the earliest +spree_products_stores+ row (by
+      +created_at+) as the product's home store.
+    DESC
+    task populate_publications: :environment do
+      unless ActiveRecord::Base.connection.table_exists?(Spree::StoreProduct.table_name)
+        puts "  #{Spree::StoreProduct.table_name} table not found — nothing to migrate."
+        next
+      end
+
+      batch_size = (ENV['BATCH_SIZE'] || 1_000).to_i
+      publications_created = 0
+
+      # Pass 1: per store, batch-publish products onto the store's default
+      # channel via +Channel#add_products+. One upsert + one touch_all per
+      # batch beats the previous per-product loop by orders of magnitude on
+      # large catalogs. +add_products+ is upsert-based with +on_duplicate:
+      # :skip+, so existing publications on re-run are no-ops.
+      Spree::Store.find_each do |store|
+        channel = store.default_channel
+        unless channel
+          puts "  Store '#{store.name}' has no default channel — skipping."
+          next
+        end
+
+        store_publications = 0
+        Spree::StoreProduct.where(store_id: store.id).in_batches(of: batch_size) do |batch|
+          store_publications += channel.add_products(batch.pluck(:product_id))
+        end
+
+        publications_created += store_publications
+        puts "  Store '#{store.name}': created #{store_publications} publication(s)" if store_publications.positive?
+      end
+
+      # Pass 2: assign +store_id+ on products that still don't have one,
+      # using the earliest legacy row per product.
+      products_processed = 0
+
+      Spree::Product.where(store_id: nil).find_each(batch_size: batch_size) do |product|
+        store_id = Spree::StoreProduct.where(product_id: product.id).order(:created_at).limit(1).pick(:store_id)
+        next unless store_id
+
+        product.update_column(:store_id, store_id)
+        products_processed += 1
+      end
+
+      puts "  Processed #{products_processed} products"
+      puts "  Created #{publications_created} publications"
+    end
+  end
+end

data/lib/tasks/upgrade.rake

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+# spree:upgrade — runs the data-backfill rake tasks shipped with the
+# currently-installed spree_core. Intended to run on production (or any
+# environment) after `bundle update` + `db:migrate` have already happened
+# in your deploy pipeline.
+#
+# Walks EVERY upgrade manifest whose `to` is ≤ the installed minor version,
+# in ascending order. So an app that's been on 5.3 and jumps straight to
+# 5.5 still gets the 5.3→5.4 data backfills before the 5.4→5.5 ones.
+# Every step in every manifest is required to be idempotent — re-running
+# the task on an already-upgraded app is a safe no-op.
+#
+# Usage:
+#   bundle exec rake spree:upgrade                 # walk all eligible manifests
+#   bundle exec rake spree:upgrade DRY_RUN=1       # print plan, run nothing
+#   bundle exec rake spree:upgrade STEP=channels   # run one step by id (any manifest)
+#   bundle exec rake spree:upgrade TO=5.4          # cap the walk at this version
+#
+# Manifests live alongside this file at lib/spree/upgrades/<from>_to_<to>/
+# manifest.yml and ship inside the spree_core gem.
+
+require 'yaml'
+
+namespace :spree do
+  desc 'Run the post-deploy upgrade tasks for the installed Spree version'
+  task upgrade: :environment do
+    Spree::Upgrade::Runner.new(
+      target_version: ENV['TO'],
+      step_id:        ENV['STEP'],
+      dry_run:        ENV['DRY_RUN'] == '1'
+    ).call
+  end
+end
+
+module Spree
+  module Upgrade
+    # Two-segment "5.5" form of the installed Spree version.
+    def self.installed_minor_version
+      Spree.version.split('.').first(2).join('.')
+    end
+
+    # Root directory containing N_M_to_O_P/manifest.yml files inside
+    # the spree_core gem.
+    def self.manifests_root
+      File.expand_path('../spree/upgrades', __dir__)
+    end
+
+    # All available manifest directories, parsed into { from:, to:, dir: }.
+    # Sorted by `to` ascending, with `from` as a tiebreaker (smallest first)
+    # for the rare case where two manifests share a `to` boundary.
+    def self.available_manifests
+      Dir.glob(File.join(manifests_root, '*_to_*')).filter_map do |dir|
+        name = File.basename(dir)
+        match = name.match(/\A([\d_]+)_to_([\d_]+)\z/)
+        next unless match
+
+        { from: match[1].tr('_', '.'), to: match[2].tr('_', '.'), dir: dir }
+      end.sort_by { |m| version_parts(m[:to]) + version_parts(m[:from]) }
+    end
+
+    def self.version_parts(v)
+      v.split('.').map { |s| Integer(s, 10) rescue 0 }
+    end
+
+    # Compare two dotted-version strings (returns -1, 0, +1).
+    def self.compare(a, b)
+      version_parts(a) <=> version_parts(b)
+    end
+
+    # The runner is a class (not a method) so individual concerns (selection,
+    # rendering, invocation) stay separable and the plan can be inspected
+    # without execution.
+    class Runner
+      attr_reader :target_version, :step_id, :dry_run, :target_explicit
+
+      def initialize(target_version: nil, step_id: nil, dry_run: false)
+        @target_explicit = !target_version.nil?
+        @target_version  = target_version || Spree::Upgrade.installed_minor_version
+        @step_id         = step_id
+        @dry_run         = dry_run
+      end
+
+      def call
+        manifests = eligible_manifests
+
+        if manifests.empty?
+          puts "  No upgrade manifests apply to Spree #{target_version} (installed: #{Spree::Upgrade.installed_minor_version})."
+          return
+        end
+
+        if step_id
+          run_single_step(manifests)
+        else
+          run_full_walk(manifests)
+        end
+      end
+
+      private
+
+      # In plan-mode without explicit TO, show manifests ahead of the installed
+      # version — the path the operator is about to walk. Otherwise filter to
+      # manifests whose `to` is ≤ target.
+      def eligible_manifests
+        Spree::Upgrade.available_manifests
+          .select { |manifest| manifest_eligible?(manifest) }
+          .map { |entry| load_manifest_yaml(entry) }
+      end
+
+      def manifest_eligible?(manifest)
+        if dry_run && !target_explicit
+          Spree::Upgrade.compare(manifest[:from], Spree::Upgrade.installed_minor_version) >= 0
+        else
+          Spree::Upgrade.compare(manifest[:to], target_version) <= 0
+        end
+      end
+
+      def load_manifest_yaml(entry)
+        YAML.safe_load_file(File.join(entry[:dir], 'manifest.yml'))
+      end
+
+      def run_full_walk(manifests)
+        total_steps = manifests.sum { |m| m['steps'].size }
+        reported_target = if dry_run && !target_explicit
+                            manifests.map { |m| m['to'] }.compact.max_by { |v| Spree::Upgrade.version_parts(v) } || target_version
+                          else
+                            target_version
+                          end
+        puts
+        puts "  Walking #{manifests.size} manifest(s), #{total_steps} step(s) total. Target: Spree #{reported_target}."
+
+        manifests.each do |manifest|
+          print_manifest_header(manifest)
+          manifest['steps'].each_with_index do |step, i|
+            print_step(step, i + 1, manifest['steps'].size)
+            unless dry_run
+              invoke(step)
+              print_step_complete(step)
+            end
+          end
+        end
+
+        puts
+        puts dry_run ? '  (dry run — nothing executed)' : '  Upgrade tasks complete.'
+      end
+
+      # STEP=<id> looks across every eligible manifest; we need exactly one
+      # match. Multiple matches are likely a manifest bug (two manifests
+      # referencing the same step id) but we surface it rather than picking
+      # silently.
+      def run_single_step(manifests)
+        matches = manifests.flat_map do |manifest|
+          manifest['steps'].select { |s| s['id'] == step_id }.map { |s| [manifest, s] }
+        end
+
+        if matches.empty?
+          available = manifests.flat_map { |m| m['steps'] }.map { |s| s['id'] }.uniq.join(', ')
+          abort "  No step with id '#{step_id}' in any eligible manifest. Available: #{available}"
+        elsif matches.size > 1
+          locations = matches.map { |m, _| "#{m['from']} → #{m['to']}" }.join(', ')
+          abort "  Step id '#{step_id}' is ambiguous — defined in: #{locations}. Pass TO=<version> to narrow."
+        end
+
+        manifest, step = matches.first
+        print_manifest_header(manifest)
+        print_step(step, 1, 1)
+        unless dry_run
+          invoke(step)
+          print_step_complete(step)
+        end
+
+        puts
+        puts dry_run ? '  (dry run — nothing executed)' : "  Step '#{step_id}' complete."
+      end
+
+      def print_manifest_header(manifest)
+        puts
+        puts "  ── Spree #{manifest['from']} → #{manifest['to']} ──"
+        puts "  Docs: #{manifest['docs']}" if manifest['docs']
+      end
+
+      def print_step(step, index, total)
+        puts
+        puts "  Step #{index}/#{total} [#{step['id']}]"
+        puts "    #{step['name']}"
+        puts "    > bin/rake #{step['task']}"
+        return unless step['notes']
+
+        step['notes'].each_line { |line| puts "    #{line.chomp}" }
+      end
+
+      def print_step_complete(step)
+        puts "    ✓ #{step['task']} done."
+      end
+
+      def invoke(step)
+        task = step.fetch('task')
+        puts "    Running #{task}..."
+
+        # Rake caches invoked tasks in-process; explicit reenable lets a
+        # single `rake spree:upgrade` run re-invoke aggregators that share
+        # subtasks across multiple manifests (e.g. two manifests both
+        # depending on `spree:install:migrations` would otherwise only
+        # invoke it once).
+        rake_task = Rake::Task[task]
+        rake_task.reenable
+        rake_task.invoke
+      end
+    end
+  end
+end