spree_core 5.2.6 → 5.3.0.rc1

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '5.2.6'.freeze
+  VERSION = '5.3.0.rc1'.freeze
 
   def self.version
     VERSION

data/lib/spree/core.rb

@@ -14,12 +14,10 @@ require 'action_mailer/railtie'
 require 'active_merchant'
 require 'acts_as_list'
 require 'acts-as-taggable-on'
-require 'auto_strip_attributes'
 require 'awesome_nested_set'
 require 'cancan'
 require 'countries/global'
 require 'friendly_id'
-require 'kaminari'
 require 'monetize'
 require 'mobility'
 require 'name_of_person'
@@ -32,6 +30,7 @@ require 'wannabe_bool'
 require 'geocoder'
 require 'oembed'
 require 'safely_block'
+require 'ar_lazy_preload'
 
 # This is required because ActiveModel::Validations#invalid? conflicts with the
 # invalid state of a Payment. In the future this should be removed.
@@ -40,7 +39,7 @@ StateMachines::Machine.ignore_method_conflicts = true
 module Spree
   mattr_accessor :base_class, :user_class, :admin_user_class,
                  :private_storage_service_name, :public_storage_service_name,
-                 :cdn_host, :root_domain, :searcher_class, :queues,
+                 :cdn_host, :root_domain, :searcher_class, :events_adapter_class, :queues,
                  :google_places_api_key, :screenshot_api_token
 
   def self.base_class(constantize: true)
@@ -97,18 +96,20 @@ module Spree
   def self.queues
     @@queues ||= OpenStruct.new(
       default: :default,
+      events: :default,
       exports: :default,
       images: :default,
       imports: :default,
+      products: :default,
       reports: :default,
       variants: :default,
       taxons: :default,
       stock_location_stock_items: :default,
       coupon_codes: :default,
-      webhooks: :default,
       themes: :default,
       addresses: :default,
-      gift_cards: :default
+      gift_cards: :default,
+      webhooks: :default
     )
   end
 
@@ -122,6 +123,23 @@ module Spree
     end
   end
 
+  # Returns the events adapter class used for publishing and subscribing to events.
+  #
+  # @example Using a custom adapter
+  #   Spree.events_adapter_class = 'MyApp::Events::KafkaAdapter'
+  #
+  # @param constantize [Boolean] whether to return the class or the string
+  # @return [Class, String] the adapter class or its name
+  def self.events_adapter_class(constantize: true)
+    @@events_adapter_class ||= 'Spree::Events::Adapters::ActiveSupportNotifications'
+
+    if @@events_adapter_class.is_a?(Class)
+      raise 'Spree.events_adapter_class MUST be a String or Symbol object, not a Class object.'
+    elsif @@events_adapter_class.is_a?(String) || @@events_adapter_class.is_a?(Symbol)
+      constantize ? @@events_adapter_class.to_s.constantize : @@events_adapter_class.to_s
+    end
+  end
+
   def self.google_places_api_key
     @@google_places_api_key
   end
@@ -288,51 +306,25 @@ module Spree
     Rails.application.config.spree.integrations = value
   end
 
-  # Page Builder configuration accessor
-  def self.page_builder
-    @page_builder ||= PageBuilderConfig.new
+  # Event subscribers that handle lifecycle and custom events
+  # @example Adding a custom subscriber
+  #   Spree.subscribers << MyApp::OrderNotificationSubscriber
+  # @example Removing a built-in subscriber
+  #   Spree.subscribers.delete(Spree::ExportSubscriber)
+  def self.subscribers
+    Rails.application.config.spree.subscribers
   end
 
-  class PageBuilderConfig
-    def themes
-      Rails.application.config.spree.themes
-    end
-
-    def themes=(value)
-      Rails.application.config.spree.themes = value
-    end
-
-    def theme_layout_sections
-      Rails.application.config.spree.theme_layout_sections
-    end
-
-    def theme_layout_sections=(value)
-      Rails.application.config.spree.theme_layout_sections = value
-    end
-
-    def pages
-      Rails.application.config.spree.pages
-    end
-
-    def pages=(value)
-      Rails.application.config.spree.pages = value
-    end
-
-    def page_sections
-      Rails.application.config.spree.page_sections
-    end
-
-    def page_sections=(value)
-      Rails.application.config.spree.page_sections = value
-    end
+  def self.subscribers=(value)
+    Rails.application.config.spree.subscribers = value
+  end
 
-    def page_blocks
-      Rails.application.config.spree.page_blocks
-    end
+  def self.pricing
+    Rails.application.config.spree.pricing
+  end
 
-    def page_blocks=(value)
-      Rails.application.config.spree.page_blocks = value
-    end
+  def self.pricing=(value)
+    Rails.application.config.spree.pricing = value
   end
 
   def self.analytics
@@ -444,6 +436,8 @@ require 'spree/permitted_attributes'
 require 'spree/service_module'
 require 'spree/database_type_utilities'
 require 'spree/analytics'
+require 'spree/events'
+require 'spree/webhooks'
 
 require 'spree/core/partials'
 require 'spree/core/importer'
@@ -462,6 +456,7 @@ require 'spree/core/preferences/store'
 require 'spree/core/preferences/scoped_store'
 require 'spree/core/preferences/runtime_configuration'
 
-require 'spree/core/webhooks'
 require 'spree/core/permission_configuration'
 require 'spree/core/ransack_configuration'
+require 'spree/core/pricing/context'
+require 'spree/core/pricing/resolver'

data/lib/spree/events/adapters/active_support_notifications.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Spree
+  module Events
+    module Adapters
+      # Adapter for ActiveSupport::Notifications backend.
+      #
+      # This adapter wraps Rails' built-in notification system to provide
+      # the Spree event infrastructure. It can be swapped out for other
+      # implementations (e.g., Redis pub/sub, Kafka) without changing
+      # the subscriber API.
+      #
+      # @example Publishing an event
+      #   adapter = ActiveSupportNotifications.new(registry)
+      #   adapter.publish('order.complete', { id: 1 })
+      #
+      class ActiveSupportNotifications < Base
+        NAMESPACE = 'spree'
+
+        def initialize(registry)
+          super
+          @as_subscription = nil
+          @mutex = Mutex.new
+        end
+
+        # Publish an event to all matching subscribers
+        #
+        # @param event_name [String] The event name
+        # @param payload [Hash] The event payload
+        # @param metadata [Hash] Additional metadata
+        # @return [Spree::Event] The published event
+        def publish(event_name, payload, metadata = {})
+          event = build_event(event_name, payload, metadata)
+          instrument_name = namespaced_event(event_name)
+
+          ::ActiveSupport::Notifications.instrument(instrument_name, event: event) do
+            # The block is intentionally empty - we use the instrument
+            # to trigger subscribers, not to wrap code execution
+          end
+
+          event
+        end
+
+        # Subscribe to an event pattern
+        #
+        # This method registers a subscriber in the registry.
+        # The actual AS::N subscription is created once via activate!
+        #
+        # @param pattern [String] Event pattern (supports wildcards)
+        # @param subscriber [Class, Proc] The subscriber
+        # @param options [Hash] Subscription options
+        def subscribe(pattern, subscriber, options = {})
+          # Register in our registry
+          registry.register(pattern, subscriber, options)
+
+          # Ensure the global AS::N subscription exists
+          ensure_as_subscription
+        end
+
+        # Unsubscribe from an event pattern
+        #
+        # @param pattern [String] Event pattern
+        # @param subscriber [Class, Proc] The subscriber to remove
+        def unsubscribe(pattern, subscriber)
+          registry.unregister(pattern, subscriber)
+        end
+
+        # Activate all registered subscriptions
+        #
+        # This is called during Rails initialization to set up
+        # the single AS::N subscription that catches all Spree events.
+        def activate!
+          ensure_as_subscription
+        end
+
+        # Deactivate all AS::N subscriptions
+        def deactivate!
+          @mutex.synchronize do
+            if @as_subscription
+              ::ActiveSupport::Notifications.unsubscribe(@as_subscription)
+              @as_subscription = nil
+            end
+          end
+        end
+
+        private
+
+        def namespaced_event(event_name)
+          "#{event_name}.#{NAMESPACE}"
+        end
+
+        # Create a single AS::N subscription that catches all Spree events
+        def ensure_as_subscription
+          @mutex.synchronize do
+            return if @as_subscription
+
+            # Match all events ending with .spree
+            @as_subscription = ::ActiveSupport::Notifications.subscribe(/\.#{NAMESPACE}$/) do |_name, _start, _finish, _id, as_payload|
+              # Extract our event from the AS::N payload
+              event = as_payload[:event]
+              next unless event
+
+              # Find and invoke all matching subscribers
+              invoke_subscribers(event)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/spree/events/adapters/base.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Spree
+  module Events
+    module Adapters
+      # Base class for event adapters.
+      #
+      # Adapters are responsible for the actual publishing and subscription
+      # management of events. The default adapter uses ActiveSupport::Notifications,
+      # but you can create custom adapters for other backends like Kafka, RabbitMQ,
+      # or Redis Pub/Sub.
+      #
+      # @example Creating a custom adapter
+      #   class MyApp::Events::KafkaAdapter < Spree::Events::Adapters::Base
+      #     def publish(event_name, payload, metadata = {})
+      #       event = Spree::Event.new(name: event_name, payload: payload, metadata: metadata)
+      #       kafka_producer.produce(event.to_json, topic: event_name)
+      #       event
+      #     end
+      #
+      #     def activate!
+      #       @kafka_producer = Kafka.new.producer
+      #     end
+      #
+      #     def deactivate!
+      #       @kafka_producer&.shutdown
+      #     end
+      #   end
+      #
+      # @example Configuring Spree to use your adapter
+      #   # config/initializers/spree.rb
+      #   Spree.events_adapter_class = 'MyApp::Events::KafkaAdapter'
+      #
+      class Base
+        attr_reader :registry
+
+        # Initialize the adapter with a registry.
+        #
+        # @param registry [Spree::Events::Registry] the subscription registry
+        def initialize(registry)
+          @registry = registry
+        end
+
+        # Publish an event to all matching subscribers.
+        #
+        # @param event_name [String] the event name (e.g., 'order.complete')
+        # @param payload [Hash] the event payload (should be serializable)
+        # @param metadata [Hash] additional metadata for the event
+        # @return [Spree::Event] the published event
+        #
+        # @example
+        #   adapter.publish('order.complete', order.serializable_hash, { user_id: 1 })
+        #
+        def publish(event_name, payload, metadata = {})
+          raise NotImplementedError, "#{self.class}#publish must be implemented"
+        end
+
+        # Subscribe to an event pattern.
+        #
+        # This method should register the subscriber in the registry.
+        # The adapter is responsible for ensuring events are routed to
+        # matching subscribers.
+        #
+        # @param pattern [String] event pattern (supports wildcards like 'order.*')
+        # @param subscriber [Class, Proc] the subscriber class or callable
+        # @param options [Hash] subscription options
+        # @option options [Boolean] :async (true) whether to run async via ActiveJob
+        #
+        # @example
+        #   adapter.subscribe('order.complete', MySubscriber)
+        #   adapter.subscribe('order.*', AuditLogger, async: false)
+        #
+        def subscribe(pattern, subscriber, options = {})
+          raise NotImplementedError, "#{self.class}#subscribe must be implemented"
+        end
+
+        # Unsubscribe from an event pattern.
+        #
+        # @param pattern [String] event pattern
+        # @param subscriber [Class, Proc] the subscriber to remove
+        # @return [Boolean] true if removed, false if not found
+        #
+        def unsubscribe(pattern, subscriber)
+          raise NotImplementedError, "#{self.class}#unsubscribe must be implemented"
+        end
+
+        # Activate the adapter.
+        #
+        # Called during Rails initialization. Use this to set up connections,
+        # start consumers, or perform any initialization needed.
+        #
+        def activate!
+          raise NotImplementedError, "#{self.class}#activate! must be implemented"
+        end
+
+        # Deactivate the adapter.
+        #
+        # Called during shutdown or when resetting the event system.
+        # Use this to clean up connections and resources.
+        #
+        def deactivate!
+          raise NotImplementedError, "#{self.class}#deactivate! must be implemented"
+        end
+
+        protected
+
+        # Helper to create an event object.
+        #
+        # @param event_name [String]
+        # @param payload [Hash]
+        # @param metadata [Hash]
+        # @return [Spree::Event]
+        def build_event(event_name, payload, metadata)
+          Spree::Event.new(
+            name: event_name,
+            payload: payload,
+            metadata: metadata
+          )
+        end
+
+        # Find and invoke all matching subscribers for an event.
+        #
+        # Checks if events are enabled and invokes each matching subscriber.
+        # Errors are caught and handled via handle_subscriber_error.
+        #
+        # @param event [Spree::Event] the event to dispatch
+        def invoke_subscribers(event)
+          return unless Spree::Events.enabled?
+
+          subscriptions = registry.subscriptions_for(event.name)
+
+          subscriptions.each do |subscription|
+            invoke_subscriber(subscription.subscriber, event, subscription.options)
+          rescue StandardError => e
+            handle_subscriber_error(e, event, subscription)
+          end
+        end
+
+        # Invoke a single subscriber with an event.
+        #
+        # Handles different subscriber types (Proc, callable, Spree::Subscriber)
+        # and async/sync execution via ActiveJob.
+        #
+        # @param subscriber [Class, Proc, #call] the subscriber
+        # @param event [Spree::Event] the event
+        # @param options [Hash] subscription options
+        def invoke_subscriber(subscriber, event, options)
+          async = options.fetch(:async, true)
+
+          if subscriber.is_a?(Proc)
+            # Block subscribers run synchronously
+            subscriber.call(event)
+          elsif subscriber.respond_to?(:call)
+            # Callable objects (including subscriber instances)
+            if async && defined?(Spree::Events::SubscriberJob)
+              Spree::Events::SubscriberJob.perform_later(subscriber.name, event.to_h)
+            else
+              subscriber.call(event)
+            end
+          elsif subscriber.is_a?(Class) && subscriber < Spree::Subscriber
+            # Subscriber classes
+            if async && defined?(Spree::Events::SubscriberJob)
+              Spree::Events::SubscriberJob.perform_later(subscriber.name, event.to_h)
+            else
+              subscriber.new.call(event)
+            end
+          else
+            raise ArgumentError, "Invalid subscriber: #{subscriber.inspect}. Must be a Proc, callable, or Spree::Subscriber subclass."
+          end
+        end
+
+        # Handle errors that occur during subscriber invocation.
+        #
+        # Reports the error to Rails.error and re-raises in development/test
+        # for visibility. In production, the error is swallowed after reporting.
+        #
+        # @param error [StandardError] the error that occurred
+        # @param event [Spree::Event] the event being processed
+        # @param subscription [Spree::Events::Registry::Subscription] the subscription
+        def handle_subscriber_error(error, event, subscription)
+          Rails.error.report(error, context: {
+            event_name: event.name,
+            subscriber: subscription.subscriber.to_s,
+            event_id: event.metadata['event_id']
+          })
+
+          # Re-raise in development/test for visibility
+          raise if Rails.env.development? || Rails.env.test?
+        end
+      end
+    end
+  end
+end

data/lib/spree/events/registry.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Spree
+  module Events
+    # Registry for managing event subscribers across different adapters.
+    #
+    # The registry provides an adapter-agnostic way to track subscriptions.
+    # This allows Spree to support different event backends (ActiveSupport::Notifications,
+    # Kafka, Redis Pub/Sub, etc.) while maintaining a consistent subscription API.
+    #
+    # Thread safety: Uses a Mutex for safe concurrent access during subscription
+    # registration/unregistration, which may happen during Rails initialization
+    # or hot reloading in development.
+    #
+    # @example
+    #   registry = Spree::Events::Registry.new
+    #   registry.register('order.*', MySubscriber, async: true)
+    #   registry.subscriptions_for('order.complete') # => [Subscription]
+    #
+    class Registry
+      # Immutable subscription data using Ruby 3.2+ Data class
+      Subscription = Data.define(:pattern, :subscriber, :options) do
+        def async?
+          options.fetch(:async, true)
+        end
+      end
+
+      def initialize
+        @subscriptions = []
+        @mutex = Mutex.new
+      end
+
+      # Register a subscriber for an event pattern
+      #
+      # @param pattern [String] Event pattern (supports wildcards like 'order.*')
+      # @param subscriber [Class, Proc] The subscriber class or callable
+      # @param options [Hash] Subscription options (:async, etc.)
+      # @return [Subscription]
+      def register(pattern, subscriber, options = {})
+        subscription = Subscription.new(
+          pattern: pattern.to_s,
+          subscriber: subscriber,
+          options: options.freeze
+        )
+
+        @mutex.synchronize { @subscriptions << subscription }
+        subscription
+      end
+
+      # Unregister a subscriber
+      #
+      # @param pattern [String] Event pattern
+      # @param subscriber [Class, Proc] The subscriber to remove
+      # @return [Boolean] true if removed
+      def unregister(pattern, subscriber)
+        @mutex.synchronize do
+          original_size = @subscriptions.size
+          @subscriptions.reject! { |s| s.pattern == pattern.to_s && s.subscriber == subscriber }
+          @subscriptions.size < original_size
+        end
+      end
+
+      # Find all subscriptions matching an event name
+      #
+      # @param event_name [String] The event name
+      # @return [Array<Subscription>]
+      def subscriptions_for(event_name)
+        @mutex.synchronize do
+          @subscriptions.select { |s| Spree::Event.matches?(event_name, s.pattern) }
+        end
+      end
+
+      # @return [Array<Subscription>]
+      def all_subscriptions
+        @mutex.synchronize { @subscriptions.dup }
+      end
+
+      # @return [Array<String>] Unique patterns
+      def patterns
+        @mutex.synchronize { @subscriptions.map(&:pattern).uniq }
+      end
+
+      # @return [Integer]
+      def size
+        @mutex.synchronize { @subscriptions.size }
+      end
+
+      # @param pattern [String]
+      # @return [Boolean]
+      def registered?(pattern)
+        @mutex.synchronize { @subscriptions.any? { |s| s.pattern == pattern.to_s } }
+      end
+
+      def clear!
+        @mutex.synchronize { @subscriptions.clear }
+      end
+    end
+  end
+end