spree_core 5.6.1 → 6.0.0.beta1

data/db/migrate/20260806120001_add_rate_provider_to_delivery_methods.rb

@@ -0,0 +1,7 @@
+class AddRateProviderToDeliveryMethods < ActiveRecord::Migration[7.2]
+  def change
+    # Blank means the Internal provider (calculator-backed), so existing rows
+    # need no backfill.
+    add_column :spree_delivery_methods, :rate_provider, :string
+  end
+end

data/db/migrate/20260806120002_add_carrier_columns_to_delivery_rates.rb

@@ -0,0 +1,13 @@
+class AddCarrierColumnsToDeliveryRates < ActiveRecord::Migration[7.2]
+  def change
+    add_column :spree_delivery_rates, :carrier, :string
+    add_column :spree_delivery_rates, :service_level, :string
+    add_column :spree_delivery_rates, :estimated_delivery_date, :date
+
+    if connection.adapter_name.downcase.include?('postgresql')
+      add_column :spree_delivery_rates, :metadata, :jsonb
+    else
+      add_column :spree_delivery_rates, :metadata, :json
+    end
+  end
+end

data/db/migrate/20260806130001_add_unique_store_type_index_to_spree_integrations.rb

@@ -0,0 +1,9 @@
+class AddUniqueStoreTypeIndexToSpreeIntegrations < ActiveRecord::Migration[7.2]
+  def change
+    # Backs the existing one-integration-per-(store, type) model validation.
+    # No de-duplication step: core ships no Integration subclasses and none
+    # were creatable before this release, so the table is empty everywhere.
+    add_index :spree_integrations, [:store_id, :type], unique: true,
+              name: 'index_spree_integrations_on_store_id_and_type', if_not_exists: true
+  end
+end

data/db/migrate/20260807000001_add_permissions_to_spree_roles.rb

@@ -0,0 +1,14 @@
+class AddPermissionsToSpreeRoles < ActiveRecord::Migration[8.1]
+  def change
+    change_table :spree_roles do |t|
+      t.string :description
+      t.boolean :mutable, default: true, null: false
+
+      if t.respond_to?(:jsonb)
+        t.jsonb :permissions
+      else
+        t.json :permissions
+      end
+    end
+  end
+end

data/db/migrate/20260807000001_create_spree_companies.rb

@@ -0,0 +1,66 @@
+class CreateSpreeCompanies < ActiveRecord::Migration[8.1]
+  def change
+    create_table :spree_companies do |t|
+      t.references :store, null: false
+      t.references :parent                   # self-referential tree, nil = root
+      t.string :name, null: false
+      # 'company' (legal entity) or 'division' (organizational unit). No DB
+      # default per the string-column rule; the model normalizes a blank kind.
+      t.string :kind, null: false
+      # No external_id column — ERP/CRM identity lives on
+      # Spree::ExternalReference. No tax_exempt boolean — exemption is a certificate scoped to a
+      # jurisdiction, which a flag cannot express (docs/plans/decisions.md
+      # 2026-08-07).
+      if t.respond_to?(:jsonb)
+        t.jsonb :metadata
+      else
+        t.json :metadata
+      end
+      # Which of the node's addresses to prefill with. The address book itself
+      # is ordinary spree_addresses rows owned by the node, so a default is a
+      # pointer at one of them — the same shape the customer
+      # (bill_address_id / ship_address_id) and the seller
+      # (billing_address_id) already use. Two columns cannot disagree about
+      # which row is default, so nothing has to demote a previous one.
+      t.bigint :default_bill_address_id
+      t.bigint :default_ship_address_id
+      t.timestamps
+    end
+
+    # Membership gives a customer standing over the node and its subtree.
+    # Always customer-backed — the not-yet-registered case is an invitation.
+    create_table :spree_company_memberships do |t|
+      t.references :company, null: false
+      t.references :customer, null: false
+      t.timestamps
+    end
+
+    add_index :spree_company_memberships, [:company_id, :customer_id], unique: true,
+              name: 'idx_company_memberships_on_company_and_customer'
+
+    create_table :spree_company_invitations do |t|
+      t.references :company, null: false
+      t.references :inviter                  # customer who invited; nil = staff
+      t.references :customer                 # bound at acceptance
+      t.string :email, null: false
+      t.string :token, null: false           # plaintext, like the staff invitation token
+      t.datetime :expires_at, null: false
+      t.datetime :accepted_at
+      t.datetime :revoked_at
+      if t.respond_to?(:jsonb)
+        t.jsonb :metadata
+      else
+        t.json :metadata
+      end
+      t.timestamps
+    end
+
+    add_index :spree_company_invitations, :token, unique: true
+    add_index :spree_company_invitations, [:company_id, :email]
+
+    # Both sides: exemption has to resolve while the buyer is still in
+    # checkout, and completion copies the node onto the order.
+    add_reference :spree_carts, :company
+    add_reference :spree_orders, :company
+  end
+end

data/db/migrate/20260807000003_create_spree_tax_exemption_certificates.rb

@@ -0,0 +1,31 @@
+class CreateSpreeTaxExemptionCertificates < ActiveRecord::Migration[8.1]
+  def change
+    create_table :spree_tax_exemption_certificates do |t|
+      t.references :company, null: false
+      # Codes, not references: Country and State are being dropped, and a blank
+      # code is what "everywhere" means here. Same shape as spree_tax_rates.
+      t.string :country_code                  # nil = every country
+      t.string :state_code                   # nil = the entire country
+      t.string :certificate_number, null: false
+      t.string :reason_code, null: false     # resale, government, … — becomes the
+                                             # provider's entity use code
+      t.string :status, null: false          # no DB default: set by the creating service
+      t.datetime :issued_at
+      t.datetime :expires_at
+      t.string :issuing_authority
+      # Who accepted the certificate, and when — the same pair every other
+      # reviewed record keeps.
+      t.datetime :verified_at
+      t.references :verified_by
+      if t.respond_to?(:jsonb)
+        t.jsonb :metadata
+      else
+        t.json :metadata
+      end
+      t.timestamps
+    end
+
+    add_index :spree_tax_exemption_certificates, [:company_id, :status]
+    add_index :spree_tax_exemption_certificates, [:country_code, :state_code]
+  end
+end

data/db/migrate/20260807120001_remove_claim_type_from_spree_claims.rb

@@ -0,0 +1,5 @@
+class RemoveClaimTypeFromSpreeClaims < ActiveRecord::Migration[8.1]
+  def change
+    remove_column :spree_claims, :claim_type, :string, null: false
+  end
+end

data/db/migrate/20260807130001_add_country_state_codes_to_consumers.rb

@@ -0,0 +1,28 @@
+class AddCountryStateCodesToConsumers < ActiveRecord::Migration[7.2]
+  def change
+    add_column :spree_addresses, :country_code, :string
+    add_column :spree_addresses, :state_code, :string
+    add_index :spree_addresses, :country_code
+
+    # State members carry their country too: a subdivision code is only unique
+    # within its country ("CA" is California and several other things), and
+    # coverage queries would otherwise need the states table to resolve it.
+    add_column :spree_delivery_zone_members, :country_code, :string
+    add_column :spree_delivery_zone_members, :state_code, :string
+    add_index :spree_delivery_zone_members, :country_code
+
+    add_column :spree_market_countries, :country_code, :string
+    add_index :spree_market_countries, [:market_id, :country_code],
+              unique: true, name: 'index_spree_market_countries_on_market_id_and_country_code'
+
+    # The country foreign key stays until 6.1 so the upgrade task keeps its
+    # source data, but nothing writes it any more — a market country is
+    # identified by its ISO code now.
+    change_column_null :spree_market_countries, :country_id, true
+
+    add_column :spree_stock_locations, :country_code, :string
+    add_column :spree_stock_locations, :state_code, :string
+
+    add_column :spree_stores, :default_country_code, :string
+  end
+end

data/db/migrate/20260807150001_reindex_spree_categories_by_store.rb

@@ -0,0 +1,42 @@
+require 'spree/category_permalink_deduplicator'
+
+class ReindexSpreeCategoriesByStore < ActiveRecord::Migration[8.1]
+  PERMALINK_INDEX = 'index_spree_categories_on_permalink_and_store_id'.freeze
+
+  # Categories are store-owned in 6.0, so uniqueness is scoped to the store rather
+  # than the taxonomy. The old taxonomy-scoped indexes stop constraining anything
+  # once spree:migrate_taxons_to_categories_and_collections nulls taxonomy_id,
+  # because SQL treats NULLs as distinct in unique indexes.
+  #
+  # The permalink is the category's full path ("men/clothing/shirts"), so it
+  # already encodes the hierarchy: scoping it by parent_id was always redundant,
+  # and (permalink, store_id) is the real constraint. Name uniqueness is dropped
+  # entirely — two categories may share a name in different branches, which their
+  # permalinks already distinguish.
+  #
+  # The duplicates are resolved here rather than in the upgrade rake task. A 5.6
+  # store has already run spree:taxons:backfill_store_id (5.5 -> 5.6), so its
+  # categories carry a store_id by the time this runs, and any cross-taxonomy
+  # permalink collision would fail index creation and block the deploy.
+  def up
+    remove_index :spree_categories, name: 'index_spree_categories_on_name_and_parent_id_and_taxonomy_id', if_exists: true
+    remove_index :spree_categories, name: 'idx_on_permalink_parent_id_taxonomy_id_0aed458a0c', if_exists: true
+
+    renamed = Spree::CategoryPermalinkDeduplicator.new(connection).call
+    say "resolved #{renamed} duplicate category permalinks", true if renamed.positive?
+
+    add_index :spree_categories, %i[permalink store_id],
+              name: PERMALINK_INDEX, unique: true, if_not_exists: true
+  end
+
+  def down
+    remove_index :spree_categories, name: PERMALINK_INDEX, if_exists: true
+
+    add_index :spree_categories, %i[name parent_id taxonomy_id],
+              name: 'index_spree_categories_on_name_and_parent_id_and_taxonomy_id',
+              unique: true, if_not_exists: true
+    add_index :spree_categories, %i[permalink parent_id taxonomy_id],
+              name: 'idx_on_permalink_parent_id_taxonomy_id_0aed458a0c',
+              unique: true, if_not_exists: true
+  end
+end

data/db/migrate/20260809000001_rename_metafields_to_custom_fields.rb

@@ -0,0 +1,126 @@
+class RenameMetafieldsToCustomFields < ActiveRecord::Migration[7.2]
+  # STI class names and the `metafield_type` column both store the Ruby class
+  # name. A renamed class cannot load its own legacy rows, so the substitution
+  # runs here rather than in the upgrade manifest — after this migration the
+  # models are unusable until the strings match.
+  TYPE_RENAMES = {
+    'Spree::Metafields::ShortText' => 'Spree::CustomFields::ShortText',
+    'Spree::Metafields::LongText' => 'Spree::CustomFields::LongText',
+    'Spree::Metafields::RichText' => 'Spree::CustomFields::RichText',
+    'Spree::Metafields::Number' => 'Spree::CustomFields::Number',
+    'Spree::Metafields::Boolean' => 'Spree::CustomFields::Boolean',
+    'Spree::Metafields::Json' => 'Spree::CustomFields::Json'
+  }.freeze
+
+  def up
+    rename_table :spree_metafield_definitions, :spree_custom_field_definitions
+    rename_table :spree_metafields, :spree_custom_fields
+
+    rename_column :spree_custom_fields, :metafield_definition_id, :custom_field_definition_id
+    rename_column :spree_custom_field_definitions, :metafield_type, :field_type
+    rename_column :spree_custom_field_definitions, :name, :label
+
+    rename_index :spree_custom_fields, 'index_metafields_on_resource_and_definition',
+                 'index_custom_fields_on_resource_and_definition'
+
+    TYPE_RENAMES.each do |from, to|
+      execute_type_rename(:spree_custom_fields, :type, from, to)
+      execute_type_rename(:spree_custom_field_definitions, :field_type, from, to)
+    end
+
+    # Rich-text values move out of Action Text and into the shared `value`
+    # column (docs/plans/6.0-rich-text-descriptions.md). Action Text keys rows
+    # by the owner's STI base class, so they are found under the pre-rename
+    # class name. The source rows are left in place as the rollback path; the
+    # table is dropped in 6.1.
+    copy_action_text_bodies_into_values
+
+    # display_on (both/front_end/back_end) collapses to a boolean. Only
+    # back_end meant "hide from the storefront"; front_end-only was never a
+    # supported value on definitions.
+    add_column :spree_custom_field_definitions, :storefront_visible, :boolean, default: true, null: false
+    execute(<<~SQL.squish)
+      UPDATE spree_custom_field_definitions
+      SET storefront_visible = #{quoted_false}
+      WHERE display_on = 'back_end'
+    SQL
+    remove_column :spree_custom_field_definitions, :display_on
+  end
+
+  def down
+    add_column :spree_custom_field_definitions, :display_on, :string, default: 'both', null: false
+    execute(<<~SQL.squish)
+      UPDATE spree_custom_field_definitions
+      SET display_on = 'back_end'
+      WHERE storefront_visible = #{quoted_false}
+    SQL
+    add_index :spree_custom_field_definitions, :display_on
+    remove_column :spree_custom_field_definitions, :storefront_visible
+
+    # The Action Text rows were never deleted, so rolling back only needs to
+    # clear the copied column.
+    clear_rich_text_values
+
+    TYPE_RENAMES.each do |from, to|
+      execute_type_rename(:spree_custom_fields, :type, to, from)
+      execute_type_rename(:spree_custom_field_definitions, :field_type, to, from)
+    end
+
+    rename_index :spree_custom_fields, 'index_custom_fields_on_resource_and_definition',
+                 'index_metafields_on_resource_and_definition'
+
+    rename_column :spree_custom_field_definitions, :label, :name
+    rename_column :spree_custom_field_definitions, :field_type, :metafield_type
+    rename_column :spree_custom_fields, :custom_field_definition_id, :metafield_definition_id
+
+    rename_table :spree_custom_fields, :spree_metafields
+    rename_table :spree_custom_field_definitions, :spree_metafield_definitions
+  end
+
+  private
+
+  RICH_TEXT_TYPE = 'Spree::CustomFields::RichText'.freeze
+  # Action Text stores the owner's STI base class, so rows written before this
+  # migration are filed under the pre-rename name.
+  LEGACY_ACTION_TEXT_OWNER = 'Spree::Metafield'.freeze
+
+  # A correlated subquery rather than UPDATE ... FROM / UPDATE ... JOIN, which
+  # are spelled differently on PostgreSQL, MySQL and SQLite.
+  def copy_action_text_bodies_into_values
+    return unless connection.table_exists?(:action_text_rich_texts)
+
+    body = <<~SQL.squish
+      SELECT #{quote_column_name('body')} FROM #{quote_table_name('action_text_rich_texts')}
+      WHERE #{quote_table_name('action_text_rich_texts')}.#{quote_column_name('record_id')} = #{quote_table_name('spree_custom_fields')}.#{quote_column_name('id')}
+        AND #{quote_table_name('action_text_rich_texts')}.#{quote_column_name('record_type')} = #{quote(LEGACY_ACTION_TEXT_OWNER)}
+        AND #{quote_table_name('action_text_rich_texts')}.#{quote_column_name('name')} = #{quote('value')}
+    SQL
+
+    execute(<<~SQL.squish)
+      UPDATE #{quote_table_name('spree_custom_fields')}
+      SET #{quote_column_name('value')} = (#{body})
+      WHERE #{quote_column_name('type')} = #{quote(RICH_TEXT_TYPE)}
+        AND EXISTS (#{body})
+    SQL
+  end
+
+  def clear_rich_text_values
+    execute(<<~SQL.squish)
+      UPDATE #{quote_table_name('spree_custom_fields')}
+      SET #{quote_column_name('value')} = NULL
+      WHERE #{quote_column_name('type')} = #{quote(RICH_TEXT_TYPE)}
+    SQL
+  end
+
+  def execute_type_rename(table, column, from, to)
+    execute(<<~SQL.squish)
+      UPDATE #{quote_table_name(table)}
+      SET #{quote_column_name(column)} = #{quote(to)}
+      WHERE #{quote_column_name(column)} = #{quote(from)}
+    SQL
+  end
+
+  def quoted_false
+    connection.quoted_false
+  end
+end

data/db/migrate/20260809100001_support_multi_rate_delivery_methods.rb

@@ -0,0 +1,35 @@
+class SupportMultiRateDeliveryMethods < ActiveRecord::Migration[8.1]
+  def change
+    # A carrier provider now yields one rate per service, so a fulfillment can
+    # hold several rates for the same delivery method (decisions.md
+    # 2026-08-09). Keep a non-unique index for the lookup path.
+    remove_index :spree_delivery_rates, name: 'spree_delivery_rates_join_index'
+    add_index :spree_delivery_rates, [:fulfillment_id, :delivery_method_id],
+              name: 'spree_delivery_rates_join_index'
+
+    # Provider-priced rates carry their own display name ("UPS Ground" or a
+    # merchant label override); calculator rates leave it null and fall back
+    # to the delivery method's name.
+    add_column :spree_delivery_rates, :name, :string
+
+    # Method-level handling fee applied on top of provider quotes — the
+    # default when a service row doesn't override it.
+    add_column :spree_delivery_methods, :markup_flat, :decimal, precision: 10, scale: 2, default: 0
+    add_column :spree_delivery_methods, :markup_percent, :decimal, precision: 8, scale: 2, default: 0
+
+    create_table :spree_delivery_method_services do |t|
+      t.references :delivery_method, null: false
+      t.string :carrier, null: false
+      t.string :service, null: false
+      t.string :label
+      t.decimal :markup_flat, precision: 10, scale: 2
+      t.decimal :markup_percent, precision: 8, scale: 2
+      t.integer :position, default: 0
+
+      t.timestamps
+    end
+
+    add_index :spree_delivery_method_services, [:delivery_method_id, :carrier, :service],
+              unique: true, name: 'idx_delivery_method_services_uniqueness'
+  end
+end

data/db/migrate/20260809120001_consolidate_metadata_columns.rb

@@ -0,0 +1,120 @@
+class ConsolidateMetadataColumns < ActiveRecord::Migration[7.2]
+  # Records which tables this migration renamed, so `down` reverses exactly those.
+  # Dropped on the way back down.
+  CONSOLIDATED_TABLES_REGISTRY = :spree_consolidated_metadata_tables
+
+  # The merge lives here rather than in the upgrade rake task because the manifest
+  # runs AFTER db:migrate (see upgrade.rake and the CLI's upgrade command) — a
+  # merge step scheduled there would find public_metadata already dropped and
+  # silently lose whatever it held.
+  def up
+    tables = legacy_tables
+    return if tables.empty?
+
+    create_table CONSOLIDATED_TABLES_REGISTRY, if_not_exists: true do |t|
+      t.string :table_name, null: false
+    end
+
+    tables.each do |table_name|
+      merge_public_metadata_into_private(table_name)
+
+      rename_column table_name, :private_metadata, :metadata
+      remove_column table_name, :public_metadata
+
+      connection.exec_insert(
+        "INSERT INTO #{connection.quote_table_name(CONSOLIDATED_TABLES_REGISTRY)} (table_name) " \
+        "VALUES (#{connection.quote(table_name)})"
+      )
+    end
+  end
+
+  # Restores the column shape, NOT the original split of values. The merge is
+  # one-way: once public keys are folded into `metadata` there is no record of
+  # which side they came from, and keeping a shadow copy of a column being deleted
+  # would defeat the consolidation. Rolling back therefore returns every value
+  # under `private_metadata` and leaves `public_metadata` empty — code that reads
+  # the public side sees nothing.
+  #
+  # Set FORCE_METADATA_ROLLBACK=true to accept that and proceed.
+  def down
+    tables = consolidated_tables
+
+    if tables.any? && ENV['FORCE_METADATA_ROLLBACK'] != 'true'
+      raise ActiveRecord::IrreversibleMigration,
+            'Rolling back would restore the public_metadata column empty: the merge into ' \
+            'metadata is one-way and the original split is not recoverable. Re-run with ' \
+            'FORCE_METADATA_ROLLBACK=true to restore the column shape and accept the loss.'
+    end
+
+    tables.each do |table_name|
+      rename_column table_name, :metadata, :private_metadata
+
+      change_table table_name do |t|
+        if t.respond_to?(:jsonb)
+          t.jsonb :public_metadata
+        else
+          t.json :public_metadata
+        end
+      end
+    end
+
+    drop_table CONSOLIDATED_TABLES_REGISTRY, if_exists: true
+  end
+
+  private
+
+  # Copies public_metadata into private_metadata, private winning on key collision
+  # since that is the side the `metadata` accessor and the API have always read.
+  # Row by row: merging two JSON documents in one UPDATE would need a different
+  # expression per adapter, and this runs once.
+  def merge_public_metadata_into_private(table_name)
+    quoted_table = connection.quote_table_name(table_name)
+    rows = connection.select_all(
+      "SELECT id, public_metadata, private_metadata FROM #{quoted_table} WHERE public_metadata IS NOT NULL"
+    )
+
+    rows.each do |row|
+      public_metadata = parse_json(row['public_metadata'])
+      next if public_metadata.blank?
+
+      merged = public_metadata.merge(parse_json(row['private_metadata']))
+
+      connection.exec_update(
+        "UPDATE #{quoted_table} SET private_metadata = #{connection.quote(merged.to_json)} " \
+        "WHERE id = #{connection.quote(row['id'])}"
+      )
+    end
+  end
+
+  # Anything that isn't a Hash — an array or scalar an application stored in the
+  # untyped column, unparseable text — becomes {} rather than aborting the migration.
+  def parse_json(value)
+    parsed = value.is_a?(String) ? (JSON.parse(value) rescue nil) : value
+
+    parsed.is_a?(Hash) ? parsed : {}
+  end
+
+  # Tables still carrying the legacy pair. The columns are the whole signal: a table
+  # born with a single `metadata` column has no `public_metadata`, so it can never
+  # match. A table that somehow has all three is skipped rather than guessed at —
+  # renaming onto an existing `metadata` would fail anyway.
+  def legacy_tables
+    connection.tables.select do |table_name|
+      column_exists?(table_name, :private_metadata) &&
+        column_exists?(table_name, :public_metadata) &&
+        !column_exists?(table_name, :metadata)
+    end
+  end
+
+  # Tables this migration consolidated, identified by the marker it wrote on the way
+  # up rather than by shape. Shape alone cannot distinguish a table we renamed from
+  # one that was born with a single `metadata` column — both end up with exactly that
+  # column — and reversing the latter would break models that have always read it.
+  def consolidated_tables
+    return [] unless connection.table_exists?(CONSOLIDATED_TABLES_REGISTRY)
+
+    connection.select_values(
+      "SELECT table_name FROM #{connection.quote_table_name(CONSOLIDATED_TABLES_REGISTRY)}"
+    ).select { |table_name| column_exists?(table_name, :metadata) }
+  end
+end

data/db/migrate/20260809150001_promote_shipping_categories_to_delivery_profiles.rb

@@ -0,0 +1,153 @@
+class PromoteShippingCategoriesToDeliveryProfiles < ActiveRecord::Migration[8.1]
+  # ShippingCategory promoted in place (docs/plans/6.0-delivery-profiles.md):
+  # the table and the product foreign key are renamed, so 5.x category
+  # assignments become profile assignments without copying. The backfill here
+  # is mechanical continuity wiring only — judgement calls (store assignment
+  # of formerly-global categories, default flagging, collapsing the method
+  # m:n) belong to spree:upgrade:migrate_delivery_profiles.
+  def up
+    rename_table :spree_shipping_categories, :spree_delivery_profiles
+    rename_column :spree_products, :shipping_category_id, :delivery_profile_id
+
+    # Nullable until the upgrade task assigns stores to 5.x rows; tightened
+    # in 6.1.
+    add_reference :spree_delivery_profiles, :store, index: true
+    add_column :spree_delivery_profiles, :default, :boolean, null: false, default: false
+    # STI: profile kinds declare behavior (Shipping, Digital, extension
+    # kinds) and give seeds a rename-proof handle.
+    add_column :spree_delivery_profiles, :type, :string
+    add_column :spree_delivery_profiles, :position, :integer, default: 0
+    add_index :spree_delivery_profiles, :type
+
+    # Origin groups partition a profile's fulfillment origins: every zone
+    # and method belongs to a group, so "same products, different warehouse,
+    # different rates" is one profile with two groups. Simple stores keep a
+    # single nameless group covering every location and never see the layer.
+    create_table :spree_delivery_origin_groups do |t|
+      t.references :delivery_profile, null: false, index: true
+      t.string :name
+      t.integer :position, default: 0
+      t.timestamps
+    end
+
+    create_table :spree_delivery_origin_group_locations do |t|
+      t.references :delivery_origin_group, null: false
+      t.references :stock_location, null: false
+      t.timestamps
+    end
+    add_index :spree_delivery_origin_group_locations,
+              [:delivery_origin_group_id, :stock_location_id],
+              unique: true, name: 'idx_delivery_origin_group_locations_uniqueness'
+
+    add_reference :spree_delivery_zones, :delivery_profile, index: true
+    add_reference :spree_delivery_zones, :delivery_origin_group, index: true
+    add_reference :spree_delivery_methods, :delivery_profile, index: true
+    add_reference :spree_delivery_methods, :delivery_origin_group, index: true
+    add_reference :spree_delivery_methods, :delivery_zone, index: true
+    add_reference :spree_product_types, :delivery_profile, index: true
+
+    # Behavior routes through provider and profile classes; the string
+    # vocabulary goes away entirely.
+    remove_column :spree_delivery_methods, :fulfillment_type
+    remove_column :spree_product_types, :fulfillment_types
+
+    backfill_store_defaults
+
+    drop_table :spree_delivery_method_zones
+  end
+
+  def down
+    create_table :spree_delivery_method_zones do |t|
+      t.references :delivery_method, null: false
+      t.references :delivery_zone, null: false
+      t.timestamps
+    end
+    execute <<~SQL
+      INSERT INTO spree_delivery_method_zones (delivery_method_id, delivery_zone_id, created_at, updated_at)
+      SELECT id, delivery_zone_id, created_at, updated_at
+      FROM spree_delivery_methods WHERE delivery_zone_id IS NOT NULL
+    SQL
+
+    if connection.respond_to?(:supports_json?) && connection.supports_json?
+      add_column :spree_product_types, :fulfillment_types, :json
+    else
+      add_column :spree_product_types, :fulfillment_types, :text
+    end
+    add_column :spree_delivery_methods, :fulfillment_type, :string
+    remove_reference :spree_product_types, :delivery_profile
+    remove_reference :spree_delivery_methods, :delivery_zone
+    remove_reference :spree_delivery_methods, :delivery_origin_group
+    remove_reference :spree_delivery_methods, :delivery_profile
+    remove_reference :spree_delivery_zones, :delivery_origin_group
+    remove_reference :spree_delivery_zones, :delivery_profile
+    drop_table :spree_delivery_origin_group_locations
+    drop_table :spree_delivery_origin_groups
+    remove_column :spree_delivery_profiles, :position
+    remove_column :spree_delivery_profiles, :type
+    remove_column :spree_delivery_profiles, :default
+    remove_reference :spree_delivery_profiles, :store
+    rename_column :spree_products, :delivery_profile_id, :shipping_category_id
+    rename_table :spree_delivery_profiles, :spree_shipping_categories
+  end
+
+  private
+
+  # Anonymous readers — migrations never depend on application models.
+  class MigrationStore < ActiveRecord::Base
+    self.table_name = 'spree_stores'
+  end
+
+  class MigrationProfile < ActiveRecord::Base
+    self.table_name = 'spree_delivery_profiles'
+    # The table gains an STI `type` column in this very migration. Without
+    # disabling inheritance, writing the kind makes Rails try to instantiate
+    # the real subclass — which is not a descendant of this reader.
+    self.inheritance_column = nil
+  end
+
+  class MigrationZone < ActiveRecord::Base
+    self.table_name = 'spree_delivery_zones'
+  end
+
+  class MigrationProduct < ActiveRecord::Base
+    self.table_name = 'spree_products'
+  end
+
+  class MigrationMethod < ActiveRecord::Base
+    self.table_name = 'spree_delivery_methods'
+  end
+
+  class MigrationMethodZone < ActiveRecord::Base
+    self.table_name = 'spree_delivery_method_zones'
+  end
+
+  class MigrationOriginGroup < ActiveRecord::Base
+    self.table_name = 'spree_delivery_origin_groups'
+  end
+
+  # Every store needs its default profile, and this branch's existing zones
+  # and methods need a home so a migrated development database keeps
+  # quoting. 5.x rows (store_id nil) are deliberately untouched here.
+  def backfill_store_defaults
+    MigrationStore.find_each do |store|
+      profile = MigrationProfile.create!(store_id: store.id, name: 'General', default: true, type: 'Spree::DeliveryProfiles::Shipping')
+      # The nameless default group: no location members means every store
+      # location, so a single-group profile behaves as if the layer weren't
+      # there.
+      origin_group = MigrationOriginGroup.create!(delivery_profile_id: profile.id, position: 1)
+
+      MigrationZone.where(store_id: store.id).update_all(delivery_profile_id: profile.id, delivery_origin_group_id: origin_group.id)
+      # The association is required going forward; this branch's products
+      # never carried a category, so they all belong to the default profile.
+      MigrationProduct.where(store_id: store.id, delivery_profile_id: nil).update_all(delivery_profile_id: profile.id)
+
+      MigrationMethod.where(store_id: store.id).find_each do |method|
+        zone_ids = MigrationMethodZone.where(delivery_method_id: method.id).order(:id).pluck(:delivery_zone_id)
+        if zone_ids.size > 1
+          say "Delivery method #{method.id} was linked to #{zone_ids.size} zones; keeping the first — recreate the method for the other zones if both were intended."
+        end
+        method.update_columns(delivery_profile_id: profile.id, delivery_origin_group_id: origin_group.id, delivery_zone_id: zone_ids.first)
+      end
+    end
+  end
+end