spree_core 5.6.0 → 6.0.0.beta1

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

@@ -0,0 +1,26 @@
+module Spree
+  module Adjusters
+    # Base class for adjusters registered in +Spree.adjusters+. An adjuster is
+    # invoked once per order recalculation and owns a family of typed rows
+    # (Discount or Fee) — it writes, refreshes and removes them so the rows
+    # always reflect the order's current state. Tax is not an adjuster; it is
+    # written by the sale's tax provider after all adjusters ran.
+    class Base
+      def self.adjust(order)
+        new(order).update
+      end
+
+      def initialize(order)
+        @order = order
+      end
+
+      def update
+        raise NotImplementedError, "Please implement 'update' in your adjuster: #{self.class.name}"
+      end
+
+      private
+
+      attr_reader :order
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  module Adjusters
+    # Largest-remainder apportionment of an integer cent total across weights.
+    # Shared by promotion order-level distribution and manual admin discounts
+    # so both split identically (sum of shares always equals the total).
+    module LargestRemainder
+      module_function
+
+      # @param total_cents [Integer]
+      # @param weights [Array<Numeric>] proportional bases (sum must be > 0)
+      # @return [Array<Integer>] per-weight shares in cents, summing to total_cents
+      def largest_remainder_shares(total_cents, weights)
+        weights_sum = weights.sum
+        raw = weights.map { |weight| Rational(total_cents) * Rational(weight) / Rational(weights_sum) }
+        shares = raw.map(&:floor)
+        remainder = total_cents - shares.sum
+        raw.each_with_index.sort_by { |value, index| [shares[index] - value, index] }.first(remainder).each do |_, index|
+          shares[index] += 1
+        end
+        shares
+      end
+    end
+  end
+end

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

@@ -0,0 +1,253 @@
+module Spree
+  module Adjusters
+    # Recomputes all promotion Discount rows for an order from the promotions
+    # connected to it (plus any promotions being activated right now, passed as
+    # +extra_promotions+). Candidates are computed for every eligible promotion
+    # on every recalculation; only applied discounts are persisted — losing
+    # candidates are simply not written, so "reinstatement" needs no stored
+    # rows. Selection policy is isolated in {#select_applicable} (winner-only
+    # in 6.0; 6.1 stacking replaces just that method).
+    #
+    # Competition groups mirror the legacy semantics: line-level actions
+    # compete per line item, fulfillment actions compete per fulfillment, and
+    # order-level actions compete order-wide — the order-wide winner is
+    # distributed proportionally across line items (largest-remainder over
+    # each line's remaining discounted base), so no order-attached rows exist.
+    class Promotion < Base
+      def initialize(order, extra_promotions: [])
+        super(order)
+        @extra_promotions = extra_promotions
+        @applied_row_ids = []
+      end
+
+      def update
+        apply_line_item_discounts
+        apply_fulfillment_discounts
+        apply_order_level_discount
+        sync_coupon_promotion_joins
+        cleanup_stale_rows
+      end
+
+      # @param action [Spree::PromotionAction]
+      # @return [Boolean] whether the action currently yields any candidate
+      def candidate_for?(action)
+        case action.discount_scope
+        when :line_item
+          order.line_items.any? { |line_item| line_item_candidates(line_item).any? { |c| c[:action].id == action.id } }
+        when :fulfillment
+          order.fulfillments.any? && eligible_promotions.include?(action.promotion)
+        when :order
+          order_level_candidates.any? { |c| c[:action].id == action.id }
+        else
+          false
+        end
+      end
+
+      private
+
+      attr_reader :extra_promotions
+
+      # THE selection seam: 6.0 is winner-takes-all per competition group.
+      # 6.1 stacking replaces this method with a combines_with partition —
+      # persistence, clamping and proration below already support multiple
+      # applied rows per adjustable.
+      def select_applicable(candidates)
+        return [] if candidates.empty?
+
+        # Most negative amount wins; ties go to the newest action.
+        [candidates.min_by { |candidate| [candidate[:amount], -candidate[:action].id] }]
+      end
+
+      def eligible_promotions
+        @eligible_promotions ||= begin
+          promotions = (order.promotions.includes(:promotion_actions).to_a + extra_promotions + coupon_promotions).uniq(&:id)
+          promotions.select { |promotion| promotion.eligible?(order) }
+        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]
+      end
+
+      # A coupon promotion that produced rows becomes an applied promotion —
+      # the join drives the storefront discounts summary and completion-time
+      # usage accounting.
+      def sync_coupon_promotion_joins
+        coupon_promotions.each do |promotion|
+          next unless order.discounts.where(promotion_id: promotion.id).exists?
+
+          order.order_promotions.find_or_create_by!(promotion: promotion)
+        end
+      end
+
+      def discount_actions(scope)
+        eligible_promotions.flat_map(&:promotion_actions).select { |action| action.discount_scope == scope }
+      end
+
+      def apply_line_item_discounts
+        order.line_items.each do |line_item|
+          applicable = select_applicable(line_item_candidates(line_item))
+          applicable.each do |candidate|
+            amount = clamp(candidate[:amount], discountable_base(line_item))
+            next if amount.zero?
+
+            persist_discount(line_item, candidate, amount)
+          end
+        end
+      end
+
+      def line_item_candidates(line_item)
+        @line_item_candidates ||= {}
+        @line_item_candidates[line_item.id] ||= discount_actions(:line_item).filter_map do |action|
+          next unless action.promotion.line_item_actionable?(order, line_item)
+
+          amount = action.compute_amount(line_item)
+          next if amount.zero?
+
+          candidate(action, amount)
+        end
+      end
+
+      def apply_fulfillment_discounts
+        actions = discount_actions(:fulfillment)
+        return if actions.empty?
+
+        order.fulfillments.each do |fulfillment|
+          candidates = actions.map { |action| candidate(action, action.compute_amount(fulfillment)) }
+          select_applicable(candidates).each do |chosen|
+            amount = clamp(chosen[:amount], fulfillment.cost)
+            # Free shipping rows persist even at zero amount — row existence
+            # is the "this order has free shipping" signal.
+            next if amount.zero? && !chosen[:action].persist_at_zero?
+
+            persist_discount(fulfillment, chosen, amount)
+          end
+        end
+      end
+
+      def order_level_candidates
+        @order_level_candidates ||= discount_actions(:order).filter_map do |action|
+          amount = action.compute_amount(order)
+          next if amount.zero?
+
+          candidate(action, amount)
+        end
+      end
+
+      def apply_order_level_discount
+        select_applicable(order_level_candidates).each do |chosen|
+          distribute_over_line_items(chosen)
+        end
+      end
+
+      # Largest-remainder distribution (in cents) of the order-wide winner over
+      # each line's remaining discounted base, so shares always sum exactly to
+      # the promotion amount and no line goes below zero.
+      def distribute_over_line_items(chosen)
+        line_items = order.line_items.to_a
+        bases = line_items.map { |line_item| [discountable_base(line_item), BigDecimal(0)].max }
+        bases_sum = bases.sum
+        return if bases_sum <= 0
+
+        total_cents = [chosen[:amount].abs, bases_sum].min * 100
+        shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares(total_cents.round, bases)
+
+        line_items.each_with_index do |line_item, index|
+          amount = -BigDecimal(shares[index]) / 100
+          next if amount.zero?
+
+          persist_discount(line_item, chosen, amount)
+        end
+      end
+
+      # Combined discounts never push an adjustable's net below zero.
+      def clamp(amount, base)
+        [amount, -[base, BigDecimal(0)].max].max
+      end
+
+      # The adjustable's remaining discounted amount: its own base minus
+      # discounts already applied — manual/custom rows plus promotion rows
+      # written earlier in this pass. Stale promotion rows from previous
+      # passes are excluded (they're about to be cleaned up) so recalculation
+      # never compounds against its own output.
+      def discountable_base(adjustable)
+        base = adjustable.is_a?(Spree::LineItem) ? adjustable.amount : adjustable.cost
+        applied = adjustable.discounts.reload.select do |row|
+          !row.promotion? || @applied_row_ids.include?(row.id)
+        end
+        base + applied.sum(&:amount)
+      end
+
+      def candidate(action, amount)
+        value, value_type = value_snapshot(action)
+        {
+          action: action,
+          promotion: action.promotion,
+          amount: amount,
+          label: action.send(:label),
+          code: action.promotion.code_for_order(order),
+          value: value,
+          value_type: value_type
+        }
+      end
+
+      def value_snapshot(action)
+        calculator = action.try(:calculator)
+        return [nil, nil] unless calculator
+
+        if calculator.respond_to?(:preferred_percent)
+          [calculator.preferred_percent, 'percent']
+        elsif calculator.respond_to?(:preferred_flat_percent)
+          [calculator.preferred_flat_percent, 'percent']
+        elsif calculator.respond_to?(:preferred_amount)
+          [calculator.preferred_amount, 'flat']
+        else
+          [nil, nil]
+        end
+      end
+
+      def persist_discount(adjustable, candidate, amount)
+        row = adjustable.discounts.find_or_initialize_by(kind: 'promotion', promotion_action_id: candidate[:action].id)
+        row.assign_attributes(
+          owner_attributes(adjustable).merge(
+            amount: amount,
+            label: candidate[:label],
+            code: candidate[:code],
+            value: candidate[:value],
+            value_type: candidate[:value_type],
+            promotion: candidate[:promotion]
+          )
+        )
+        row.save!
+        @applied_row_ids << row.id
+        row
+      end
+
+      def owner_attributes(adjustable)
+        owner = adjustable.owner
+        owner.is_a?(Spree::Order) ? { order: owner, cart: nil } : { cart: owner, order: nil }
+      end
+
+      # Everything not written in this pass is stale: losing candidates,
+      # promotions that stopped being eligible, and rows whose promotion was
+      # deleted (FKs nullified). Manual and custom-kind discounts are not ours.
+      def cleanup_stale_rows
+        order.discounts.promotion.where.not(id: @applied_row_ids).destroy_all
+      end
+    end
+  end
+end

data/app/models/spree/admin_user.rb

@@ -0,0 +1,26 @@
+# Default staff/admin model.
+# Ships in the gem with has_secure_password on the existing spree_admin_users table.
+module Spree
+  class AdminUser < Spree.base_class
+    self.table_name = 'spree_admin_users'
+
+    has_secure_password validations: false
+
+    include Spree::AdminUserMethods
+    include Spree::AccountLockout
+    include Spree::PasswordPolicy
+
+    validates :email, presence: true, uniqueness: { case_sensitive: false }
+
+    # Back-compat with callers and auth strategies that check +valid_password?+.
+    # Guards a blank digest (password-less accounts) so it returns false instead
+    # of raising BCrypt::Errors::InvalidHash on older Rails/bcrypt versions.
+    # @param password [String]
+    # @return [Boolean]
+    def valid_password?(password)
+      return false if password_digest.blank?
+
+      authenticate(password).present?
+    end
+  end
+end

data/app/models/spree/allowed_origin.rb

@@ -12,7 +12,7 @@ module Spree
 
     belongs_to :store, class_name: 'Spree::Store'
 
-    validates :store, :origin, presence: true
+    validates :origin, presence: true
     validates :origin, uniqueness: { scope: [:store_id, *spree_base_uniqueness_scope] }
     validate :origin_must_be_valid_http_url
 

data/app/models/spree/api_key.rb

@@ -2,31 +2,29 @@ module Spree
   class ApiKey < Spree.base_class
     has_prefix_id :key  # Spree-specific: api key
 
+    include Spree::SingleStoreResource
+
     KEY_TYPES = %w[publishable secret].freeze
     PREFIXES = { 'publishable' => 'pk_', 'secret' => 'sk_' }.freeze
     TOKEN_LENGTH = 24
 
-    # Admin API authorization scopes. Granted to secret keys at creation; checked
-    # by ScopedAuthorization on every admin request. See
-    # docs/plans/5.5-admin-api-key-scopes.md for the full design.
-    SCOPES = %w[
-      read_orders write_orders
-      read_products write_products
-      read_promotions write_promotions
-      read_customers write_customers
-      read_payments write_payments
-      read_fulfillments write_fulfillments
-      read_refunds write_refunds
-      read_gift_cards write_gift_cards
-      read_store_credits write_store_credits
-      read_stock write_stock
-      read_categories write_categories
-      read_settings write_settings
-      read_webhooks write_webhooks
-      read_api_keys write_api_keys
-      read_dashboard
-      read_all write_all
-    ].freeze
+    # Convenience aliases expanded at check time (never stored expanded).
+    ALIAS_SCOPES = %w[read_all write_all].freeze
+
+    # Admin API authorization scopes — the permission catalog keys a store's
+    # own back office may hold, plus the aliases. Derived from the catalog so
+    # an extension registering a resource
+    # (`Spree.permissions.register_scope`) makes its keys mintable on secret
+    # keys with no further wiring. See docs/plans/6.0-admin-rbac.md.
+    #
+    # Staff-grantable only: a secret key is issued against a store, so keys
+    # that exist for another audience (a seller's own profile or books) are
+    # not mintable on one.
+    #
+    # @return [Array<String>]
+    def self.known_scopes
+      Spree.permissions.grantable_keys(Spree::PermissionConfiguration::STAFF_AUDIENCE) + ALIAS_SCOPES
+    end
 
     # Scopes are stored in a JSON column (jsonb on PostgreSQL, json elsewhere).
     # The DB driver handles array <-> JSON conversion; no `serialize` needed.
@@ -55,11 +53,11 @@ module Spree
     belongs_to :revoked_by, polymorphic: true, optional: true
 
     validates :name, presence: true
+    validates_store_uniqueness :name, soft_delete_column: :revoked_at
     validates :key_type, presence: true, inclusion: { in: KEY_TYPES }
     validates :token, presence: true, uniqueness: { scope: spree_base_uniqueness_scope }, if: :publishable?
     validates :token_digest, presence: true, uniqueness: true, if: :secret?
     validates :token_prefix, presence: true, if: :secret?
-    validates :store, presence: true
     validates :scopes, presence: true, if: -> { secret? && scopes_enforceable? }
     validate :validate_known_scopes, if: -> { secret? && scopes_enforceable? }
     # Scopes are fixed for the life of the secret — mirroring Stripe/GitHub/AWS:
@@ -158,24 +156,27 @@ module Spree
     end
 
     def validate_known_scopes
-      invalid = scopes - SCOPES
-      errors.add(:scopes, "contains unknown scopes: #{invalid.join(', ')}") if invalid.any?
+      invalid = scopes - self.class.known_scopes
+      return if invalid.empty?
+
+      errors.add(:scopes, :unknown_scopes, scopes: invalid.join(', '),
+                 message: Spree.t('errors.messages.unknown_scopes', scopes: invalid.join(', ')))
     end
 
     def scopes_immutable
-      errors.add(:scopes, Spree.t(:api_key_scopes_immutable))
+      errors.add(:scopes, :api_key_scopes_immutable, message: Spree.t(:api_key_scopes_immutable))
     end
 
     def channel_binding_valid
       if secret?
-        errors.add(:channel, Spree.t(:api_key_channel_publishable_only))
+        errors.add(:channel, :api_key_channel_publishable_only, message: Spree.t(:api_key_channel_publishable_only))
       elsif channel && channel.store_id != store_id
-        errors.add(:channel, Spree.t(:api_key_channel_must_belong_to_store))
+        errors.add(:channel, :api_key_channel_must_belong_to_store, message: Spree.t(:api_key_channel_must_belong_to_store))
       end
     end
 
     def channel_immutable
-      errors.add(:channel, Spree.t(:api_key_channel_immutable))
+      errors.add(:channel, :api_key_channel_immutable, message: Spree.t(:api_key_channel_immutable))
     end
 
     # Generates the token on creation. For publishable keys, stores the raw token

data/app/models/spree/asset.rb

@@ -1,213 +1,16 @@
-module Spree
-  class Asset < Spree.base_class
-    has_prefix_id :media
-
-    include Support::ActiveStorage
-    include Rails.application.routes.url_helpers
-    include Spree::ImageMethods # legacy, will be removed in Spree 6
-    include Spree::Metafields
-    include Spree::Metadata
-
-    # Legacy styles support (was in Spree::Image::Configuration::ActiveStorage)
-    # @deprecated Will be removed in Spree 6
-    def self.styles
-      @styles ||= Spree::Config.product_image_variant_sizes.transform_values do |dimensions|
-        "#{dimensions[0]}x#{dimensions[1]}>"
-      end
-    end
-
-    def default_style
-      :small
-    end
-
-    publishes_lifecycle_events
-
-    EXTERNAL_URL_METAFIELD_KEY = 'external.url'
-    MEDIA_TYPES = %w[image video external_video].freeze
-
-    after_initialize { self.media_type ||= 'image' }
-
-    belongs_to :viewable, polymorphic: true, touch: true
-    has_many :variant_media, class_name: 'Spree::VariantMedia', foreign_key: :media_id,
-             dependent: :destroy, inverse_of: :asset
-    has_many :variants, through: :variant_media, source: :variant, class_name: 'Spree::Variant'
-    acts_as_list scope: [:viewable_id, :viewable_type]
-
-    delegate :key, :attached?, :variant, :variable?, :blob, :filename, :variation, to: :attachment
-
-    validates :media_type, inclusion: { in: MEDIA_TYPES }
-    validates :attachment, attached: true, content_type: Rails.application.config.active_storage.web_image_content_types,
-              if: -> { media_type == 'image' }
-    validates :external_video_url, presence: true, if: -> { media_type.in?(%w[video external_video]) }
-
-    WEBP_SAVER_OPTIONS = {
-      strip: true,
-      quality: 75,
-      lossless: false,
-      alpha_q: 85,
-      reduction_effort: 6,
-      smart_subsample: true
-    }.freeze
-
-    has_one_attached :attachment, service: Spree.public_storage_service_name do |attachable|
-      # Note: Key order matters for variation digest matching.
-      # Active Storage reorders keys alphabetically when calling variant(:name),
-      # so we must define them in alphabetical order: format, resize_to_fill, saver
-      #
-      # IMPORTANT: Use string values (not symbols) for format because the variation key
-      # is JSON-encoded in URLs. JSON converts symbols to strings, so "webp" != :webp
-      # after round-tripping, which causes digest mismatches.
-      Spree::Config.product_image_variant_sizes.each do |name, (width, height)|
-        attachable.variant name,
-                           format: "webp",
-                           resize_to_fill: [width, height],
-                           saver: WEBP_SAVER_OPTIONS,
-                           preprocessed: true
-      end
-    end
-
-    default_scope { includes(attachment_attachment: :blob) }
-
-    # STI was disabled in Spree::Image, keep it disabled here
-    self.inheritance_column = nil
-
-    store_accessor :private_metadata, :session_uploaded_assets_uuid
-    scope :with_session_uploaded_assets_uuid, lambda { |uuid|
-      where(session_id: uuid)
-    }
-    scope :with_external_url, ->(url) { url.present? ? with_metafield_key_value(EXTERNAL_URL_METAFIELD_KEY, url.strip) : none }
-
-    # Callbacks merged from Spree::Image
-    after_commit :touch_product_variants, if: :should_touch_product_variants?, on: :update
-    after_commit :update_viewable_thumbnail_on_create, on: :create
-    after_commit :update_viewable_thumbnail_on_destroy, on: :destroy
-    after_commit :update_viewable_thumbnail_on_reorder, on: :update, if: :saved_change_to_position?
-    after_commit :update_viewable_thumbnail_on_viewable_change, on: :update, if: :saved_change_to_viewable_id?
-
-    after_create :increment_viewable_media_count
-    after_destroy :decrement_viewable_media_count
-
-    def product
-      @product ||= case viewable_type
-                   when 'Spree::Variant' then viewable&.product
-                   when 'Spree::Product' then viewable
-                   end
-    end
-
-    # Accepts prefixed IDs ("variant_abc") or raw IDs from admin forms.
-    # Variants from a different product are silently dropped — the security
-    # boundary against form tampering.
-    def variant_ids=(ids)
-      return if viewable_type != 'Spree::Product' || product.blank?
+# frozen_string_literal: true
 
-      super(Spree::VariantMedia.resolve_variant_ids(product, ids || []))
-    end
-
-    def focal_point
-      return nil if focal_point_x.nil? || focal_point_y.nil?
-
-      { x: focal_point_x, y: focal_point_y }
-    end
-
-    def focal_point=(point)
-      if point.nil?
-        self.focal_point_x = nil
-        self.focal_point_y = nil
-      else
-        self.focal_point_x = point[:x]
-        self.focal_point_y = point[:y]
-      end
-    end
-
-    def external_url
-      get_metafield(EXTERNAL_URL_METAFIELD_KEY)&.value
-    end
-
-    def external_url=(url)
-      set_metafield(EXTERNAL_URL_METAFIELD_KEY, url.strip)
-    end
-
-    def skip_import?
-      false
-    end
-
-    def event_prefix
-      'media'
-    end
-
-    # @deprecated
-    def styles
-      Spree::Deprecation.warn("Asset#styles is deprecated and will be removed in Spree 6.0. Please use active storage variants with cdn_image_url")
-
-      self.class.styles.map do |_, size|
-        width, height = size.chop.split('x').map(&:to_i)
-
-        {
-          url: generate_url(size: size),
-          size: size,
-          width: width,
-          height: height
-        }
-      end
-    end
-
-    private
-
-    def touch_product_variants
-      product = viewable.is_a?(Spree::Product) ? viewable : viewable.product
-      product.variants.touch_all
-    end
-
-    def should_touch_product_variants?
-      return false unless saved_change_to_position?
-
-      case viewable
-      when Spree::Product
-        true
-      when Spree::Variant
-        viewable.is_master? && viewable.product.has_variants?
-      else
-        false
-      end
-    end
-
-    def increment_viewable_media_count
-      case viewable
-      when Spree::Variant
-        Spree::Variant.increment_counter(:media_count, viewable_id)
-        Spree::Product.increment_counter(:media_count, viewable.product_id)
-      when Spree::Product
-        Spree::Product.increment_counter(:media_count, viewable_id)
-      end
-    end
-
-    def decrement_viewable_media_count
-      case viewable
-      when Spree::Variant
-        Spree::Variant.decrement_counter(:media_count, viewable_id)
-        Spree::Product.decrement_counter(:media_count, viewable.product_id)
-      when Spree::Product
-        Spree::Product.decrement_counter(:media_count, viewable_id)
-      end
-    end
-
-    def update_viewable_thumbnail
-      case viewable
-      when Spree::Variant
-        viewable.update_thumbnail!
-        viewable.product.update_thumbnail!
-      when Spree::Product
-        viewable.update_thumbnail!
-        # Linked variants resolve their own thumbnail through gallery_media,
-        # which sorts by this asset's product-level position. Reorders or
-        # destroys here can change a linked variant's first asset.
-        variants.find_each(&:update_thumbnail!)
-      end
-    end
-
-    alias update_viewable_thumbnail_on_create update_viewable_thumbnail
-    alias update_viewable_thumbnail_on_destroy update_viewable_thumbnail
-    alias update_viewable_thumbnail_on_reorder update_viewable_thumbnail
-    alias update_viewable_thumbnail_on_viewable_change update_viewable_thumbnail
-  end
+module Spree
+  # Deprecation alias for Spree::Media, renamed from Spree::Asset in 6.0.
+  # Retained for one release so existing code and extensions that reference
+  # Spree::Asset keep working; the canonical class is Spree::Media. Removed in
+  # 6.1, together with Spree::Image (which this replaces).
+  #
+  # This is a true constant alias — the underlying class, table (spree_media)
+  # and prefix (media) are all Spree::Media. Only the constant differs, so
+  # is_a?, polymorphic *_type strings, and class_name: references keep
+  # resolving to Spree::Media.
+  Asset = Media
+
+  Spree::Deprecation.warn('Spree::Asset is deprecated and will be removed in Spree 6.1. Use Spree::Media instead.')
 end