spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/models/concerns/spree/post_sale/taxed_line.rb

@@ -0,0 +1,51 @@
+module Spree
+  module PostSale
+    # The tax side of a line on a return, claim or exchange: the rows the tax
+    # provider writes on it (see Spree::TaxProvider::Base#estimate_refund).
+    #
+    # Including models answer +credited_quantity+ and +credited_worth+, which
+    # the provider reads, and +fold_tax_lines!+, which copies the rows written
+    # at opening onto the line's own columns.
+    module TaxedLine
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :tax_lines, class_name: 'Spree::TaxLine', dependent: :destroy
+      end
+
+      # Whether this line's tax goes through the provider when it is refunded.
+      # A line opened before refunds carried tax recorded none against a taxed
+      # sale line, and is refunded exactly as it was opened.
+      #
+      # Read from the columns, which are written once at opening, rather than
+      # the rows: settling rewrites or deletes the rows, and a settle whose
+      # money step then failed would otherwise leave the line looking like one
+      # that never carried tax.
+      #
+      # @return [Boolean]
+      def settles_tax?
+        recorded_tax_total.positive? || line_item.nil? || !line_item.tax_lines.exists?
+      end
+
+      # The tax this line gives back, as its credit rows stand now.
+      #
+      # @return [BigDecimal]
+      def credited_tax_total
+        tax_lines.credits.sum(:amount)
+      end
+
+      private
+
+      # The tax copied onto the line's columns when it opened.
+      def recorded_tax_total
+        tax_total
+      end
+
+      # @return [Array(BigDecimal, BigDecimal)] included and additional tax
+      def tax_totals_from(rows)
+        included, additional = rows.partition(&:included?)
+        [included.sum(0.to_d, &:amount), additional.sum(0.to_d, &:amount)]
+      end
+    end
+  end
+end

data/app/models/concerns/spree/preference_schema/json_schema.rb

@@ -0,0 +1,139 @@
+module Spree
+  module PreferenceSchema
+    # Compiles a class's preference declarations into the JSON Schema of its
+    # `preferences` object — the contract the OpenAPI components, the SDK
+    # types, the `/…/types` endpoints and write validation all read, so none
+    # of them is written by hand.
+    module JsonSchema
+      DECIMAL_PATTERN = '^-?\d+(\.\d+)?$'.freeze
+
+      # Domain formats, with the pattern that makes each one checkable by any
+      # validator, not only those that know the format's name.
+      FORMATS = {
+        currency: { format: 'currency', pattern: '^[A-Z]{3}$' },
+        iso_country: { format: 'iso-country', pattern: '^[A-Z]{2}$' },
+        timezone: { format: 'timezone' },
+        locale: { format: 'locale' },
+        url: { format: 'uri' },
+        color: { format: 'color', pattern: '^#[0-9A-Fa-f]{6}$' }
+      }.freeze
+
+      # @param klass [Class] a class including {Spree::PreferenceSchema}
+      # @return [Hash] a JSON Schema object (string keys)
+      def self.for(klass)
+        fields = klass.preference_schema
+        definitions = klass.preference_definitions
+        properties = fields.to_h do |field|
+          [field[:key].to_s, property_schema(definitions.fetch(field[:key]), default: field[:default])]
+        end
+
+        { 'type' => 'object', 'properties' => properties, 'additionalProperties' => false }
+      end
+
+      # The published schema plus the deprecated preferences, which a write
+      # still accepts until their removal although no read returns them.
+      #
+      # @param klass [Class]
+      # @return [Hash]
+      def self.writable(klass)
+        deprecated = klass.preference_definitions.filter_map do |name, definition|
+          [name.to_s, property_schema(definition)] if definition[:deprecated] && !definition[:internal]
+        end
+        schema = klass.preference_json_schema
+        schema.merge('properties' => schema['properties'].merge(deprecated.to_h))
+      end
+
+      # The schema of one declared preference.
+      #
+      # @param definition [Hash] an entry of `preference_definitions`
+      # @param default [Object] the declared default, already evaluated
+      # @return [Hash]
+      def self.property_schema(definition, default: declared_default(definition))
+        schema = value_schema(definition)
+        choices = definition[:choices]
+        choices = choices.call if choices.respond_to?(:call)
+        schema['enum'] = choices.map { |choice| choice.is_a?(Symbol) ? choice.to_s : choice } if choices.present?
+        default = definition[:dynamic_default] ? nil : wire_default(default, definition)
+        unset_reads_null = default.nil? && !definition[:dynamic_default]
+
+        # A value nothing has set reads back as null, so a preference without
+        # a default is nullable on the wire whatever its declared type — and so
+        # is a secret, whose default is never sent.
+        if (definition[:nullable] || unset_reads_null || definition[:type] == :password) && schema['type']
+          schema['type'] = [schema['type'], 'null']
+          schema['enum'] += [nil] if schema['enum']
+        end
+        # A secret's default would leak alongside the masked value.
+        schema['default'] = default unless default.nil? || definition[:type] == :password
+        schema
+      end
+
+      # A default can be a block that reads the database (the default store's
+      # currency); one that cannot be read here is left out.
+      def self.declared_default(definition)
+        definition[:default].call
+      rescue StandardError
+        nil
+      end
+
+      def self.value_schema(definition)
+        case definition[:type]
+        when :string then string_schema(definition[:format])
+        when :text then { 'type' => 'string', 'x-spree-widget' => 'textarea' }
+        when :boolean then { 'type' => 'boolean' }
+        when :integer then { 'type' => 'integer' }
+        when :decimal, :money then item_schema(definition[:type], definition)
+        when :password then { 'type' => 'string', 'x-spree-secret' => true }
+        when :date then { 'type' => 'string', 'format' => 'date' }
+        when :datetime then { 'type' => 'string', 'format' => 'date-time' }
+        when :array
+          schema = { 'type' => 'array' }
+          schema['items'] = item_schema(definition[:of], definition) if definition[:of]
+          schema
+        when :hash
+          schema = { 'type' => 'object' }
+          if definition[:keys] && definition[:values]
+            schema['propertyNames'] = definition[:keys] == :currency ? string_schema(:currency) : { 'type' => 'string' }
+            schema['additionalProperties'] = item_schema(definition[:values], definition)
+          end
+          schema
+        else
+          {}
+        end
+      end
+
+      def self.item_schema(item_type, definition)
+        case item_type
+        when :string then string_schema(definition[:format])
+        when :integer then { 'type' => 'integer' }
+        when :boolean then { 'type' => 'boolean' }
+        when :decimal then { 'type' => 'string', 'pattern' => DECIMAL_PATTERN }
+        when :money then { 'type' => 'string', 'format' => 'money', 'pattern' => DECIMAL_PATTERN }
+        when :id
+          prefix = Spree::Preferences::Preferable.preference_model(definition)._prefix_id_prefix
+          { 'type' => 'string', 'format' => 'prefixed-id', 'pattern' => "^#{prefix}_[A-Za-z0-9]+$", 'x-spree-prefix' => prefix }
+        when :object
+          properties = definition[:properties].to_h { |name, type| [name.to_s, item_schema(type, {})] }
+          { 'type' => 'object', 'properties' => properties, 'required' => properties.keys, 'additionalProperties' => false }
+        else
+          {}
+        end
+      end
+
+      def self.string_schema(format)
+        { 'type' => 'string' }.merge(FORMATS.fetch(format, {}).transform_keys(&:to_s))
+      end
+
+      # The default in the form the API takes it back: a decimal as its exact
+      # string without trailing zeros ("100", "0.23"), as every API decimal is.
+      def self.wire_default(default, definition)
+        return default if default.nil?
+        return Spree::Money::Rounding.format_decimal(default) if %i[decimal money].include?(definition[:type])
+
+        default.as_json
+      end
+
+      private_class_method :declared_default, :value_schema, :item_schema, :string_schema, :wire_default
+    end
+  end
+end

data/app/models/concerns/spree/preference_schema.rb

@@ -50,12 +50,41 @@ module Spree
       # runtime. Each entry also caches `key_string` (frozen) so hot-path
       # serializers don't allocate `pref.to_s` per request.
       def preference_schema
-        @preference_schema ||= compute_preference_schema
+        return @preference_schema if @preference_schema
 
-        # An empty list to callers either way; only the memo tells the two
-        # apart, so a schema that could not be computed is retried rather than
-        # settled on.
-        @preference_schema || []
+        fields, complete = compute_preference_schema
+        # Settled on only when every default could be read; one computed
+        # before the database was up is retried next time.
+        @preference_schema = fields if complete
+        fields
+      end
+
+      # The JSON Schema of this class's `preferences` object (see
+      # {Spree::PreferenceSchema::JsonSchema}). Memoized like
+      # {#preference_schema}.
+      #
+      # @return [Hash]
+      def preference_json_schema
+        return @preference_json_schema if @preference_json_schema
+
+        schema = Spree::PreferenceSchema::JsonSchema.for(self)
+        @preference_json_schema = schema if @preference_schema
+        schema
+      end
+
+      # Checks a `preferences` payload against {#preference_json_schema}, which
+      # also accepts deprecated preferences until their removal.
+      #
+      # @param values [Hash{String => Object}]
+      # @return [Array<Hash{Symbol => String}>] `{ pointer:, message: }` per failure, empty when it matches
+      def preference_failures(values)
+        # The published schema plus deprecated preferences, which a write
+        # still accepts until their removal. Memoized like the published one.
+        schemer = @preference_schemer || JSONSchemer.schema(Spree::PreferenceSchema::JsonSchema.writable(self))
+        @preference_schemer ||= schemer if @preference_schema
+        schemer.validate(values).map do |error|
+          { pointer: error['data_pointer'], message: error['error'] }
+        end
       end
 
       # Wire-safe variant of `preference_schema` with `:password`
@@ -77,6 +106,10 @@ module Spree
           wire = { key: field[:key], type: field[:type], default: field[:default] }
           wire[:choices] = field[:choices] if field[:choices].present?
           wire[:default] = nil if field[:type] == :password
+          # A decimal default goes out as the decimal string the API takes back.
+          if %i[decimal money].include?(field[:type]) && field[:default].is_a?(Numeric)
+            wire[:default] = Spree::Money::Rounding.format_decimal(field[:default])
+          end
           wire.freeze
         end.freeze
       end
@@ -93,35 +126,26 @@ module Spree
                                       .freeze
       end
 
-      # Declared order first, so a form reads the way its author grouped the
-      # fields; anything the macro did not record (an association writer that
-      # looks like a preference) keeps its existing place at the end.
-      def ordered_preferences(instance)
-        defined = instance.defined_preferences
-        return defined unless respond_to?(:declared_preference_order)
-
-        declared = declared_preference_order & defined
-        declared + (defined - declared)
-      end
-
+      # @return [Array(Array<Hash>, Boolean)] the fields, and whether their
+      #   defaults could all be read
       def compute_preference_schema
         # Only instantiation is guarded. `new` touches the database to read
         # the column list, so it fails whenever the schema is asked for before
-        # a connection exists — at boot, or in a rake task on an empty
-        # database. Describing the preferences themselves is pure Ruby, so an
-        # error there is a real bug: left inside the rescue it would return an
-        # empty schema and quietly strip every field from the admin form.
-        # Nil rather than an empty list, so `preference_schema`'s `||=` asks
-        # again next time. Memoizing the failure would leave a class describing
-        # no preferences for the life of the process because it was first asked
-        # before the database was up.
+        # a connection exists — at boot, in a rake task on an empty database,
+        # or while generating the SDK types. An uninitialized instance still
+        # describes every preference, since the declarations are pure Ruby;
+        # only a default read from the database is missing, so that result is
+        # not memoized. An error describing the preferences themselves is a
+        # real bug and is left to raise.
+        complete = true
         instance = begin
           new
         rescue StandardError
-          return nil
+          complete = false
+          allocate
         end
 
-        ordered_preferences(instance).filter_map do |pref|
+        fields = instance.defined_preferences.filter_map do |pref|
           next if instance.preference_deprecated(pref)
           # Written by Spree, not supplied by the operator — a value a
           # provider hands back after we register something with it. Offering
@@ -137,6 +161,7 @@ module Spree
             choices: instance.preference_choices(pref)
           }.compact.freeze
         end
+        [fields, complete]
       end
 
       # Builds a `parse_on_set:` lambda for `preference :foo_ids, :array`
@@ -161,6 +186,9 @@ module Spree
       #   relation builder; defaults to the unscoped `klass`.
       # @return [Proc] suitable for the `parse_on_set:` preference option.
       def normalize_id_preference(klass: nil, scope: nil)
+        Spree::Deprecation.warn(
+          '`normalize_id_preference` is deprecated. Declare the list as `preference :name, :array, of: :id, model:, scope:`.'
+        )
         lambda do |values, owner = nil|
           raw = Array(values).flat_map { |v| v.to_s.split(',') }.compact_blank.map(&:strip)
           next raw unless klass
@@ -189,11 +217,10 @@ module Spree
         registered_subclasses.find { |klass| klass.api_type == shorthand.to_s }
       end
 
-      # Returns a `[{ type:, label:, description:, preference_schema: }]`
-      # array for every concrete subclass in `subclasses`. Sorted by label
-      # for stable output. Uses `serialized_preference_schema` so
-      # `:password` defaults are redacted — `/types` is an unauthenticated
-      # discovery surface and must never leak gateway-shipped defaults.
+      # Returns a `[{ type:, label:, description:, schema: }]` array for every
+      # registered subclass, sorted by label for stable output. `schema` is
+      # the JSON Schema of the subclass's `preferences`, which never carries a
+      # secret's default.
       #
       # `label` and `description` are a fallback, not the admin UI's copy:
       # they resolve in the request's locale, which is the store's rather
@@ -210,12 +237,15 @@ module Spree
             # Asking for only one left promotion types with a null description
             # and no fallback for a client without its own translation.
             description: subclass_description(klass),
-            preference_schema: klass.respond_to?(:serialized_preference_schema) ? klass.serialized_preference_schema : []
+            schema: klass.preference_json_schema
           }
           # Only present when true, so families without the concept keep
           # their wire shape byte-identical. Pickers stop offering a
           # superseded kind; existing rows still render and match.
           entry[:superseded] = true if klass.respond_to?(:superseded?) && klass.superseded?
+          # Provider families (payment methods) add their gallery logo and
+          # setup guide; other families keep their wire shape unchanged.
+          entry.merge!(klass.provider_listing) if klass.respond_to?(:provider_listing)
           entry
         end.sort_by { |entry| entry[:label] }
       end

data/app/models/concerns/spree/product_scopes.rb

@@ -20,7 +20,8 @@ module Spree
                             .group("#{Variant.table_name}.product_id")
                             .to_sql
 
-        price_expr = Arel.sql('COALESCE(price_agg.agg_price, 999999999)')
+        # Above any price decimal(19,4) holds, so an unpriced product sorts last.
+        price_expr = Arel.sql('COALESCE(price_agg.agg_price, 1000000000000000)')
 
         joins("LEFT JOIN (#{price_agg_sql}) AS price_agg ON price_agg.product_id = #{Product.table_name}.id").
           select("#{Product.table_name}.*").
@@ -109,6 +110,9 @@ module Spree
       #
       #   Spree::Product.in_taxon(taxon).count(distinct: true)
       scope :in_taxon, ->(taxon) {
+        taxon = Spree::Category.find_by_prefix_id(taxon) if taxon.is_a?(String)
+        next none if taxon.nil?
+
         joins(:product_categories).
           where("#{Spree::ProductCategory.table_name}.category_id" => taxon.cached_self_and_descendants_ids).distinct
       }
@@ -156,7 +160,8 @@ module Spree
           where(Spree::ProductCategory.table_name => { category_id: taxon_ids }).
           select("#{Product.table_name}.*", "#{min_position_sql} AS min_taxon_position").
           group("#{Product.table_name}.id").
-          order(Arel.sql("#{min_position_sql} ASC"))
+          # Ties fall back to id, so the order holds across queries and pages.
+          order(Arel.sql("#{min_position_sql} ASC"), arel_table[:id].asc)
       }
 
       scope :with_option_value, ->(option, value) {
@@ -218,6 +223,15 @@ module Spree
         channel = Spree::Current.channel
         return where(discontinue_on: [nil, Time.current.beginning_of_minute..]) unless channel
 
+        not_discontinued_on(channel)
+      end
+
+      # Published on the channel and not yet unpublished from it — a channel
+      # publication's end date is the product's discontinuation there.
+      #
+      # @param channel [Spree::Channel]
+      # @return [ActiveRecord::Relation<Spree::Product>]
+      def self.not_discontinued_on(channel)
         for_channel(channel).where(Spree::ProductPublication.table_name => { unpublished_at: [nil, Time.current.beginning_of_minute..] })
       end
 

data/app/models/concerns/spree/provider_listing.rb

@@ -0,0 +1,41 @@
+module Spree
+  # What a provider shows on its gallery card in the dashboard: a logo and a
+  # link to its setup guide. Shared by integrations and payment methods so a
+  # provider gem declares both the same way whichever family it extends.
+  #
+  #   class SpreeStripe::Gateway < Spree::Gateway
+  #     def self.logo_url = 'https://example.com/stripe.png'
+  #     def self.docs_url = 'https://spreecommerce.org/docs/integrations/payments/stripe'
+  #   end
+  module ProviderListing
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Logo shown on the gallery card: an absolute URL to publicly hosted
+      # brand assets, or a `data:` URI for gems that want to be self-contained
+      # (works air-gapped, no CSP domain to allowlist). Anything an `<img src>`
+      # accepts. Deliberately not an asset-pipeline path — provider gems must
+      # not force an asset pipeline onto headless API hosts. Hosted logos are a
+      # courtesy, not a guarantee: the dashboard falls back to a letter avatar
+      # when unset or unreachable.
+      #
+      # @return [String, nil]
+      def logo_url
+        nil
+      end
+
+      # Absolute URL of the provider's setup guide, linked from its gallery
+      # card. A third-party gem points at its own documentation.
+      #
+      # @return [String, nil]
+      def docs_url
+        nil
+      end
+
+      # @return [Hash] the listing attributes merged into a type-discovery entry
+      def provider_listing
+        { logo_url: logo_url, docs_url: docs_url }
+      end
+    end
+  end
+end

data/app/models/concerns/spree/publishable.rb

@@ -36,9 +36,12 @@ module Spree
   module Publishable
     extend ActiveSupport::Concern
 
+    LIFECYCLE_ACTIONS = { create: :created, update: :updated, delete: :deleted }.freeze
+
     included do
       class_attribute :publish_events, default: true
       class_attribute :lifecycle_events_enabled, default: false
+      class_attribute :lifecycle_event_actions, default: []
 
       after_update :mark_real_update_for_events
     end
@@ -76,6 +79,9 @@ module Spree
         events &= Array(options[:only]) if options[:only]
         events -= Array(options[:except]) if options[:except]
 
+        self.lifecycle_event_actions = events.map { |event| LIFECYCLE_ACTIONS.fetch(event) }
+        lifecycle_event_actions.each { |action| publishes_event(action) }
+
         if events.include?(:create)
           after_commit :publish_create_event, on: :create, if: :should_publish_events?
         end
@@ -90,6 +96,51 @@ module Spree
         end
       end
 
+      # A subclass publishes its lifecycle events under its own prefix, which may
+      # differ from its parent's, so they are declared again for it.
+      def inherited(subclass)
+        super
+        subclass.lifecycle_event_actions.each { |action| subclass.publishes_event(action) }
+      end
+
+      # Declare events this model publishes, each carrying this model's Store
+      # serializer as its payload.
+      #
+      # @param names [Array<Symbol, String>] actions (`:placed`, prefixed with
+      #   {event_prefix}) or full dotted names (`'customer.password_reset'`)
+      # @param options [Hash] see {publishes_event}
+      # @return [void]
+      #
+      # @example
+      #   publishes_events :placed, :paid, :shipped
+      def publishes_events(*names, **options)
+        names.each { |name| publishes_event(name, **options) }
+      end
+
+      # Declare one event this model publishes. Publishing a name no model
+      # declared raises in development and test.
+      #
+      # @param name [Symbol, String] an action or a full dotted name
+      # @param serializer [String, nil] payload serializer class name, when the
+      #   payload is not this model's Store serializer
+      # @param credential [String, nil] for a payload carrying a live credential,
+      #   the permission key needed to point a webhook endpoint at it; such an
+      #   event reaches only endpoints that name it outright
+      # @param deprecated_alias_of [String, nil] the event this one duplicates
+      # @param webhook [Boolean] false for an event no webhook endpoint may
+      #   receive, even one subscribed to `*`
+      # @return [void]
+      #
+      # @example
+      #   publishes_event :canceled, serializer: 'Spree::Api::V3::OrderCanceledEventSerializer'
+      #   publishes_event 'customer.password_reset_requested', serializer: '...', credential: 'write_customers'
+      def publishes_event(name, serializer: nil, credential: nil, deprecated_alias_of: nil, webhook: true)
+        Spree::Events.catalog.declare(
+          self, name,
+          serializer: serializer, credential: credential, deprecated_alias_of: deprecated_alias_of, webhook: webhook
+        )
+      end
+
       # Disable lifecycle events for this model
       #
       # @example
@@ -145,10 +196,13 @@ module Spree
     #   order.publish_event('order.placed', metadata: { user_id: 1 })
     #
     def publish_event(event_name, payload = nil, metadata = {})
+      # Checked even while events are disabled, so every spec that reaches a
+      # publish also proves the event is declared.
+      Spree::Events.catalog.verify_declared!(event_name)
       return unless Spree::Events.enabled?
 
       @_current_event_name = event_name
-      payload ||= event_payload
+      payload ||= event_payload_for(event_name)
       Spree::Events.publish(event_name, payload, metadata)
     ensure
       @_current_event_name = nil
@@ -161,20 +215,19 @@ module Spree
     #
     # @return [Hash]
     def event_payload
-      serializer = event_serializer_class
-
-      unless serializer
-        return {
-          id: respond_to?(:prefixed_id) ? prefixed_id : id,
-          created_at: created_at&.iso8601,
-          updated_at: updated_at&.iso8601
-        }
-      end
+      build_event_payload(event_serializer_class)
+    end
 
-      # Use as_json to ensure all values are JSON-safe primitives.
-      # Alba's to_h can return raw Ruby objects (e.g., Spree::Money) which
-      # ActiveJob cannot serialize for async event subscribers.
-      serializer.new(self, params: event_serializer_params).to_h.as_json
+    # The payload for one event, built with the serializer the catalog declares
+    # for it, falling back to this model's Store serializer.
+    #
+    # @param event_name [String]
+    # @param params [Hash] extra serializer params the event serializer reads,
+    #   e.g. the reset token of a password reset request
+    # @return [Hash]
+    def event_payload_for(event_name, **params)
+      serializer = Spree::Events.catalog.find(event_name)&.serializer_name&.safe_constantize
+      build_event_payload(serializer || event_serializer_class, params)
     end
 
     # Find the event serializer class for this model
@@ -223,6 +276,21 @@ module Spree
 
     private
 
+    def build_event_payload(serializer, params = {})
+      unless serializer
+        return {
+          id: respond_to?(:prefixed_id) ? prefixed_id : id,
+          created_at: created_at&.iso8601,
+          updated_at: updated_at&.iso8601
+        }
+      end
+
+      # Use as_json to ensure all values are JSON-safe primitives.
+      # Alba's to_h can return raw Ruby objects (e.g., Spree::Money) which
+      # ActiveJob cannot serialize for async event subscribers.
+      serializer.new(self, params: event_serializer_params.merge(params)).to_h.as_json
+    end
+
     # Build params for V3 serializers
     #
     # @return [Hash]

data/app/models/concerns/spree/purchase/addresses.rb

@@ -59,17 +59,17 @@ module Spree
 
         return false if preferred_stock_location_id.present?
 
-        # An address is needed when any item's profile ships to one —
-        # answered by the profile kind, resolved once per profile.
-        profile_requires_address = Hash.new do |cache, profile|
-          cache[profile] = profile.present? && profile.requires_shipping_address?
-        end
+        items_require_shipping_address?
+      end
 
-        # Both profile paths are preloaded: the variant's own override, and the
-        # product's for the variants that inherit it.
-        line_items.includes(variant: [:delivery_profile, { product: :delivery_profile }]).any? do |line_item|
-          profile_requires_address[line_item.variant&.resolved_delivery_profile]
-        end
+      # Whether delivery can be proposed yet: once there is a destination (a
+      # shipping address, or a pickup intent for a purchase that never gets
+      # one), or straight away when no item ships to an address. Quoted
+      # without a destination, only pickup qualifies.
+      #
+      # @return [Boolean]
+      def can_propose_deliveries?
+        ship_address.present? || preferred_stock_location_id.present? || !items_require_shipping_address?
       end
 
       # @deprecated The shipping address is canonical — use +use_shipping+ to
@@ -174,6 +174,19 @@ module Spree
 
       private
 
+      def items_require_shipping_address?
+        # Answered by the profile kind, resolved once per profile.
+        profile_requires_address = Hash.new do |cache, profile|
+          cache[profile] = profile.present? && profile.requires_shipping_address?
+        end
+
+        # Both profile paths are preloaded: the variant's own override, and the
+        # product's for the variants that inherit it.
+        line_items.includes(variant: [:delivery_profile, { product: :delivery_profile }]).any? do |line_item|
+          profile_requires_address[line_item.variant&.resolved_delivery_profile]
+        end
+      end
+
       # The address behind an id a client may select, or nil when the id names
       # one this purchase has no business shipping to.
       #

data/app/models/concerns/spree/purchase/currency.rb

@@ -15,7 +15,7 @@ module Spree
 
         supported_codes = store.supported_currencies_list.map(&:iso_code)
         unless supported_codes.include?(currency)
-          errors.add(:currency, :currency_not_supported_by_store, message: Spree.t(:currency_not_supported_by_store))
+          errors.add(:currency, :currency_not_supported_by_store, message: I18n.t('spree.currency_not_supported_by_store'))
         end
       end