spree_core 5.2.6 → 5.3.0.rc1

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

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module Spree
+  # Concern for models that publish events.
+  #
+  # This concern is included in Spree::Base, so all Spree models
+  # can emit events. Event payloads are generated using dedicated
+  # serializers from the Spree::Events namespace.
+  #
+  # @example Disabling events for a specific model
+  #   class Spree::LogEntry < Spree.base_class
+  #     self.publish_events = false
+  #   end
+  #
+  # @example Publishing custom events
+  #   class Spree::Order < Spree.base_class
+  #     def complete!
+  #       # ... completion logic ...
+  #       publish_event('order.completed')
+  #     end
+  #   end
+  #
+  # @example Creating an event serializer (required for each model that publishes events)
+  #   # app/serializers/spree/events/order_serializer.rb
+  #   class Spree::Events::OrderSerializer < Spree::Events::BaseSerializer
+  #     protected
+  #
+  #     def attributes
+  #       {
+  #         id: resource.id,
+  #         number: resource.number,
+  #         state: resource.state.to_s,
+  #         # ... other attributes
+  #       }
+  #     end
+  #   end
+  #
+  module Publishable
+    extend ActiveSupport::Concern
+
+    # Error raised when a model tries to publish an event but has no serializer defined
+    class MissingSerializerError < StandardError
+      def initialize(model_class)
+        serializer_name = "Spree::Events::#{model_class.name.demodulize}Serializer"
+        super(
+          "Missing event serializer for #{model_class.name}. " \
+          "Please create #{serializer_name} that inherits from Spree::Events::BaseSerializer. " \
+          "Example:\n\n" \
+          "  class #{serializer_name} < Spree::Events::BaseSerializer\n" \
+          "    protected\n\n" \
+          "    def attributes\n" \
+          "      {\n" \
+          "        id: resource.id,\n" \
+          "        # add other attributes here\n" \
+          "        updated_at: timestamp(resource.updated_at)\n" \
+          "      }\n" \
+          "    end\n" \
+          "  end"
+        )
+      end
+    end
+
+    included do
+      class_attribute :publish_events, default: true
+      class_attribute :lifecycle_events_enabled, default: false
+    end
+
+    class_methods do
+      # Enable automatic lifecycle event publishing
+      #
+      # @param options [Hash] Options for lifecycle events
+      # @option options [Array<Symbol>] :only Limit to specific events (:create, :update, :delete)
+      # @option options [Array<Symbol>] :except Exclude specific events
+      # @return [void]
+      #
+      # @example
+      #   publishes_lifecycle_events
+      #   publishes_lifecycle_events only: [:create, :delete]
+      #   publishes_lifecycle_events except: [:update]
+      #
+      def publishes_lifecycle_events(options = {})
+        # Guard against duplicate callback registration (important for code reload in development)
+        return if lifecycle_events_enabled
+
+        self.lifecycle_events_enabled = true
+
+        events = [:create, :update, :delete]
+        events &= Array(options[:only]) if options[:only]
+        events -= Array(options[:except]) if options[:except]
+
+        if events.include?(:create)
+          after_commit :publish_create_event, on: :create, if: :should_publish_events?
+        end
+
+        if events.include?(:update)
+          after_commit :publish_update_event, on: :update, if: :should_publish_events?
+        end
+
+        if events.include?(:delete)
+          before_destroy :capture_pre_destroy_payload, if: :should_publish_events?
+          after_commit :publish_delete_event, on: :destroy, if: :should_publish_events?
+        end
+      end
+
+      # Disable lifecycle events for this model
+      #
+      # @example
+      #   class Spree::LogEntry < Spree.base_class
+      #     skip_lifecycle_events
+      #   end
+      #
+      def skip_lifecycle_events
+        self.publish_events = false
+      end
+
+      # Get the event name prefix for this model
+      #
+      # If a parent class has explicitly set an event_prefix, it will be inherited.
+      # Otherwise, uses model_name.element (e.g., 'order' for Spree::Order)
+      #
+      # @return [String] e.g., 'order' for Spree::Order
+      def event_prefix
+        # If this class has an explicitly set prefix, use it
+        return @event_prefix if defined?(@event_prefix) && @event_prefix.present?
+
+        # Check if a parent class has an explicitly set prefix
+        parent = superclass
+        while parent && parent.respond_to?(:event_prefix)
+          if parent.instance_variable_defined?(:@event_prefix) && parent.instance_variable_get(:@event_prefix).present?
+            return parent.instance_variable_get(:@event_prefix)
+          end
+          parent = parent.superclass
+        end
+
+        # Default to model_name.element
+        @event_prefix ||= model_name.element
+      end
+
+      # Set a custom event prefix
+      #
+      # @param prefix [String]
+      def event_prefix=(prefix)
+        @event_prefix = prefix
+      end
+    end
+
+    # Publish an event with this model's data
+    #
+    # @param event_name [String] The event name (e.g., 'order.complete')
+    # @param payload [Hash, nil] Custom payload (defaults to event_payload)
+    # @param metadata [Hash] Additional metadata
+    # @return [Spree::Event] The published event
+    #
+    # @example
+    #   order.publish_event('order.completed')
+    #   order.publish_event('order.completed', { custom: 'data' })
+    #   order.publish_event('order.completed', metadata: { user_id: 1 })
+    #
+    def publish_event(event_name, payload = nil, metadata = {})
+      return unless Spree::Events.enabled?
+
+      @_current_event_name = event_name
+      payload ||= event_payload
+      Spree::Events.publish(event_name, payload, metadata)
+    ensure
+      @_current_event_name = nil
+    end
+
+    # Get the payload for events
+    #
+    # Uses dedicated event serializer (Spree::Events::ModelSerializer).
+    # Raises MissingSerializerError if no serializer is defined.
+    #
+    # @return [Hash]
+    # @raise [MissingSerializerError] if no serializer is defined for this model
+    def event_payload
+      serializer = event_serializer_class
+
+      raise MissingSerializerError, self.class unless serializer
+
+      serializer.serialize(self, event_context)
+    end
+
+    # Find the event serializer class for this model
+    #
+    # Looks for Spree::Events::ModelNameSerializer (e.g., Spree::Events::OrderSerializer)
+    # Also walks up the class hierarchy to find a serializer for parent classes.
+    # This allows subclasses like Spree::Exports::Products to use ExportSerializer.
+    #
+    # @return [Class, nil] The serializer class or nil if not found
+    def event_serializer_class
+      return nil unless self.class.name
+
+      # Try this class and walk up the hierarchy
+      klass = self.class
+      while klass && klass != Object && klass != BasicObject
+        class_name = klass.name&.demodulize
+        # Skip looking for BaseSerializer - that's the parent class for all serializers
+        if class_name.present? && class_name != 'Base'
+          serializer = "Spree::Events::#{class_name}Serializer".safe_constantize
+          return serializer if serializer
+        end
+
+        klass = klass.superclass
+      end
+
+      nil
+    end
+
+    # Context passed to the event serializer
+    #
+    # @return [Hash]
+    def event_context
+      {
+        event_name: @_current_event_name,
+        store_id: Spree::Current.store&.id,
+        triggered_at: Time.current
+      }
+    end
+
+    # Get the event prefix for this instance
+    #
+    # @return [String]
+    def event_prefix
+      self.class.event_prefix
+    end
+
+    private
+
+    def should_publish_events?
+      self.class.publish_events && Spree::Events.enabled?
+    end
+
+    def publish_create_event
+      publish_event("#{event_prefix}.created")
+    end
+
+    def publish_update_event
+      publish_event("#{event_prefix}.updated")
+    end
+
+    def publish_delete_event
+      # For delete, we need to capture the data before it's gone
+      # The after_commit runs after the record is deleted, so we use
+      # the previously captured payload
+      publish_event("#{event_prefix}.deleted", @_pre_destroy_payload || event_payload)
+    end
+
+    def capture_pre_destroy_payload
+      @_pre_destroy_payload = event_payload
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      auto_strip_attributes :name
+      normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
 
       validates :name, presence: true,
                        uniqueness: { case_sensitive: false, allow_blank: true, scope: spree_base_uniqueness_scope }

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

@@ -9,7 +9,12 @@ module Spree
     include Spree::AdminUserMethods
     include Spree::RansackableAttributes
     include Spree::MultiSearchable
+    include Spree::Publishable
+
     included do
+      # Enable lifecycle events for user models
+      publishes_lifecycle_events
+
       # we need to have this callback before any dependent: :destroy associations
       # https://github.com/rails/rails/issues/3458
       before_validation :clone_billing_address, if: :use_billing?
@@ -18,7 +23,7 @@ module Spree
       attr_accessor :use_billing
 
       has_person_name
-      auto_strip_attributes :email, :first_name, :last_name
+      normalizes :email, :first_name, :last_name, with: ->(value) { value&.to_s&.squish&.presence }
       acts_as_taggable_on :tags
 
       #
@@ -33,6 +38,8 @@ module Spree
       has_many :wished_items, through: :wishlists, source: :wished_items
       has_many :gateway_customers, class_name: 'Spree::GatewayCustomer', foreign_key: :user_id
       has_many :gift_cards, class_name: 'Spree::GiftCard', foreign_key: :user_id, dependent: :destroy
+      has_many :customer_group_users, class_name: 'Spree::CustomerGroupUser', foreign_key: :user_id, as: :user, dependent: :destroy
+      has_many :customer_groups, through: :customer_group_users, class_name: 'Spree::CustomerGroup'
       belongs_to :ship_address, class_name: 'Spree::Address', optional: true
       belongs_to :bill_address, class_name: 'Spree::Address', optional: true
 
@@ -40,6 +47,7 @@ module Spree
       # Attachments
       #
       has_one_attached :avatar, service: Spree.public_storage_service_name
+      has_rich_text :internal_note
 
       #
       # Attributes
@@ -157,6 +165,18 @@ module Spree
       name&.full
     end
 
+    def event_serializer_class
+      Spree::Events::UserSerializer
+    end
+
+    def event_prefix
+      if self.class == Spree.admin_user_class && Spree.admin_user_class != Spree.user_class
+        'admin'
+      else
+        'user'
+      end
+    end
+
     private
 
     def check_completed_orders

data/app/models/spree/ability.rb

@@ -166,9 +166,9 @@ module Spree
       end
       can :accept, Spree::Invitation, invitee_id: [user.id, nil], invitee_type: user.class.name, status: 'pending'
       can :read, ::Spree::Policy
-      can :read, ::Spree::Page
-      can :read, ::Spree::Post
-      can :read, ::Spree::PostCategory
+      can :read, ::Spree::Page if defined?(Spree::Page)
+      can :read, ::Spree::Post if defined?(Spree::Post)
+      can :read, ::Spree::PostCategory if defined?(Spree::PostCategory)
     end
 
     def protect_admin_role

data/app/models/spree/address.rb

@@ -4,9 +4,6 @@ module Spree
 
     include Spree::Metafields
     include Spree::Metadata
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
 
     serialize :preferences, type: Hash, coder: YAML, default: {}
 

data/app/models/spree/adjustable/promotion_accumulator.rb

@@ -25,7 +25,7 @@ module Spree
       def add_adjustment(adjustment, opts = {})
         return unless adjustment.promotion?
 
-        source = opts[:source] || adjustment.source
+        source = opts[:source] || adjustment.cached_source
         promotion = opts[:promotion] || source.promotion
 
         add(adjustments, adjustment, adjustment.id)

data/app/models/spree/adjustment.rb

@@ -96,19 +96,45 @@ module Spree
       !included?
     end
 
+    # Returns the source using Rails.cache to avoid repeated database lookups.
+    # Sources are cached by their type and ID combination.
+    # Cache is automatically invalidated when the source is saved (see AdjustmentSource concern).
+    #
+    # @return [Object, nil] The source object (TaxRate, PromotionAction, etc.)
+    def cached_source
+      return nil if source_type.blank? || source_id.blank?
+
+      Rails.cache.fetch(source_cache_key) { source }
+    rescue TypeError
+      # Handle objects that can't be serialized (e.g., mock objects in tests)
+      source
+    end
+
+    # Cache key for the source object
+    def source_cache_key
+      "spree/adjustment_source/#{source_type}/#{source_id}"
+    end
+
     # Passing a target here would always be recommended as it would avoid
     # hitting the database again and would ensure you're compute values over
     # the specific object amount passed here.
     def update!(target = adjustable)
-      return amount if closed? || source.blank?
+      src = cached_source
+      return amount if closed? || src.blank?
+
+      new_amount = src.compute_amount(target)
+      new_eligible = promotion? ? src.promotion.eligible?(target) : eligible
 
-      amount = source.compute_amount(target)
-      attributes = { amount: amount, updated_at: Time.current }
-      attributes[:eligible] = source.promotion.eligible?(target) if promotion?
+      changed_attributes = {}
+      changed_attributes[:amount] = new_amount if new_amount != amount
+      changed_attributes[:eligible] = new_eligible if new_eligible != eligible
 
-      update_columns(attributes)
+      if changed_attributes.any?
+        changed_attributes[:updated_at] = Time.current
+        update_columns(changed_attributes)
+      end
 
-      amount
+      new_amount
     end
 
     private

data/app/models/spree/asset.rb

@@ -3,9 +3,8 @@ module Spree
     include Support::ActiveStorage
     include Spree::Metafields
     include Spree::Metadata
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
+
+    publishes_lifecycle_events
 
     EXTERNAL_URL_METAFIELD_KEY = 'external.url'
 
@@ -63,5 +62,9 @@ module Spree
     def skip_import?
       false
     end
+
+    def event_prefix
+      'asset'
+    end
   end
 end

data/app/models/spree/base.rb

@@ -3,6 +3,7 @@ class Spree::Base < ApplicationRecord
   include Spree::RansackableAttributes
   include Spree::TranslatableResourceScopes
   include Spree::IntegrationsConcern
+  include Spree::Publishable
 
   after_initialize do
     if has_attribute?(:preferences) && !preferences.nil?
@@ -10,7 +11,8 @@ class Spree::Base < ApplicationRecord
     end
   end
 
-  if Kaminari.config.page_method_name != :page
+  # only for backwards compatibility with Kaminari
+  if defined?(Kaminari) && Kaminari.config.page_method_name != :page
     def self.page(num)
       send Kaminari.config.page_method_name, num
     end

data/app/models/spree/classification.rb

@@ -4,8 +4,8 @@ module Spree
     acts_as_list scope: :taxon
 
     with_options inverse_of: :classifications, touch: true do
-      belongs_to :product, class_name: 'Spree::Product'
-      belongs_to :taxon, class_name: 'Spree::Taxon'
+      belongs_to :product, class_name: 'Spree::Product', counter_cache: :classification_count
+      belongs_to :taxon, class_name: 'Spree::Taxon', counter_cache: :classification_count
     end
 
     validates :taxon, :product, presence: true

data/app/models/spree/credit_card.rb

@@ -5,9 +5,6 @@ module Spree
     include Spree::Metadata
     include Spree::PaymentSourceConcern
 
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
     if defined?(Spree::Security::CreditCards)
       include Spree::Security::CreditCards
     end

data/app/models/spree/current.rb

@@ -1,13 +1,34 @@
 module Spree
   class Current < ::ActiveSupport::CurrentAttributes
-    attribute :store, :webhooks_subscribers
+    attribute :store, :currency, :zone, :price_lists, :global_pricing_context
 
     def store
       super || Spree::Store.default
     end
 
-    def webhooks_subscribers
-      super || store&.active_webhooks_subscribers || Spree::Webhooks::Subscriber.none
+    def currency
+      super || store&.default_currency
+    end
+
+    def zone
+      super || Spree::Zone.default_tax || store&.checkout_zone
+    end
+
+    def price_lists
+      super || begin
+        context = global_pricing_context
+        self.price_lists = Spree::PriceList.for_context(context)
+      end
+    end
+
+    def global_pricing_context
+      super || begin
+        self.global_pricing_context = Spree::Pricing::Context.new(
+          currency: currency,
+          store: store,
+          zone: zone
+        )
+      end
     end
   end
 end

data/app/models/spree/custom_domain.rb

@@ -4,7 +4,7 @@ module Spree
     include Spree::Metafields
     include Spree::Metadata
 
-    auto_strip_attributes :url
+    normalizes :url, with: ->(value) { value&.to_s&.squish&.presence }
 
     #
     # Associations

data/app/models/spree/customer_group.rb

@@ -0,0 +1,94 @@
+module Spree
+  class CustomerGroup < Spree.base_class
+    acts_as_paranoid
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store', inverse_of: :customer_groups
+    has_many :customer_group_users, class_name: 'Spree::CustomerGroupUser', dependent: :destroy
+    has_many :users, through: :customer_group_users, source: :user, source_type: Spree.user_class.to_s
+
+    #
+    # Validations
+    #
+    validates :name, presence: true, uniqueness: { scope: [:store_id], conditions: -> { where(deleted_at: nil) } }
+    validates :store, presence: true
+
+    #
+    # Scopes
+    #
+    scope :for_store, ->(store) { where(store: store) }
+
+    #
+    # Instance Methods
+    #
+    def users_count
+      customer_group_users.count
+    end
+
+    # Bulk add customers to the group
+    # @param user_ids [Array] array of user IDs to add
+    # @return [Integer] number of customers added
+    def add_customers(user_ids)
+      return 0 if user_ids.blank?
+
+      user_ids = Array(user_ids).map(&:to_s).uniq
+      return 0 if user_ids.empty?
+
+      # Get existing user IDs to avoid duplicates
+      existing_user_ids = customer_group_users.where(user_id: user_ids).pluck(:user_id).map(&:to_s).to_set
+
+      now = Time.current
+      user_type = Spree.user_class.to_s
+
+      records_to_insert = user_ids.filter_map do |user_id|
+        next if existing_user_ids.include?(user_id)
+
+        {
+          customer_group_id: id,
+          user_id: user_id,
+          user_type: user_type,
+          created_at: now,
+          updated_at: now
+        }
+      end
+
+      return 0 if records_to_insert.empty?
+
+      Spree::CustomerGroupUser.upsert_all(records_to_insert, on_duplicate: :skip)
+      added_user_ids = records_to_insert.map { |r| r[:user_id] }
+      touch_users(added_user_ids)
+      touch
+
+      records_to_insert.size
+    end
+
+    # Bulk remove customers from the group
+    # @param user_ids [Array] array of user IDs to remove
+    # @return [Integer] number of customers removed
+    def remove_customers(user_ids)
+      return 0 if user_ids.blank?
+
+      user_ids = Array(user_ids).map(&:to_s).uniq
+      return 0 if user_ids.empty?
+
+      deleted_count = customer_group_users.where(user_id: user_ids).delete_all
+
+      if deleted_count > 0
+        touch_users(user_ids)
+        touch
+      end
+
+      deleted_count
+    end
+
+    private
+
+    def touch_users(user_ids)
+      return if user_ids.blank?
+
+      Spree.user_class.where(id: user_ids).touch_all
+    end
+  end
+end

data/app/models/spree/customer_group_user.rb

@@ -0,0 +1,16 @@
+module Spree
+  class CustomerGroupUser < Spree.base_class
+    #
+    # Associations
+    #
+    belongs_to :customer_group, class_name: 'Spree::CustomerGroup'
+    belongs_to :user, polymorphic: true
+
+    #
+    # Validations
+    #
+    validates :customer_group, presence: true
+    validates :user, presence: true
+    validates :customer_group_id, uniqueness: { scope: [:user_id, :user_type] }
+  end
+end

data/app/models/spree/customer_return.rb

@@ -4,9 +4,8 @@ module Spree
     include Spree::NumberIdentifier
     include Spree::Metafields
     include Spree::Metadata
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
+
+    publishes_lifecycle_events
 
     belongs_to :stock_location
     belongs_to :store, class_name: 'Spree::Store', inverse_of: :customer_returns

data/app/models/spree/digital.rb

@@ -1,12 +1,10 @@
 module Spree
   class Digital < Spree.base_class
+    publishes_lifecycle_events
+
     belongs_to :variant
     has_many :digital_links, dependent: :destroy
 
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
-
     has_one_attached :attachment, service: Spree.private_storage_service_name
 
     validates :attachment, attached: true

data/app/models/spree/digital_link.rb

@@ -1,14 +1,13 @@
 module Spree
   class DigitalLink < Spree.base_class
+    publishes_lifecycle_events
+
     if Rails::VERSION::STRING >= '7.1.0'
       has_secure_token on: :save
     else
       has_secure_token
     end
 
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
     if defined?(Spree::Security::DigitalLinks)
       include Spree::Security::DigitalLinks
     end