spree_core 5.6.1 → 6.0.0.beta2

data/lib/tasks/delivery_method_rules_migration.rake

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0: fold the FlatRate calculator's eligibility bound preferences
+# into DeliveryMethodRule rows (docs/plans/6.0-delivery-method-rules.md).
+# The calculator preferences keep working as a deprecation bridge through
+# 6.0; this task moves the data so the bridge can drop in 6.1.
+namespace :spree do
+  desc 'Convert FlatRate calculator eligibility bounds into delivery method rules'
+  task migrate_calculator_bounds_to_delivery_method_rules: :environment do
+    converted = 0
+
+    Spree::Calculator::Shipping::FlatRate.where(calculable_type: %w[Spree::DeliveryMethod Spree::ShippingMethod]).find_each do |calculator|
+      delivery_method = Spree::DeliveryMethod.unscoped.find_by(id: calculator.calculable_id)
+      next unless delivery_method
+
+      prefs = calculator.preferences || {}
+      min_total = prefs[:minimum_item_total]
+      max_total = prefs[:maximum_item_total]
+      min_weight = prefs[:minimum_weight]
+      max_weight = prefs[:maximum_weight]
+
+      if (min_total.present? || max_total.present?) &&
+          !delivery_method.delivery_method_rules.exists?(type: 'Spree::DeliveryMethodRules::ItemTotalRule')
+        delivery_method.delivery_method_rules.create!(
+          type: 'Spree::DeliveryMethodRules::ItemTotalRule',
+          preferences: { minimum_amount: min_total, maximum_amount: max_total }
+        )
+        converted += 1
+      end
+
+      if (min_weight.present? || max_weight.present?) &&
+          !delivery_method.delivery_method_rules.exists?(type: 'Spree::DeliveryMethodRules::WeightRule')
+        delivery_method.delivery_method_rules.create!(
+          type: 'Spree::DeliveryMethodRules::WeightRule',
+          preferences: { minimum_weight: min_weight, maximum_weight: max_weight }
+        )
+        converted += 1
+      end
+
+      # Clear the migrated bounds so the calculator's legacy nil-guards stop
+      # double-enforcing (the rules own eligibility now).
+      if min_total.present? || max_total.present? || min_weight.present? || max_weight.present?
+        calculator.update_columns(
+          preferences: prefs.except(:minimum_item_total, :maximum_item_total, :minimum_weight, :maximum_weight)
+        )
+      end
+    end
+
+    puts "migrate_calculator_bounds_to_delivery_method_rules done. #{converted} rules created."
+  end
+end

data/lib/tasks/delivery_migration.rake

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0 data backfills for the fulfillment & delivery rename
+# (docs/plans/6.0-fulfillment-and-delivery.md, Wave 7). Batched and
+# idempotent — every statement narrows to legacy values only.
+namespace :spree do
+  desc 'Backfill fulfillment/delivery naming into stored strings, statuses and types'
+  task migrate_shipping_to_delivery: :environment do
+    batch_size = ENV.fetch('BATCH_SIZE', 5_000).to_i
+
+    say = ->(message) { puts message }
+
+    # 1. Stored polymorphic class names. spree_state_changes has no model
+    # anymore (removed in 6.0; the table survives until 6.1 as legacy data),
+    # so it is read through an anonymous ActiveRecord class.
+    state_changes = Class.new(ActiveRecord::Base) { self.table_name = 'spree_state_changes' }
+
+    {
+      state_changes => :stateful_type,
+      Spree::StockMovement => :originator_type
+    }.each do |klass, column|
+      count = klass.where(column => 'Spree::Shipment').in_batches(of: batch_size).update_all(column => 'Spree::Fulfillment')
+      say.call "#{klass.table_name}.#{column}: #{count} rows Spree::Shipment → Spree::Fulfillment"
+    end
+
+    adjustments = Class.new(ActiveRecord::Base) { self.table_name = 'spree_adjustments' }
+    if adjustments.table_exists?
+      count = adjustments.where(adjustable_type: 'Spree::Shipment').in_batches(of: batch_size).update_all(adjustable_type: 'Spree::Fulfillment')
+      say.call "spree_adjustments.adjustable_type: #{count} rows Spree::Shipment → Spree::Fulfillment"
+    end
+
+    # The name column distinguishes the machine ('shipment' rows become
+    # 'fulfillment'); the recorded states keep their history except the
+    # renamed terminal value.
+    state_changes.where(name: 'shipment').in_batches(of: batch_size).update_all(name: 'fulfillment')
+    state_changes.where(name: 'fulfillment', previous_state: 'shipped').in_batches(of: batch_size).update_all(previous_state: 'fulfilled')
+    state_changes.where(name: 'fulfillment', next_state: 'shipped').in_batches(of: batch_size).update_all(next_state: 'fulfilled')
+
+    # 2. Status value rename on fulfillments ('shipped' → 'fulfilled').
+    count = Spree::Fulfillment.unscoped.where(status: 'shipped').in_batches(of: batch_size).update_all(status: 'fulfilled')
+    say.call "spree_fulfillments.status: #{count} rows shipped → fulfilled"
+
+    # 3. Provider backfill on delivery methods. The provider class is the
+    # sole carrier of delivery behavior — there is no type string to set.
+    digital_method_ids = Spree::DeliveryMethod.unscoped.
+      joins("INNER JOIN #{Spree::Calculator.table_name} calculators ON calculators.calculable_id = #{Spree::DeliveryMethod.table_name}.id AND calculators.calculable_type IN ('Spree::ShippingMethod', 'Spree::DeliveryMethod')").
+      where("calculators.type LIKE '%DigitalDelivery'").
+      ids
+
+    if digital_method_ids.any?
+      Spree::DeliveryMethod.unscoped.where(id: digital_method_ids).update_all(
+        fulfillment_provider: 'Spree::FulfillmentProvider::Digital'
+      )
+      say.call "delivery methods marked digital: #{digital_method_ids.size}"
+    end
+
+    Spree::DeliveryMethod.unscoped.where(fulfillment_provider: nil).update_all(fulfillment_provider: 'Spree::FulfillmentProvider::Manual')
+
+    # Copy the resolved type onto existing fulfillments from their selected
+    # delivery rate's method's provider; anything unresolvable defaults to
+    # shipping. (Digital-category products are converted to Digital-kind
+    # profiles by spree:upgrade:migrate_delivery_profiles.)
+    provider_fulfillment_type = lambda do |provider_name|
+      provider_class = provider_name&.safe_constantize
+      if provider_class.nil? then 'shipping'
+      elsif provider_class.digital? then 'digital'
+      elsif provider_class.pickup_point? then 'pickup_point'
+      elsif provider_class.pickup? then 'pickup'
+      else 'shipping'
+      end
+    end
+
+    Spree::Fulfillment.unscoped.where(fulfillment_type: nil).in_batches(of: batch_size) do |batch|
+      batch.each do |fulfillment|
+        provider_name = Spree::DeliveryMethod.unscoped.
+          joins("INNER JOIN #{Spree::DeliveryRate.table_name} rates ON rates.delivery_method_id = #{Spree::DeliveryMethod.table_name}.id").
+          where(rates: { fulfillment_id: fulfillment.id, selected: true }).
+          pick(:fulfillment_provider)
+        fulfillment.update_columns(fulfillment_type: provider_fulfillment_type.call(provider_name))
+      end
+      print '.'
+    end
+    puts
+
+    # 4. display_on → storefront_visible boolean. The new column defaults to
+    # true, so only back_end rows need flipping. Each converted row has its
+    # legacy display_on cleared, which makes the conversion strictly one-shot:
+    # a re-run finds nothing left to convert, so a later admin change to
+    # storefront_visible is never undone.
+    if Spree::DeliveryMethod.column_names.include?('display_on')
+      # front_end-only had no real workflow and folds into visible — but it
+      # also means staff can now see those methods, so name them explicitly
+      # before the value is cleared.
+      front_end_only = Spree::DeliveryMethod.unscoped.where(display_on: 'front_end').pluck(:id, :name)
+
+      count = Spree::DeliveryMethod.unscoped.
+        where(display_on: 'back_end').
+        update_all(storefront_visible: false, display_on: nil)
+      say.call "spree_delivery_methods.storefront_visible: #{count} back_end rows set to false"
+
+      converted = Spree::DeliveryMethod.unscoped.where.not(display_on: nil).update_all(display_on: nil)
+      say.call "spree_delivery_methods.display_on: #{converted} remaining rows cleared (conversion is one-shot)"
+
+      if front_end_only.any?
+        say.call "spree_delivery_methods: #{front_end_only.size} front_end-only rows are now visible to staff as well as customers:"
+        front_end_only.each { |id, name| say.call "  - ##{id} #{name}" }
+      end
+    end
+
+    say.call 'migrate_shipping_to_delivery done.'
+  end
+
+  desc 'Convert delivery-referenced legacy Zones into DeliveryZones with typed members'
+  task migrate_zones_to_delivery_zones: :environment do
+    # Rows whose delivery_zone_id predates the rename still point at legacy
+    # spree_zones ids. Run this immediately after db:migrate — before new
+    # DeliveryZones are created — so unmigrated ids are unambiguous.
+    #
+    # Zones now belong to a delivery profile, so a legacy zone shared by
+    # methods in different profiles becomes one DeliveryZone per profile.
+    migrated = {}
+    Spree::DeliveryZone.find_each do |delivery_zone|
+      source_id = delivery_zone.metadata&.dig('migrated_from_zone_id')
+      migrated[[source_id.to_i, delivery_zone.delivery_profile_id]] = delivery_zone.id if source_id
+    end
+
+    referenced_ids = Spree::DeliveryMethod.unscoped.distinct.pluck(:delivery_zone_id).compact
+    legacy_zones = Spree::Zone.where(id: referenced_ids - migrated.values)
+
+    # Members are named by ISO code in 6.0, and countries and states stopped
+    # being records — so the legacy tables are read directly by id, the way
+    # this task's sibling upgrade steps read tables their models no longer own.
+    connection = ActiveRecord::Base.connection
+    country_code_for = lambda do |country_id|
+      return nil if country_id.blank?
+
+      connection.select_value(
+        "SELECT iso FROM spree_countries WHERE id = #{connection.quote(country_id)}"
+      )
+    end
+
+    state_pair_for = lambda do |state_id|
+      return nil if state_id.blank?
+
+      row = connection.select_one(<<~SQL.squish)
+        SELECT spree_states.abbr AS abbr, spree_countries.iso AS iso
+        FROM spree_states
+        INNER JOIN spree_countries ON spree_countries.id = spree_states.country_id
+        WHERE spree_states.id = #{connection.quote(state_id)}
+      SQL
+      row && [row['abbr'], row['iso']]
+    end
+
+    copy_members = lambda do |zone, delivery_zone|
+      zone.zone_members.find_each do |member|
+        case member.zoneable_type
+        when 'Spree::Country'
+          iso = country_code_for.call(member.zoneable_id)
+          next if iso.blank?
+
+          delivery_zone.members.create!(member_type: 'country', country_code: iso)
+        when 'Spree::State'
+          pair = state_pair_for.call(member.zoneable_id)
+          next if pair.nil?
+
+          abbr, iso = pair
+          # A state member carries its country too: a subdivision code is only
+          # unique within its country.
+          delivery_zone.members.create!(member_type: 'state', state_code: abbr, country_code: iso)
+        end
+      end
+    end
+
+    legacy_zones.find_each do |zone|
+      if Spree::DeliveryZone.exists?(id: zone.id) && !migrated.value?(zone.id)
+        puts "SKIP zone #{zone.id} (#{zone.name}): a DeliveryZone with the same id already exists — resolve manually"
+        next
+      end
+
+      methods_by_home = Spree::DeliveryMethod.unscoped.where(delivery_zone_id: zone.id).
+        group_by { |method| [method.store_id, method.delivery_profile_id] }
+
+      methods_by_home.each do |(store_id, profile_id), methods|
+        profile_id ||= Spree::DeliveryProfile.where(store_id: store_id, default: true).pick(:id)
+
+        delivery_zone_id = migrated[[zone.id, profile_id]] ||= begin
+          name = zone.name
+          name = "#{zone.name} (#{profile_id})" if Spree::DeliveryZone.exists?(store_id: store_id, name: name)
+
+          delivery_zone = Spree::DeliveryZone.create!(
+            name: name,
+            description: zone.description,
+            store_id: store_id,
+            delivery_profile_id: profile_id,
+            metadata: { 'migrated_from_zone_id' => zone.id }
+          )
+          copy_members.call(zone, delivery_zone)
+          puts "zone #{zone.id} (#{zone.name}) → delivery zone #{delivery_zone.id} (#{delivery_zone.members.count} members)"
+          delivery_zone.id
+        end
+
+        Spree::DeliveryMethod.unscoped.where(id: methods.map(&:id)).update_all(delivery_zone_id: delivery_zone_id)
+      end
+    end
+
+    unreferenced = Spree::Zone.where.not(id: referenced_ids).where(kind: 'shipping')
+    unreferenced.find_each do |zone|
+      puts "SKIP unreferenced shipping zone #{zone.id} (#{zone.name}) — no delivery method uses it"
+    end
+
+    puts 'migrate_zones_to_delivery_zones done. Tax-scoped zones stay on Spree::Zone for the tax provider migration.'
+  end
+end

data/lib/tasks/delivery_profiles_migration.rake

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0: finish promoting shipping categories into delivery profiles
+# (docs/plans/6.0-delivery-profiles.md). The schema migration renamed the
+# table and the product foreign key, so 5.x rows arrive as store-less,
+# kind-less profiles; this task makes the judgement calls the migration
+# deliberately left out: store assignment, kind detection, folding
+# non-narrowing categories into the store default, and re-homing methods
+# from the legacy method↔category m:n (spree_shipping_method_categories,
+# which survives to 6.1 as this task's source and rollback reference).
+namespace :spree do
+  desc 'Assign 5.x shipping-category rows their store, kind and methods as delivery profiles'
+  task migrate_delivery_profiles: :environment do
+    # The m:n has no model anymore — read it anonymously.
+    method_categories = Class.new(ActiveRecord::Base) { self.table_name = 'spree_shipping_method_categories' }
+    has_legacy_join = method_categories.table_exists?
+
+    digital_provider = 'Spree::FulfillmentProvider::Digital'
+
+    Spree::DeliveryProfile.where(store_id: nil).find_each do |legacy_profile|
+      store_ids = Spree::Product.unscoped.where(delivery_profile_id: legacy_profile.id).
+        distinct.pluck(:store_id).compact
+
+      if store_ids.empty?
+        puts "profile #{legacy_profile.id} (#{legacy_profile.name}): no products reference it — removed"
+        legacy_profile.delete
+        next
+      end
+
+      # Categories were global; products are single-store. The first store
+      # keeps the row, every further store gets its own copy.
+      store_ids.each_with_index do |store_id, index|
+        store = Spree::Store.find(store_id)
+        default_profile = store.default_delivery_profile
+
+        linked_method_ids = if has_legacy_join
+                              method_categories.where(shipping_category_id: legacy_profile.id).
+                                pluck(:shipping_method_id)
+                            else
+                              []
+                            end
+        category_methods = Spree::DeliveryMethod.unscoped.where(id: linked_method_ids, store_id: store_id)
+        store_methods = Spree::DeliveryMethod.unscoped.where(store_id: store_id)
+
+        digital = category_methods.any? && category_methods.where.not(fulfillment_provider: digital_provider).none?
+        # A category narrows when its method set differs from the store's
+        # full set — only then does it carry information worth keeping.
+        narrowing = category_methods.any? && category_methods.count != store_methods.count
+
+        if !digital && !narrowing
+          count = Spree::Product.unscoped.where(delivery_profile_id: legacy_profile.id, store_id: store_id).
+            update_all(delivery_profile_id: default_profile.id)
+          puts "store #{store.code}: category '#{legacy_profile.name}' does not narrow the method set — #{count} products moved to the default profile"
+          next
+        end
+
+        target = if index.zero?
+                   legacy_profile
+                 else
+                   Spree::DeliveryProfile.new(name: legacy_profile.name)
+                 end
+        target.store_id = store_id
+        target.type = digital ? 'Spree::DeliveryProfiles::Digital' : 'Spree::DeliveryProfiles::Shipping'
+        target.name = "#{legacy_profile.name} (#{store.code})" if Spree::DeliveryProfile.where(store_id: store_id, name: target.name).where.not(id: target.id).exists?
+        target.save!(validate: false)
+        # Promoted rows are updates, so the after_create hook never made
+        # their default origin group.
+        origin_group = target.delivery_origin_groups.first || target.delivery_origin_groups.create!
+
+        unless index.zero?
+          Spree::Product.unscoped.where(delivery_profile_id: legacy_profile.id, store_id: store_id).
+            update_all(delivery_profile_id: target.id)
+        end
+
+        # A method solely linked to this category moves in with it; a method
+        # shared across categories cannot be expressed single-parent.
+        category_methods.find_each do |method|
+          other_links = method_categories.where(shipping_method_id: method.id).
+            where.not(shipping_category_id: legacy_profile.id).count
+          if other_links.zero?
+            method.update_columns(delivery_profile_id: target.id, delivery_origin_group_id: origin_group.id)
+          else
+            puts "WARNING store #{store.code}: delivery method #{method.id} (#{method.name}) was linked to #{other_links + 1} categories — it stays in the default profile and no longer serves '#{target.name}'. Recreate it inside that profile if intended."
+          end
+        end
+
+        puts "store #{store.code}: category '#{legacy_profile.name}' → #{digital ? 'digital' : 'shipping'} profile #{target.id} (#{category_methods.count} linked methods)"
+      end
+
+      # Fully folded into store defaults? Nothing references the row anymore.
+      legacy_profile.reload
+      if legacy_profile.store_id.nil? && Spree::Product.unscoped.where(delivery_profile_id: legacy_profile.id).none?
+        legacy_profile.delete
+      end
+    end
+
+    # Any product still pointing nowhere lands on its store's default.
+    Spree::Store.all.find_each do |store|
+      default_profile = store.default_delivery_profile
+      next unless default_profile
+
+      count = Spree::Product.unscoped.where(store_id: store.id, delivery_profile_id: nil).
+        update_all(delivery_profile_id: default_profile.id)
+      puts "store #{store.code}: #{count} unassigned products moved to the default profile" if count.positive?
+    end
+
+    puts 'migrate_delivery_profiles done. spree_shipping_method_categories is kept until 6.1 as the rollback reference.'
+  end
+end

data/lib/tasks/fold_store_credit_categories.rake

@@ -0,0 +1,40 @@
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Copies each store credit's legacy category name into its memo
+      (Spree 6.0). Store credits no longer carry a category — the reason a
+      credit exists is its originator (return, exchange, claim, gift card)
+      plus the free-text memo — so this keeps the only information a
+      category row held visible in the dashboard once the column and table
+      are dropped in 6.1.
+
+      Only credits with a blank memo are touched, so nothing an admin wrote
+      is overwritten. Idempotent — a credit whose memo is already filled is
+      skipped, and installs without the legacy tables are a no-op.
+    DESC
+    task fold_store_credit_categories: :environment do
+      connection = ActiveRecord::Base.connection
+      credits = Spree::StoreCredit.table_name
+      categories = 'spree_store_credit_categories'
+
+      unless connection.table_exists?(categories) && connection.column_exists?(credits, :category_id)
+        puts '  Legacy store credit categories are gone — nothing to fold.'
+        next
+      end
+
+      legacy_category = Class.new(ActiveRecord::Base) { self.table_name = 'spree_store_credit_categories' }
+      folded = 0
+
+      legacy_category.pluck(:id, :name).each do |category_id, name|
+        next if name.blank?
+
+        folded += Spree::StoreCredit.unscoped
+                                    .where(category_id: category_id)
+                                    .where(memo: [nil, ''])
+                                    .update_all(memo: name)
+      end
+
+      puts "  Copied the category name into the memo of #{folded} store credit(s)."
+    end
+  end
+end

data/lib/tasks/fulfillment_statuses_migration.rake

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0 status remap for the fulfillment lifecycle
+# (docs/plans/6.0-fulfillment-and-delivery.md, Phase 7). Batched and
+# idempotent — every statement narrows to legacy values only, so a second run
+# finds nothing left to do and an interrupted run resumes for free.
+namespace :spree do
+  desc 'Remap fulfillment statuses onto the unfulfilled/fulfilled/delivered vocabulary'
+  task migrate_fulfillment_statuses: :environment do
+    batch_size = ENV.fetch('BATCH_SIZE', 5_000).to_i
+    say = ->(message) { puts message }
+
+    fulfillments = Spree::Fulfillment.unscoped
+
+    # pending and ready both described a package still on the shelf. The
+    # difference between them was the order's payment state, which is no longer
+    # a property of the fulfillment.
+    %w(pending ready).each do |legacy|
+      count = fulfillments.where(status: legacy).in_batches(of: batch_size).update_all(status: 'unfulfilled')
+      say.call "spree_fulfillments.status: #{count} rows #{legacy} → unfulfilled"
+    end
+
+    # ready_for_pickup meant "waiting at the counter", which is what fulfilled
+    # means for a pickup fulfillment now.
+    count = fulfillments.where(status: 'ready_for_pickup').in_batches(of: batch_size).update_all(status: 'fulfilled')
+    say.call "spree_fulfillments.status: #{count} rows ready_for_pickup → fulfilled"
+
+    # Under the old machine a pickup fulfillment reached `fulfilled` only when
+    # the customer collected it — that is confirmed receipt, so those rows are
+    # delivered rather than merely handed over. Shipping fulfillments stay
+    # `fulfilled`: whether they arrived was never recorded.
+    pickup_method_ids = Spree::DeliveryMethod.with_provider(:pickup?).ids
+
+    if pickup_method_ids.any?
+      pickup_fulfillment_ids = Spree::DeliveryRate.
+                               where(selected: true, delivery_method_id: pickup_method_ids).
+                               select(:fulfillment_id)
+
+      count = fulfillments.
+              where(status: 'fulfilled', id: pickup_fulfillment_ids).
+              where(delivered_at: nil).
+              in_batches(of: batch_size).
+              update_all('status = \'delivered\', delivered_at = fulfilled_at')
+      say.call "spree_fulfillments.status: #{count} pickup rows fulfilled → delivered"
+    end
+
+    # Order rollups are derived, so they are recomputed rather than mapped —
+    # this also picks up the new `delivered` value for orders whose parcels all
+    # arrived.
+    # 'fulfilled' is included because the pickup remap above can move an
+    # order's parcels to delivered, which its stored rollup cannot know yet.
+    orders = Spree::Order.where(fulfillment_status: %w(pending ready ready_for_pickup fulfilled))
+    total = orders.count
+    orders.find_each { |order| order.update_statuses! }
+    say.call "spree_orders.fulfillment_status: #{total} orders recomputed"
+
+    say.call 'migrate_fulfillment_statuses done.'
+  end
+end