spree_core 6.0.0.rc1 → 6.0.0.rc2

data/app/models/spree/price_list.rb

@@ -7,6 +7,9 @@ module Spree
 
     include Spree::SingleStoreResource
     include Spree::HasListPosition
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :price_adjustment_percentage, places: 3
 
     MATCH_POLICIES = %w[all any].freeze
 
@@ -94,6 +97,7 @@ module Spree
     # `catalog_id` is queryable so a picker can offer the lists that are
     # actually available — unowned, plus the one the catalog already holds.
     self.whitelisted_ransackable_attributes = %w[status match_policy starts_at ends_at catalog_id]
+    search_by :name
 
     scope :by_position, -> { ordered }
     scope :for_store, ->(store) { where(store: store) }
@@ -333,9 +337,9 @@ module Spree
 
       return if prices_to_insert.empty?
 
-      # Use upsert_all with on_duplicate: :skip to handle race conditions
+      # Use upsert_all with on_duplicate: :skip to handle race conditions.
+      # Placeholders charge nothing, so the variants are not touched.
       Spree::Price.upsert_all(prices_to_insert, on_duplicate: :skip)
-      touch_variants(variant_ids)
       touch
     end
 
@@ -354,10 +358,13 @@ module Spree
       variant_ids = Spree::Variant.where(product_id: product_ids).distinct.pluck(:id)
       return if variant_ids.empty?
 
+      removed_prices = prices.where(variant_id: variant_ids)
+      priced_variant_ids = removed_prices.where.not(amount: nil).distinct.pluck(:variant_id)
+
       # Use delete_all for hard delete - this bypasses acts_as_paranoid
       # which is required for the unique index to work when re-adding products
-      prices.where(variant_id: variant_ids).delete_all
-      touch_variants(variant_ids)
+      removed_prices.delete_all
+      touch_variants(priced_variant_ids)
       touch
     end
 
@@ -386,9 +393,8 @@ module Spree
 
         current = current_values[price_id]
 
-        # Parse amounts using LocalizedNumber for proper decimal handling
-        amount = attrs[:amount].present? ? Spree::LocalizedNumber.parse(attrs[:amount]) : nil
-        compare_at_amount = attrs[:compare_at_amount].present? ? Spree::LocalizedNumber.parse(attrs[:compare_at_amount]) : nil
+        amount = Spree::Money::Rounding.parse_decimal(attrs[:amount])
+        compare_at_amount = Spree::Money::Rounding.parse_decimal(attrs[:compare_at_amount])
 
         # Clear compare_at_amount if it equals amount
         compare_at_amount = nil if compare_at_amount == amount

data/app/models/spree/price_rules/channel_rule.rb

@@ -9,11 +9,8 @@ module Spree
       # against raw `channel_id` rows directly. Scope confines the
       # existence check to the price-list's store so cross-store channel
       # IDs can't sneak in.
-      preference :channel_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Channel,
-                   scope: ->(rule) { rule.store.channels }
-                 )
+      preference :channel_ids, :array, of: :id, model: 'Spree::Channel', default: [],
+                 scope: ->(rule) { rule.store.channels }
 
       def channels
         return [] if preferred_channel_ids.blank?

data/app/models/spree/price_rules/customer_group_rule.rb

@@ -10,11 +10,8 @@ module Spree
       # callers and decodes them on write so eligibility checks compare
       # against raw `customer_group_id` rows directly. Scope confines
       # the existence check to the price-list's store.
-      preference :customer_group_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::CustomerGroup,
-                   scope: ->(rule) { rule.store.customer_groups }
-                 )
+      preference :customer_group_ids, :array, of: :id, model: 'Spree::CustomerGroup', default: [],
+                 scope: ->(rule) { rule.store.customer_groups }
 
       def customer_groups
         return [] if preferred_customer_group_ids.blank?

data/app/models/spree/price_rules/market_rule.rb

@@ -6,11 +6,8 @@ module Spree
       # against raw `market_id` rows directly. Scope confines the
       # existence check to the price-list's store so cross-store market
       # IDs can't sneak in.
-      preference :market_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Market,
-                   scope: ->(rule) { rule.store.markets }
-                 )
+      preference :market_ids, :array, of: :id, model: 'Spree::Market', default: [],
+                 scope: ->(rule) { rule.store.markets }
 
       def markets
         return [] if preferred_market_ids.blank?

data/app/models/spree/price_rules/user_rule.rb

@@ -10,9 +10,7 @@ module Spree
       # e.g. `usr_…`) from API callers and decodes them on write. Resolves
       # `Spree.customer_class` lazily — the user class is configured at boot,
       # and class-body evaluation runs before that on cold loads.
-      preference :user_ids, :array, default: [], parse_on_set: ->(values) {
-        normalize_id_preference(klass: Spree.customer_class).call(values)
-      }
+      preference :user_ids, :array, of: :id, model: -> { Spree.customer_class }, default: []
 
       def users
         return [] if preferred_user_ids.blank?

data/app/models/spree/product/channels.rb

@@ -43,8 +43,7 @@ module Spree
               "Spree::Product##{legacy_attr}= is deprecated; set #{publication_attr} on " \
               "ProductPublication instead (writes to every channel's publication). "
             )
-            super(value)
-            product_publications.each { |publication| publication.public_send("#{publication_attr}=", value) }
+            write_publication_date(legacy_attr, value)
           end
 
           # Reading +available_on+/+discontinue_on+ prefers the current-channel
@@ -92,6 +91,14 @@ module Spree
 
       private
 
+      # Writes a legacy date column together with the matching date on every
+      # channel's publication, so the two never disagree.
+      def write_publication_date(legacy_attr, value)
+        write_attribute(legacy_attr, value)
+        publication_attr = DEPRECATED_DATE_TO_PUBLICATION_FIELD.fetch(legacy_attr.to_sym)
+        product_publications.each { |publication| publication.public_send("#{publication_attr}=", value) }
+      end
+
       def assign_default_store
         self.store ||= Spree::Current.store || Spree::Store.default
       end

data/app/models/spree/product.rb

@@ -40,8 +40,7 @@ module Spree
     publishes_lifecycle_events
     publishes_events :activated, :approved, :archived, :back_in_stock, :drafted, :out_of_stock, :proposed, :rejected
 
-    MEMOIZED_METHODS = %w[total_on_hand category_and_ancestors
-                          default_variant_id tax_category default_variant variant_for_images
+    MEMOIZED_METHODS = %w[total_on_hand default_variant_id tax_category default_variant variant_for_images
                           primary_category buy_box_variants resolved_delivery_profile
                           purchasable? in_stock? backorderable? digital?]
 
@@ -243,8 +242,6 @@ module Spree
     after_create :set_default_variant
 
     after_save :auto_promote_default_variant
-    after_save :run_touch_callbacks, if: :saved_changes?
-    after_touch :touch_categories
 
     after_commit :auto_match_collections, if: :eligible_for_collection_matching?
 
@@ -364,7 +361,21 @@ module Spree
       super(manual_ids | collections.automatic.ids)
     end
 
-    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at seller_id]
+    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at seller_id price]
+
+    # The default variant's base price in the current currency — what the
+    # product lists show — so a list can filter on it like a column.
+    ransacker :price, type: :decimal do |parent|
+      prices = Spree::Price.arel_table
+      Arel::Nodes::Grouping.new(
+        prices.project(prices[:amount]).
+          where(prices[:variant_id].eq(parent.table[:default_variant_id])).
+          where(prices[:currency].eq(Spree::Current.currency)).
+          where(prices[:price_list_id].eq(nil)).
+          where(prices[:deleted_at].eq(nil)).
+          take(1)
+      )
+    end
     self.whitelisted_ransackable_associations = %w[categories collections store channels variants default_variant tags labels
                                                    product_type product_categories option_types seller]
     # The storefront filters by tag, category and collection; every other hop
@@ -376,6 +387,12 @@ module Spree
                                              search in_stock out_of_stock with_option_value_ids
 
                                              ascend_by_price descend_by_price]
+    self.ransackable_scope_types = {
+      'in_taxon' => 'id', 'in_category' => 'id', 'in_collection' => 'id',
+      'in_categories' => { list: 'id' }, 'with_option_value_ids' => { list: 'id' },
+      'price_between' => %w[decimal decimal], 'price_lte' => 'decimal', 'price_gte' => 'decimal',
+      'ascend_by_price' => 'boolean', 'descend_by_price' => 'boolean'
+    }
 
     # All product-level convenience attributes delegate to the default variant —
     # one target, no branching. Reads resolve the existing default variant
@@ -696,7 +713,7 @@ module Spree
     end
 
     def discontinue!
-      self.discontinue_on = Time.current
+      write_publication_date(:discontinue_on, Time.current)
       self.status = 'archived'
       save(validate: false)
     end
@@ -996,23 +1013,6 @@ module Spree
       errors.add(:seller, :invalid)
     end
 
-    def run_touch_callbacks
-      run_callbacks(:touch)
-    end
-
-    def category_and_ancestors
-      @category_and_ancestors ||= categories.map(&:self_and_ancestors).flatten.uniq
-    end
-
-    # Iterate through this product's categories and touch their timestamps in a batch
-    def touch_categories
-      if categories.any?
-        Spree::Products::TouchCategoriesJob.
-          set(wait: 5.seconds).
-          perform_later(category_and_ancestors.map(&:id))
-      end
-    end
-
     def ensure_not_in_complete_orders
       if orders.complete.any?
         errors.add(:base, :cannot_destroy_if_attached_to_line_items)

data/app/models/spree/product_type.rb

@@ -37,6 +37,7 @@ module Spree
     validates :store, presence: true
 
     self.whitelisted_ransackable_attributes = %w[name]
+    search_by :name
     self.whitelisted_ransackable_associations = %w[option_types]
 
     # Replace-set writer for the flat API payload. Each entry is

data/app/models/spree/promotion/actions/create_line_items.rb

@@ -42,7 +42,7 @@ module Spree
         # @param line_item [Spree::LineItem]
         # @return [BigDecimal] never positive
         def compute_amount(line_item)
-          line_item.price * gifted_quantity_of(line_item) * -1
+          -Spree::Money::Rounding.to_currency(line_item.price * gifted_quantity_of(line_item), line_item.currency)
         end
 
         # Tops the order up to the promised quantity and discounts it.

data/app/models/spree/promotion/rules/category.rb

@@ -35,7 +35,7 @@ module Spree
         # Preferences
         #
         MATCH_POLICIES = %w(any all)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first, choices: MATCH_POLICIES
 
         #
         # Attributes

data/app/models/spree/promotion/rules/channel.rb

@@ -8,11 +8,8 @@ module Spree
         # against the order's raw `channel_id` directly. Scope confines the
         # existence check to the promotion's store so cross-store channel
         # IDs can't sneak in.
-        preference :channel_ids, :array, default: [],
-                   parse_on_set: normalize_id_preference(
-                     klass: Spree::Channel,
-                     scope: ->(rule) { rule.promotion.store.channels }
-                   )
+        preference :channel_ids, :array, of: :id, model: 'Spree::Channel', default: [],
+                   scope: ->(rule) { rule.promotion.store.channels }
 
         def channels
           return Spree::Channel.none if preferred_channel_ids.blank?

data/app/models/spree/promotion/rules/country.rb

@@ -9,11 +9,10 @@ module Spree
   class Promotion
     module Rules
       class Country < Spree::PromotionRule
-        preference :country_codes, :array, default: [], parse_on_set: lambda { |values|
-          normalize_id_preference.call(values).map(&:upcase)
-        }
+        preference :country_codes, :array, of: :string, format: :iso_country, default: [],
+                   parse_on_set: ->(values) { Array(values).flat_map { |value| value.to_s.split(',') }.map { |code| code.strip.upcase }.compact_blank }
         preference :country_id, :integer # legacy single-country shortcut
-        preference :country_code, :string # legacy ISO-based shortcut
+        preference :country_code, :string, format: :iso_country # legacy ISO-based shortcut
 
         def countries
           isos = configured_country_codes.presence || [configured_country_code].compact_blank

data/app/models/spree/promotion/rules/currency.rb

@@ -3,7 +3,7 @@ module Spree
   class Promotion
     module Rules
       class Currency < Spree::PromotionRule
-        preference :currency, :string
+        preference :currency, :string, format: :currency
 
         def eligible?(order, options = {})
           return true if order.currency == preferred_currency

data/app/models/spree/promotion/rules/customer_group.rb

@@ -9,11 +9,8 @@ module Spree
         # Scoped to the promotion's own store: groups are store-owned, so an
         # id from elsewhere must raise rather than link a promotion to an
         # audience its store cannot see.
-        preference :customer_group_ids, :array, default: [],
-                   parse_on_set: normalize_id_preference(
-                     klass: Spree::CustomerGroup,
-                     scope: ->(rule) { rule.promotion.store.customer_groups }
-                   )
+        preference :customer_group_ids, :array, of: :id, model: 'Spree::CustomerGroup', default: [],
+                   scope: ->(rule) { rule.promotion.store.customer_groups }
 
         def customer_groups
           return Spree::CustomerGroup.none if preferred_customer_group_ids.blank?

data/app/models/spree/promotion/rules/item_total.rb

@@ -4,9 +4,9 @@ module Spree
   class Promotion
     module Rules
       class ItemTotal < Spree::PromotionRule
-        preference :amount_min, :decimal, default: 100.00
+        preference :amount_min, :money, default: 100.00
         preference :operator_min, :string, default: '>'
-        preference :amount_max, :decimal, default: nil, nullable: true
+        preference :amount_max, :money, default: nil, nullable: true
         preference :operator_max, :string, default: '<'
 
         OPERATORS_MIN = ['gt', 'gte']

data/app/models/spree/promotion/rules/market.rb

@@ -8,11 +8,8 @@ module Spree
         # against the order's raw `market_id` directly. Scope confines the
         # existence check to the promotion's store so cross-store market
         # IDs can't sneak in.
-        preference :market_ids, :array, default: [],
-                   parse_on_set: normalize_id_preference(
-                     klass: Spree::Market,
-                     scope: ->(rule) { rule.promotion.store.markets }
-                   )
+        preference :market_ids, :array, of: :id, model: 'Spree::Market', default: [],
+                   scope: ->(rule) { rule.promotion.store.markets }
 
         def markets
           return Spree::Market.none if preferred_market_ids.blank?

data/app/models/spree/promotion/rules/option_value.rb

@@ -3,13 +3,12 @@ module Spree
     module Rules
       class OptionValue < Spree::PromotionRule
         MATCH_POLICIES = %w(any)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first, choices: MATCH_POLICIES
         # Stored as raw Spree::OptionValue ids. Accepts prefixed IDs (`optval_…`)
         # from API callers and decodes them on write so eligibility checks compare
         # against stable option-value rows, not join-table ids that shift when
         # variants are reconfigured.
-        preference :eligible_values, :array, default: [],
-                   parse_on_set: normalize_id_preference(klass: Spree::OptionValue)
+        preference :eligible_values, :array, of: :id, model: 'Spree::OptionValue', default: []
 
         # @param promotable [Object]
         # @return [Boolean]

data/app/models/spree/promotion/rules/product.rb

@@ -28,7 +28,7 @@ module Spree
         # Preferences
         #
         MATCH_POLICIES = %w(any all none)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first, choices: MATCH_POLICIES
 
         #
         # Attributes

data/app/models/spree/promotion.rb

@@ -87,6 +87,7 @@ module Spree
     # `name` is whitelisted so the admin global search / command palette can
     # filter via the `name_or_code_cont` predicate without a dedicated scope.
     self.whitelisted_ransackable_attributes = ['name', 'path', 'promotion_category_id', 'code', 'kind', 'starts_at', 'expires_at']
+    search_by :name, :code
     self.whitelisted_ransackable_associations = %w[coupon_codes]
 
     def self.with_coupon_code(coupon_code)

data/app/models/spree/purchase_order.rb

@@ -58,7 +58,9 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[number status currency reference expected_at
                                                  cancel_by ordered_at received_at closed_short_at
                                                  supplier_id destination_location_id created_at]
+    search_by :number, :reference
     self.whitelisted_ransackable_scopes = %w[open closed overdue past_cancel_by]
+    self.ransackable_scope_types = %w[open closed overdue past_cancel_by].index_with('boolean')
     self.whitelisted_ransackable_associations = %w[supplier destination_location items]
 
     # What the supplier will invoice for everything ordered.

data/app/models/spree/refund.rb

@@ -5,6 +5,9 @@ module Spree
     include Spree::ActedBy
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :amount
     include Spree::InstrumentsGatewayCalls
     if defined?(Spree::Security::Refunds)
       include Spree::Security::Refunds
@@ -56,10 +59,6 @@ module Spree
     # back through a payment that may belong to several orders.
     before_validation :assign_order_from_payment, on: :create
 
-    def amount=(amount)
-      self[:amount] = Spree::LocalizedNumber.parse(amount)
-    end
-
     def money
       Spree::Money.new(amount, currency: currency)
     end
@@ -121,9 +120,7 @@ module Spree
     def perform!
       return true if transaction_id.present?
 
-      credit_cents = Spree::Money.new(amount.to_f, currency: currency).amount_in_cents
-
-      @response = process!(credit_cents)
+      @response = process!(payment.payment_method.gateway_amount(amount, currency))
 
       self.transaction_id = @response.authorization
       update_columns(transaction_id: transaction_id)
@@ -166,19 +163,20 @@ module Spree
     end
 
     # return a payment response object if successful or else raise an error
-    def process!(credit_cents)
-      refund_total_in_cents = calculate_refund_amount(credit_cents)
+    # @param credit_amount [Spree::Money, Integer] as PaymentMethod#gateway_amount returns it
+    def process!(credit_amount)
+      refund_total = calculate_refund_amount(credit_amount)
 
       response = instrument_gateway_call(:credit, payment.payment_method) do
         if payment.payment_method.payment_profiles_supported?
-          payment.payment_method.credit(refund_total_in_cents, payment.source, payment.transaction_id, originator: self)
+          payment.payment_method.credit(refund_total, payment.source, payment.transaction_id, originator: self)
         else
-          payment.payment_method.credit(refund_total_in_cents, payment.transaction_id, originator: self)
+          payment.payment_method.credit(refund_total, payment.transaction_id, originator: self)
         end
       end
 
       if response.success?
-        track_order_as_refunded(refund_total_in_cents)
+        track_order_as_refunded(refund_total)
       else
         Rails.logger.error(I18n.t('spree.gateway_error') + "  #{response.to_yaml}")
         text = response.params['message'] || response.params['response_reason_text'] || response.message
@@ -191,12 +189,12 @@ module Spree
       raise Core::GatewayError, I18n.t('spree.unable_to_connect_to_gateway')
     end
 
-    def calculate_refund_amount(credit_cents)
+    def calculate_refund_amount(credit_amount)
       # Overwrite this for more complex calculations
-      credit_cents
+      credit_amount
     end
 
-    def track_order_as_refunded(credit_cents)
+    def track_order_as_refunded(credit_amount)
       # You can track refunds here
     end
 

data/app/models/spree/return.rb

@@ -52,6 +52,7 @@ module Spree
     delegate :currency, to: :order
 
     self.whitelisted_ransackable_attributes = %w[number status created_at]
+    search_by :number
     self.whitelisted_ransackable_associations = %w[order reason]
 
     # The label that currently binds the inbound parcel — bought or uploaded,

data/app/models/spree/saved_report.rb

@@ -23,6 +23,7 @@ module Spree
     scope :seeded, -> { where(seeded: true) }
 
     self.whitelisted_ransackable_attributes = %w[name seeded created_at updated_at]
+    search_by :name
 
     def event_serializer_class
       'Spree::Api::V3::SavedReportEventSerializer'.safe_constantize

data/app/models/spree/search_provider/base.rb

@@ -1,6 +1,10 @@
 module Spree
   module SearchProvider
     class Base
+      # Sort keys a provider accepts beyond the product's sortable
+      # attributes. `price` also sorts descending as `-price`.
+      SORT_FIELDS = %w[price best_selling manual].freeze
+
       attr_reader :store
 
       # Whether this provider requires background indexing jobs.

data/app/models/spree/seller.rb

@@ -41,6 +41,12 @@ module Spree
     has_status :pending, :invited, :canceled, :onboarding, :ready_for_review,
                :approved, :rejected, :suspended, default: :pending
 
+    # The storefront lists approved sellers only, and a seller's contact
+    # address is back-office data.
+    self.whitelisted_ransackable_attributes = %w[status contact_email]
+    search_by :name
+    self.private_ransackable_attributes = { store: %w[status contact_email], seller: %w[status contact_email] }
+
     # Who remits consumer tax on this seller's sales. `seller` means they are
     # merchant of record; `platform` is the marketplace-facilitator case, and
     # only Enterprise decides a seller belongs there — core just reads it.
@@ -196,6 +202,7 @@ module Spree
     has_one_attached :logo, service: Spree.public_storage_service_name
     has_one_attached :square_logo, service: Spree.public_storage_service_name
     has_one_attached :cover_photo, service: Spree.public_storage_service_name
+    signed_id_attachments :logo, :square_logo, :cover_photo
 
     #
     # Validations
@@ -340,7 +347,7 @@ module Spree
     # A seller keeps no clock of their own: a date means whatever the
     # marketplace says it means, so their panel reads timestamps in the
     # store's zone rather than in whichever one their browser sits in.
-    delegate :preferred_timezone, to: :store, allow_nil: true
+    delegate :preferred_timezone, :timezone, to: :store, allow_nil: true
 
     # Sellers holding an account with one provider, for the reverse lookup a
     # provider webhook does — it knows the account, not the seller.

data/app/models/spree/seller_payout.rb

@@ -60,6 +60,7 @@ module Spree
     scope :owed, -> { where(status: %w[pending processing]) }
 
     self.whitelisted_ransackable_attributes = %w[amount currency status provider reference period_start period_end created_at seller_id]
+    search_by :reference
     # Filtered by the provider's API shorthand (`system`); the column holds
     # its class name.
     ransacker :provider, formatter: ->(value) { Spree::ApiTyped.class_name_for(Spree.payout_providers, value) } do |parent|

data/app/models/spree/seller_requirement.rb

@@ -21,6 +21,7 @@ module Spree
     self.type_labels_scope = 'spree.seller_requirement_types'
 
     has_prefix_id :selreq
+    search_by :name
 
     acts_as_list scope: :store
 

data/app/models/spree/seller_requirement_submission.rb

@@ -38,6 +38,7 @@ module Spree
     # Private, and served only through the admin and seller branches: these
     # are business registrations and identity documents.
     has_one_attached :file, service: Spree.private_storage_service_name
+    signed_id_attachments :file
 
     #
     # Validations

data/app/models/spree/seller_transfer.rb

@@ -112,6 +112,7 @@ module Spree
     end
 
     self.whitelisted_ransackable_attributes = %w[amount currency kind status provider reference created_at seller_id order_id payout_id]
+    search_by :reference
     # Filtered by the provider's API shorthand (`system`); the column holds
     # its class name.
     ransacker :provider, formatter: ->(value) { Spree::ApiTyped.class_name_for(Spree.payout_providers, value) } do |parent|

data/app/models/spree/shipping_label.rb

@@ -39,6 +39,7 @@ module Spree
     # merchant's account details, and is served only through an
     # authenticated, streamed download.
     has_one_attached :file, service: Spree.private_storage_service_name
+    signed_id_attachments :file
 
     validates :source, inclusion: { in: SOURCES }
     validates :owner_type, inclusion: { in: OWNER_TYPES }

data/app/models/spree/stock/estimator.rb

@@ -121,7 +121,7 @@ module Spree
 
         percent = service_row&.markup_percent || delivery_method.markup_percent || 0
         flat = service_row&.markup_flat || delivery_method.markup_flat || 0
-        (cost * (1 + (percent / 100)) + flat).round(2)
+        Spree::Money::Rounding.to_currency(cost * (1 + (percent / 100)) + flat, currency)
       end
 
       # Display name for provider-priced rates: the merchant's label override,

data/app/models/spree/stock_level.rb

@@ -38,7 +38,9 @@ module Spree
 
     self.whitelisted_ransackable_attributes = %w[count_on_hand allocated_count reserved_count incoming_count
                                                  stock_location_id variant_id]
+    search_by :variant_sku, :variant_product_name
     self.whitelisted_ransackable_scopes = %w[with_stock_status]
+    self.ransackable_scope_types = { 'with_stock_status' => { list: 'text' } }
     self.whitelisted_ransackable_associations = %w[variant stock_location]
 
     scope :with_active_stock_location, -> { joins(:stock_location).merge(Spree::StockLocation.active) }

data/app/models/spree/stock_location.rb

@@ -50,6 +50,7 @@ module Spree
       country_code state_code created_at updated_at
       seller_id
     ]
+    search_by :name
     self.whitelisted_ransackable_associations = %w[seller]
 
     scope :active, -> { where(active: true) }

data/app/models/spree/stock_transfer.rb

@@ -66,7 +66,9 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[number status reference source_location_id
                                                  destination_location_id shipped_at received_at
                                                  closed_short_at created_at]
+    search_by :number, :reference
     self.whitelisted_ransackable_scopes = %w[open closed]
+    self.ransackable_scope_types = %w[open closed].index_with('boolean')
     self.whitelisted_ransackable_associations = %w[source_location destination_location items]
 
     # Whether the merchant may still edit the lines. Once the box is sealed and