spree_core 5.6.0 → 6.0.0.beta1

data/lib/tasks/tax_zones_migration.rake

@@ -0,0 +1,147 @@
+namespace :spree do
+  desc <<~DESC
+    Converts the zones tax rates were configured against into the country and
+    state codes a rate now carries (Spree 6.0). A zone spanning several
+    countries becomes one rate per country, since a rate can name only one
+    jurisdiction — which is what lets a tax line report the country that taxed
+    it. Idempotent: rates that already carry a country or state are skipped, and
+    so are rates whose zone had no members, which stay as "everywhere" rates.
+  DESC
+  task migrate_tax_zones: :environment do
+    # One entry per taxing jurisdiction in the zone. State members carry their
+    # own country, so a mixed zone still yields complete pairs.
+    #
+    # Reads spree_countries and spree_states directly: countries and states are
+    # reference data rather than records in 6.0, so the ids the members hold
+    # can only be resolved against the tables the upgrade keeps.
+    connection = ActiveRecord::Base.connection
+    country_code_by_id = lambda do |id|
+      connection.select_value("SELECT iso FROM spree_countries WHERE id = #{connection.quote(id)}")
+    end
+    state_pair_by_id = lambda do |id|
+      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(id)}
+      SQL
+      row && { country_code: row['iso'], state_code: row['abbr'] }
+    end
+
+    jurisdictions_for = lambda do |zone|
+      zone.zone_members.filter_map do |member|
+        case member.zoneable_type
+        when 'Spree::Country'
+          iso = country_code_by_id.call(member.zoneable_id)
+          { country_code: iso, state_code: nil } if iso
+        when 'Spree::State'
+          state_pair_by_id.call(member.zoneable_id)
+        end
+      end.uniq
+    end
+
+    converted = 0
+    duplicated = 0
+    skipped = 0
+
+    Spree::TaxRate.with_deleted.
+      where(country_code: nil, state_code: nil).where.not(zone_id: nil).find_each do |rate|
+      zone = Spree::Zone.find_by(id: rate.zone_id)
+      jurisdictions = zone ? jurisdictions_for.call(zone) : []
+
+      if jurisdictions.empty?
+        skipped += 1
+        next
+      end
+
+      first, *rest = jurisdictions
+
+      # One rate's split is all-or-nothing. Stamping the source before the copies
+      # exist means an interrupted run leaves a converted rate whose other
+      # jurisdictions were never created — and the next run skips it, because it
+      # now carries a country. The merchant would be short a rate with nothing
+      # saying so.
+      ApplicationRecord.transaction do
+        rate.update_columns(country_code: first[:country_code], state_code: first[:state_code], updated_at: Time.current)
+
+        rest.each do |jurisdiction|
+          Spree::TaxRate.insert(
+            rate.attributes.slice(*Spree::TaxRate.column_names).except('id', 'created_at', 'updated_at').merge(
+              'country_code' => jurisdiction[:country_code],
+              'state_code' => jurisdiction[:state_code],
+              'created_at' => Time.current,
+              'updated_at' => Time.current
+            )
+          )
+        end
+      end
+
+      converted += 1
+      duplicated += rest.size
+    end
+
+    puts "  Converted #{converted} tax rates, split #{duplicated} extra rate(s) off multi-jurisdiction zones, " \
+         "skipped #{skipped}."
+
+    # Price lists could also be restricted by zone. Markets are how pricing
+    # targets geography now, so each zone rule becomes a MarketRule where the
+    # zone's countries exactly match one of the store's markets — the one
+    # mapping that provably keeps the same buyers on the same prices. A rule
+    # whose countries match no market cannot be restated without silently
+    # re-scoping who pays what, so its price list is deactivated instead and
+    # reported with the countries it named, for the merchant to rebuild as a
+    # market. Zones naming states resolve to those states' countries.
+    zone_country_codes = lambda do |zone_ids|
+      members = Spree::ZoneMember.where(zone_id: zone_ids)
+      country_ids = members.where(zoneable_type: 'Spree::Country').pluck(:zoneable_id)
+      state_ids = members.where(zoneable_type: 'Spree::State').pluck(:zoneable_id)
+
+      isos = country_ids.filter_map { |id| country_code_by_id.call(id) }
+      isos += state_ids.filter_map { |id| state_pair_by_id.call(id)&.fetch(:country_code) }
+      isos.uniq.sort
+    end
+
+    rules_matched = 0
+    lists_deactivated = []
+
+    Spree::PriceRule.where(type: 'Spree::PriceRules::ZoneRule').find_each do |rule|
+      stored = rule.preferences.with_indifferent_access
+      zone_ids = Array(stored[:zone_ids]).reject(&:blank?)
+      isos = zone_country_codes.call(zone_ids)
+
+      price_list = Spree::PriceList.with_deleted.find_by(id: rule.price_list_id)
+      market = if price_list && isos.any?
+                 price_list.store.markets.find { |candidate| candidate.country_codes == isos }
+               end
+
+      if market
+        rule.update_columns(
+          type: 'Spree::PriceRules::MarketRule',
+          preferences: stored.except(:zone_ids, :country_codes).
+                       merge(market_ids: [market.id.to_s]).to_h.symbolize_keys,
+          updated_at: Time.current
+        )
+        rules_matched += 1
+      else
+        # Without a matching market the restriction is unrepresentable; the
+        # list must not quietly widen to every buyer, so it goes dark until
+        # the merchant rebuilds the geography as a market.
+        if price_list && !price_list.deleted? && price_list.status != 'inactive'
+          price_list.update_columns(status: 'inactive', updated_at: Time.current)
+        end
+        lists_deactivated << [price_list, isos]
+        rule.delete
+      end
+    end
+
+    puts "  Converted #{rules_matched} zone price rule(s) to market rules." if rules_matched.positive?
+    if lists_deactivated.any?
+      puts "  Deactivated #{lists_deactivated.size} price list(s) whose zone matched no market — " \
+           'create a market for the countries, then re-add the rule and reactivate:'
+      lists_deactivated.each do |list, isos|
+        label = list ? "#{list.name} (#{list.id})" : 'deleted price list'
+        puts "    - #{label}: #{isos.any? ? isos.join(', ') : 'no resolvable countries'}"
+      end
+    end
+  end
+end

data/lib/tasks/taxons.rake

@@ -11,14 +11,14 @@ namespace :spree do
       # 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).
+        Spree::Category.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
+      # Mirror Spree::Category#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
@@ -26,11 +26,11 @@ namespace :spree do
 
         # 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 = Spree::Category.unscoped.where.not(store_id: nil).
+                   where(id: Spree::Category.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).
+            updated += Spree::Category.unscoped.where(store_id: nil, parent_id: parent_ids).
                        update_all(store_id: store_id)
           end
         end
@@ -45,8 +45,8 @@ namespace :spree do
     # 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))
+      Spree::Category.unscoped.in_batches(of: 1000) do |batch|
+        Spree::Category.recalculate_products_count(batch.pluck(:id))
         print '.'
       end
     end
@@ -58,14 +58,13 @@ namespace :spree do
       puts "\nDone!"
     end
 
-    desc 'Reset counter caches (children_count, classification_count, products_count) on taxons'
+    desc 'Reset counter caches (children_count, products_count) on taxons'
     task reset_counter_caches: :environment do |_t, _args|
       puts 'Resetting taxon counter caches...'
 
-      Spree::Taxon.find_each do |taxon|
+      Spree::Category.find_each do |taxon|
         taxon.update_columns(
           children_count: taxon.children.count,
-          classification_count: taxon.classifications.count,
           updated_at: Time.current
         )
         print '.'

data/lib/tasks/typed_adjustments_migration.rake

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0: convert legacy polymorphic spree_adjustments rows into the typed
+# TaxLine / Discount / Fee tables (docs/plans/6.0-6.1-split-adjustments.md, Wave 7).
+#
+# Contract:
+#   - Legacy rows are READ ONLY — spree_adjustments stays in place through 6.0
+#     and remains the rollback source.
+#   - Order totals are never touched; a per-order reconciliation asserts the
+#     typed sums match the order's stored totals. Orders that do not reconcile
+#     are logged and marked recalculation-frozen (metadata flag), never
+#     force-balanced.
+#   - Idempotent: orders with any typed rows already present are skipped.
+namespace :spree do
+  desc 'Convert legacy spree_adjustments into typed TaxLine/Discount/Fee rows'
+  task migrate_adjustments_to_typed_rows: :environment do
+    legacy = Class.new(ActiveRecord::Base) { self.table_name = 'spree_adjustments' }
+    abort 'spree_adjustments table not found — nothing to migrate' unless legacy.table_exists?
+
+    batch_size = ENV.fetch('BATCH_SIZE', 500).to_i
+    stats = Hash.new(0)
+
+    order_ids = legacy.distinct.pluck(:order_id)
+    puts "#{order_ids.size} orders carry legacy adjustments"
+
+    order_ids.each_slice(batch_size) do |slice|
+      Spree::Order.unscoped.where(id: slice).includes(:line_items).each do |order|
+        if Spree::TaxLine.where(order_id: order.id).exists? ||
+            Spree::Discount.where(order_id: order.id).exists? ||
+            Spree::Fee.where(order_id: order.id).exists?
+          stats[:skipped_already_typed] += 1
+          next
+        end
+
+        rows = legacy.where(order_id: order.id).to_a
+        frozen_reason = nil
+
+        ActiveRecord::Base.transaction do
+          rows.each do |row|
+            adjustable = Spree::TypedAdjustmentsMigration.resolve_typed_adjustable(order, row)
+
+            case row.source_type
+            when 'Spree::TaxRate'
+              next unless row.eligible
+
+              tax_rate = Spree::TaxRate.with_deleted.find_by(id: row.source_id)
+              Spree::TaxLine.create!(
+                order_id: order.id,
+                line_item: adjustable[:line_item],
+                fulfillment: adjustable[:fulfillment],
+                tax_rate_id: tax_rate&.id,
+                amount: row.amount,
+                rate: tax_rate&.amount || 0,
+                label: row.label.to_s.presence || 'Tax',
+                included: row.included,
+                provider_id: 'internal'
+              )
+              stats[:tax_lines] += 1
+            when 'Spree::PromotionAction'
+              next unless row.eligible
+
+              action = Spree::PromotionAction.with_deleted.find_by(id: row.source_id)
+              promotion = action&.promotion
+              Spree::TypedAdjustmentsMigration.build_distributed_discounts(order, row, adjustable, promotion, action, stats)
+            when nil
+              if row.amount.to_f.negative?
+                Spree::TypedAdjustmentsMigration.build_distributed_discounts(order, row, adjustable, nil, nil, stats, kind: 'manual')
+              else
+                Spree::Fee.create!(
+                  order_id: order.id,
+                  line_item: adjustable[:line_item],
+                  fulfillment: adjustable[:fulfillment],
+                  amount: row.amount,
+                  label: row.label.to_s.presence || 'Fee',
+                  kind: 'surcharge'
+                )
+                stats[:fees] += 1
+              end
+            when 'Spree::ReturnAuthorization'
+              frozen_reason = 'return_authorization_adjustment'
+              stats[:skipped_return_authorization] += 1
+            else
+              Spree::Fee.create!(
+                order_id: order.id,
+                line_item: adjustable[:line_item],
+                fulfillment: adjustable[:fulfillment],
+                amount: [row.amount, 0].max,
+                label: row.label.to_s.presence || row.source_type,
+                kind: 'surcharge',
+                metadata: { 'legacy_source_type' => row.source_type, 'legacy_source_id' => row.source_id }
+              )
+              stats[:fees_unknown_source] += 1
+            end
+          end
+
+          # Reconciliation: typed sums must match the stored order totals the
+          # customer was charged. discount_total compares against promotion rows;
+          # tax against tax lines.
+          unless frozen_reason
+            promo_delta = (Spree::Discount.where(order_id: order.id, kind: 'promotion').sum(:amount) - order.discount_total.to_d).abs
+            tax_delta = (Spree::TaxLine.where(order_id: order.id, included: false).sum(:amount) - order.additional_tax_total.to_d).abs
+            frozen_reason = 'totals_do_not_reconcile' if promo_delta > 0.01 || tax_delta > 0.01
+          end
+
+          if frozen_reason
+            order.update_columns(
+              metadata: (order.metadata || {}).merge(
+                'typed_adjustments_frozen' => frozen_reason,
+                'typed_adjustments_frozen_at' => Time.current.iso8601
+              )
+            )
+            stats[:frozen_orders] += 1
+            puts "FROZEN order #{order.number}: #{frozen_reason}"
+          end
+        end
+      rescue StandardError => e
+        stats[:errored_orders] += 1
+        puts "ERROR order #{order.number}: #{e.class} #{e.message}"
+      end
+      print '.'
+    end
+
+    puts
+    stats.each { |key, value| puts "#{key}: #{value}" }
+    puts 'migrate_adjustments_to_typed_rows done. spree_adjustments left intact for rollback.'
+  end
+end
+
+module Spree
+  module TypedAdjustmentsMigration
+    module_function
+
+    # Resolves the legacy adjustable into the typed target hash. Order-level
+    # rows return an empty target — the caller distributes them across line items.
+    def resolve_typed_adjustable(order, row)
+      case row.adjustable_type
+      when 'Spree::LineItem'
+        line_item = order.line_items.detect { |item| item.id == row.adjustable_id }
+        { line_item: line_item }
+      when 'Spree::Fulfillment', 'Spree::Shipment'
+        { fulfillment: Spree::Fulfillment.unscoped.find_by(id: row.adjustable_id) }
+      else
+        {}
+      end
+    end
+
+    # Line/fulfillment-targeted discounts become one row; order-level amounts
+    # are distributed across line items largest-remainder over their amounts,
+    # matching the runtime adjuster so migrated and fresh data split identically.
+    def build_distributed_discounts(order, row, adjustable, promotion, action, stats, kind: 'promotion')
+      base_attributes = {
+        order_id: order.id,
+        label: row.label.to_s.presence || promotion&.name || 'Discount',
+        kind: kind,
+        code: promotion&.code.presence,
+        promotion_id: promotion&.id,
+        promotion_action_id: action&.id
+      }
+
+      if adjustable[:line_item] || adjustable[:fulfillment]
+        Spree::Discount.create!(
+          base_attributes.merge(
+            line_item: adjustable[:line_item],
+            fulfillment: adjustable[:fulfillment],
+            amount: [row.amount, 0].min
+          )
+        )
+        stats[:discounts] += 1
+        return
+      end
+
+      line_items = order.line_items.to_a
+      bases = line_items.map { |item| [item.amount.to_d, BigDecimal(0)].max }
+      bases_sum = bases.sum
+      return if bases_sum <= 0
+
+      total_cents = ([row.amount.to_d.abs, bases_sum].min * 100).round
+      shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares(total_cents, bases)
+
+      line_items.each_with_index do |item, index|
+        amount = -BigDecimal(shares[index]) / 100
+        next if amount.zero?
+
+        Spree::Discount.create!(base_attributes.merge(line_item: item, amount: amount))
+        stats[:discounts_distributed] += 1
+      end
+    end
+  end
+end

data/lib/tasks/typed_stock_movements_migration.rake

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+# Defined here rather than in lib/spree/core/ — this is a one-release upgrade
+# step that dies with the polymorphic originator in 6.1, not engine
+# infrastructure. Same placement as Spree::ReturnsMigrator in a sibling task.
+module Spree
+  # Types the legacy stock-movement history and reconciles open fulfillments
+  # onto the allocation model (docs/plans/6.0-typed-stock-movements.md).
+  #
+  # Two jobs in one idempotent task. Typing narrows to rows without a kind;
+  # reconciliation skips fulfillments that already hold an allocation. Both
+  # predicates are queries over the data itself, so an interrupted run resumes
+  # for free and a second run finds nothing to do. That same predicate is what
+  # makes the deploy window safe: a fulfillment shipped before the task runs
+  # never gets an allocation, and dispatch only ships allocated units.
+  #
+  # Whether a fulfillment had shipped decides how its history reads. A closed
+  # one's departure was a departure. An open one's was the promise it still
+  # holds, so it types as the allocation and carries the counters with it —
+  # which also means reconciliation finds an allocation already there and
+  # leaves it alone. Reconciliation is left holding the open fulfillments that
+  # recorded no movement at all.
+  #
+  # Runs after spree:migrate_shipping_to_delivery, which rewrites the
+  # 'Spree::Shipment' originator strings, and after
+  # spree:upgrade:migrate_returns, because a legacy authorization id says
+  # nothing about the new record — the returns migrator preserves the number,
+  # not the id, and one authorization can become either a Return or an
+  # Exchange.
+  class TypedStockMovementsMigration
+    LEGACY_ADJUSTMENT_REASON = 'Legacy manual adjustment'
+    LEGACY_RETURN_TABLE = 'spree_return_authorizations'
+    FULFILLMENT_ORIGINATOR_TYPES = ['Spree::Fulfillment', 'Spree::Shipment'].freeze
+
+    def initialize(batch_size: 5_000)
+      @batch_size = batch_size
+      @typed = 0
+      @reconciled = 0
+    end
+
+    # @return [Hash] counts of rows typed and fulfillments reconciled
+    def call
+      type_history
+      reconcile_open_fulfillments
+
+      { typed: @typed, reconciled: @reconciled }
+    end
+
+    private
+
+    attr_reader :batch_size
+
+    def type_history
+      Spree::StockMovement.unscoped.where(kind: nil).find_each(batch_size: batch_size) do |movement|
+        # Read before the update rewrites it: the legacy sign is what says which
+        # way the stock went, and a typed row keeps only the magnitude.
+        legacy_quantity = movement.quantity.to_i
+        attributes = attributes_for(movement)
+
+        ActiveRecord::Base.transaction do
+          Spree::StockMovement.unscoped.where(id: movement.id).update_all(attributes.merge(updated_at: Time.current))
+          carry_promise(movement.stock_level_id, legacy_quantity) if open_fulfillment_row?(attributes)
+        end
+
+        @typed += 1
+      end
+    end
+
+    def open_fulfillment_row?(attributes)
+      attributes[:fulfillment_id].present? && open_fulfillment_ids.include?(attributes[:fulfillment_id])
+    end
+
+    # Turning an open fulfillment's placement row into its allocation has to
+    # move the counters with it, because the relabelling above skips callbacks.
+    # Legacy placement took the units off the shelf; under the allocation model
+    # they sit on the shelf and are promised, so both counters move by the same
+    # amount and availability comes out unchanged — which is what makes a
+    # pre-upgrade fulfillment safe to ship or cancel afterwards.
+    def carry_promise(stock_level_id, legacy_quantity)
+      delta = -legacy_quantity
+      return if delta.zero?
+
+      Spree::StockLevel.update_counters(
+        stock_level_id,
+        count_on_hand: delta,
+        allocated_count: delta,
+        touch: true
+      )
+    end
+
+    # Fulfillments still open when the upgrade runs. Read once: every
+    # fulfillment-originated row asks about them, and the set does not change
+    # while the task runs — typing and reconciliation both leave the status
+    # alone.
+    def open_fulfillment_ids
+      @open_fulfillment_ids ||= open_fulfillments.pluck(:id).to_set
+    end
+
+    def attributes_for(movement)
+      return { kind: 'adjusted', reason: LEGACY_ADJUSTMENT_REASON } if movement.originator_type.blank?
+
+      case movement.originator_type
+      when *FULFILLMENT_ORIGINATOR_TYPES then fulfillment_attributes(movement)
+      when 'Spree::StockTransfer' then stock_transfer_attributes(movement)
+      when 'Spree::ReturnAuthorization' then return_attributes(movement)
+      else by_sign(movement)
+      end
+    end
+
+    # A departure, or the restock of a cancellation or relocation, carrying
+    # the order the fulfillment belonged to so "which order was this for?"
+    # costs no join.
+    #
+    # A fulfillment still open when the upgrade runs never shipped: the
+    # departure it recorded at placement was the promise, and a promise is an
+    # allocation now — typing it 'shipped' would retire an allocation the
+    # fulfillment still holds, leaving it unable to ship or be cancelled. One
+    # that has already gone out keeps the departure.
+    def fulfillment_attributes(movement)
+      fulfillment = Spree::Fulfillment.find_by(id: movement.originator_id)
+      return by_sign(movement) if fulfillment.nil?
+
+      departure = open_fulfillment_ids.include?(fulfillment.id) ? 'allocated' : 'shipped'
+
+      by_sign(movement, negative: departure, positive: 'released').
+        merge(fulfillment_id: fulfillment.id, order_id: fulfillment.order_id)
+    end
+
+    def stock_transfer_attributes(movement)
+      return by_sign(movement) unless Spree::StockTransfer.exists?(id: movement.originator_id)
+
+      by_sign(movement).merge(stock_transfer_id: movement.originator_id)
+    end
+
+    # The legacy id is worthless on its own, so the authorization is read by
+    # name and its preserved number matched against whichever record the
+    # returns migrator produced.
+    def return_attributes(movement)
+      attributes = { kind: 'received', quantity: movement.quantity.to_i.abs }
+      record = migrated_return_for(movement.originator_id)
+
+      case record
+      when Spree::Return then attributes.merge(return_id: record.id, order_id: record.order_id)
+      when Spree::Exchange then attributes.merge(exchange_id: record.id, order_id: record.order_id)
+      else attributes
+      end
+    end
+
+    def migrated_return_for(authorization_id)
+      return nil unless legacy_returns
+
+      number = legacy_returns.where(id: authorization_id).pick(:number)
+      return nil if number.blank?
+
+      Spree::Return.find_by(number: number) || Spree::Exchange.find_by(number: number)
+    end
+
+    def legacy_returns
+      return @legacy_returns if defined?(@legacy_returns)
+
+      @legacy_returns =
+        if ActiveRecord::Base.connection.table_exists?(LEGACY_RETURN_TABLE)
+          Class.new(Spree.base_class) do
+            self.table_name = LEGACY_RETURN_TABLE
+            def self.name = 'LegacyReturnAuthorization'
+          end
+        end
+    end
+
+    # A movement whose cause cannot be resolved is still a true statement
+    # about stock, so it is typed by which way the stock went and left with no
+    # cause key rather than skipped. The three order-driven kinds are written
+    # positive — the kind carries the direction now.
+    def by_sign(movement, negative: 'shipped', positive: 'received')
+      quantity = movement.quantity.to_i
+
+      { kind: quantity.negative? ? negative : positive, quantity: quantity.abs }
+    end
+
+    # Under the old model an unfulfilled fulfillment on a placed order had
+    # already taken its units off the shelf. Under the new one those units are
+    # on the shelf and allocated, so both counters move together and
+    # availability is unchanged by construction — backordered units included,
+    # since the pair of increments cancels out the negative on-hand that used
+    # to represent them.
+    def reconcile_open_fulfillments
+      open_fulfillments.find_each(batch_size: batch_size) do |fulfillment|
+        next if fulfillment.stock_location.nil?
+        next if Spree::StockMovement.exists?(fulfillment_id: fulfillment.id, kind: 'allocated')
+
+        reconcile(fulfillment)
+      end
+    end
+
+    def open_fulfillments
+      Spree::Fulfillment.
+        where(status: 'unfulfilled').
+        joins(:order).
+        where.not(Spree::Order.table_name => { completed_at: nil })
+    end
+
+    def reconcile(fulfillment)
+      quantities = fulfillment.fulfillment_items.group(:variant_id).sum(:quantity)
+      return if quantities.empty?
+
+      ActiveRecord::Base.transaction do
+        quantities.each do |variant_id, quantity|
+          quantity = quantity.to_i
+          next unless quantity.positive?
+
+          variant = Spree::Variant.with_deleted.find_by(id: variant_id)
+          next if variant.nil? || !variant.should_track_inventory?
+
+          stock_level = fulfillment.stock_location.stock_level_or_create(variant)
+          # A direct column write, not a `received` movement: no goods
+          # arrived. The allocation below is what gives the jump a cause.
+          #
+          # Incremented in the database rather than read and written back, so a
+          # count that moved since it was read is added to rather than replaced.
+          Spree::StockLevel.update_counters(stock_level.id, count_on_hand: quantity, touch: true)
+          fulfillment.stock_location.allocate(variant, quantity, fulfillment)
+        end
+      end
+
+      @reconciled += 1
+    end
+  end
+end
+
+namespace :spree do
+  desc <<~DESC
+    Type legacy stock movements and reconcile open fulfillments onto allocations.
+
+    Gives every pre-6.0 movement a kind and a concrete cause key derived from
+    its polymorphic originator, then puts the units of every open fulfillment
+    on a placed order back on the shelf and allocates them, which is where
+    they belong now that stock leaves at dispatch rather than at placement.
+
+    Run after spree:migrate_shipping_to_delivery and after
+    spree:upgrade:migrate_returns. Idempotent. Tune the load size with
+    BATCH_SIZE (default 5000).
+  DESC
+  task migrate_stock_movements_to_typed_rows: :environment do
+    result = Spree::TypedStockMovementsMigration.new(batch_size: ENV.fetch('BATCH_SIZE', 5_000).to_i).call
+
+    puts "spree_stock_movements: #{result[:typed]} legacy rows typed"
+    puts "spree_fulfillments: #{result[:reconciled]} open fulfillments reconciled onto allocations"
+    puts 'migrate_stock_movements_to_typed_rows done.'
+  end
+end