spree_core 6.0.0.rc2 → 6.0.0.rc4

data/app/tools/spree/agent_tools/upload_file.rb

@@ -0,0 +1,104 @@
+module Spree
+  module AgentTools
+    # Stores a file the merchant provided, through the Admin API's own upload
+    # endpoint, and answers with the id every other write accepts.
+    #
+    # The dashboard uploads in two steps: ask for a storage target, then PUT
+    # the bytes to it. An agent has no second request to make, so this sends
+    # the bytes with the request — the multipart shape `POST /files` already
+    # accepts — and the endpoint owns the type allowlist, the size cap and
+    # which store the file belongs to.
+    #
+    # Storing a file is not yet using it: the id is attached by whichever
+    # tool the merchant asked for next, under that tool's own permission.
+    class UploadFile < Spree::AgentTool
+      tool_name 'upload_file'
+      description 'Store a file the merchant provided — a CSV to import, an image for a ' \
+                  'product, a document to attach — and return the id other tools accept. ' \
+                  'Send text as text; use encoding "base64" only for images, PDFs and other ' \
+                  'binary files. Storing a file does nothing on its own.'
+      # The endpoint's own floor, which is the gate the dashboard's uploader
+      # passes; whatever uses the file checks its own permission after.
+      permission 'write_products'
+      mutating!
+
+      param :filename, description: 'The file name, with its extension', required: true
+      param :content, description: 'The file contents — text as text, binary base64 encoded',
+                      required: true
+      param :encoding, description: '"base64" for a binary file; omit for text'
+      param :content_type, description: "The file's media type, e.g. text/csv or application/pdf"
+
+      # A private upload accepts any type, which is right for the dashboard —
+      # a merchant picking a file has already decided. A model repeating a
+      # filename back has decided nothing, so an agent is held to the kinds
+      # it has a reason to send.
+      PERMITTED_CONTENT_TYPES = %w[
+        text/csv
+        text/plain
+        application/pdf
+        image/jpeg
+        image/png
+        image/webp
+        image/gif
+        application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+      ].freeze
+
+      def call(filename:, content:, encoding: nil, content_type: nil)
+        bytes, error = decode(content, encoding)
+        return { error: error } if error
+
+        # Read from the bytes, not from what the caller named it: Marcel
+        # places the content first, so a renamed script is not a CSV.
+        kind = Marcel::MimeType.for(StringIO.new(bytes), name: filename,
+                                                         declared_type: content_type.presence)
+        unless PERMITTED_CONTENT_TYPES.include?(kind)
+          return { error: "Files of type #{kind.inspect} are not accepted here.",
+                   supported_content_types: PERMITTED_CONTENT_TYPES }
+        end
+
+        response = ApiDispatch.new(context).call(
+          method: :post,
+          path: '/api/v3/admin/files',
+          body: {
+            'filename' => filename,
+            'content_type' => kind,
+            # Agent uploads are private: a purchase order or a customer list
+            # is not something to put behind a public URL, and a private
+            # upload is the one that accepts a document at all.
+            'visibility' => 'private',
+            'file' => StringIO.new(bytes)
+          }.compact
+        )
+        return { error: response.error_message } unless response.success?
+
+        data = response.data.to_h
+
+        {
+          ok: true,
+          file_id: data['signed_id'],
+          filename: data['filename'],
+          content_type: data['content_type'],
+          byte_size: data['byte_size']
+        }
+      end
+
+      def summary(arguments)
+        "Store the file #{arguments[:filename]}"
+      end
+
+      private
+
+      # Text arrives as text. Base64 is a third larger and a model has to
+      # emit every byte of it, so it is asked for only where the bytes are
+      # not text at all.
+      def decode(content, encoding)
+        raw = content.to_s
+        return [raw, nil] unless encoding.to_s == 'base64'
+
+        [Base64.strict_decode64(raw.gsub(/\s+/, '')), nil]
+      rescue ArgumentError
+        [nil, 'content is not valid base64. Send text as text, without the encoding parameter.']
+      end
+    end
+  end
+end

data/app/workflows/spree/carts/complete.rb

@@ -77,6 +77,19 @@ module Spree
       def complete_draft_order
         result = Spree.order_complete_workflow.call(order: cart, payment_pending: payment_pending)
         failure(result.value, result.error) if result.failure?
+
+        # A draft leaves before FINALIZE, so the document that phase files is
+        # filed here — otherwise it charged tax that never reached the return.
+        # A draft holding several sellers' goods divides like a checkout, and
+        # each of its orders is a sale of its own to file.
+        if result.value.is_a?(Spree::OrderGroup)
+          @order_group = result.value
+          @order = order_group.orders.order(:id).first
+        else
+          @order = result.value
+        end
+        external_step :commit_tax
+
         halt!(result.value)
       end
 
@@ -141,6 +154,26 @@ module Spree
       def recalculate_in_lock
         Spree::Carts::PriceItems.apply(@confirmed_prices) if @confirmed_prices.present?
         cart.recalculate_totals!
+      rescue Spree::Tax::ProviderError => error
+        # The engine that decides this sale's tax did not produce any.
+        # Completing anyway would place an order whose tax nobody computed, so
+        # the sale is refused — as a failure the caller can render, not as an
+        # exception that reads like a broken checkout.
+        Rails.error.report(error, context: { order_id: cart.id }, source: 'spree.checkout')
+
+        if error.is_a?(Spree::Tax::CalculationRefused)
+          # The engine said no to this request. Its message names the problem —
+          # the postcode, the missing company code — and asking the customer to
+          # retry would be asking them to repeat something that cannot work.
+          failure(cart, code: 'tax_calculation_refused', message: error.message.to_s)
+        else
+          # It could not be asked. Retrying may work, and the reason belongs in
+          # the error tracker rather than the response: the raw message names
+          # the endpoint and the transport, which tells a shopper nothing and
+          # tells everyone else too much.
+          failure(cart, code: 'tax_provider_unavailable',
+                        message: I18n.t('spree.cart_line_item.tax_unavailable'))
+        end
       end
 
       def verify_expected_total
@@ -253,9 +286,10 @@ module Spree
 
           line_item_map = copy_line_items!(cart, order)
           fulfillment_map = copy_fulfillments!(cart, order, line_item_map)
-          copy_typed_lines!(cart, order, line_item_map, fulfillment_map)
+          fee_map = copy_typed_lines!(cart, order, line_item_map, fulfillment_map)
           copy_promotions!(cart, order)
           copy_tax_identifier!(cart, order)
+          copy_tax_exemptions!(cart, order, line_item_map, fulfillment_map, fee_map)
           copy_po_document!(cart, order)
           repoint_money_records!(cart, order)
 
@@ -290,6 +324,71 @@ module Spree
         order.create_tax_identifier!(attributes.merge('source' => source_of(resolved)))
       end
 
+      # Freezes the exemption evidence the sale was priced with, beside the
+      # registration and for the same reason. A certificate lapses on its own
+      # date with nothing written to it, can be revoked, and is destroyed with
+      # its company — so a provider re-resolving at commit or refund time would
+      # file a credit for an exempt sale as a consumer refund and declare tax
+      # that was never collected. Read from the cart, which is what was priced.
+      #
+      # An empty list is still written: "found no claim" and "placed before this
+      # existed" are different facts, and the reader tells them apart.
+      def copy_tax_exemptions!(cart, order, line_item_map, fulfillment_map, fee_map)
+        translation = exemption_item_ids(line_item_map, fulfillment_map, fee_map)
+        claims = cart.usable_exemptions.map { |claim| reown_claim(claim, translation) }
+
+        order.update_column(:applied_tax_exemptions, claims)
+      end
+
+      # An override names its line by prefixed id, and completion mints new ones.
+      # Left as the cart's it matches nothing — which widens the claim rather
+      # than narrowing it, exempting every line instead of carving one out.
+      def reown_claim(claim, translation)
+        snapshot = claim.to_snapshot
+        overrides = Array(snapshot['item_overrides'])
+        return snapshot if overrides.empty?
+
+        snapshot.merge(
+          'item_overrides' => overrides.map do |override|
+            reowned = translation[override['item_id'].to_s]
+            next override.merge('item_id' => reowned) if reowned
+
+            # It narrowed nothing while the cart was priced either, so it is
+            # left alone and reported rather than dropped.
+            report_unmatched_override(override)
+            override
+          end
+        )
+      end
+
+      # Cart prefixed id → order prefixed id, encoded from the ids the copy maps
+      # already carry rather than by reloading the records.
+      def exemption_item_ids(line_item_map, fulfillment_map, fee_map)
+        translation = {}
+
+        line_item_map.each do |cart_line_item, order_line_item|
+          translation[cart_line_item.prefixed_id] = order_line_item.prefixed_id
+        end
+        { Spree::Fulfillment => fulfillment_map, Spree::Fee => fee_map }.each do |klass, ids|
+          ids.each do |cart_id, order_id|
+            translation[klass.prefixed_id_for(cart_id)] = klass.prefixed_id_for(order_id)
+          end
+        end
+
+        translation
+      end
+
+      def report_unmatched_override(override)
+        Rails.error.report(
+          Spree::Tax::UnusableExemptionError.new(
+            "A tax exemption override named #{override['item_id'].inspect}, which is not part of this sale"
+          ),
+          handled: true,
+          context: { item_id: override['item_id'] },
+          source: 'spree.core'
+        )
+      end
+
       # The buyer's purchase order follows the number onto the order. The same
       # blob is attached to both records rather than uploaded twice — the cart
       # keeps its copy so a completion that rolls back leaves the buyer's
@@ -366,6 +465,9 @@ module Spree
       # Fees before tax lines, because a fee is something tax is charged on: a
       # tax line copied first would reach the order still naming the cart's
       # fee, and that row is then destroyed with it.
+      #
+      # @return [Hash{Integer => Integer}] cart fee id → order fee id, which an
+      #   exemption override may name
       def copy_typed_lines!(cart, order, line_item_map, fulfillment_map)
         line_item_id_map = line_item_map.transform_keys(&:id).transform_values(&:id)
         fee_map = {}
@@ -392,6 +494,8 @@ module Spree
             fee_map[row.id] = copy.id if klass == Spree::Fee
           end
         end
+
+        fee_map
       end
 
       def copy_promotions!(cart, order)
@@ -458,7 +562,16 @@ module Spree
       # separate sale with its own tax, and an unfiled sibling is a hole in the
       # merchant's return that only surfaces at filing time.
       def commit_tax
-        placed_orders.each { |placed| placed.tax_provider.commit(placed) }
+        placed_orders.each do |placed|
+          placed.tax_provider.commit(placed)
+        rescue Spree::Tax::ProviderError => error
+          # Deliberately not a failure. The order is placed and paid; refusing
+          # now would leave the customer charged for a sale the platform denies
+          # having taken. Filing is idempotent and replayable, so the document
+          # can follow — an unfiled sale is a reporting gap to chase, not a
+          # reason to break the checkout that produced it.
+          Rails.error.report(error, context: { order_id: placed.id }, source: 'spree.checkout')
+        end
       end
 
       # What this checkout produced: the children of a split, or the one order

data/app/workflows/spree/catalogs/set_price_list.rb

@@ -90,8 +90,8 @@ module Spree
       # settled by its assignments. Rules are reconciled by replacement, so
       # the audience rules the caller never mentioned are merged back in;
       # without this, editing a catalog's name through the inline payload
-      # would destroy a market rule and silently change how its prices are
-      # restated for VAT.
+      # would destroy a market rule and silently change which buyers its
+      # prices apply to.
       def merged_rules(rows)
         existing = catalog.price_list&.price_rules&.to_a || []
         untouched = existing.reject(&:contextual?)

data/app/workflows/spree/orders/cancel.rb

@@ -253,8 +253,16 @@ module Spree
 
       # Reverses the filed tax document. The canceled sale must stop appearing
       # in the merchant's tax liability.
+      #
+      # Reported rather than raised, as `Carts::Complete` treats its filing. The
+      # cancellation and its payments are already settled by now, and the steps
+      # after this one update statuses and announce `order.canceled` — so
+      # raising abandoned a cancelled order half-recorded. Void is idempotent, so
+      # a standing document can follow.
       def void_tax
         order.tax_provider.void(order)
+      rescue Spree::Tax::ProviderError => error
+        Rails.error.report(error, context: { order_id: order.id }, source: 'spree.orders.cancel')
       end
     end
   end

data/app/workflows/spree/orders/complete.rb

@@ -43,6 +43,7 @@ module Spree
             step :split_by_seller
             step :finalize_fulfillments
             step :place_order
+            step :freeze_tax_exemptions
             step :use_coupon_codes
             step :redeem_gift_card
             step :fulfill_auto_fulfillments
@@ -151,6 +152,13 @@ module Spree
         order.update!(status: 'placed', completed_at: Time.current)
       end
 
+      # Pins what the sale was priced with, as `Carts::Complete` does for a cart.
+      # A draft is its own source, so nothing needs translating — and it is the
+      # path company certificates take, which left it resolving live at credit.
+      def freeze_tax_exemptions
+        order.update_column(:applied_tax_exemptions, order.usable_exemptions.map(&:to_snapshot))
+      end
+
       def use_coupon_codes
         Spree::CouponCodes::CouponCodesHandler.new(order: order).use_all_codes
       end

data/app/{services → workflows}/spree/orders/create.rb

@@ -8,18 +8,18 @@ module Spree
     # Standalone from Spree::Carts::Create (storefront). Admin-created orders
     # are first-class Spree::Order records (status: 'draft') in 5.x and remain
     # so in 6.0 — Spree::Cart in 6.0 is storefront-only.
-    class Create
-      prepend Spree::ServiceModule::Base
-
+    class Create < Spree::Workflow
       attr_reader :discount_application_errors
 
-      # @param store [Spree::Store]
-      # @param customer [Object, nil] resolved customer (Spree.customer_class instance)
-      # @param created_by [Object, nil] the staff member creating the draft
-      #   (Spree.admin_user_class instance); nil for machine callers (secret keys)
-      # @param params [Hash] order params (see admin API docs)
+      # @param store [Spree::Store] the store the order belongs to
+      # @param customer [Object, nil] who is ordering, when they are an
+      #   existing customer; the order keeps `email` either way
+      # @param created_by [Object, nil] who is placing it — a staff member, or
+      #   the credential acting for one
+      # @param params [Hash] the order's own attributes, plus `items`,
+      #   addresses and a coupon code
       # @return [Spree::ServiceModule::Result]
-      def call(store:, customer: nil, created_by: nil, params: {})
+      def perform(store:, customer: nil, created_by: nil, params: {})
         @store = store
         @customer = customer
         @created_by = created_by

data/app/workflows/spree/purchase_orders/create.rb

@@ -17,6 +17,9 @@ module Spree
       # @param currency [String, nil] defaults to the store's; set it for a
       #   foreign-currency order
       # @param expected_at [Date, nil]
+      # @param cancel_by [Date, nil] the date past which the merchant no longer
+      #   wants the goods, so an order still open after it reads as overdue to
+      #   cancel rather than merely late
       # @param reference [String, nil] the supplier's own order number
       # @param notes [String, nil]
       # @param metadata [Hash, nil]

data/app/workflows/spree/returns/refund.rb

@@ -65,6 +65,10 @@ module Spree
       # The refunded amount goes with them, because it can be less than those
       # lines are worth — a restocking fee, or an agreed part-refund. Without it
       # a provider would credit the tax on goods whose value the merchant kept.
+      # Reported rather than raised, as filing and voiding are: the money has
+      # moved and the return is marked refunded by now, and `return.refunded`
+      # follows — so raising failed a refund that had gone through, and lost the
+      # event with it.
       def refund_tax
         received = return_record.return_line_items.select { |line| line.refund_amount.positive? }
         return if received.empty?

data/app/{services → workflows}/spree/stock_levels/bulk_upsert.rb

@@ -12,18 +12,22 @@ module Spree
     # A feed states absolute levels (+count_on_hand+), which is what an
     # external system knows. The movement records the delta between what Spree
     # held and what the feed says.
-    class BulkUpsert
-      prepend Spree::ServiceModule::Base
+    class BulkUpsert < Spree::Workflow
 
       # What the stock history shows against a movement this service wrote.
       FEED_REASON = 'inventory_feed'.freeze
 
-      # @param rows [Array<Hash>] each with +variant_id+, +stock_location_id+,
-      #   and either +count_on_hand+ (absolute) or +adjustment+ (relative);
-      #   +backorderable+ optional
+      # @param store [Spree::Store] whose shelves these are. Ids are resolved
+      #   through it, so a row naming another store's variant is not found
+      #   rather than written.
+      # @param rows [Array<Hash>] one per shelf: +variant_id+ and
+      #   +stock_location_id+ naming it (prefixed ids, or raw), then either
+      #   +count_on_hand+ (the figure it should end at) or +adjustment+ (a
+      #   signed change); +backorderable+ optional
       # @return [Spree::ServiceModule::Result] +{ stock_level_count: N }+
-      def call(rows:)
-        rows = Array(rows).map { |row| row.with_indifferent_access }
+      def perform(store:, rows:)
+        @store = store
+        rows = resolve(Array(rows).map { |row| row.with_indifferent_access })
         keyed = rows.select { |row| row[:variant_id].present? && row[:stock_location_id].present? }
         return success(stock_level_count: 0) if keyed.empty?
 
@@ -41,6 +45,44 @@ module Spree
 
       private
 
+      # Names become this store's own ids, or nothing.
+      #
+      # Resolved here rather than by the caller, because a row reaching
+      # `find_or_initialize_by` unscoped writes to whichever shelf the id
+      # happens to name — including another merchant's. One caller decoding
+      # ids correctly does not make the workflow safe for the next one.
+      def resolve(rows)
+        variants = scoped_ids(store_variants, Spree::Variant, rows.map { |row| row[:variant_id] })
+        locations = scoped_ids(store_stock_locations, Spree::StockLocation,
+                               rows.map { |row| row[:stock_location_id] })
+
+        rows.map do |row|
+          row.merge(
+            variant_id: variants[row[:variant_id]],
+            stock_location_id: locations[row[:stock_location_id]]
+          ).compact
+        end
+      end
+
+      # Accepts a prefixed id or a raw one: the Admin API speaks prefixed,
+      # while the importer and seeds hold records they already loaded.
+      def scoped_ids(scope, model, values)
+        decoded = values.compact.uniq.index_with do |value|
+          model.decode_own_prefixed_id(value) || value
+        end
+        found = scope.where(id: decoded.values.compact).pluck(:id).map(&:to_s).to_set
+
+        decoded.transform_values { |id| id if id && found.include?(id.to_s) }
+      end
+
+      def store_variants
+        @store.variants
+      end
+
+      def store_stock_locations
+        @store.stock_locations
+      end
+
       def apply_row(row)
         stock_level = Spree::StockLevel.find_or_initialize_by(
           variant_id: row[:variant_id], stock_location_id: row[:stock_location_id]

data/app/workflows/spree/variants/create.rb

@@ -1,9 +1,12 @@
 module Spree
   module Variants
-    # Creates a variant on a product. The single gate for variant creation —
-    # the standalone variants endpoint and the nested payload on a product
-    # write both run through it, so a :validate handler sees every variant a
-    # catalog gains.
+    # Adds one variant to a product that already exists. A product being
+    # created carries its variants in the same write instead, which is one
+    # request and reconciles the list rather than adding to it.
+    #
+    # The single gate for variant creation — the standalone variants endpoint
+    # and the nested payload on a product write both run through it, so a
+    # :validate handler sees every variant a catalog gains.
     #
     # The product is a parameter rather than something read off the payload
     # because everything nested needs it: an option value attaches an option

data/config/locales/en.yml

@@ -429,6 +429,12 @@ en:
           attributes:
             company:
               must_be_legal_entity: must be a legal entity, not a division
+            tax_exemption_reason:
+              not_offered: is not a tax exemption reason this store offers
+        spree/tax_exemption_reason:
+          attributes:
+            base:
+              in_use: is recorded on tax exemption certificates and cannot be deleted
         spree/tax_identifier:
           attributes:
             company:
@@ -613,8 +619,10 @@ en:
     messages:
       already_confirmed: was already confirmed
       forbidden_reporting_member: references data you are not allowed to read
+      fragment_present: cannot contain a fragment
       invalid_document_number_affix: 'can only contain uppercase letters, digits, dashes and #'
       invalid_system_key: can only contain lowercase letters, digits and underscores
+      invalid_uri: must be a valid URL
       locked_after_first_number: cannot change once numbering has started
       not_a_number: is not a number
       not_found: not found
@@ -622,7 +630,10 @@ en:
       not_saved:
         one: '1 error prohibited this %{resource} from being saved:'
         other: "%{count} errors prohibited this %{resource} from being saved:"
+      relative_uri: must be an absolute URL
+      secured_uri: must start with https, because authorization codes are delivered to it
       seeded_report_read_only: is a built-in report and cannot be changed — save a copy instead
+      unspecified_scheme: must include a scheme, such as https
   number:
     currency:
       format:
@@ -688,6 +699,7 @@ en:
       pricing_unavailable: Prices could not be confirmed. Please try again.
       quantity_must_be_positive: Quantity must be at least 1. Use DELETE to remove the item.
       quantity_rule_violated: "%{li_name} cannot be ordered in that quantity. Try %{quantities}."
+      tax_unavailable: Tax could not be calculated. Please try again.
     catalogs:
       no_price_list_to_import: This catalog has no price list to import products from.
       product_not_in_store: One of those products belongs to another store.
@@ -1785,6 +1797,8 @@ en:
       gb_vat: UK VAT
       us_ein: US EIN
     tax_provider_unavailable: The tax service could not work out the tax to give back. Try again in a few minutes.
+    tax_providers:
+      internal: Spree tax rates
     terms_of_service: Terms of Service
     there_are_no_items_for_this_order: There are no items for this order
     tiered_flat_rate: Tiered Flat Rate

data/db/migrate/20250902143122_fix_policies_store_association.rb

@@ -2,10 +2,12 @@ class FixPoliciesStoreAssociation < ActiveRecord::Migration[7.2]
   def change
     add_reference :spree_policies, :owner, polymorphic: true, index: true
 
-    Spree::Policy.reset_column_information
-    Spree::Policy.all.each do |policy|
-      policy.update(owner_id: policy.store_id, owner_type: 'Spree::Store')
-    end
+    policies = Arel::Table.new(:spree_policies)
+    connection.update(
+      Arel::UpdateManager.new.table(policies).set(
+        [[policies[:owner_id], policies[:store_id]], [policies[:owner_type], 'Spree::Store']]
+      )
+    )
 
     remove_index :spree_policies, [:store_id, :slug], unique: true, if_exists: true
     remove_index :spree_policies, [:store_id, :position], if_exists: true

data/db/migrate/20260515000001_add_store_id_to_spree_newsletter_subscribers.rb

@@ -5,8 +5,17 @@ class AddStoreIdToSpreeNewsletterSubscribers < ActiveRecord::Migration[7.2]
     # For spree_multi_tenant we need handle the backfill and indices there
     return if defined?(SpreeMultiTenant)
 
-    default_store = Spree::Store.default
-    Spree::NewsletterSubscriber.update_all(store_id: default_store.id) if default_store&.persisted?
+    # Read without the models: Spree::Store expects its columns (preferences,
+    # metadata) in the format later migrations convert them to, so loading a
+    # store here crashes on a database upgraded from an earlier release.
+    stores = Arel::Table.new(:spree_stores)
+    default_store_id = connection.select_value(
+      stores.project(stores[:id]).where(stores[:deleted_at].eq(nil).and(stores[:default].eq(true))).take(1)
+    )
+    if default_store_id.present?
+      subscribers = Arel::Table.new(:spree_newsletter_subscribers)
+      connection.update(Arel::UpdateManager.new.table(subscribers).set([[subscribers[:store_id], default_store_id]]))
+    end
 
     change_column_null :spree_newsletter_subscribers, :store_id, false
 

data/db/migrate/20260904100001_add_applied_tax_exemptions_to_spree_orders.rb

@@ -0,0 +1,16 @@
+class AddAppliedTaxExemptionsToSpreeOrders < ActiveRecord::Migration[8.1]
+  # The exemption claims a placed order was priced with, frozen at completion
+  # beside its tax registration. Certificates lapse on their own date with
+  # nothing written to them, can be revoked, and are destroyed with their
+  # company — so resolving them again when a provider files or credits the sale
+  # is not the evidence the sale was priced with.
+  def change
+    change_table :spree_orders, bulk: true do |t|
+      if t.respond_to?(:jsonb)
+        t.jsonb :applied_tax_exemptions
+      else
+        t.json :applied_tax_exemptions
+      end
+    end
+  end
+end

data/db/migrate/20260914230000_add_store_to_spree_option_types.rb

@@ -5,8 +5,18 @@ class AddStoreToSpreeOptionTypes < ActiveRecord::Migration[8.1]
     # Existing option types were installation-wide, so they belong to the
     # store that has been using them. Left nullable: a fresh install has no
     # store yet, and the association enforces presence from the model side.
-    default_store = Spree::Store.where(default: true).first || Spree::Store.first
-    Spree::OptionType.update_all(store_id: default_store.id) if default_store
+    # Read without the models: Spree::Store expects its columns (preferences,
+    # metadata) in the format later migrations convert them to, so loading a
+    # store here crashes on a database upgraded from an earlier release.
+    stores = Arel::Table.new(:spree_stores)
+    default_store_id = connection.select_value(
+      stores.project(stores[:id]).where(stores[:deleted_at].eq(nil))
+            .order(stores[:default].desc, stores[:id].asc).take(1)
+    )
+    if default_store_id.present?
+      option_types = Arel::Table.new(:spree_option_types)
+      connection.update(Arel::UpdateManager.new.table(option_types).set([[option_types[:store_id], default_store_id]]))
+    end
 
     # Names are unique within a store now, so two stores may each define `size`.
     remove_index :spree_option_types, :name, unique: true, if_exists: true