spree_core 5.6.1 → 6.0.0.beta2

data/lib/tasks/backfill_media_store_ids.rake

@@ -0,0 +1,70 @@
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Assigns a store to every media row (Spree 6.0). Idempotent — rows that
+      already carry a store_id are skipped, so an interrupted run resumes for
+      free.
+
+      Media used to reach its store through its viewable. The media library
+      breaks that chain: a file uploaded before anyone has decided where it
+      goes has no viewable to ask, so the store moved onto the row itself.
+
+      Rows are matched to their product's store. Anything left unowned —
+      media whose viewable was deleted out from under it — goes to the default
+      store, since a row with no store is invisible to every library query and
+      would otherwise sit in storage with no way to find or delete it.
+
+      Run this AFTER spree:media:migrate_master_images_to_product_media and let
+      its jobs drain: that step moves media between viewables, and a row
+      re-homed afterwards would keep the store stamped here.
+    DESC
+    task backfill_media_store_ids: :environment do
+      store = Spree::Store.default
+      abort '  No default store found — create a store first.' if store.nil?
+
+      media_table = Spree::Media.table_name
+      products_table = Spree::Product.table_name
+      variants_table = Spree::Variant.table_name
+
+      # Set-based updates rather than row-by-row: a catalog's media table is
+      # one of the largest in the schema, and both answers are a single join
+      # away in the database already.
+      from_products = Spree::Media.connection.update(<<~SQL.squish)
+        UPDATE #{media_table}
+        SET store_id = (
+          SELECT store_id FROM #{products_table}
+          WHERE #{products_table}.id = #{media_table}.viewable_id
+        )
+        WHERE store_id IS NULL
+          AND viewable_type = 'Spree::Product'
+          AND EXISTS (
+            SELECT 1 FROM #{products_table}
+            WHERE #{products_table}.id = #{media_table}.viewable_id
+          )
+      SQL
+
+      from_variants = Spree::Media.connection.update(<<~SQL.squish)
+        UPDATE #{media_table}
+        SET store_id = (
+          SELECT #{products_table}.store_id
+          FROM #{variants_table}
+          INNER JOIN #{products_table} ON #{products_table}.id = #{variants_table}.product_id
+          WHERE #{variants_table}.id = #{media_table}.viewable_id
+        )
+        WHERE store_id IS NULL
+          AND viewable_type = 'Spree::Variant'
+          AND EXISTS (
+            SELECT 1 FROM #{variants_table}
+            INNER JOIN #{products_table} ON #{products_table}.id = #{variants_table}.product_id
+            WHERE #{variants_table}.id = #{media_table}.viewable_id
+          )
+      SQL
+
+      orphaned = Spree::Media.unscoped.where(store_id: nil).update_all(store_id: store.id)
+
+      puts "  Assigned #{from_products} product media row(s) and #{from_variants} variant media row(s) " \
+           'from their product.'
+      puts "  Assigned #{orphaned} unowned media row(s) to store #{store.name} (#{store.id})."
+    end
+  end
+end

data/lib/tasks/backfill_reason_store_ids.rake

@@ -0,0 +1,28 @@
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Assigns the default store to return and refund reasons that predate
+      their store binding (Spree 6.0). Idempotent — rows that already carry a
+      store_id are skipped.
+
+      The rename migration already backfills and then enforces NOT NULL, so
+      this is a safety net rather than the primary path: it covers installs
+      whose migration ran before any store existed, leaving rows unowned and
+      the constraint unapplied. Running it on an already-migrated store is a
+      no-op.
+
+      Claim reasons need no backfill — the table is new in 6.0 and its rows
+      are born with a store.
+    DESC
+    task backfill_reason_store_ids: :environment do
+      store = Spree::Store.default
+      abort '  No default store found — create a store first.' if store.nil?
+
+      return_reasons = Spree::ReturnReason.where(store_id: nil).update_all(store_id: store.id)
+      refund_reasons = Spree::RefundReason.where(store_id: nil).update_all(store_id: store.id)
+
+      puts "  Assigned #{return_reasons} return reason(s) and #{refund_reasons} refund reason(s) " \
+           "to store #{store.name} (#{store.id})."
+    end
+  end
+end

data/lib/tasks/capture_methods_migration.rake

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0 conversion of the per-payment-method auto_capture boolean onto the
+# capture_method vocabulary (docs/plans/6.0-store-scoped-configuration.md).
+# Idempotent — it only writes rows whose capture_method is still empty, so a
+# second run finds nothing to do and an interrupted run resumes for free.
+namespace :spree do
+  desc 'Convert payment method auto_capture booleans into capture_method values'
+  task migrate_capture_methods: :environment do
+    batch_size = ENV.fetch('BATCH_SIZE', 5_000).to_i
+    say = ->(message) { puts message }
+
+    payment_methods = Spree::PaymentMethod.unscoped.where(capture_method: nil)
+
+    # A method that captured on authorization charges at checkout. One that did
+    # not only recorded "not at checkout" — the old column could not say
+    # whether dispatch or staff was meant to take the money, and the store's
+    # own setting is what decided. Leaving those rows empty is what makes them
+    # keep inheriting it, so only the true case is written here.
+    count = payment_methods.where(auto_capture: true).
+            in_batches(of: batch_size).
+            update_all(capture_method: 'checkout')
+    say.call "spree_payment_methods.capture_method: #{count} rows auto_capture → checkout"
+
+    remaining = Spree::PaymentMethod.unscoped.where(capture_method: nil, auto_capture: false).count
+    say.call "spree_payment_methods.capture_method: #{remaining} rows left inheriting the store setting"
+
+    say.call 'migrate_capture_methods done.'
+  end
+end

data/lib/tasks/carts_migration.rake

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0: convert incomplete orders into Spree::Cart rows
+# (docs/plans/6.0-cart-order-split.md, Wave 7 — the last flip).
+#
+# Every order that never completed and was never canceled becomes a cart with
+# the same token/binding; its money and checkout records are re-owned
+# (cart_id set, order_id nulled) and the hollow order row is deleted.
+# Completed and canceled orders are untouched (their cart_id stays nil).
+# Orders holding payment sessions convert last so an interrupted run leaves
+# the riskiest rows for the retry. Idempotent — converted orders are gone.
+namespace :spree do
+  desc 'Detach cart-phase fulfillment items from orders they never belonged to'
+  # Early 6.0 builds wrote the cart's id into fulfillment_items.order_id during
+  # checkout, silently linking the item to whichever order shared that id.
+  # Cart-phase items carry no order — completion stamps the real one onto the
+  # copied rows. Idempotent.
+  task repair_cart_fulfillment_item_orders: :environment do
+    count = Spree::FulfillmentItem.
+            where.not(order_id: nil).
+            where(fulfillment_id: Spree::Fulfillment.where.not(cart_id: nil).select(:id)).
+            update_all(order_id: nil)
+    puts "spree_fulfillment_items: #{count} cart-phase rows detached from orders"
+  end
+
+  desc 'Convert incomplete legacy orders into Spree::Cart rows'
+  task migrate_incomplete_orders_to_carts: :environment do
+    batch_size = ENV.fetch('BATCH_SIZE', 250).to_i
+    stats = Hash.new(0)
+
+    # spree_state_changes has no model anymore (removed in 6.0; the table
+    # survives until 6.1 as legacy data), so read it anonymously.
+    state_changes = Class.new(ActiveRecord::Base) { self.table_name = 'spree_state_changes' }
+
+    incomplete = Spree::Order.unscoped.where(completed_at: nil, canceled_at: nil)
+    with_sessions_ids = incomplete.joins(:payment_sessions).distinct.ids
+    plain_ids = incomplete.where.not(id: with_sessions_ids).ids
+
+    puts "#{plain_ids.size} incomplete orders to convert (+#{with_sessions_ids.size} with payment sessions, converted last)"
+
+    convert = lambda do |order|
+      ActiveRecord::Base.transaction do
+        cart = Spree::Cart.new(
+          store_id: order.store_id,
+          token: order.token,
+          email: order.email,
+          currency: order.currency,
+          locale: order.locale,
+          customer_id: order.user_id,
+          market_id: order.market_id,
+          channel_id: order.channel_id,
+          ship_address_id: order.ship_address_id,
+          bill_address_id: order.bill_address_id,
+          accept_marketing: order.accept_marketing,
+          customer_note: order.customer_note,
+          last_ip_address: order.last_ip_address,
+          gift_card_id: order.gift_card_id,
+          metadata: order.metadata,
+          item_total: order.item_total,
+          total_quantity: order.total_quantity,
+          adjustment_total: order.adjustment_total,
+          included_tax_total: order.included_tax_total,
+          additional_tax_total: order.additional_tax_total,
+          taxable_adjustment_total: order.taxable_adjustment_total,
+          non_taxable_adjustment_total: order.non_taxable_adjustment_total,
+          discount_total: order.discount_total,
+          fee_total: order.fee_total,
+          delivery_total: order.delivery_total,
+          payment_total: order.payment_total,
+          total: order.total
+        )
+        cart.preferred_stock_location_id = order.preferred_stock_location_id if order.preferred_stock_location_id.present?
+        # save!(validate: false) skips before_validation, so resolve the now
+        # mandatory market/channel explicitly (legacy rows may have neither).
+        cart.send(:ensure_market_presence)
+        cart.send(:ensure_channel_presence)
+        cart.save!(validate: false)
+        cart.update_columns(created_at: order.created_at, updated_at: order.updated_at)
+
+        # Re-own every dual-FK record. Money records move, never copy.
+        [
+          Spree::LineItem, Spree::Fulfillment, Spree::Payment, Spree::PaymentSession,
+          Spree::StockReservation, Spree::CouponCode, Spree::OrderPromotion,
+          Spree::TaxLine, Spree::Discount, Spree::Fee
+        ].each do |klass|
+          klass.unscoped.where(order_id: order.id).update_all(cart_id: cart.id, order_id: nil)
+        end
+
+        # Order-owned support rows that don't survive the conversion: the
+        # order row must go, and these reference it without a cart leg.
+        Spree::FulfillmentItem.unscoped.where(order_id: order.id).update_all(order_id: nil)
+        state_changes.where(stateful_type: 'Spree::Order', stateful_id: order.id).delete_all
+
+        order.delete
+        stats[:converted] += 1
+      end
+    rescue StandardError => e
+      stats[:errored] += 1
+      puts "ERROR order #{order.number}: #{e.class} #{e.message}"
+    end
+
+    [plain_ids, with_sessions_ids].each do |ids|
+      ids.each_slice(batch_size) do |slice|
+        Spree::Order.unscoped.where(id: slice).each { |order| convert.call(order) }
+        print '.'
+      end
+    end
+
+    puts
+    stats.each { |key, value| puts "#{key}: #{value}" }
+    puts 'migrate_incomplete_orders_to_carts done.'
+  end
+end

data/lib/tasks/categories_and_collections.rake

@@ -0,0 +1,188 @@
+require 'spree/category_permalink_deduplicator'
+
+namespace :spree do
+  # Migrates rule-based (automatic) categories to Spree::Collection and rewrites the
+  # class-name strings that Phase 3 renamed. Idempotent (each automatic category is
+  # migrated + deleted in its own transaction, so a re-run skips what's already gone;
+  # the string backfills only touch rows still holding the old names). Run AFTER
+  # spree:taxons:backfill_store_id so every category has a store.
+  desc 'Migrate automatic taxons to Collections and backfill renamed class-name strings (6.0)'
+  task migrate_taxons_to_categories_and_collections: :environment do
+    # Polymorphic/STI rows on a category can hold either the pre-6.0 name or the
+    # post-Phase-3 name, depending on whether they were touched between deploy and
+    # this run — match both when moving a category's rows onto its new collection.
+    category_type_strings = ['Spree::Taxon', 'Spree::Category'].freeze
+
+    move_polymorphic = lambda do |klass, type_col, id_col, category, collection, extra = {}|
+      klass.where(extra.merge(type_col => category_type_strings, id_col => category.id)).
+        update_all(type_col => 'Spree::Collection', id_col => collection.id)
+    end
+
+    automatic_ids = Spree::Category.unscoped.where(automatic: true).ids
+    automatic_ids |= Spree::TaxonRule.distinct.pluck(:taxon_id) if defined?(Spree::TaxonRule)
+    automatic_ids.compact!
+
+    puts "Migrating #{automatic_ids.size} automatic categories to collections..."
+    migrated = 0
+    skipped = 0
+    failed = 0
+
+    Spree::Category.unscoped.where(id: automatic_ids).find_each do |category|
+      store_id = category.store_id || category.store&.id
+
+      if store_id.nil?
+        warn "  skip category ##{category.id} (#{category[:name].inspect}): no store"
+        skipped += 1
+        next
+      end
+
+      # Automatic categories are rule-based leaves; refuse to destroy a subtree.
+      if category.children.exists?
+        warn "  skip category ##{category.id} (#{category[:name].inspect}): has child categories"
+        skipped += 1
+        next
+      end
+
+      begin
+        ApplicationRecord.transaction do
+          collection = Spree::Collection.new(
+            name: category[:name],
+            permalink: category[:permalink],
+            automatic: true,
+            rules_match_policy: category.rules_match_policy,
+            sort_order: category.sort_order,
+            position: category.position,
+            store_id: store_id,
+            meta_title: category[:meta_title],
+            meta_description: category[:meta_description],
+            meta_keywords: category[:meta_keywords],
+            metadata: category.metadata
+          )
+          # Membership is copied verbatim below, so don't rebuild it from the rules.
+          collection.marked_for_regenerate_products = false
+          collection.save!(validate: false)
+
+          # Table-backend translations (collection_translations has no pretty_name;
+          # description is ActionText, moved separately below).
+          Spree::Category::Translation.where(spree_category_id: category.id).find_each do |translation|
+            Spree::Collection::Translation.create!(
+              spree_collection_id: collection.id,
+              locale: translation.locale,
+              name: translation.name,
+              permalink: translation.permalink,
+              meta_title: translation.meta_title,
+              meta_description: translation.meta_description,
+              meta_keywords: translation.meta_keywords
+            )
+          end
+
+          # Move (not copy) the polymorphic records that `category.destroy!` would
+          # otherwise purge/destroy: ActionText description, images, custom fields, slugs.
+          move_polymorphic.call(ActionText::RichText, :record_type, :record_id, category, collection)
+          move_polymorphic.call(ActiveStorage::Attachment, :record_type, :record_id, category, collection, name: %w[image square_image])
+          move_polymorphic.call(Spree::Metafield, :resource_type, :resource_id, category, collection)
+          move_polymorphic.call(FriendlyId::Slug, :sluggable_type, :sluggable_id, category, collection)
+
+          # Rules -> collection_rules (remap the STI type; insert_all bypasses the
+          # regenerate-on-create callback since membership is copied directly).
+          rule_rows = Spree::TaxonRule.where(taxon_id: category.id).map do |rule|
+            {
+              collection_id: collection.id,
+              type: rule.type.sub('Spree::TaxonRules::', 'Spree::CollectionRules::'),
+              value: rule.value,
+              match_policy: rule.match_policy,
+              created_at: Time.current,
+              updated_at: Time.current
+            }
+          end
+          Spree::CollectionRule.insert_all(rule_rows) if rule_rows.any?
+
+          # Materialized membership: product_categories -> product_collections.
+          membership_rows = Spree::ProductCategory.where(category_id: category.id).map do |product_category|
+            {
+              collection_id: collection.id,
+              product_id: product_category.product_id,
+              position: product_category.position,
+              created_at: Time.current,
+              updated_at: Time.current
+            }
+          end
+          product_ids = membership_rows.map { |row| row[:product_id] }.uniq
+          Spree::ProductCollection.insert_all(membership_rows) if membership_rows.any?
+
+          # insert_all bypasses the counter caches — recompute them.
+          Spree::Collection.reset_counters(collection.id, :product_collections)
+          product_ids.each { |id| Spree::Product.reset_counters(id, :product_collections) }
+
+          # Drop the automatic category (its product_categories + taxon_rules cascade).
+          category.destroy!
+        end
+      rescue => e
+        # Isolate failures (e.g. a permalink collision) to the offending category —
+        # its transaction rolls back and the run continues. Re-run to retry (idempotent).
+        warn "  FAILED category ##{category.id} (#{category[:name].inspect}): #{e.class}: #{e.message}"
+        failed += 1
+        next
+      end
+
+      migrated += 1
+      print '.'
+    end
+
+    puts "\n  migrated #{migrated}, skipped #{skipped}, failed #{failed}. (Manual categories stay as categories.)"
+
+    # Sever the taxonomy structure from the surviving (manual) categories — in 6.0
+    # categories are store-owned; Taxonomy + the taxonomy_id column drop in 6.1.
+    puts 'Severing taxonomy links from surviving categories...'
+
+    # Drop legacy taxonomy roots (parentless, taxonomy-backed containers) left with no
+    # children after the automatic migration; non-empty roots stay as top-level categories.
+    # Runs BEFORE the store_id backfill so throwaway roots can't trip the store-scoped
+    # unique index on their way out.
+    parent_ids = Spree::Category.unscoped.where.not(parent_id: nil).distinct.pluck(:parent_id)
+    childless_root_ids = Spree::Category.unscoped.where.not(taxonomy_id: nil).
+                         where(parent_id: nil).where.not(id: parent_ids).ids
+    Spree::Category.unscoped.where(id: childless_root_ids).find_each(&:destroy!)
+    puts "  dropped #{childless_root_ids.size} childless taxonomy roots."
+
+    # Normally a no-op: the migration deduplicates over this same row set (it too
+    # groups by the store a category belongs to *or resolves through its
+    # taxonomy*). It runs again because db:migrate is not part of the upgrade
+    # manifest — the deploy pipeline owns it — so this task can be invoked against
+    # a database whose migrations have not run, where the backfill below would
+    # otherwise trip over duplicates that nothing has resolved yet.
+    renamed = Spree::CategoryPermalinkDeduplicator.new.call
+    puts "  resolved #{renamed} duplicate category permalinks." if renamed.positive?
+
+    # Backfill store_id from the taxonomy so nulling taxonomy_id never orphans a
+    # category (belt-and-suspenders alongside spree:taxons:backfill_store_id).
+    Spree::Taxonomy.find_each do |taxonomy|
+      Spree::Category.unscoped.where(store_id: nil, taxonomy_id: taxonomy.id).
+        update_all(store_id: taxonomy.store_id)
+    end
+
+    # Null the taxonomy link on everything that remains — categories are store-owned now.
+    severed = Spree::Category.unscoped.where.not(taxonomy_id: nil).update_all(taxonomy_id: nil)
+    puts "  severed taxonomy_id on #{severed} categories."
+
+    # Backfill the class-name strings Phase 3 renamed, for the surviving (manual)
+    # category rows that still hold the pre-6.0 names.
+    puts 'Backfilling renamed class-name strings...'
+    [
+      [Spree::Metafield, :resource_type, 'Spree::Taxon', 'Spree::Category'],
+      [Spree::MetafieldDefinition, :resource_type, 'Spree::Taxon', 'Spree::Category'],
+      [ActiveStorage::Attachment, :record_type, 'Spree::Taxon', 'Spree::Category'],
+      # description is an ActionText field (translates :description, backend: :action_text);
+      # surviving categories keep their rich-text description without this.
+      [ActionText::RichText, :record_type, 'Spree::Taxon', 'Spree::Category'],
+      [FriendlyId::Slug, :sluggable_type, 'Spree::Taxon', 'Spree::Category'],
+      [Spree::PromotionRule, :type, 'Spree::Promotion::Rules::Taxon', 'Spree::Promotion::Rules::Category'],
+      [Spree::PromotionRule, :type, 'Spree::Promotion::Rules::Taxon', 'Spree::Promotion::Rules::Category']
+    ].each do |model, column, from, to|
+      count = model.where(column => from).update_all(column => to)
+      puts "  #{model.table_name}.#{column}: #{count} rows #{from} -> #{to}"
+    end
+
+    puts 'Done!'
+  end
+end

data/lib/tasks/cli.rake

@@ -8,13 +8,20 @@ namespace :spree do
       print key.plaintext_token
     end
 
-    desc 'Create an API key'
+    desc 'Create an API key (REPLACE=true revokes active keys of the same name first)'
     task create_api_key: :environment do
       name = ENV.fetch('NAME')
       key_type = ENV.fetch('KEY_TYPE')
       scopes = ENV.fetch('SCOPES', '').split(',').map(&:strip).reject(&:empty?)
       store = Spree::Store.default
-      key = store.api_keys.create!(name: name, key_type: key_type, scopes: scopes)
+      # Names are unique among a store's active keys, so a key the CLI mints
+      # under a fixed name on every run supersedes the previous one. Both
+      # steps in one transaction: a failed create must not leave the operator
+      # with the old key revoked and no replacement.
+      key = Spree::ApiKey.transaction do
+        store.api_keys.active.where(name: name).find_each(&:revoke!) if ENV['REPLACE'] == 'true'
+        store.api_keys.create!(name: name, key_type: key_type, scopes: scopes)
+      end
       print key.plaintext_token
     end
 
@@ -39,12 +46,24 @@ namespace :spree do
     task create_admin: :environment do
       email = ENV.fetch('EMAIL')
       password = ENV.fetch('PASSWORD')
+
+      # Creates the role row if the database predates it, so this works on a
+      # freshly migrated app that has not been seeded.
+      admin_role = Spree::Role.default_admin_role
+
+      # Never silently ignore the supplied password: an operator rerunning
+      # this to "reset" a password would otherwise get a success exit while
+      # nothing changed.
+      if Spree.admin_user_class.exists?(email: email)
+        abort "An admin with email #{email} already exists — password NOT changed. Use a password reset to change it."
+      end
+
       admin = Spree.admin_user_class.create!(
         email: email,
         password: password,
         password_confirmation: password
       )
-      admin.add_role('admin', Spree::Store.default)
+      admin.add_role(admin_role.name, Spree::Store.default)
       print admin.email
     end
   end

data/lib/tasks/consolidate_metadata.rake

@@ -0,0 +1,73 @@
+module Spree
+  module MetadataConsolidator
+    # JSON columns come back as a Hash on some adapters and a String on others.
+    # Anything that isn't a Hash — an array or scalar an application stored in the
+    # untyped column, unparseable text — becomes {} rather than aborting the run.
+    def self.parse(value)
+      parsed = value.is_a?(String) ? (JSON.parse(value) rescue nil) : value
+
+      parsed.is_a?(Hash) ? parsed : {}
+    end
+  end
+end
+
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Reports whether any table still carries the pre-6.0 public_metadata /
+      private_metadata pair, and merges public_metadata into private_metadata if so.
+
+      The 6.0 migration does this merge itself, before it drops the column, so a
+      normal `db:migrate` needs nothing from this task. It exists for installs whose
+      schema was changed out of band — a manually dropped column, a half-applied
+      migration, an extension table that adopted the pair and was missed.
+
+      Keys present in both columns keep the private value, matching the migration.
+      Idempotent, and a no-op on an already-consolidated schema.
+    DESC
+    task consolidate_metadata: :environment do
+      connection = ActiveRecord::Base.connection
+
+      tables = connection.tables.select do |table_name|
+        connection.column_exists?(table_name, :public_metadata) &&
+          connection.column_exists?(table_name, :private_metadata)
+      end
+
+      if tables.empty?
+        puts '  No table carries both metadata columns — nothing to do.'
+        next
+      end
+
+      merged_total = 0
+
+      tables.sort.each do |table_name|
+        quoted_table = connection.quote_table_name(table_name)
+        # Selected rather than filtered in SQL: PostgreSQL has no equality operator
+        # for `json`, so `WHERE public_metadata <> '{}'` is not portable.
+        rows = connection.select_all(
+          "SELECT id, public_metadata, private_metadata FROM #{quoted_table} WHERE public_metadata IS NOT NULL"
+        )
+
+        merged_for_table = 0
+
+        rows.each do |row|
+          public_metadata = Spree::MetadataConsolidator.parse(row['public_metadata'])
+          next if public_metadata.blank?
+
+          merged = public_metadata.merge(Spree::MetadataConsolidator.parse(row['private_metadata']))
+
+          connection.exec_update(
+            "UPDATE #{quoted_table} SET private_metadata = #{connection.quote(merged.to_json)} " \
+            "WHERE id = #{connection.quote(row['id'])}"
+          )
+          merged_for_table += 1
+        end
+
+        merged_total += merged_for_table
+        puts "  #{table_name}: merged #{merged_for_table} row(s)." if merged_for_table.positive?
+      end
+
+      puts "  Done. Merged #{merged_total} row(s) across #{tables.size} table(s) still carrying both columns."
+    end
+  end
+end

data/lib/tasks/core.rake

@@ -1,15 +1,5 @@
 require 'active_record'
 
-namespace :db do
-  task migrate_admin_users_to_role_users: :environment do |_t, _args|
-    default_store = Spree::Store.default
-    Spree::RoleUser.where(resource: nil).each do |role_user|
-      role_user.update_columns(resource_type: default_store.class.name, resource_id: default_store.id)
-    end
-  end
-
-end
-
 namespace :core do
   desc 'Set "active" status on draft products where make_active_at is in the past'
   task activate_products: :environment do |_t, _args|
@@ -36,7 +26,7 @@ namespace :core do
 
   desc 'Migrate newsletter subscribers'
   task migrate_newsletter_subscribers: :environment do |_t, _args|
-    Spree.user_class.where(accepts_email_marketing: true).in_batches(of: 500) do |user_batch|
+    Spree.customer_class.where(accepts_email_marketing: true).in_batches(of: 500) do |user_batch|
       subscriber_attributes = user_batch.pluck(:id, :email, :updated_at).map do |id, email, updated_at|
         {
           email: Spree::NewsletterSubscriber.new(email: email).email, # normalized email

data/lib/tasks/deliveries_migration.rake

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0: the tracking number that lived on the fulfillment becomes its
+# primary Spree::Delivery (docs/plans/6.0-shipping-labels-and-deliveries.md).
+# Idempotent — a fulfillment that already has a delivery for its number is
+# skipped, so an interrupted run resumes for free. Labels are not backfilled:
+# the provider metadata keys only ever existed on the unreleased 6.0 edge.
+namespace :spree do
+  desc 'Create a delivery for every fulfillment that carries a 5.6 tracking number'
+  task migrate_deliveries: :environment do
+    batch_size = ENV.fetch('BATCH_SIZE', 1_000).to_i
+    say = ->(message) { puts message }
+
+    created = 0
+    skipped = 0
+
+    # The column is dropped in 6.1; until then the model reads tracking from
+    # the delivery, so the legacy value is read straight off the row.
+    fulfillments = Spree::Fulfillment.unscoped.
+                   where.not(tracking: [nil, '']).
+                   where.not(id: Spree::Delivery.where(owner_type: 'Spree::Fulfillment').select(:owner_id))
+
+    fulfillments.includes(:order, :cart).find_in_batches(batch_size: batch_size) do |batch|
+      batch.each do |fulfillment|
+        tracking = fulfillment.read_attribute(:tracking).to_s.squish
+        if fulfillment.owner&.store.nil?
+          skipped += 1
+          say.call "  skipped #{fulfillment.number}: its order or cart is gone, so it has no store"
+          next
+        end
+
+        # A dev database that ran the withdrawn 20260811 carrier migration
+        # still has the column; anywhere else it never existed.
+        carrier = fulfillment.has_attribute?(:tracking_carrier) ? fulfillment.read_attribute(:tracking_carrier) : nil
+
+        result = Spree.delivery_create_service.call(
+          owner: fulfillment, tracking_number: tracking, carrier: carrier
+        )
+
+        if result.success?
+          created += 1
+        else
+          skipped += 1
+          say.call "  skipped #{fulfillment.number}: #{result.error}"
+        end
+      end
+    end
+
+    say.call "spree_deliveries: #{created} created, #{skipped} skipped"
+    say.call 'migrate_deliveries done.'
+  end
+end