spree_core 6.0.0.beta4 → 6.0.0.rc1

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
 

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

@@ -0,0 +1,87 @@
+module Spree
+  module Purchase
+    # One-release bridges for the names renamed in 6.0, shared by
+    # {Spree::Cart} and {Spree::Order}. Before 6.0 a cart was an incomplete
+    # order, so extensions written against 5.x (payment gateways, checkout
+    # plugins) call the legacy names on carts too. Every legacy name warns and
+    # forwards to its replacement. Removed in 6.1.
+    #
+    # Renamed columns are also registered with +alias_attribute+, so the legacy
+    # name keeps working in +where+ / +find_by+ (those paths do not warn).
+    module DeprecatedAliases
+      extend ActiveSupport::Concern
+
+      RENAMED_ATTRIBUTES = {
+        promo_total: :discount_total,
+        item_count: :total_quantity,
+        shipment_total: :delivery_total,
+        ship_total: :delivery_total,
+        special_instructions: :customer_note
+      }.freeze
+
+      RENAMED_METHODS = {
+        display_promo_total: :display_discount_total,
+        display_shipment_total: :display_delivery_total,
+        display_ship_total: :display_delivery_total,
+        shipping_discount: :fulfillment_discount,
+        delivery_required?: :delivery_step_required?,
+        requires_ship_address?: :shipping_address_required?,
+        set_shipments_cost: :set_fulfillments_cost,
+        ensure_updated_shipments: :ensure_updated_fulfillments,
+        create_proposed_fulfillments: :rebuild_fulfillments!,
+        create_proposed_shipments: :rebuild_fulfillments!,
+        associate_user!: :associate_customer!,
+        update_with_updater!: :recalculate_totals!,
+        all_line_items: :line_items
+      }.freeze
+
+      # 5.x took a store argument; payment methods now always come from the
+      # purchase's own store.
+      RENAMED_PAYMENT_METHOD_READERS = %i[
+        available_payment_methods
+        collect_payment_methods
+        collect_frontend_payment_methods
+      ].freeze
+
+      included do
+        include Spree::DeprecatedCustomerAlias
+
+        RENAMED_ATTRIBUTES.each do |legacy_name, current_name|
+          alias_attribute legacy_name, current_name
+        end
+      end
+
+      RENAMED_ATTRIBUTES.each do |legacy_name, current_name|
+        define_method(legacy_name) do
+          warn_deprecated_name(legacy_name, current_name)
+          public_send(current_name)
+        end
+
+        define_method(:"#{legacy_name}=") do |value|
+          warn_deprecated_name(:"#{legacy_name}=", :"#{current_name}=")
+          public_send(:"#{current_name}=", value)
+        end
+      end
+
+      RENAMED_METHODS.each do |legacy_name, current_name|
+        define_method(legacy_name) do |*args, **options, &block|
+          warn_deprecated_name(legacy_name, current_name)
+          public_send(current_name, *args, **options, &block)
+        end
+      end
+
+      RENAMED_PAYMENT_METHOD_READERS.each do |legacy_name|
+        define_method(legacy_name) do |*|
+          warn_deprecated_name(legacy_name, :payment_methods)
+          payment_methods
+        end
+      end
+
+      private
+
+      def warn_deprecated_name(legacy_name, current_name)
+        Spree::Deprecation.warn("#{self.class.name}##{legacy_name} is deprecated and will be removed in Spree 6.1. Use ##{current_name} instead.")
+      end
+    end
+  end
+end

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

@@ -51,16 +51,22 @@ module Spree
 
         payment = payments.checkout.store_credits.where(source: gift_card.store_credits).first
         return unless payment
+        # Nothing is left for the card to pay, and a store credit cannot hold
+        # a zero amount, so the card is released rather than resized.
+        return remove_gift_card unless total.positive?
 
         gift_card.with_lock do
-          new_amount = [gift_card.amount_remaining + payment.amount, total].min
+          # A locking read: a plain reload can return the transaction's older
+          # snapshot, and a resize committed since would be applied again.
+          payment.lock!
+          new_amount = [gift_card.spendable_amount + payment.amount, total].min
           next if payment.amount == new_amount
 
           difference = new_amount - payment.amount
-          # update_column bypasses Payment#max_amount validation which can
-          # fail on stale in-memory state; bounds enforced via min() above.
-          payment.update_column(:amount, new_amount)
           payment.source.update_column(:amount, new_amount)
+          # Skips Payment#max_amount, which can fail on stale in-memory state;
+          # min() above bounds the amount.
+          payment.update_store_credit_amount!(new_amount)
           gift_card.amount_used += difference
           gift_card.save!
         end

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

@@ -22,7 +22,7 @@ module Spree
         return if locale.blank? || store.blank?
 
         unless store.supported_locales_list.include?(locale)
-          errors.add(:locale, :locale_not_supported_by_store, message: Spree.t(:locale_not_supported_by_store))
+          errors.add(:locale, :locale_not_supported_by_store, message: I18n.t('spree.locale_not_supported_by_store'))
         end
       end
     end

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

@@ -31,11 +31,15 @@ module Spree
         payments.pending
       end
 
-      # Active front-end payment methods available for this record.
+      # Active front-end payment methods available for this record. Store
+      # credit is never one of them: it is applied through its own endpoint
+      # before the buyer chooses how to pay the rest.
       #
       # @return [Array<Spree::PaymentMethod>]
       def payment_methods
-        store.payment_methods.active.storefront_visible.select { |payment_method| payment_method.available_for_order?(self) }
+        store.payment_methods.active.storefront_visible.select do |payment_method|
+          !payment_method.store_credit? && payment_method.available_for_order?(self)
+        end
       end
 
       # Free checkouts have no money to collect.
@@ -71,7 +75,7 @@ module Spree
         # Don't run if there are authorized payments
         return if pending_payments.any? && unprocessed_payments.empty?
         # Never complete without a successfully processed payment.
-        raise Spree::Core::GatewayError, Spree.t(:no_payment_found) if unprocessed_payments.empty?
+        raise Spree::Core::GatewayError, I18n.t('spree.no_payment_found') if unprocessed_payments.empty?
 
         unprocessed_payments.each do |payment|
           break if settled_payment_total >= total

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

@@ -83,8 +83,8 @@ module Spree
         return if stored_size <= MAX_PO_DOCUMENT_SIZE
 
         errors.add(
-          :po_document, :po_document_too_large, message: Spree.t(
-            :po_document_too_large,
+          :po_document, :po_document_too_large, message: I18n.t(
+            'spree.po_document_too_large',
             size: ActiveSupport::NumberHelper.number_to_human_size(MAX_PO_DOCUMENT_SIZE)
           )
         )

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

@@ -10,9 +10,37 @@ module Spree
         line_items.sum(:quantity)
       end
 
+      # What promotion calculators take a share of: the line amounts less the
+      # free gifts, so a gift never enlarges a percentage off the order.
+      #
       # @return [BigDecimal]
       def amount
-        line_items.sum(BigDecimal('0'), &:amount)
+        line_items.sum(BigDecimal('0'), &:amount) - gift_amount
+      end
+
+      # The list price of the units gift promotions give away. The gift keeps
+      # its price on its line and is paid for by a discount, so anything
+      # measuring what the shopper spends has to take it out.
+      #
+      # @param promotion [Spree::Promotion, nil] the promotion doing the
+      #   measuring; its own gifts are always taken out, since a gift cannot
+      #   be what qualifies the promotion giving it away
+      # @param own_gift_only [Boolean] true while deciding whether another
+      #   promotion gives its gift, so two gift promotions with spend
+      #   thresholds do not each wait on the other
+      # @return [BigDecimal]
+      def gift_amount(promotion: nil, own_gift_only: false)
+        return BigDecimal('0') if line_items.empty?
+
+        excluded_gift_promo_actions = gift_promo_actions(promotion, own_gift_only).select do |action|
+          action.promotion_id == promotion&.id || action.gives_away?(self)
+        end
+        return BigDecimal('0') if excluded_gift_promo_actions.empty?
+
+        line_items.sum(BigDecimal('0')) do |line_item|
+          gifted_quantity = excluded_gift_promo_actions.sum { |action| action.gifted_quantity_of(line_item) }
+          line_item.price * [gifted_quantity, line_item.quantity].min
+        end
       end
 
       # Re-sums what the customer has actually paid, and nothing else. A
@@ -78,6 +106,26 @@ module Spree
 
       private
 
+      # Other promotions' gifts are looked for among the promotions a
+      # recalculation writes discounts for, so a gift leaves the measure
+      # exactly when its discount can be written.
+      def gift_promo_actions(promotion, own_gift_only)
+        own = promotion ? promotion.actions.grep(Spree::Promotion::Actions::CreateLineItems) : []
+        return own if own_gift_only
+
+        discounting_ids = promotion_ids + Spree::Promotion.held_by_saved_coupon_code(self).map(&:id)
+        return own if discounting_ids.empty?
+
+        gifting_cart_variants = Spree::PromotionActionLineItem.
+                                where(variant_id: line_items.map(&:variant_id)).
+                                select(:promotion_action_id)
+        others = Spree::Promotion::Actions::CreateLineItems.
+                 where(promotion_id: discounting_ids, id: gifting_cart_variants).
+                 includes(:promotion, :promotion_action_line_items)
+
+        (own + others.to_a).uniq(&:id)
+      end
+
       # Completed payments less their refunds, as a scalar subquery so the
       # sum and the write are one statement.
       #

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

@@ -97,7 +97,7 @@ module Spree
       variant_ids = items.reject(&:marked_for_destruction?).filter_map(&:variant_id)
       return if variant_ids.uniq.size == variant_ids.size
 
-      errors.add(:items, :duplicate_variant, message: Spree.t('errors.messages.duplicate_variant'))
+      errors.add(:items, :duplicate_variant, message: I18n.t('spree.errors.messages.duplicate_variant'))
     end
   end
 end

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

@@ -25,10 +25,6 @@ module Spree
           model_class.arel_table[attribute.to_sym].lower.matches("%#{escaped}%", '\\')
         end
       end
-
-      # Backward compatibility aliases — remove in Spree 6.0
-      def self.sanitize_query_for_multi_search(query) = sanitize_query_for_search(query)
-      def self.multi_search_condition(model_class, attribute, query) = search_condition(model_class, attribute, query)
     end
   end
 end

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

@@ -0,0 +1,59 @@
+module Spree
+  # Stores a model's `:password` preferences in a separate `secret_preferences`
+  # text column, encrypted with Active Record encryption whenever keys are
+  # configured, so the `preferences` column never holds a secret. Declarations
+  # are unchanged: `preference :secret_key, :password` and
+  # `preferred_secret_key` read and write the encrypted column.
+  #
+  # Values written before encryption was enabled stay readable and are
+  # encrypted on the next save, or at once by
+  # `spree:upgrade:encrypt_secret_preferences`.
+  module SecretPreferences
+    extend ActiveSupport::Concern
+
+    included do
+      serialize :secret_preferences, coder: TextHashSerializer
+
+      if ActiveRecord::Encryption.config.has_primary_key?
+        encrypts :secret_preferences, support_unencrypted_data: true
+      end
+
+      before_save :move_secret_preferences
+    end
+
+    # The column is `text`, since ciphertext cannot live in a JSON column. An
+    # empty column stays nil rather than `{}`: encrypted attributes compare the
+    # stored value with the loaded one, so `{}` would mark every record without
+    # secrets as changed.
+    class TextHashSerializer
+      def self.dump(hash)
+        ActiveSupport::JSON.encode(hash) unless hash.nil?
+      end
+
+      def self.load(json)
+        Spree::Metadata::HashSerializer.load(ActiveSupport::JSON.decode(json)) unless json.nil?
+      end
+    end
+
+    # Both columns as they should be stored, when `preferences` holds a secret
+    # — one assigned as part of a whole hash, or one the upgrade has not moved
+    # yet. A secret found there is the newer value and wins.
+    #
+    # @return [Hash{Symbol => Hash}, nil] `preferences:` and `secret_preferences:`, or nil when there is nothing to move
+    def separated_secret_preferences
+      secrets = (preferences || {}).slice(*self.class.secret_preference_names)
+      return if secrets.empty?
+
+      { preferences: preferences.except(*secrets.keys), secret_preferences: (secret_preferences || {}).merge(secrets) }
+    end
+
+    private
+
+    # Keeps a secret out of the plain `preferences` column when the record is
+    # saved.
+    def move_secret_preferences
+      separated = separated_secret_preferences
+      assign_attributes(separated) if separated
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module Spree
 
     def ensure_store_association_is_not_changed
       if store_id_changed? && persisted?
-        errors.add(:store, :store_association_can_not_be_changed, message: Spree.t('errors.messages.store_association_can_not_be_changed'))
+        errors.add(:store, :store_association_can_not_be_changed, message: I18n.t('spree.errors.messages.store_association_can_not_be_changed'))
       end
     end
   end

data/app/models/concerns/spree/stores/email_branding.rb

@@ -0,0 +1,31 @@
+module Spree
+  module Stores
+    # The colors and font of a store's customer emails (see Spree::Emails::Branding).
+    # All optional: a blank one keeps the shipped design.
+    module EmailBranding
+      extend ActiveSupport::Concern
+
+      included do
+        Spree::Emails::Branding.attribute_names.each { |name| preference :"email_#{name}", :string }
+
+        validate :email_branding_valid
+      end
+
+      # @param overrides [Hash] unsaved values, e.g. to preview them
+      # @return [Spree::Emails::Branding]
+      def email_branding(overrides = {})
+        saved = Spree::Emails::Branding.attribute_names.to_h { |name| [name, public_send(:"preferred_email_#{name}")] }
+        Spree::Emails::Branding.new(saved.merge(overrides.to_h.stringify_keys.slice(*saved.keys)))
+      end
+
+      private
+
+      def email_branding_valid
+        branding = email_branding
+        return if branding.valid?
+
+        branding.errors.each { |error| errors.add(:"preferred_email_#{error.attribute}", error.type) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Spree
+  # Names and describes each kind in a family of typed subclasses (promotion
+  # rules, collection rules, …) from one translation scope keyed by
+  # +api_type+, so the `/types` endpoints and dashboard pickers label
+  # extension kinds the same way as built-in ones.
+  #
+  #   class Spree::PromotionRule < Spree.base_class
+  #     include Spree::TypeLabels
+  #     self.type_labels_scope = 'spree.promotion_rule_types'
+  #   end
+  #
+  #   Spree::Promotion::Rules::Currency.human_name # => spree.promotion_rule_types.currency.name
+  module TypeLabels
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :type_labels_scope, instance_writer: false
+    end
+
+    class_methods do
+      # @return [String] the kind's name, falling back to its humanized +api_type+
+      def human_name
+        I18n.t("#{type_labels_scope}.#{api_type}.name", default: api_type.titleize)
+      end
+
+      # @return [String] what the kind does, empty when it has no translation
+      def human_description
+        I18n.t("#{type_labels_scope}.#{api_type}.description", default: '')
+      end
+    end
+
+    # @return [String]
+    def human_name = self.class.human_name
+
+    # @return [String]
+    def human_description = self.class.human_description
+  end
+end

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

@@ -49,7 +49,7 @@ module Spree
     private
 
     def exactly_one_owner
-      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
     end
   end
 end

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

@@ -93,6 +93,12 @@ module Spree
       record.save! if record.changed?
 
       record.id
+    rescue ActiveRecord::RecordInvalid => e
+      # A row saved from the owner's `after_save` fails inside the owner's own
+      # save, and a plain `save` swallows the exception — so its errors are
+      # copied onto the owner, or the caller learns only that something failed.
+      e.record.errors.full_messages.each { |message| errors.add(:base, message) }
+      raise
     end
 
     # Decode `*_ids` array preferences (`customer_group_ids`, `user_ids`,

data/app/models/spree/address.rb

@@ -7,7 +7,7 @@ module Spree
     include Spree::HasCustomFields
     include Spree::Metadata
 
-    serialize :preferences, type: Hash, coder: YAML, default: {}
+    serialize :preferences, coder: Spree::Metadata::HashSerializer, default: {}
 
     NO_ZIPCODE_ISO_CODES ||= [
       'AO', 'AG', 'AW', 'BS', 'BZ', 'BJ', 'BM', 'BO', 'BW', 'BF', 'BI', 'CM', 'CF', 'KM', 'CG',
@@ -27,6 +27,10 @@ module Spree
     # those attributes depending of the logic of their applications
     ADDRESS_FIELDS = %w(first_name last_name company address1 address2 city state postal_code country phone)
 
+    # The columns a delivery quote reads. A change to anything else (a phone
+    # number, the recipient's name) leaves the parcel going where it was.
+    DESTINATION_FIELDS = %w(address1 address2 city state_code postal_code country_code).freeze
+
     # Beyond identity and ownership, three groups are excluded because they
     # cannot tell two addresses apart. Latitude and longitude are derived from
     # the address, so an entry whose geocoding has already run would otherwise
@@ -379,6 +383,12 @@ module Spree
       attributes.except(*EXCLUDED_KEYS_FOR_COMPARISON)
     end
 
+    # @return [Boolean] whether the last save moved this address somewhere
+    #   else, as opposed to correcting who receives the parcel
+    def saved_change_to_destination?
+      saved_changes.keys.intersect?(DESTINATION_FIELDS)
+    end
+
     # A country alone doesn't make an address — a new one is pre-filled with the
     # store's default, so both the code and the association are ignored here.
     def empty?

data/app/models/spree/adjusters/promotion.rb

@@ -65,22 +65,8 @@ module Spree
         end
       end
 
-      # The owner's PERSISTED coupon code keeps its promotion in candidacy
-      # even before it ever applied — the discount activates on the exact
-      # recalculation where the cart first qualifies, and deactivates the
-      # same way (Shopify-parity for cart-level discount codes). In-memory
-      # assignments deliberately don't participate: unsaved codes belong to
-      # the explicit PromotionHandler::Coupon path.
       def coupon_promotions
-        return [] unless order.class.respond_to?(:column_names) && order.class.column_names.include?('coupon_code')
-
-        code = order.read_attribute(:coupon_code)
-        return [] if code.blank?
-
-        promotion = order.store.promotions.active.with_coupon_code(code)
-        return [] if promotion.nil? || promotion.usage_limit_exceeded?(order)
-
-        [promotion]
+        Spree::Promotion.held_by_saved_coupon_code(order)
       end
 
       # A coupon promotion that produced rows becomes an applied promotion —

data/app/models/spree/allowed_origin.rb

@@ -10,7 +10,6 @@ module Spree
 
     include Spree::SingleStoreResource
 
-    belongs_to :store, class_name: 'Spree::Store'
 
     validates :origin, presence: true
     validates :origin, uniqueness: { scope: [:store_id, *spree_base_uniqueness_scope] }

data/app/models/spree/api_key.rb

@@ -44,7 +44,6 @@ module Spree
       publishable? ? token : @plaintext_token
     end
 
-    belongs_to :store, class_name: 'Spree::Store'
     # Optional single-channel binding for publishable keys. A bound key
     # server-assigns the request's channel (see Api::V3::ChannelResolution),
     # making channel identity unforgeable instead of client-asserted via the
@@ -162,23 +161,23 @@ module Spree
       return if invalid.empty?
 
       errors.add(:scopes, :unknown_scopes, scopes: invalid.join(', '),
-                 message: Spree.t('errors.messages.unknown_scopes', scopes: invalid.join(', ')))
+                 message: I18n.t('spree.errors.messages.unknown_scopes', scopes: invalid.join(', ')))
     end
 
     def scopes_immutable
-      errors.add(:scopes, :api_key_scopes_immutable, message: Spree.t(:api_key_scopes_immutable))
+      errors.add(:scopes, :api_key_scopes_immutable, message: I18n.t('spree.api_key_scopes_immutable'))
     end
 
     def channel_binding_valid
       if secret?
-        errors.add(:channel, :api_key_channel_publishable_only, message: Spree.t(:api_key_channel_publishable_only))
+        errors.add(:channel, :api_key_channel_publishable_only, message: I18n.t('spree.api_key_channel_publishable_only'))
       elsif channel && channel.store_id != store_id
-        errors.add(:channel, :api_key_channel_must_belong_to_store, message: Spree.t(:api_key_channel_must_belong_to_store))
+        errors.add(:channel, :api_key_channel_must_belong_to_store, message: I18n.t('spree.api_key_channel_must_belong_to_store'))
       end
     end
 
     def channel_immutable
-      errors.add(:channel, :api_key_channel_immutable, message: Spree.t(:api_key_channel_immutable))
+      errors.add(:channel, :api_key_channel_immutable, message: I18n.t('spree.api_key_channel_immutable'))
     end
 
     # Generates the token on creation. For publishable keys, stores the raw token

data/app/models/spree/authentication/strategies/oidc_strategy.rb

@@ -129,7 +129,7 @@ module Spree
         # Password login is not available through an OIDC provider — the browser
         # redirect is the only entry point.
         def authenticate
-          failure(Spree.t('errors.messages.oidc_requires_redirect'))
+          failure(I18n.t('spree.errors.messages.oidc_requires_redirect'))
         end
 
         # Completes the login started by +#authorization_url+: exchanges the
@@ -138,13 +138,13 @@ module Spree
         # @return [Spree::ServiceModule::Result]
         def callback
           code = params[:code]
-          return authentication_failure(Spree.t('errors.messages.oidc_missing_code')) if code.blank?
+          return authentication_failure(I18n.t('spree.errors.messages.oidc_missing_code')) if code.blank?
 
           claims = verify_id_token(exchange_code_for_tokens(code).fetch('id_token'))
           resolve_user(claims)
         rescue StandardError => e
           Rails.logger.error("[Spree] OIDC callback failed for #{config[:label] || config[:issuer]}: #{e.message}")
-          authentication_failure(Spree.t('errors.messages.oidc_authentication_failed'))
+          authentication_failure(I18n.t('spree.errors.messages.oidc_authentication_failed'))
         end
 
         # True when the last +#callback+ failed because no account here is
@@ -168,7 +168,7 @@ module Spree
         #    every member of a corporate tenant would become store staff.
         def resolve_user(claims)
           subject = claims['sub']
-          return authentication_failure(Spree.t('errors.messages.oidc_authentication_failed')) if subject.blank?
+          return authentication_failure(I18n.t('spree.errors.messages.oidc_authentication_failed')) if subject.blank?
 
           identity = Spree::UserIdentity.find_by(
             provider: registry_key,
@@ -191,7 +191,7 @@ module Spree
 
         def not_provisioned_failure
           @account_not_provisioned = true
-          failure(Spree.t('errors.messages.oidc_account_not_provisioned'))
+          failure(I18n.t('spree.errors.messages.oidc_account_not_provisioned'))
         end
 
         # Only an email the provider asserts as verified may claim an existing