spree_core 5.6.1 → 6.0.0.beta2

data/lib/tasks/inventory_operations_migration.rake

@@ -0,0 +1,223 @@
+module Spree
+  # Turns 5.x "external receive" stock transfers into purchase orders.
+  #
+  # A supplier receive was never a transfer: it has a cost, a supplier and an
+  # expected date, none of which moving stock between two of the merchant's own
+  # warehouses has (docs/plans/6.0-inventory-operations.md). Each source-less
+  # transfer becomes a Spree::PurchaseOrder against a "Migrated receives"
+  # supplier, its existing movements are re-pointed at the new order, and the
+  # transfer is soft-deleted so its number stays readable.
+  #
+  # Stock is never touched: those movements already moved it, at the time.
+  class ExternalReceivesMigrator
+    # Historical unit costs are unknowable — nothing recorded them.
+    UNKNOWN_UNIT_COST = 0
+    SUPPLIER_NAME = 'Migrated receives'.freeze
+
+    def initialize(output: $stdout)
+      @output = output
+      @migrated = 0
+      @skipped = 0
+    end
+
+    def call
+      pending.find_each { |transfer| migrate_one(transfer) }
+      backfilled = backfill_internal_transfers
+
+      @output.puts "  Migrated #{@migrated} external receive(s), skipped #{@skipped}."
+      @output.puts "  Backfilled store and status on #{backfilled} internal transfer(s)."
+    end
+
+    private
+
+    # Only live, source-less rows. A previous run's output is soft-deleted, so
+    # re-running picks up just what it could not reach.
+    def pending
+      Spree::StockTransfer.where(source_location_id: nil)
+    end
+
+    def migrate_one(transfer)
+      destination = transfer.destination_location
+
+      if destination.nil? || destination.store.nil?
+        skip(transfer, 'its destination location has no store')
+        return
+      end
+
+      Spree::StockTransfer.transaction do
+        movements = transfer.stock_movements.to_a
+        purchase_order = build_purchase_order(transfer, destination, movements)
+
+        # A receive whose movements no longer resolve to a variant has nothing
+        # to order; the transfer is left for a human to look at.
+        if purchase_order.items.empty?
+          skip(transfer, 'no stock movements to build lines from')
+          raise ActiveRecord::Rollback
+        end
+
+        # A legacy receive whose movements cancel out to zero for a variant
+        # cannot become a line, and must not take the rest of the run with it.
+        unless purchase_order.save
+          skip(transfer, purchase_order.errors.full_messages.join(', '))
+          raise ActiveRecord::Rollback
+        end
+
+        receipt = mint_receipt(purchase_order, transfer)
+        Spree::StockMovement.where(id: movements.map(&:id)).update_all(
+          purchase_order_id: purchase_order.id,
+          stock_receipt_id: receipt.id
+        )
+        transfer.update_columns(status: 'received', deleted_at: Time.current)
+
+        @output.puts "  #{transfer.number} → #{purchase_order.number} (#{purchase_order.items.size} line(s))"
+        @migrated += 1
+      end
+    end
+
+    def build_purchase_order(transfer, destination, movements)
+      store = destination.store
+
+      purchase_order = store.purchase_orders.new(
+        supplier: supplier_for(store),
+        destination_location: destination,
+        currency: store.default_currency,
+        status: 'received',
+        received_at: transfer.created_at,
+        reference: transfer.reference.presence || transfer.number,
+        notes: "Migrated from stock transfer #{transfer.number}."
+      )
+
+      lines_from(movements).each do |variant_id, quantity|
+        purchase_order.items.build(
+          variant_id: variant_id,
+          quantity_ordered: quantity,
+          quantity_received: quantity,
+          unit_cost: UNKNOWN_UNIT_COST
+        )
+      end
+
+      purchase_order
+    end
+
+    # The receive itself, as the record every later delivery gets: one
+    # receipt, dated when the transfer was, accepting every line in full.
+    def mint_receipt(purchase_order, transfer)
+      receipt = purchase_order.stock_receipts.build(
+        store: purchase_order.store,
+        received_at: transfer.created_at,
+        reference: transfer.number,
+        notes: "Migrated from stock transfer #{transfer.number}."
+      )
+      purchase_order.items.each do |item|
+        receipt.items.build(line: item, quantity_accepted: item.quantity_received)
+      end
+      receipt.save!
+      receipt
+    end
+
+    # One line per variant, summing the movements that named it: a 5.x receive
+    # of five SKUs is five movement rows whose only link is the transfer.
+    #
+    # Signed, so rows that offset each other total what they actually moved.
+    # A variant summing to zero is dropped — it received nothing, and a line
+    # of zero would fail validation and take the whole transfer with it. A
+    # negative total is left alone deliberately: the line then refuses to
+    # validate and the transfer is skipped for someone to look at, which is
+    # the right answer for a receive that reads as a dispatch.
+    def lines_from(movements)
+      totals = movements.each_with_object({}) do |movement, lines|
+        variant_id = movement.stock_level&.variant_id
+        next if variant_id.nil?
+
+        lines[variant_id] = lines.fetch(variant_id, 0) + movement.quantity
+      end
+
+      totals.reject { |_variant_id, quantity| quantity.zero? }
+    end
+
+    def supplier_for(store)
+      @suppliers ||= {}
+      @suppliers[store.id] ||= store.suppliers.find_or_create_by!(name: SUPPLIER_NAME) do |supplier|
+        supplier.notes = 'Created by spree:upgrade:migrate_external_receives_to_purchase_orders ' \
+                         'to own receives that predate purchase orders.'
+      end
+    end
+
+    # Every 5.x transfer moved its stock the instant it was created, so it is
+    # retroactively a completed one — which is what today's reality already is.
+    def backfill_internal_transfers
+      scope = Spree::StockTransfer.where(status: nil).or(Spree::StockTransfer.where(store_id: nil))
+      count = 0
+
+      scope.includes(:destination_location).find_each do |transfer|
+        store_id = transfer.store_id || transfer.destination_location&.store_id
+        next if store_id.nil?
+
+        transfer.update_columns(
+          store_id: store_id,
+          status: transfer.status || 'received',
+          received_at: transfer.received_at || transfer.created_at
+        )
+        count += 1
+      end
+
+      count
+    end
+
+    def skip(transfer, reason)
+      @output.puts "  Skipping transfer #{transfer.number}: #{reason}."
+      @skipped += 1
+    end
+  end
+end
+
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Converts 5.x "external receive" stock transfers — the ones with no source
+      location — into purchase orders, and gives every other transfer the store
+      and status the 6.0 lifecycle expects.
+
+      The original transfer is soft-deleted so its T-… number stays findable
+      for historical reporting without the same receive appearing twice in the
+      admin. Purge them with spree:upgrade:purge_migrated_external_receives
+      once nobody needs the old numbers.
+
+      Idempotent: stock is never touched, and a transfer already migrated is
+      out of scope on the next run.
+    DESC
+    task migrate_external_receives_to_purchase_orders: :environment do
+      Spree::ExternalReceivesMigrator.new.call
+    end
+
+    desc <<~DESC
+      Deletes the stock transfers that
+      spree:upgrade:migrate_external_receives_to_purchase_orders soft-deleted,
+      once their T-… numbers are no longer needed.
+
+      Only source-less, soft-deleted rows whose movements now belong to a
+      purchase order are removed — a transfer still owning its ledger is left
+      alone.
+    DESC
+    task purge_migrated_external_receives: :environment do
+      still_owning_movements = Spree::StockMovement.where(purchase_order_id: nil).
+                              where.not(stock_transfer_id: nil).select(:stock_transfer_id)
+
+      migrated = Spree::StockTransfer.only_deleted.
+                 where(source_location_id: nil).
+                 where.not(id: still_owning_movements)
+
+      count = 0
+      migrated.find_each do |transfer|
+        # The movements kept naming the transfer for lineage while it was only
+        # soft-deleted. It is about to stop existing, so that reference has to
+        # go with it rather than becoming an id that resolves to nothing.
+        Spree::StockMovement.where(stock_transfer_id: transfer.id).update_all(stock_transfer_id: nil)
+        transfer.really_destroy!
+        count += 1
+      end
+
+      puts "  Purged #{count} migrated external receive(s)."
+    end
+  end
+end

data/lib/tasks/markets.rake

@@ -11,7 +11,12 @@ namespace :spree do
         countries = if zone
                       zone.country_list.to_a
                     else
-                      default_country = Spree::Country.find_by(id: store.read_attribute(:default_country_id))
+                      # Countries are reference data in 6.0, so the legacy id
+                      # is resolved against the table the upgrade keeps.
+                      iso = ActiveRecord::Base.connection.select_value(
+                        "SELECT iso FROM spree_countries WHERE id = #{ActiveRecord::Base.connection.quote(store.read_attribute(:default_country_id))}"
+                      ) if store.read_attribute(:default_country_id)
+                      default_country = Spree::Country.by_iso(iso) if iso
                       default_country ? [default_country] : []
                     end
 
@@ -28,7 +33,7 @@ namespace :spree do
           currency: iso_country&.currency_code || store.read_attribute(:default_currency) || 'USD',
           default_locale: iso_country&.languages_official&.first || store.read_attribute(:default_locale) || 'en',
           default: true,
-          country_ids: countries.map(&:id)
+          countries: countries
         )
 
         store.update_column(:checkout_zone_id, nil) if checkout_zone_id

data/lib/tasks/media.rake

@@ -17,7 +17,7 @@ namespace :spree do
       puts 'Done!'
     end
 
-    # Enqueues Spree::Media::MigrateProductAssetsJob for every product that
+    # Enqueues Spree::Images::MigrateProductMediaJob for every product that
     # still has at least one variant-pinned asset. The job is idempotent, so
     # re-running this task is safe.
     #
@@ -38,7 +38,7 @@ namespace :spree do
 
       relation = Spree::Product.where(id: variant_product_ids)
       relation.find_each(batch_size: batch_size) do |product|
-        Spree::Media::MigrateProductAssetsJob.perform_later(product.id)
+        Spree::Images::MigrateProductMediaJob.perform_later(product.id)
       end
 
       puts "Enqueued migration jobs for #{relation.count} products on the #{Spree.queues.images} queue."

data/lib/tasks/media_class_rename.rake

@@ -0,0 +1,56 @@
+namespace :spree do
+  # Spree::Asset and Spree::Image became Spree::Media in 6.0. The table rename
+  # travels with db:migrate, but the old class names are also written into data:
+  # Active Storage's polymorphic owner column, and custom field resource types.
+  #
+  # The Active Storage rows are the critical ones — every product image and
+  # video is attached through `record_type`, so without this step the files are
+  # orphaned from their media rows.
+  #
+  # Idempotent — rows already carrying 'Spree::Media' are left alone.
+  desc 'Rewrite stored Spree::Asset / Spree::Image class names to Spree::Media (6.0)'
+  task migrate_media_class_names: :environment do
+    legacy_names = %w[Spree::Asset Spree::Image]
+
+    # A definition for Spree::Image may already exist alongside one for
+    # Spree::Asset with the same namespace and key. Renaming both would violate
+    # the definition's uniqueness, so fold the duplicates into the survivor
+    # before the bulk rewrite below touches them.
+    # Group by what the uniqueness index covers. Any group holding more than one
+    # row collapses to a single survivor — including a group of only legacy rows
+    # (a Spree::Asset and a Spree::Image sharing a key), which would otherwise
+    # both rewrite to Spree::Media and collide.
+    puts 'Merging duplicate custom field definitions...'
+    Spree::CustomFieldDefinition.transaction do
+      Spree::CustomFieldDefinition.
+        where(resource_type: legacy_names + ['Spree::Media']).
+        group_by { |definition| [definition.namespace, definition.key] }.
+        each_value do |group|
+          next if group.one?
+
+          # Prefer a row already on the new name so its id keeps its custom fields.
+          survivor = group.find { |definition| definition.resource_type == 'Spree::Media' } || group.first
+
+          (group - [survivor]).each do |duplicate|
+            Spree::CustomField.where(custom_field_definition_id: duplicate.id).
+              update_all(custom_field_definition_id: survivor.id)
+            duplicate.delete
+          end
+        end
+    end
+
+    puts 'Rewriting renamed class-name strings...'
+    [
+      [ActiveStorage::Attachment, :record_type],
+      [Spree::CustomField, :resource_type],
+      [Spree::CustomFieldDefinition, :resource_type]
+    ].each do |model, column|
+      legacy_names.each do |legacy_name|
+        count = model.where(column => legacy_name).update_all(column => 'Spree::Media')
+        puts "  #{model.table_name}.#{column}: #{count} rows #{legacy_name} -> Spree::Media"
+      end
+    end
+
+    puts 'Done!'
+  end
+end

data/lib/tasks/migrate_country_state_codes.rake

@@ -0,0 +1,228 @@
+# Defined here rather than in lib/spree/core/ — this is a one-release upgrade
+# step that dies with the country and state tables in 6.1, not engine
+# infrastructure. Same placement as Spree::ReturnsMigrator in a sibling task.
+module Spree
+  # Copies country and state foreign keys onto the ISO string columns that
+  # replace them. Driven by `rake spree:upgrade:migrate_country_state_codes`.
+  #
+  # Reads the legacy tables through throwaway model classes: Spree::Country and
+  # Spree::State stop being ActiveRecord models in 6.0, but this task has to
+  # keep working against a database where their tables are still present.
+  #
+  # Resumable by construction. Every table is filled with one UPDATE ... FROM
+  # scoped to the rows whose ISO column is still null, so the work outstanding
+  # is a query rather than tracked state. An interrupted run picks up where it
+  # stopped, and re-running when nothing is left is a no-op.
+  class CountryStateCodeMigrator
+    COUNTRIES_TABLE = 'spree_countries'.freeze
+    STATES_TABLE = 'spree_states'.freeze
+
+    # @return [Hash, nil] rows filled per table, or nil when there is nothing to migrate
+    def call
+      return nil unless connection.table_exists?(COUNTRIES_TABLE)
+
+      {
+        addresses: backfill_addresses,
+        delivery_zone_members: backfill_delivery_zone_members,
+        market_countries: backfill_market_countries,
+        stock_locations: backfill_stock_locations,
+        stores: backfill_stores
+      }
+    end
+
+    private
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def quote(value)
+      connection.quote_table_name(value)
+    end
+
+    # Country ISO for every row whose FK still resolves. The state branch is
+    # separate because a row can carry a country without a state.
+    def backfill_country_code(table, foreign_key: 'country_id', column: 'country_code')
+      return 0 unless connection.column_exists?(table, column)
+
+      update_from(
+        table: table,
+        source: COUNTRIES_TABLE,
+        assignments: { column => 'iso' },
+        foreign_key: foreign_key,
+        guard: column
+      )
+    end
+
+    def backfill_addresses
+      filled = backfill_country_code(Spree::Address.table_name)
+      filled + backfill_state_code(Spree::Address.table_name)
+    end
+
+    def backfill_delivery_zone_members
+      table = Spree::DeliveryZoneMember.table_name
+      filled = backfill_country_code(table)
+      filled += copy_state_code(table)
+      # A state member records no country of its own, so its country comes from
+      # the state's — without it, coverage queries could not tell which country
+      # an abbreviation belongs to. Runs before normalization, which needs both
+      # halves to resolve a code.
+      filled += backfill_country_code_from_state(table)
+      normalize_state_codes(table)
+      filled
+    end
+
+    def backfill_market_countries
+      backfill_country_code(Spree::MarketCountry.table_name)
+    end
+
+    def backfill_stock_locations
+      table = Spree::StockLocation.table_name
+      backfill_country_code(table) + backfill_state_code(table)
+    end
+
+    def backfill_stores
+      backfill_country_code(
+        Spree::Store.table_name,
+        foreign_key: 'default_country_id',
+        column: 'default_country_code'
+      )
+    end
+
+    # Copies the code across, then normalizes it: the pre-6.0 seed wrote codes
+    # ISO has since retired (Odisha as OR, Gauteng as GT) and occasionally in
+    # lower case, while matching compares stored codes verbatim. Left as-is,
+    # a backfilled address would silently stop matching zones written with the
+    # successor code.
+    def backfill_state_code(table)
+      return 0 unless connection.column_exists?(table, 'state_code')
+
+      filled = copy_state_code(table)
+      normalize_state_codes(table)
+      filled
+    end
+
+    # The verbatim copy, split out so callers that still have to derive the
+    # country can normalize afterwards rather than before.
+    def copy_state_code(table)
+      return 0 unless connection.column_exists?(table, 'state_code')
+
+      update_from(
+        table: table,
+        source: STATES_TABLE,
+        assignments: { 'state_code' => 'abbr' },
+        foreign_key: 'state_id',
+        guard: 'state_code'
+      )
+    end
+
+    # Rewrites any code that isn't already the canonical one for its country.
+    def normalize_state_codes(table)
+      quoted_table = quote(table)
+      rows = connection.select_rows(<<~SQL.squish)
+        SELECT DISTINCT country_code, state_code FROM #{quoted_table}
+        WHERE state_code IS NOT NULL AND country_code IS NOT NULL
+      SQL
+
+      rows.each do |country_code, state_code|
+        canonical = Spree::IsoData.subdivision_code(country_code, state_code)
+        next if canonical.blank? || canonical == state_code
+
+        connection.update(<<~SQL.squish)
+          UPDATE #{quoted_table} SET state_code = #{connection.quote(canonical)}
+          WHERE country_code = #{connection.quote(country_code)}
+            AND state_code = #{connection.quote(state_code)}
+        SQL
+      end
+    end
+
+    # Country ISO for state members, resolved through the state's own country.
+    def backfill_country_code_from_state(table)
+      quoted_table = quote(table)
+      states = quote(STATES_TABLE)
+      countries = quote(COUNTRIES_TABLE)
+
+      sql = <<~SQL.squish
+        UPDATE #{quoted_table}
+        SET country_code = (
+          SELECT #{countries}.iso
+          FROM #{states}
+          INNER JOIN #{countries} ON #{countries}.id = #{states}.country_id
+          WHERE #{states}.id = #{quoted_table}.state_id
+        )
+        WHERE #{quoted_table}.country_code IS NULL
+          AND #{quoted_table}.state_id IS NOT NULL
+      SQL
+
+      connection.update(sql)
+    end
+
+    # A correlated subquery rather than UPDATE ... FROM: the latter's syntax
+    # differs across PostgreSQL, MySQL and SQLite, and this shape runs on all
+    # three. Row counts here are small — a few hundred thousand addresses at
+    # most — so the simpler portable form is worth more than the speed.
+    def update_from(table:, source:, assignments:, foreign_key:, guard:)
+      return 0 unless connection.table_exists?(source)
+
+      quoted_table = quote(table)
+      quoted_source = quote(source)
+
+      sets = assignments.map do |target_column, source_column|
+        <<~SQL.squish
+          #{target_column} = (
+            SELECT #{quoted_source}.#{source_column}
+            FROM #{quoted_source}
+            WHERE #{quoted_source}.id = #{quoted_table}.#{foreign_key}
+          )
+        SQL
+      end
+
+      sql = <<~SQL.squish
+        UPDATE #{quoted_table}
+        SET #{sets.join(', ')}
+        WHERE #{quoted_table}.#{guard} IS NULL
+          AND #{quoted_table}.#{foreign_key} IS NOT NULL
+      SQL
+
+      connection.update(sql)
+    end
+  end
+end
+
+namespace :spree do
+  namespace :upgrade do
+    desc <<~DESC
+      Copies country and state foreign keys onto the ISO code columns that
+      replace them (docs/plans/6.0-drop-country-state-models.md).
+
+      Countries and states stop being database records in Spree 6; addresses,
+      delivery zone members, market countries, stock locations and stores name
+      them by ISO code instead. This fills those columns from the existing
+      foreign keys.
+
+      Delivery zone members that name a state also gain their country, which
+      the state row used to supply. A subdivision code is only unique within
+      its country, so the pair is what makes a member resolvable on its own.
+
+      Resumable by construction: each table is filled with a single statement
+      scoped to the rows whose ISO column is still empty, so an interrupted
+      run picks up where it stopped and re-running when nothing is left is a
+      no-op — no cursor to track, no state to reset.
+
+      Run after spree:migrate_zones_to_delivery_zones, so converted zone
+      members are present to be backfilled.
+    DESC
+    task migrate_country_state_codes: :environment do
+      result = Spree::CountryStateCodeMigrator.new.call
+
+      if result.nil?
+        puts '  spree_countries not found — nothing to migrate.'
+        next
+      end
+
+      result.each do |table, filled|
+        puts "  #{table}: filled #{filled} row(s)."
+      end
+    end
+  end
+end

data/lib/tasks/migrate_promotion_option_value_rules.rake

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# 5.6 → 6.0: rewrite Option Value promotion rules that still store
+# Spree::OptionValueVariant join-row ids into stable Spree::OptionValue ids.
+module Spree
+  # Rewrites legacy join-row ids in Option Value promotion rules. Ambiguous or
+  # unresolvable ids are reported and left untouched so operators can review
+  # affected rules before continuing.
+  class PromotionOptionValueRulesMigrator
+    Issue = Data.define(:rule_id, :raw_id, :kind)
+
+    # @return [Integer] number of rules rewritten
+    attr_reader :converted
+
+    # @return [Array<Issue>] ids that could not be mapped
+    attr_reader :issues
+
+    # @param skip_failed [Boolean] when true, report issues but do not abort
+    def initialize(skip_failed: false)
+      @skip_failed = skip_failed
+      @converted = 0
+      @issues = []
+    end
+
+    # @return [void]
+    def call
+      total = Spree::Promotion::Rules::OptionValue.count
+
+      Spree::Promotion::Rules::OptionValue.find_each do |rule|
+        migrate_rule(rule)
+      end
+
+      report(total)
+    end
+
+    private
+
+    # @param rule [Spree::Promotion::Rules::OptionValue]
+    # @return [void]
+    def migrate_rule(rule)
+      raw = Array(rule.preferred_eligible_values).map(&:to_s).compact_blank
+      return if raw.empty?
+
+      mapped = []
+      rule_issues = []
+
+      raw.each do |raw_id|
+        resolution = resolve_id(raw_id)
+        case resolution
+        in :ambiguous
+          rule_issues << Issue.new(rule_id: rule.id, raw_id: raw_id, kind: :ambiguous)
+        in :unresolved
+          rule_issues << Issue.new(rule_id: rule.id, raw_id: raw_id, kind: :unresolved)
+        in String
+          mapped << resolution
+        end
+      end
+
+      if rule_issues.any?
+        @issues.concat(rule_issues)
+        return
+      end
+
+      mapped.uniq!
+      return if mapped == raw
+
+      rule.update!(preferred_eligible_values: mapped)
+      @converted += 1
+    end
+
+    # @param raw_id [String]
+    # @return [String, :ambiguous, :unresolved]
+    def resolve_id(raw_id)
+      join_row = Spree::OptionValueVariant.find_by(id: raw_id)
+      option_value = Spree::OptionValue.exists?(raw_id)
+
+      if join_row && option_value
+        :ambiguous
+      elsif join_row
+        join_row.option_value_id.to_s
+      elsif option_value
+        raw_id
+      else
+        :unresolved
+      end
+    end
+
+    # @param total [Integer]
+    # @return [void]
+    def report(total)
+      puts "Option Value promotion rules: #{@converted}/#{total} converted to option value ids"
+
+      return if @issues.empty?
+
+      puts "  #{@issues.size} eligible value id(s) could not be migrated:"
+      @issues.each do |issue|
+        puts "  rule ##{issue.rule_id} id #{issue.raw_id}: #{issue.kind}"
+      end
+
+      if @skip_failed
+        report_skip_notice
+        return
+      end
+
+      abort '  Re-run after fixing affected rules, or pass SKIP_FAILED_ROWS=true to continue without converting them.'
+    end
+
+    # @return [void]
+    def report_skip_notice
+      puts '  Continuing anyway (SKIP_FAILED_ROWS=true).'
+    end
+  end
+end
+
+namespace :spree do
+  namespace :upgrade do
+    desc 'Rewrite Option Value promotion rules from join-row ids to option value ids'
+    task migrate_promotion_option_value_rules: :environment do
+      Spree::PromotionOptionValueRulesMigrator.new(
+        skip_failed: ENV['SKIP_FAILED_ROWS'] == 'true'
+      ).call
+    end
+  end
+end