Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Fixed reloading subscribers code in dev environment
Damian Legawieccf0ac9d159dd
diff --git a/core/lib/spree/core/engine.rb b/core/lib/spree/core/engine.rbindex ee365f40ba..9b1cfbe876 100644--- a/core/lib/spree/core/engine.rb+++ b/core/lib/spree/core/engine.rb@@ -388,12 +388,25 @@ module Spree# Re-enable lifecycle events for configured models after code reload# This is needed because after_commit callbacks are lost when classes are reloaded+ # We must resolve the constants fresh because Zeitwerk creates new class objectsRails.application.config.spree.eventable_models&.each do |model|- model.publishes_lifecycle_events if model.respond_to?(:publishes_lifecycle_events)+ # Resolve the model constant fresh to handle code reload+ resolved_model = begin+ model.is_a?(String) ? model.constantize : model.name.constantize+ rescue NameError+ nil+ end++ next unless resolved_model++ # Reset lifecycle_events_enabled so callbacks can be re-registered+ resolved_model.lifecycle_events_enabled = false if resolved_model.respond_to?(:lifecycle_events_enabled=)+ resolved_model.publishes_lifecycle_events if resolved_model.respond_to?(:publishes_lifecycle_events)end# Reset and re-activate event subscribers on code reload# activate! will register all subscribers from Spree.subscribers+ # Note: resolve_subscriber in register_subscribers! handles stale class referencesSpree::Events.reset!Spree::Events.activate!diff --git a/core/lib/spree/events.rb b/core/lib/spree/events.rbindex bf38eecdae..ad953e25be 100644--- a/core/lib/spree/events.rb+++ b/core/lib/spree/events.rb@@ -120,17 +120,46 @@ module Spree# This is called automatically during Rails initialization.# Can also be called in tests after reset! to re-register subscribers.#+ # In development, class objects in Spree.subscribers may become stale after+ # code reload (Zeitwerk creates new class objects). We resolve the constant+ # fresh from the class name to ensure we're using the reloaded class.+ ## @return [void]def register_subscribers!return unless defined?(Spree) && Spree.respond_to?(:subscribers)Spree.subscribers&.each do |subscriber|- subscriber.subscription_patterns.each do |pattern|- subscribe(pattern, subscriber, subscriber.subscription_options)+ # Resolve the subscriber constant fresh to handle code reload in development+ # The array may contain stale class objects after Zeitwerk reload+ resolved_subscriber = resolve_subscriber(subscriber)+ next unless resolved_subscriber++ resolved_subscriber.subscription_patterns.each do |pattern|+ subscribe(pattern, resolved_subscriber, resolved_subscriber.subscription_options)endendend+ # Resolve a subscriber to its current class object+ #+ # In development, Zeitwerk may have reloaded the class, creating a new+ # class object while the old one is still referenced in Spree.subscribers.+ # This method resolves the constant fresh to get the current class.+ #+ # @param subscriber [Class, String] The subscriber class or class name+ # @return [Class, nil] The resolved class or nil if not found+ def resolve_subscriber(subscriber)+ return subscriber unless Rails.env.development? || Rails.env.test?++ class_name = subscriber.is_a?(String) ? subscriber : subscriber.name+ return nil unless class_name++ class_name.constantize+ rescue NameError => e+ Rails.logger.warn "[Spree Events] Could not resolve subscriber #{class_name}: #{e.message}"+ nil+ end+# List all registered subscriber patterns## @return [Array<String>]diff --git a/core/spec/lib/spree/events_spec.rb b/core/spec/lib/spree/events_spec.rbindex 2297f845bc..99e784bd47 100644--- a/core/spec/lib/spree/events_spec.rb+++ b/core/spec/lib/spree/events_spec.rb@@ -219,4 +219,84 @@ RSpec.describe Spree::Events doexpect(pattern_received.size).to eq(2)endend++ describe '.resolve_subscriber' do+ it 'returns the subscriber directly in production' do+ allow(Rails.env).to receive(:development?).and_return(false)+ allow(Rails.env).to receive(:test?).and_return(false)++ subscriber = Class.new(Spree::Subscriber)+ result = described_class.resolve_subscriber(subscriber)++ expect(result).to eq(subscriber)+ end++ it 'resolves subscriber by name in development' do+ allow(Rails.env).to receive(:development?).and_return(true)++ result = described_class.resolve_subscriber(Spree::Subscriber)++ expect(result).to eq(Spree::Subscriber)+ end++ it 'handles string class names' do+ allow(Rails.env).to receive(:development?).and_return(true)++ result = described_class.resolve_subscriber('Spree::Subscriber')++ expect(result).to eq(Spree::Subscriber)+ end++ it 'returns nil for invalid class names' do+ allow(Rails.env).to receive(:development?).and_return(true)++ result = described_class.resolve_subscriber('NonExistent::Class')++ expect(result).to be_nil+ end++ it 'returns nil for anonymous classes' do+ allow(Rails.env).to receive(:development?).and_return(true)++ anonymous_class = Class.new+ result = described_class.resolve_subscriber(anonymous_class)++ expect(result).to be_nil+ end+ end++ describe '.register_subscribers!' do+ let(:test_subscriber) do+ Class.new(Spree::Subscriber) do+ subscribes_to 'test.event'++ def handle(event)+ # no-op for test+ end+ end+ end++ before do+ stub_const('TestEventSubscriber', test_subscriber)+ allow(Spree).to receive(:subscribers).and_return([TestEventSubscriber])+ end++ it 'registers subscribers from Spree.subscribers' do+ described_class.register_subscribers!++ expect(described_class.patterns).to include('test.event')+ end++ it 'resolves subscriber classes fresh (for code reload support)' do+ # Simulate what happens during code reload:+ # The class in Spree.subscribers is stale but has the same name+ old_class = test_subscriber+ allow(Spree).to receive(:subscribers).and_return([old_class])++ described_class.register_subscribers!++ # The constant TestEventSubscriber should be resolved, not the old_class directly+ expect(described_class.subscriptions.first.subscriber).to eq(TestEventSubscriber)+ end+ endend