spree_core 5.4.3 → 5.5.0.rc2

data/app/services/spree/prices/bulk_upsert.rb

@@ -0,0 +1,201 @@
+module Spree
+  module Prices
+    # Bulk-writes Spree::Price rows and sweeps stale placeholder rows in
+    # one transaction.
+    #
+    # `spree_prices` is guarded by two partial unique indexes on PG/SQLite
+    # (collapsed to one composite index on MySQL):
+    #   - base prices (price_list_id IS NULL): unique on (variant_id, currency)
+    #   - overrides   (price_list_id IS NOT NULL): unique on (variant_id, currency, price_list_id)
+    # A single `upsert_all` can only target one index, so rows ship in two
+    # batches — base vs override — each routed to the correct ON CONFLICT.
+    #
+    # Both indexes are also partial on `amount IS NOT NULL`, so `upsert_all`
+    # can't see placeholder rows (amount IS NULL) as conflict targets —
+    # filling in a placeholder via upsert inserts a sibling row instead of
+    # updating. The post-write sweep removes those.
+    class BulkUpsert
+      prepend Spree::ServiceModule::Base
+
+      # Two partial unique indexes guard `spree_prices` on PG/SQLite:
+      #   - base prices (price_list_id IS NULL): unique on (variant_id, currency)
+      #   - overrides   (price_list_id IS NOT NULL): unique on (variant_id, currency, price_list_id)
+      # A single `upsert_all` can only target one index, so base-price rows
+      # and override rows ship in separate batches.
+      BASE_UNIQUE_BY = %i[variant_id currency].freeze
+      OVERRIDE_UNIQUE_BY = %i[variant_id currency price_list_id].freeze
+
+      # @param rows [Array<Hash>] each row must carry
+      #   `variant_id`, `currency`, and `amount`; `price_list_id` and
+      #   `compare_at_amount` are optional. A blank `amount` is treated
+      #   as "clear this price."
+      # @return [Spree::ServiceModule::Result] success carries
+      #   `{ price_count: N }` — the number of rows passed to
+      #   `upsert_all`.
+      def call(rows:)
+        rows = Array(rows).map { |r| r.with_indifferent_access }
+        keyed = rows.select { |r| r[:variant_id].present? && r[:currency].present? }
+        # PG rejects an upsert with two rows hitting the same unique-key
+        # triple in one statement ("ON CONFLICT DO UPDATE command cannot
+        # affect row a second time"). Last-write-wins: keep the last
+        # occurrence of each triple.
+        deduped = keyed.reverse.uniq { |r| [r[:variant_id], r[:currency], r[:price_list_id]] }.reverse
+        upsert_rows, clear_rows = deduped.partition { |r| r[:amount].present? }
+
+        payload = build_payload(upsert_rows)
+        affected_keys = deduped.map { |r| [r[:variant_id], r[:currency], r[:price_list_id]] }
+
+        return success(price_count: 0) if affected_keys.empty?
+
+        base_rows, override_rows = payload.partition { |r| r[:price_list_id].nil? }
+
+        Spree::Price.transaction do
+          # MySQL treats NULL values as distinct in unique indexes, so
+          # `ON DUPLICATE KEY UPDATE` never fires for base prices —
+          # `upsert_all` would silently insert a sibling row. Route base
+          # rows through a SELECT-then-UPDATE/INSERT path on MySQL only.
+          if base_rows.any? && mysql?
+            upsert_base_rows_for_mysql(base_rows)
+          else
+            upsert_batch(base_rows, BASE_UNIQUE_BY)
+          end
+          upsert_batch(override_rows, OVERRIDE_UNIQUE_BY)
+          sweep(affected_keys, clear_rows)
+          # `upsert_all` and `delete_all` both skip AR callbacks, so the
+          # `Price -> Variant -> Product` `touch:` chain never fires —
+          # downstream caches (`cache_key_with_version`) would stay stale.
+          # Re-trigger the chain with one `.touch` per affected variant.
+          touch_variants(affected_keys.map(&:first).uniq)
+        end
+
+        success(price_count: payload.length)
+      end
+
+      private
+
+      # `update_only` lists only domain columns. Rails adds `updated_at`
+      # automatically (when `record_timestamps` is on, which it is for
+      # `Spree::Price`); listing it explicitly here produces
+      # `SET updated_at = …, updated_at = …` on PG and the statement fails
+      # with "multiple assignments to same column".
+      def upsert_batch(rows, unique_by)
+        return if rows.empty?
+
+        Spree::Price.upsert_all(
+          rows,
+          update_only: %i[amount compare_at_amount],
+          **upsert_opts(unique_by)
+        )
+      end
+
+      def build_payload(rows)
+        now = Time.current
+        rows.map do |row|
+          {
+            variant_id: row[:variant_id],
+            currency: row[:currency],
+            price_list_id: row[:price_list_id],
+            amount: parse_amount(row[:amount]),
+            compare_at_amount: parse_amount(row[:compare_at_amount]),
+            created_at: now,
+            updated_at: now
+          }
+        end
+      end
+
+      # Parses locale-aware decimal input ("1.234,56" in DE, "1,234.56"
+      # in en-US). Numeric values pass through; blank values become nil.
+      def parse_amount(value)
+        return nil if value.blank?
+        return value if value.is_a?(Numeric)
+
+        Spree::LocalizedNumber.parse(value)
+      end
+
+      def sweep(affected_keys, clear_rows)
+        cleared_keys = clear_rows.map { |r| [r[:variant_id], r[:currency], r[:price_list_id]] }.to_set
+        affected_set = affected_keys.to_set
+
+        candidates = Spree::Price
+          .where(
+            variant_id: affected_keys.map(&:first).uniq,
+            currency: affected_keys.map { |k| k[1] }.uniq,
+            price_list_id: affected_keys.map(&:last).uniq
+          )
+          .pluck(:id, :variant_id, :currency, :price_list_id, :amount)
+
+        doomed_ids = candidates.filter_map do |id, variant_id, currency, price_list_id, amount|
+          key = [variant_id, currency, price_list_id]
+          next unless affected_set.include?(key)
+          next id if amount.nil?
+          next id if cleared_keys.include?(key)
+
+          nil
+        end
+
+        Spree::Price.where(id: doomed_ids).delete_all if doomed_ids.any?
+      end
+
+      # Bumps `updated_at` on the affected variants and their parent
+      # products to invalidate `cache_key_with_version`-based caches —
+      # `upsert_all` and `delete_all` skip the `Price -> Variant` and
+      # `Variant -> Product` `touch:` chains otherwise.
+      #
+      # We deliberately bypass AR callbacks: invoking `Variant#touch`
+      # would fire `after_commit :remove_prices_from_master_variant`,
+      # which `delete_all`s the master's prices whenever a non-master
+      # sibling has any prices — wiping exactly the rows the bulk
+      # upsert just persisted on a freshly-created list. `touch_all`
+      # gives us the cache bust without that side effect.
+      def touch_variants(variant_ids)
+        return if variant_ids.empty?
+
+        variants = Spree::Variant.where(id: variant_ids)
+        product_ids = variants.pluck(:product_id).uniq
+        variants.touch_all
+        Spree::Product.where(id: product_ids).touch_all if product_ids.any?
+      end
+
+      # MySQL infers conflict targets from its own unique indexes and
+      # rejects an explicit `unique_by`.
+      def upsert_opts(unique_by)
+        return {} if mysql?
+
+        { unique_by: unique_by }
+      end
+
+      def mysql?
+        ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+      end
+
+      # MySQL-only path: NULLs are distinct in unique indexes, so
+      # `(variant_id, currency, NULL)` doesn't conflict with another
+      # `(variant_id, currency, NULL)` — `upsert_all` would insert a
+      # sibling instead of updating. Look up existing base rows first,
+      # update them one by one, and `insert_all` the rest.
+      def upsert_base_rows_for_mysql(rows)
+        rows_by_key = rows.index_by { |r| [r[:variant_id], r[:currency]] }
+
+        Spree::Price.where(
+          variant_id: rows.map { |r| r[:variant_id] }.uniq,
+          currency: rows.map { |r| r[:currency] }.uniq,
+          price_list_id: nil
+        ).find_each do |price|
+          # The `IN (...)` query can return cross-pairs (e.g. `v=1,c=EUR`
+          # exists in the DB even though the caller only passed `v=1,c=USD`
+          # and `v=2,c=EUR`). Skip rows the caller didn't request.
+          row = rows_by_key.delete([price.variant_id, price.currency])
+          next unless row
+
+          price.update_columns(
+            amount: row[:amount],
+            compare_at_amount: row[:compare_at_amount],
+            updated_at: row[:updated_at]
+          )
+        end
+
+        Spree::Price.insert_all(rows_by_key.values) if rows_by_key.any?
+      end
+    end
+  end
+end

data/app/services/spree/products/duplicator.rb

@@ -28,7 +28,7 @@ module Spree
           new_product.status = :draft
           new_product.name = "COPY OF #{product.name}"
           new_product.taxons = product.taxons
-          new_product.stores = product.stores
+          new_product.channels = product.channels
           new_product.created_at = nil
           new_product.deleted_at = nil
           new_product.updated_at = nil

data/app/services/spree/products/prepare_nested_attributes.rb

@@ -67,14 +67,8 @@ module Spree
           end
         end
 
-        # ensure there is at least one store
-        params[:store_ids] = [store.id] if params[:store_ids].blank?
-
-        # Preserve taxon associations from other stores
-        # Only merge taxon_ids from other stores if taxon_ids are being updated
-        if params.key?(:taxon_ids)
-          params[:taxon_ids] = merge_taxons_from_other_stores(params[:taxon_ids])
-        end
+        # ensure the product is owned by a store
+        params[:store_id] = store.id if params[:store_id].blank? && product.store_id.blank?
 
         # Add empty list for option_type_ids and mark variants as removed if there are no variants and options
         if params[:variants_attributes].blank? && variants_to_remove.any? && !params.key?(:option_type_ids)
@@ -186,28 +180,6 @@ module Spree
         attributes
       end
 
-      # Merges taxon IDs from other stores with submitted taxon IDs from current store.
-      #
-      # This prevents the loss of taxon associations from other stores when a product
-      # is edited in one store. Each store's taxonomy is independent, so editing
-      # categories in Store A should not affect categories in Store B.
-      #
-      # @param submitted_taxon_ids [Array<String>] Taxon IDs from the current store
-      # @return [Array<String>] Combined unique taxon IDs
-      def merge_taxons_from_other_stores(submitted_taxon_ids)
-        return submitted_taxon_ids if product.new_record?
-
-        # Get taxon IDs from other stores that should be preserved
-        other_stores_taxon_ids = product.taxons
-                                        .joins(:taxonomy)
-                                        .where.not(spree_taxonomies: { store_id: store.id })
-                                        .pluck(:id)
-                                        .map(&:to_s)
-
-        # Merge with submitted taxon IDs from current store and remove duplicates
-        (submitted_taxon_ids + other_stores_taxon_ids).uniq
-      end
-
       def update_option_value_variants(option_value_params, existing_variant)
         return {} unless option_value_params.present?
         return {} unless can_manage_option_types?

data/app/services/spree/sample_data/loader.rb

@@ -15,6 +15,9 @@ module Spree
               puts 'Loading sample markets...'
               load_ruby_file('markets')
 
+              puts 'Loading sample channels...'
+              load_ruby_file('channels')
+
               puts 'Loading sample metafield definitions...'
               load_ruby_file('metafield_definitions')
 
@@ -24,6 +27,12 @@ module Spree
               puts 'Loading sample products...'
               load_products
 
+              puts 'Publishing sample products on the default channel...'
+              publish_sample_products
+
+              puts 'Loading sample categories...'
+              load_categories
+
               puts 'Loading sample product translations...'
               load_product_translations
 
@@ -67,6 +76,27 @@ module Spree
         Spree::SampleData::ImportRunner.call(csv_path: csv_path, import_class: Spree::Imports::Products)
       end
 
+      def publish_sample_products
+        store = Spree::Store.default
+        store.default_channel.add_products(store.product_ids)
+      end
+
+      def load_categories
+        store = Spree::Store.default
+        csv_path = sample_data_path.join('products.csv')
+
+        require 'csv'
+        ::CSV.foreach(csv_path, headers: true) do |row|
+          product = store.products.find_by(slug: row['slug'])
+          next unless product
+
+          categories = [row['category1'], row['category2'], row['category3']].compact_blank
+          next if categories.empty?
+
+          Spree::Imports::CreateCategoriesJob.perform_now(product.id, store.id, categories)
+        end
+      end
+
       def load_product_translations
         csv_path = sample_data_path.join('product_translations.csv')
         return unless csv_path.exist?

data/app/services/spree/stock_reservations/extend.rb

@@ -0,0 +1,19 @@
+module Spree
+  module StockReservations
+    class Extend
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        return success(order) unless Spree::Config[:stock_reservations_enabled]
+
+        expires_at = Time.current + Spree::StockReservation.ttl_for(order)
+
+        Spree::StockReservation
+          .where(order_id: order.id)
+          .update_all(expires_at: expires_at, updated_at: Time.current)
+
+        success(order)
+      end
+    end
+  end
+end

data/app/services/spree/stock_reservations/release.rb

@@ -0,0 +1,12 @@
+module Spree
+  module StockReservations
+    class Release
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        Spree::StockReservation.where(order_id: order.id).delete_all
+        success(order)
+      end
+    end
+  end
+end

data/app/services/spree/stock_reservations/reserve.rb

@@ -0,0 +1,103 @@
+module Spree
+  module StockReservations
+    class Reserve
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        return success(order) unless Spree::Config[:stock_reservations_enabled]
+
+        expires_at = Time.current + Spree::StockReservation.ttl_for(order)
+
+        ApplicationRecord.transaction do
+          targets = build_targets(order)
+          break if targets.empty?
+
+          # Pessimistic lock + fresh read of count_on_hand. The lock serializes
+          # concurrent checkouts and we use the locked rows below so we never
+          # check stock against a stale association cache.
+          locked_stock_items = Spree::StockItem
+            .where(id: targets.map { |_, si| si.id })
+            .lock
+            .index_by(&:id)
+
+          held = held_by_others(locked_stock_items.keys, order.id)
+          existing = existing_reservations_for(targets)
+
+          this_order_used = Hash.new(0)
+
+          targets.each do |line_item, stock_item|
+            stock_item = locked_stock_items.fetch(stock_item.id)
+            available = stock_item.count_on_hand - held.fetch(stock_item.id, 0) - this_order_used[stock_item.id]
+
+            if available < line_item.quantity
+              raise InsufficientStockError.new(
+                line_item,
+                Spree.t(
+                  :insufficient_stock_for_reservation,
+                  default: '%{item} has only %{available} available',
+                  item: line_item.variant.name,
+                  available: [available, 0].max
+                )
+              )
+            end
+
+            this_order_used[stock_item.id] += line_item.quantity
+
+            reservation = existing[[stock_item.id, line_item.id]] ||
+                          Spree::StockReservation.new(stock_item: stock_item, line_item: line_item)
+            reservation.order = order
+            reservation.quantity = line_item.quantity
+            reservation.expires_at = expires_at
+            reservation.save!
+          end
+        end
+
+        success(order)
+      rescue InsufficientStockError => e
+        failure(e.line_item, e.message)
+      end
+
+      private
+
+      def build_targets(order)
+        order.line_items.includes(variant: { stock_items: :stock_location }).filter_map do |line_item|
+          variant = line_item.variant
+          next unless variant&.should_track_inventory?
+
+          stock_item = select_stock_item(variant)
+          next if stock_item.nil? || stock_item.backorderable?
+
+          [line_item, stock_item]
+        end
+      end
+
+      def select_stock_item(variant)
+        variant.stock_items.detect { |si| si.stock_location&.active? && si.available? }
+      end
+
+      def held_by_others(stock_item_ids, exclude_order_id)
+        return {} if stock_item_ids.empty?
+
+        Spree::StockReservation
+          .active
+          .where(stock_item_id: stock_item_ids)
+          .where.not(order_id: exclude_order_id)
+          .group(:stock_item_id)
+          .sum(:quantity)
+      end
+
+      # One SELECT for all (stock_item_id, line_item_id) pairs we need to
+      # upsert. Returns a hash keyed by [stock_item_id, line_item_id].
+      def existing_reservations_for(targets)
+        return {} if targets.empty?
+
+        stock_item_ids = targets.map { |_, si| si.id }
+        line_item_ids = targets.map { |li, _| li.id }
+
+        Spree::StockReservation
+          .where(stock_item_id: stock_item_ids, line_item_id: line_item_ids)
+          .index_by { |r| [r.stock_item_id, r.line_item_id] }
+      end
+    end
+  end
+end

data/app/services/spree/taxons/remove_products.rb

@@ -36,7 +36,7 @@ module Spree
 
           if classifications_params.any?
             opts = {}
-            opts[:unique_by] = :index_spree_products_taxons_on_product_id_and_taxon_id unless ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+            opts[:unique_by] = :index_spree_products_taxons_on_product_id_and_taxon_id unless mysql_adapter?
 
             Spree::Classification.upsert_all(
               classifications_params,
@@ -58,6 +58,12 @@ module Spree
 
         success(true)
       end
+
+      private
+
+      def mysql_adapter?
+        ActiveRecord::Base.connection.adapter_name.downcase.include?('mysql')
+      end
     end
   end
 end

data/app/subscribers/spree/product_metrics_subscriber.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 module Spree
-  # Handles order completion events to update product metrics.
-  #
-  # When an order is completed, this subscriber enqueues background jobs
-  # to refresh the metrics (units_sold_count, revenue) for each product
-  # in the order.
+  # Handles order completion events to update product metrics
+  # (+units_sold_count+, +revenue+).
   class ProductMetricsSubscriber < Spree::Subscriber
     subscribes_to 'order.completed'
 
@@ -17,12 +14,11 @@ module Spree
 
       order = Spree::Order.find_by_param(order_id)
       return unless order
-      return unless order.store_id
 
       product_ids = order.line_items.includes(:variant).map { |li| li.variant.product_id }.uniq
       return if product_ids.empty?
 
-      jobs = product_ids.map { |product_id| Spree::Products::RefreshMetricsJob.new(product_id, order.store_id) }
+      jobs = product_ids.map { |product_id| Spree::Products::RefreshMetricsJob.new(product_id) }
       ActiveJob.perform_all_later(jobs)
     end
   end

data/app/views/spree/invitation_mailer/invitation_email.html.erb

@@ -12,6 +12,10 @@
   <p>
     <%= link_to Spree.t(:accept), spree.admin_invitation_url(@invitation, token: @invitation.token, host: @invitation.store.formatted_url) %>
   </p>
+<% else %>
+  <p>
+    <%= link_to Spree.t(:accept), main_app.admin_invitation_acceptance_url(@invitation) %>
+  </p>
 <% end %>
 
 <p>

data/config/locales/en.yml

@@ -323,6 +323,10 @@ en:
               cannot_destroy_if_attached_to_line_items: Cannot delete Products that are added to placed Orders. In such cases, please discontinue them.
             discontinue_on:
               invalid_date_range: must be later than available date
+        spree/product_publication:
+          attributes:
+            unpublished_at:
+              must_be_after_published_at: must be after published date
         spree/promotion:
           attributes:
             expires_at:
@@ -574,6 +578,7 @@ en:
       invalid_token: Invalid authentication token.
       locked: Your account is locked.
       timeout: Your session expired, please sign in again to continue.
+      too_many_attempts: Too many attempts. Please wait a moment and try again.
       unauthenticated: You need to sign in or sign up before continuing.
       unconfirmed: You have to confirm your account before continuing.
     mailer:
@@ -785,6 +790,8 @@ en:
     are_you_sure: Are you sure?
     are_you_sure_delete: Are you sure you want to delete this record?
     assets: Media
+    assigned_variants: Assigned variants
+    assigned_variants_help: Pick the variants this image represents. Leave blank to apply to all variants.
     associated_adjustment_closed: The associated adjustment is closed, and will not be recalculated. Do you want to open it?
     at_symbol: "@"
     attachments: Attachments
@@ -879,7 +886,8 @@ en:
     change: Change
     change_password: Change password
     changes_published: Changes published!
-    channel: Channel
+    channel: Sales channel
+    channels: Sales channels
     charged: Charged
     checkout: Checkout
     checkout_message: Checkout message
@@ -1129,8 +1137,12 @@ en:
     errors:
       messages:
         blank: can't be blank
+        cannot_delete_default_channel: Default channel cannot be deleted. Promote another channel to default first.
         cannot_remove_icon: Cannot remove image
+        channel_store_mismatch: must belong to the same store
         could_not_create_taxon: Could not create taxon
+        invalid_order_routing_rule: is not a registered order routing rule
+        invalid_order_routing_strategy: is not a registered order routing strategy
         must_be_origin_only: must be an origin (scheme and host) without path, query, or fragment
         no_shipping_methods_available: No shipping methods available for selected location, please change your address and try again.
         store_association_can_not_be_changed: The store association can not be changed
@@ -1453,6 +1465,7 @@ en:
     new_api_key: New API Key
     new_balance: New balance
     new_billing_address: New Billing Address
+    new_channel: New sales channel
     new_country: New Country
     new_custom_domain: New Custom Domain
     new_customer: New Customer
@@ -1641,6 +1654,10 @@ en:
     order_number: Order %{number}
     order_processed_successfully: Your order has been processed successfully
     order_resumed: Order resumed
+    order_routing:
+      strategies:
+        legacy: Legacy
+        rules: Rules (ordered)
     order_state:
       address: address
       awaiting_return: awaiting return
@@ -1886,15 +1903,24 @@ en:
     promotion_not_cloned: 'Promotion has not been cloned. Reason: %{error}'
     promotion_rule: Promotion Rule
     promotion_rule_types:
+      category:
+        description: Order includes products in specified categories
+        name: Categories
       country:
         description: Limit to orders with shipping address in a specific country
         name: Country
       currency:
         description: Limit to orders in a specific currency
         name: Currency
+      customer:
+        description: Available only to the specified customers
+        name: Customers
       customer_group:
         description: Available only to customers in specified customer group(s)
         name: Customer Group(s)
+      customer_logged_in:
+        description: Available only to logged in customers
+        name: Only logged in customers
       first_order:
         description: Must be the customer's first order
         name: First order
@@ -1910,15 +1936,6 @@ en:
       product:
         description: Order includes specified product(s)
         name: Product(s)
-      taxon:
-        description: Order includes products with specified taxon(s)
-        name: Taxon(s)
-      user:
-        description: Available only to the specified customers
-        name: User
-      user_logged_in:
-        description: Available only to logged in users
-        name: User Logged In
     promotion_uses: Promotion uses
     promotionable: Promotable
     promotions: Promotions
@@ -2487,6 +2504,7 @@ en:
     view: View
     view_all: View all
     view_full_details: View full details
+    view_full_size: View full size
     view_store: View store
     view_your_store: View your store
     visibility: Visibility

data/config/routes.rb

@@ -40,6 +40,15 @@ Rails.application.routes.draw do
       )
     end
   end
+  # Used by admin mailers; the SPA derives the URL from `window.location.origin` instead.
+  direct :admin_invitation_acceptance do |invitation, _options = {}|
+    path = "/accept-invitation/#{invitation.prefixed_id}?token=#{invitation.token}"
+    base = Spree::Config[:admin_url].presence ||
+           (Rails.env.development? ? 'http://localhost:5173' : nil) ||
+           invitation.store&.formatted_url
+
+    base.present? ? "#{base.chomp('/')}#{path}" : path
+  end
 end
 
 Spree::Core::Engine.draw_routes

data/db/migrate/20260429000001_create_spree_order_cancellations.rb

@@ -0,0 +1,25 @@
+class CreateSpreeOrderCancellations < ActiveRecord::Migration[7.2]
+  def change
+    create_table :spree_order_cancellations do |t|
+      t.references :order, null: false, index: false
+      t.string :reason, null: false
+      t.text :note
+      t.boolean :restock_items, null: false
+      t.boolean :refund_payments, null: false
+      t.decimal :refund_amount, precision: 10, scale: 2
+      t.boolean :notify_customer, null: false
+      t.references :canceled_by, polymorphic: true, index: false
+      if t.respond_to? :jsonb
+        t.jsonb :metadata
+      else
+        t.json :metadata
+      end
+      t.timestamps
+    end
+
+    add_index :spree_order_cancellations, :order_id
+    add_index :spree_order_cancellations, [:canceled_by_id, :canceled_by_type],
+              name: 'idx_order_cancellations_canceled_by'
+    add_index :spree_order_cancellations, :created_at
+  end
+end