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
Use subscribers for import/exports/reports and simplify registering subscribers to be in lign with other parts of platform
Damian Legawiec8111be3ee894
diff --git a/admin/app/subscribers/spree/admin/import_row_subscriber.rb b/admin/app/subscribers/spree/admin/import_row_subscriber.rbnew file mode 100644index 0000000000..541517af23--- /dev/null+++ b/admin/app/subscribers/spree/admin/import_row_subscriber.rb@@ -0,0 +1,68 @@+# frozen_string_literal: true++module Spree+ module Admin+ # Handles ImportRow events for the admin interface.+ #+ # This subscriber listens to import_row.complete and import_row.fail events+ # and handles:+ # - Adding the row to the import view (Turbo Streams)+ # - Updating the footer in the import view (Turbo Streams)+ #+ # We use async: false because the UI updates should happen immediately.+ #+ class ImportRowSubscriber < Spree::Subscriber+ subscribes_to 'import_row.complete', 'import_row.fail', async: false++ on 'import_row.complete', :update_import_view+ on 'import_row.fail', :update_import_view++ def update_import_view(event)+ import_row_id = event.payload['id']+ return unless import_row_id++ import_row = Spree::ImportRow.find_by(id: import_row_id)+ return unless import_row++ add_row_to_import_view(import_row)+ update_footer_in_import_view(import_row)+ end++ private++ def add_row_to_import_view(import_row)+ return unless import_row.respond_to?(:broadcast_append_to)++ # we need to render this partial with store context to properly generate image URLs+ with_store_context(import_row) do+ import_row.broadcast_append_to(+ "import_#{import_row.import_id}_rows",+ target: 'rows',+ partial: 'spree/admin/imports/row',+ locals: { row: import_row, import: import_row.import }+ )+ end+ end++ def update_footer_in_import_view(import_row)+ return unless import_row.respond_to?(:broadcast_replace_to)++ import_row.broadcast_replace_to(+ "import_#{import_row.import_id}_footer",+ target: 'footer',+ partial: 'spree/admin/imports/footer',+ locals: { import: import_row.import }+ )+ end++ def with_store_context(import_row)+ store = import_row.store+ Spree::Current.store = store+ Rails.application.routes.default_url_options[:host] = store.url_or_custom_domain+ yield+ ensure+ Spree::Current.reset if defined?(Spree::Current)+ end+ end+ end+enddiff --git a/admin/app/subscribers/spree/admin/import_subscriber.rb b/admin/app/subscribers/spree/admin/import_subscriber.rbnew file mode 100644index 0000000000..1eea6c69f7--- /dev/null+++ b/admin/app/subscribers/spree/admin/import_subscriber.rb@@ -0,0 +1,35 @@+# frozen_string_literal: true++module Spree+ module Admin+ # Handles Import events for the admin interface.+ #+ # This subscriber listens to import.complete event and handles:+ # - Updating the loader in the import view (Turbo Streams)+ #+ # We use async: false because the UI update should happen immediately+ # after the import completes.+ #+ class ImportSubscriber < Spree::Subscriber+ subscribes_to 'import.complete', async: false++ on 'import.complete', :update_loader_in_import_view++ def update_loader_in_import_view(event)+ import_id = event.payload['id']+ return unless import_id++ import = Spree::Import.find_by(id: import_id)+ return unless import+ return unless import.respond_to?(:broadcast_update_to)++ import.broadcast_update_to(+ "import_#{import.id}_loader",+ target: 'loader',+ partial: 'spree/admin/imports/loader',+ locals: { import: import }+ )+ end+ end+ end+enddiff --git a/admin/lib/spree/admin/engine.rb b/admin/lib/spree/admin/engine.rbindex 676376abf8..d4273a5ea7 100644--- a/admin/lib/spree/admin/engine.rb+++ b/admin/lib/spree/admin/engine.rb@@ -178,6 +178,9 @@ module Spreeendend+ # Add app/subscribers to autoload paths+ config.paths.add 'app/subscribers', eager_load: true+# accessible via Rails.application.config.spree_admininitializer 'spree.admin.environment', before: :load_config_initializers do |app|app.config.spree_admin = Environment.new@@ -252,6 +255,14 @@ module Spreeapp.config.spree_admin.navigation.register_context(:developers_tabs)app.config.spree_admin.navigation.register_context(:audit_tabs)end++ # Add admin event subscribers+ config.after_initialize do+ Spree.subscribers.concat [+ Spree::Admin::ImportSubscriber,+ Spree::Admin::ImportRowSubscriber+ ]+ endendendenddiff --git a/admin/spec/controllers/spree/admin/invitations_controller_spec.rb b/admin/spec/controllers/spree/admin/invitations_controller_spec.rbindex dcefc0dc99..5be612767e 100644--- a/admin/spec/controllers/spree/admin/invitations_controller_spec.rb+++ b/admin/spec/controllers/spree/admin/invitations_controller_spec.rb@@ -252,14 +252,8 @@ RSpec.describe Spree::Admin::InvitationsController, type: :controller dodescribe 'PUT #resend' dostub_authorization!- before do- Spree::InvitationEmailSubscriber.unregister!- Spree::InvitationEmailSubscriber.register!- end-- after do- Spree::InvitationEmailSubscriber.unregister!- end+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }it 'publishes invitation.resend event' doinvitationdiff --git a/admin/spec/subscribers/spree/admin/import_row_subscriber_spec.rb b/admin/spec/subscribers/spree/admin/import_row_subscriber_spec.rbnew file mode 100644index 0000000000..2fced5c138--- /dev/null+++ b/admin/spec/subscribers/spree/admin/import_row_subscriber_spec.rb@@ -0,0 +1,80 @@+# frozen_string_literal: true++require 'spec_helper'++RSpec.describe Spree::Admin::ImportRowSubscriber do+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }++ describe '.subscription_patterns' do+ it 'subscribes to import_row.complete event' do+ expect(described_class.subscription_patterns).to include('import_row.complete')+ end++ it 'subscribes to import_row.fail event' do+ expect(described_class.subscription_patterns).to include('import_row.fail')+ end+ end++ describe '.event_handlers' do+ it 'routes import_row.complete to update_import_view' do+ expect(described_class.event_handlers['import_row.complete']).to eq(:update_import_view)+ end++ it 'routes import_row.fail to update_import_view' do+ expect(described_class.event_handlers['import_row.fail']).to eq(:update_import_view)+ end+ end++ describe '#update_import_view' do+ let(:store) { create(:store) }+ let(:user) { create(:admin_user) }+ let(:import) { create(:import, owner: store, user: user) }+ let(:import_row) { create(:import_row, import: import) }++ context 'with valid import_row_id' do+ it 'updates the import view' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'import_row.complete',+ payload: { 'id' => import_row.id }+ )++ expect(subscriber).to receive(:add_row_to_import_view).with(kind_of(Spree::ImportRow))+ expect(subscriber).to receive(:update_footer_in_import_view).with(kind_of(Spree::ImportRow))++ subscriber.update_import_view(event)+ end+ end++ context 'with missing import_row_id' do+ it 'does nothing' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'import_row.complete',+ payload: {}+ )++ expect(subscriber).not_to receive(:add_row_to_import_view)+ expect(subscriber).not_to receive(:update_footer_in_import_view)++ subscriber.update_import_view(event)+ end+ end++ context 'with non-existent import_row_id' do+ it 'does nothing' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'import_row.complete',+ payload: { 'id' => -999 }+ )++ expect(subscriber).not_to receive(:add_row_to_import_view)+ expect(subscriber).not_to receive(:update_footer_in_import_view)++ subscriber.update_import_view(event)+ end+ end+ end+enddiff --git a/admin/spec/subscribers/spree/admin/import_subscriber_spec.rb b/admin/spec/subscribers/spree/admin/import_subscriber_spec.rbnew file mode 100644index 0000000000..db1040db4a--- /dev/null+++ b/admin/spec/subscribers/spree/admin/import_subscriber_spec.rb@@ -0,0 +1,77 @@+# frozen_string_literal: true++require 'spec_helper'++RSpec.describe Spree::Admin::ImportSubscriber do+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }++ describe '.subscription_patterns' do+ it 'subscribes to import.complete event' do+ expect(described_class.subscription_patterns).to include('import.complete')+ end+ end++ describe '.event_handlers' do+ it 'routes import.complete to update_loader_in_import_view' do+ expect(described_class.event_handlers['import.complete']).to eq(:update_loader_in_import_view)+ end+ end++ describe '#update_loader_in_import_view' do+ let(:store) { create(:store) }+ let(:user) { create(:admin_user) }+ let(:import) { create(:import, owner: store, user: user) }++ context 'with valid import_id' do+ it 'broadcasts update to import loader' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'import.complete',+ payload: { 'id' => import.id }+ )++ found_import = Spree::Import.find(import.id)++ if found_import.respond_to?(:broadcast_update_to)+ expect_any_instance_of(Spree::Import).to receive(:broadcast_update_to).with(+ "import_#{import.id}_loader",+ target: 'loader',+ partial: 'spree/admin/imports/loader',+ locals: { import: kind_of(Spree::Import) }+ )+ end++ subscriber.update_loader_in_import_view(event)+ end+ end++ context 'with missing import_id' do+ it 'does nothing' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'import.complete',+ payload: {}+ )++ expect_any_instance_of(Spree::Import).not_to receive(:broadcast_update_to) if Spree::Import.new.respond_to?(:broadcast_update_to)++ subscriber.update_loader_in_import_view(event)+ end+ end++ context 'with non-existent import_id' do+ it 'does nothing' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'import.complete',+ payload: { 'id' => -999 }+ )++ expect(Spree::Import).to receive(:find_by).with(id: -999).and_return(nil)++ subscriber.update_loader_in_import_view(event)+ end+ end+ end+enddiff --git a/core/app/models/concerns/spree/publishable.rb b/core/app/models/concerns/spree/publishable.rbindex 334667981b..4dbf1d8cff 100644--- a/core/app/models/concerns/spree/publishable.rb+++ b/core/app/models/concerns/spree/publishable.rb@@ -112,8 +112,24 @@ module Spree# 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::Orderdef 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.elementend@@ -165,12 +181,27 @@ module Spree# 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 founddef event_serializer_classreturn nil unless self.class.name- "Spree::Events::#{self.class.name.demodulize}Serializer".safe_constantize+ # 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++ nilend# Context passed to the event serializerdiff --git a/core/app/models/spree/events.rb b/core/app/models/spree/events.rbindex e6d0262f92..52c17908ed 100644--- a/core/app/models/spree/events.rb+++ b/core/app/models/spree/events.rb@@ -95,7 +95,12 @@ module Spreeend# Activate the event system (called during Rails initialization)+ # Also registers all subscribers from Spree.subscribers+ # This method is idempotent - calling it multiple times has no effectdef activate!+ return if registry.size > 0++ register_subscribers!adapter.activate!end@@ -106,6 +111,22 @@ module Spree@adapter = nilend+ # Register all subscribers from Spree.subscribers+ #+ # This is called automatically during Rails initialization.+ # Can also be called in tests after reset! to re-register subscribers.+ #+ # @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)+ end+ end+ end+# List all registered subscriber patterns## @return [Array<String>]diff --git a/core/app/models/spree/export.rb b/core/app/models/spree/export.rbindex e1b1114ef4..1b3a3160f1 100644--- a/core/app/models/spree/export.rb+++ b/core/app/models/spree/export.rb@@ -11,6 +11,10 @@ module Spreeinclude Spree::Core::NumberGenerator.new(prefix: 'EF')+ # Set event prefix for all Export subclasses+ # This ensures Spree::Exports::Products publishes 'export.create' not 'products.create'+ self.event_prefix = 'export'+## Associations#@@ -44,7 +48,7 @@ module Spreebefore_validation :set_default_format, on: :createbefore_validation :normalize_search_params, on: :create, if: -> { search_params.present? }before_create :clear_search_params, if: -> { record_selection == 'all' }- after_commit :generate_async, on: :create+ # NOTE: generate_async is now handled by Spree::ExportSubscriber listening to 'export.create' event## Virtual attributesdiff --git a/core/app/models/spree/import.rb b/core/app/models/spree/import.rbindex de4f8e441e..1f97475538 100644--- a/core/app/models/spree/import.rb+++ b/core/app/models/spree/import.rb@@ -7,6 +7,10 @@ module Spreeinclude Spree::Core::NumberGenerator.new(prefix: 'IM')+ # Set event prefix for all Import subclasses+ # This ensures Spree::Imports::Products publishes 'import.create' not 'products.create'+ self.event_prefix = 'import'+## Associations#@@ -57,8 +61,8 @@ module Spreetransition from: :processing, to: :completedendafter_transition to: :completed, do: :send_import_completed_event- after_transition to: :completed, do: :send_import_completed_email- after_transition to: :completed, do: :update_loader_in_import_view+ # NOTE: send_import_completed_email and update_loader_in_import_view+ # are now handled by Spree::ImportSubscriber listening to 'import.complete' eventevent :fail dotransition to: :failed@@ -164,10 +168,6 @@ module Spreepublish_event('import.complete')end- def send_import_completed_email- # Spree::ImportMailer.import_done(self).deliver_later- end-# Returns the headers of the csv file# @return [Array<String>]def csv_headers@@ -210,13 +210,11 @@ module Spree# Returns the store for the import# @return [Spree::Store]def store- owner.is_a?(Spree::Store) ? owner : owner.respond_to?(:store) ? owner.store : Spree::Store.default- end-- def update_loader_in_import_view- return unless defined?(broadcast_update_to)-- broadcast_update_to "import_#{id}_loader", target: 'loader', partial: 'spree/admin/imports/loader', locals: { import: self }+ if owner.is_a?(Spree::Store)+ owner+ else+ owner.respond_to?(:store) ? owner.store : Spree::Store.default+ endend# Returns the current ability for the import@@ -248,7 +246,7 @@ module Spreedef model_classklass = "Spree::#{to_s.demodulize.singularize}".safe_constantize- raise NameError, "Missing model class for #{to_s}" unless klass+ raise NameError, "Missing model class for #{self}" unless klassklassenddiff --git a/core/app/models/spree/import_row.rb b/core/app/models/spree/import_row.rbindex 1c34a4be90..4aa78c7072 100644--- a/core/app/models/spree/import_row.rb+++ b/core/app/models/spree/import_row.rb@@ -1,5 +1,8 @@module Spreeclass ImportRow < Spree.base_class+ # Set event prefix for ImportRow+ self.event_prefix = 'import_row'+## Associations#@@ -24,15 +27,16 @@ module Spreeevent :fail dotransition to: :failedend- after_transition to: :failed, do: :add_row_to_import_view- after_transition to: :failed, do: :update_footer_in_import_view+ after_transition to: :failed, do: :publish_import_row_failed_event+ # NOTE: add_row_to_import_view and update_footer_in_import_view+ # are now handled by Spree::Admin::ImportRowSubscriberevent :complete dotransition to: :completedend-- after_transition to: :completed, do: :add_row_to_import_view- after_transition to: :completed, do: :update_footer_in_import_view+ after_transition to: :completed, do: :publish_import_row_completed_event+ # NOTE: add_row_to_import_view and update_footer_in_import_view+ # are now handled by Spree::Admin::ImportRowSubscriberend#@@ -81,29 +85,12 @@ module Spreefail!end- def add_row_to_import_view- return unless defined?(broadcast_append_to)-- # we need to render this partial with store context to properly generate image URLs- with_store_context do- broadcast_append_to "import_#{import.id}_rows", target: 'rows', partial: 'spree/admin/imports/row', locals: { row: self, import: import }- end- end-- def update_footer_in_import_view- return unless defined?(broadcast_replace_to)-- broadcast_replace_to "import_#{import_id}_footer", target: 'footer', partial: 'spree/admin/imports/footer', locals: { import: import }+ def publish_import_row_completed_event+ publish_event('import_row.complete')end- private-- def with_store_context- Spree::Current.store = store- Rails.application.routes.default_url_options[:host] = store.url_or_custom_domain- yield- ensure- Spree::Current.reset if defined?(Spree::Current)+ def publish_import_row_failed_event+ publish_event('import_row.fail')endendenddiff --git a/core/app/models/spree/report.rb b/core/app/models/spree/report.rbindex c66921f4bc..7cb4736f07 100644--- a/core/app/models/spree/report.rb+++ b/core/app/models/spree/report.rb@@ -3,6 +3,10 @@ module Spreeinclude Spree::SingleStoreResourceinclude Spree::VendorConcern if defined?(Spree::VendorConcern)+ # Set event prefix for all Report subclasses+ # This ensures Spree::Reports::SalesTotal publishes 'report.create' not 'sales_total.create'+ self.event_prefix = 'report'+## Associations#@@ -13,7 +17,7 @@ module Spree# Callbacks#after_initialize :set_default_values- after_commit :generate_async, on: :create+ # NOTE: generate_async is now handled by Spree::ReportSubscriber listening to 'report.create' event## Validationsdiff --git a/core/app/models/spree/subscriber.rb b/core/app/models/spree/subscriber.rbindex 6ca9a9087d..578924027f 100644--- a/core/app/models/spree/subscriber.rb+++ b/core/app/models/spree/subscriber.rb@@ -131,29 +131,6 @@ module Spree@event_handlers ||= {}end- # Register this subscriber with the event system- #- # Called automatically during Rails initialization for subscribers- # in the app/subscribers directory.- #- # @return [void]- def register!- return if subscription_patterns.empty?-- subscription_patterns.each do |pattern|- Spree::Events.subscribe(pattern, self, subscription_options)- end- end-- # Unregister this subscriber from the event system- #- # @return [void]- def unregister!- subscription_patterns.each do |pattern|- Spree::Events.unsubscribe(pattern, self)- end- end-# Class-level call method for when the class itself is used as subscriber## @param event [Spree::Event]diff --git a/core/app/serializers/spree/events/import_row_serializer.rb b/core/app/serializers/spree/events/import_row_serializer.rbnew file mode 100644index 0000000000..c20f5c63b4--- /dev/null+++ b/core/app/serializers/spree/events/import_row_serializer.rb@@ -0,0 +1,23 @@+# frozen_string_literal: true++module Spree+ module Events+ class ImportRowSerializer < BaseSerializer+ protected++ def attributes+ {+ id: resource.id,+ import_id: resource.import_id,+ row_number: resource.row_number,+ status: resource.status,+ validation_errors: resource.validation_errors,+ item_type: resource.item_type,+ item_id: resource.item_id,+ created_at: timestamp(resource.created_at),+ updated_at: timestamp(resource.updated_at)+ }+ end+ end+ end+enddiff --git a/core/app/serializers/spree/events/report_serializer.rb b/core/app/serializers/spree/events/report_serializer.rbnew file mode 100644index 0000000000..18601c6a7b--- /dev/null+++ b/core/app/serializers/spree/events/report_serializer.rb@@ -0,0 +1,23 @@+# frozen_string_literal: true++module Spree+ module Events+ class ReportSerializer < BaseSerializer+ protected++ def attributes+ {+ id: resource.id,+ type: resource.type,+ store_id: resource.store_id,+ user_id: resource.user_id,+ currency: resource.currency,+ date_from: timestamp(resource.date_from),+ date_to: timestamp(resource.date_to),+ created_at: timestamp(resource.created_at),+ updated_at: timestamp(resource.updated_at)+ }+ end+ end+ end+enddiff --git a/core/app/subscribers/spree/export_subscriber.rb b/core/app/subscribers/spree/export_subscriber.rbnew file mode 100644index 0000000000..114d6b43fa--- /dev/null+++ b/core/app/subscribers/spree/export_subscriber.rb@@ -0,0 +1,26 @@+# frozen_string_literal: true++module Spree+ # Handles Export lifecycle events.+ #+ # This subscriber replaces the following callbacks in Spree::Export:+ # - after_commit :generate_async, on: :create+ #+ # When an export is created, this subscriber triggers the async generation job.+ #+ # We use async: false because this subscriber just queues a background job,+ # so there's no benefit to running the subscriber itself asynchronously.+ #+ class ExportSubscriber < Spree::Subscriber+ subscribes_to 'export.create', async: false++ on 'export.create', :generate_export_async++ def generate_export_async(event)+ export_id = event.payload['id']+ return unless export_id++ Spree::Exports::GenerateJob.perform_later(export_id)+ end+ end+enddiff --git a/core/app/subscribers/spree/report_subscriber.rb b/core/app/subscribers/spree/report_subscriber.rbnew file mode 100644index 0000000000..d0dbd648cb--- /dev/null+++ b/core/app/subscribers/spree/report_subscriber.rb@@ -0,0 +1,26 @@+# frozen_string_literal: true++module Spree+ # Handles Report lifecycle events.+ #+ # This subscriber replaces the following callbacks in Spree::Report:+ # - after_commit :generate_async, on: :create+ #+ # When a report is created, this subscriber triggers the async generation job.+ #+ # We use async: false because this subscriber just queues a background job,+ # so there's no benefit to running the subscriber itself asynchronously.+ #+ class ReportSubscriber < Spree::Subscriber+ subscribes_to 'report.create', async: false++ on 'report.create', :generate_report_async++ def generate_report_async(event)+ report_id = event.payload['id']+ return unless report_id++ Spree::Reports::GenerateJob.perform_later(report_id)+ end+ end+enddiff --git a/core/lib/spree/core.rb b/core/lib/spree/core.rbindex eccc638245..9d18ec709a 100644--- a/core/lib/spree/core.rb+++ b/core/lib/spree/core.rb@@ -317,6 +317,19 @@ module SpreeRails.application.config.spree.eventable_models = valueend+ # 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++ def self.subscribers=(value)+ Rails.application.config.spree.subscribers = value+ end+def self.analytics@analytics ||= AnalyticsConfig.newenddiff --git a/core/lib/spree/core/engine.rb b/core/lib/spree/core/engine.rbindex 1c23fd1fa3..04c4d45616 100644--- a/core/lib/spree/core/engine.rb+++ b/core/lib/spree/core/engine.rb@@ -28,7 +28,8 @@ module Spree:analytics_events,:analytics_event_handlers,:integrations,- :eventable_models)+ :eventable_models,+ :subscribers)SpreeCalculators = Struct.new(:shipping_methods, :tax_rates, :promotion_actions_create_adjustments, :promotion_actions_create_item_adjustments)PromoEnvironment = Struct.new(:rules, :actions)SpreeValidators = Struct.new(:addresses)@@ -54,6 +55,11 @@ module SpreeSpree::Deprecation = ActiveSupport::Deprecation.new('6.0', 'Spree')end+ initializer 'spree.register.subscribers', before: :load_config_initializers do |app|+ # Initialize subscribers array early so engines can add subscribers via initializers+ app.config.spree.subscribers = []+ end+initializer 'spree.register.calculators', before: :after_initialize do |app|end@@ -291,6 +297,7 @@ module SpreeSpree::Product,Spree::Promotion,Spree::Refund,+ Spree::Report,Spree::ReturnAuthorization,Spree::Shipment,Spree::StockItem,@@ -312,8 +319,13 @@ module SpreeSpree::EventLogSubscriber.attach_to_notificationsend- # Register invitation email subscriber- Spree::InvitationEmailSubscriber.register!+ # Add core event subscribers+ # Other engines add their subscribers in their own after_initialize blocks+ Spree.subscribers.concat [+ Spree::ExportSubscriber,+ Spree::ReportSubscriber,+ Spree::InvitationEmailSubscriber+ ]endinitializer 'spree.promo.register.promotions.actions' do |app|@@ -352,6 +364,15 @@ module Spreeendend+ # Activate event subscribers after all engines have registered their subscribers+ # This registers an after_initialize callback late, ensuring it runs after all engine callbacks+ # Needed for console, jobs, and other contexts where to_prepare doesn't run+ initializer 'spree.events.schedule_activation', after: :load_config_initializers do |app|+ app.config.after_initialize do+ Spree::Events.activate!+ end+ end+config.to_prepare do# Ensure spree locale paths are present before decoratorsI18n.load_path.unshift(*(Dir.glob(@@ -365,14 +386,9 @@ module SpreeRails.configuration.cache_classes ? require(c) : load(c)end- # Reset and re-register event subscribers on code reload+ # Reset and re-activate event subscribers on code reload+ # activate! will register all subscribers from Spree.subscribersSpree::Events.reset!-- # Auto-register all Spree::Subscriber subclasses- # Subscribers are auto-loaded from app/subscribers directories- Spree::Subscriber.descendants.each(&:register!)-- # Activate the event systemSpree::Events.activate!endenddiff --git a/core/spec/models/spree/export_spec.rb b/core/spec/models/spree/export_spec.rbindex dfde622576..b82c9a049c 100644--- a/core/spec/models/spree/export_spec.rb+++ b/core/spec/models/spree/export_spec.rb@@ -7,9 +7,12 @@ RSpec.describe Spree::Export, :job, type: :model dolet(:search_params) { nil }let(:export) { build(:product_export, store: store, user: user, format: 'csv', search_params: search_params) }- context 'Callbacks' do- describe 'after_create' do- it 'generates the export' do+ context 'Event subscriber' do+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }++ describe 'on export.create' do+ it 'enqueues the export generation job via subscriber' doexpect { export.save! }.to have_enqueued_job(Spree::Exports::GenerateJob).with(export.id)endenddiff --git a/core/spec/models/spree/import_row_spec.rb b/core/spec/models/spree/import_row_spec.rbindex 87da010fb1..6cf49a2586 100644--- a/core/spec/models/spree/import_row_spec.rb+++ b/core/spec/models/spree/import_row_spec.rb@@ -61,15 +61,13 @@ RSpec.describe Spree::ImportRow, :job, type: :model doexpect { import_row.fail! }.to change(import_row, :status).from('processing').to('failed')end- it 'adds row to import view after transition' do- expect(import_row).to receive(:add_row_to_import_view)+ it 'publishes import_row.fail event' do+ expect(import_row).to receive(:publish_import_row_failed_event)import_row.fail!end- it 'updates footer in import view after transition' do- expect(import_row).to receive(:update_footer_in_import_view)- import_row.fail!- end+ # UI updates (add_row_to_import_view, update_footer_in_import_view)+ # are now handled by Spree::Admin::ImportRowSubscriberenddescribe 'complete event' do@@ -79,15 +77,13 @@ RSpec.describe Spree::ImportRow, :job, type: :model doexpect { import_row.complete! }.to change(import_row, :status).from('processing').to('completed')end- it 'adds row to import view after transition' do- expect(import_row).to receive(:add_row_to_import_view)+ it 'publishes import_row.complete event' do+ expect(import_row).to receive(:publish_import_row_completed_event)import_row.complete!end- it 'updates footer in import view after transition' do- expect(import_row).to receive(:update_footer_in_import_view)- import_row.complete!- end+ # UI updates (add_row_to_import_view, update_footer_in_import_view)+ # are now handled by Spree::Admin::ImportRowSubscriberendenddiff --git a/core/spec/models/spree/import_spec.rb b/core/spec/models/spree/import_spec.rbindex f342d5c825..1e21e12544 100644--- a/core/spec/models/spree/import_spec.rb+++ b/core/spec/models/spree/import_spec.rb@@ -93,15 +93,13 @@ RSpec.describe Spree::Import, :job, type: :model doexpect { import.complete! }.to change(import, :status).from('processing').to('completed')end- it 'sends import completed email after transition' do- expect(import).to receive(:send_import_completed_email)+ it 'publishes import.complete event' do+ expect(import).to receive(:send_import_completed_event)import.complete!end- it 'updates loader in import view after transition' do- expect(import).to receive(:update_loader_in_import_view)- import.complete!- end+ # Email and loader updates are now handled by ImportSubscriber+ # See spec/subscribers/spree/import_subscriber_spec.rbendenddiff --git a/core/spec/models/spree/report_spec.rb b/core/spec/models/spree/report_spec.rbindex 9d9fddd020..2a3c6c9cf7 100644--- a/core/spec/models/spree/report_spec.rb+++ b/core/spec/models/spree/report_spec.rb@@ -48,13 +48,18 @@ RSpec.describe Spree::Report, type: :model doendend- describe 'callbacks' do- describe 'after_commit on create' do- it 'enqueues generate job' do+ describe 'event subscriber' do+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }++ describe 'on report.create' do+ it 'enqueues generate job via subscriber' doexpect { report.save! }.to have_enqueued_job(Spree::Reports::GenerateJob).with(report.id)endend+ end+ describe 'callbacks' dodescribe 'after_initialize' dolet(:new_report) { Spree::Report.new(store: store) }diff --git a/core/spec/models/spree/subscriber_spec.rb b/core/spec/models/spree/subscriber_spec.rbindex 8db0dc6b1c..8bf9001b13 100644--- a/core/spec/models/spree/subscriber_spec.rb+++ b/core/spec/models/spree/subscriber_spec.rb@@ -61,37 +61,6 @@ RSpec.describe Spree::Subscriber doendend- describe '.register!' do- it 'registers the subscriber with the event system' do- subscriber_class = Class.new(described_class) do- subscribes_to 'order.complete'- end-- subscriber_class.register!-- expect(Spree::Events.patterns).to include('order.complete')- end-- it 'does nothing when no patterns defined' do- subscriber_class = Class.new(described_class)-- expect { subscriber_class.register! }.not_to change { Spree::Events.patterns.size }- end- end-- describe '.unregister!' do- it 'removes the subscriber from the event system' do- subscriber_class = Class.new(described_class) do- subscribes_to 'order.complete'- end-- subscriber_class.register!- subscriber_class.unregister!-- expect(Spree::Events.subscriptions).to be_empty- end- end-describe '#call' docontext 'without event handlers' doit 'calls the handle method' do@@ -193,7 +162,10 @@ RSpec.describe Spree::Subscriber doendend- subscriber_class.register!+ # Subscribe the class directly+ subscriber_class.subscription_patterns.each do |pattern|+ Spree::Events.subscribe(pattern, subscriber_class, subscriber_class.subscription_options)+ endSpree::Events.activate!Spree::Events.publish('test.event', { key: 'value' })diff --git a/core/spec/serializers/spree/events/import_row_serializer_spec.rb b/core/spec/serializers/spree/events/import_row_serializer_spec.rbnew file mode 100644index 0000000000..45c87ca5bf--- /dev/null+++ b/core/spec/serializers/spree/events/import_row_serializer_spec.rb@@ -0,0 +1,69 @@+# frozen_string_literal: true++require 'spec_helper'++RSpec.describe Spree::Events::ImportRowSerializer do+ subject { described_class.serialize(import_row) }++ let(:store) { create(:store) }+ let(:user) { create(:admin_user) }+ let(:import) { create(:import, owner: store, user: user) }+ let(:product) { create(:product) }+ let(:import_row) do+ create(:import_row,+ import: import,+ row_number: 1,+ status: 'completed',+ item: product,+ validation_errors: nil+ )+ end++ describe '#as_json' do+ it 'includes identity attributes' do+ expect(subject[:id]).to eq(import_row.id)+ end++ it 'includes import reference' do+ expect(subject[:import_id]).to eq(import.id)+ end++ it 'includes row_number' do+ expect(subject[:row_number]).to eq(1)+ end++ it 'includes status' do+ expect(subject[:status]).to eq('completed')+ end++ it 'includes validation_errors' do+ expect(subject).to have_key(:validation_errors)+ end++ it 'includes item polymorphic reference' do+ expect(subject[:item_type]).to eq('Spree::Product')+ expect(subject[:item_id]).to eq(product.id)+ end++ it 'includes timestamps' do+ expect(subject[:created_at]).to be_present+ expect(subject[:updated_at]).to be_present+ end++ context 'with validation errors' do+ let(:import_row) do+ create(:import_row,+ import: import,+ row_number: 2,+ status: 'failed',+ validation_errors: 'Name is required'+ )+ end++ it 'includes validation error message' do+ expect(subject[:validation_errors]).to eq('Name is required')+ expect(subject[:status]).to eq('failed')+ end+ end+ end+enddiff --git a/core/spec/serializers/spree/events/report_serializer_spec.rb b/core/spec/serializers/spree/events/report_serializer_spec.rbnew file mode 100644index 0000000000..345ae650fd--- /dev/null+++ b/core/spec/serializers/spree/events/report_serializer_spec.rb@@ -0,0 +1,48 @@+# frozen_string_literal: true++require 'spec_helper'++RSpec.describe Spree::Events::ReportSerializer do+ subject { described_class.serialize(report) }++ let(:store) { create(:store) }+ let(:user) { create(:admin_user) }+ let(:report) do+ create(:report,+ store: store,+ user: user,+ date_from: 1.month.ago,+ date_to: Time.current,+ currency: 'USD'+ )+ end++ describe '#as_json' do+ it 'includes identity attributes' do+ expect(subject[:id]).to eq(report.id)+ expect(subject[:type]).to eq(report.type)+ end++ it 'includes store reference' do+ expect(subject[:store_id]).to eq(store.id)+ end++ it 'includes user reference' do+ expect(subject[:user_id]).to eq(user.id)+ end++ it 'includes currency' do+ expect(subject[:currency]).to eq('USD')+ end++ it 'includes date range' do+ expect(subject[:date_from]).to be_present+ expect(subject[:date_to]).to be_present+ end++ it 'includes timestamps' do+ expect(subject[:created_at]).to be_present+ expect(subject[:updated_at]).to be_present+ end+ end+enddiff --git a/core/spec/subscribers/spree/event_log_subscriber_spec.rb b/core/spec/subscribers/spree/event_log_subscriber_spec.rbindex 624491cbc9..810acd1ae7 100644--- a/core/spec/subscribers/spree/event_log_subscriber_spec.rb+++ b/core/spec/subscribers/spree/event_log_subscriber_spec.rb@@ -4,6 +4,11 @@ require 'spec_helper'RSpec.describe Spree::EventLogSubscriber dodescribe '.attach_to_notifications' do+ before do+ # Detach first since it may be attached by the engine's after_initialize+ described_class.detach_from_notifications+ end+after dodescribed_class.detach_from_notificationsenddiff --git a/core/spec/subscribers/spree/export_subscriber_spec.rb b/core/spec/subscribers/spree/export_subscriber_spec.rbnew file mode 100644index 0000000000..00531c4015--- /dev/null+++ b/core/spec/subscribers/spree/export_subscriber_spec.rb@@ -0,0 +1,62 @@+# frozen_string_literal: true++require 'spec_helper'++RSpec.describe Spree::ExportSubscriber do+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }++ describe '.subscription_patterns' do+ it 'subscribes to export.create event' do+ expect(described_class.subscription_patterns).to include('export.create')+ end+ end++ describe '.event_handlers' do+ it 'routes export.create to generate_export_async' do+ expect(described_class.event_handlers['export.create']).to eq(:generate_export_async)+ end+ end++ describe '#generate_export_async' do+ let(:store) { create(:store) }+ let(:user) { create(:admin_user) }++ it 'triggers export generation job when export is created' do+ expect(Spree::Exports::GenerateJob).to receive(:perform_later).with(kind_of(Integer))++ Spree::Exports::Products.create!(+ store: store,+ user: user+ )+ end++ context 'with event payload' do+ let(:export) { create(:export, store: store, user: user) }++ it 'extracts export_id from event payload' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'export.create',+ payload: { 'id' => export.id }+ )++ expect(Spree::Exports::GenerateJob).to receive(:perform_later).with(export.id)++ subscriber.generate_export_async(event)+ end++ it 'does not call job if export_id is missing' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'export.create',+ payload: {}+ )++ expect(Spree::Exports::GenerateJob).not_to receive(:perform_later)++ subscriber.generate_export_async(event)+ end+ end+ end+enddiff --git a/core/spec/subscribers/spree/invitation_email_subscriber_spec.rb b/core/spec/subscribers/spree/invitation_email_subscriber_spec.rbindex 25cf1c0531..3a86133f02 100644--- a/core/spec/subscribers/spree/invitation_email_subscriber_spec.rb+++ b/core/spec/subscribers/spree/invitation_email_subscriber_spec.rb@@ -19,15 +19,8 @@ RSpec.describe Spree::InvitationEmailSubscriber doendend- before do- # Unregister first to avoid duplicate subscriptions from engine initialization- described_class.unregister!- described_class.register!- end-- after do- described_class.unregister!- end+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }describe 'invitation.create event' doit 'sends invitation email' dodiff --git a/core/spec/subscribers/spree/report_subscriber_spec.rb b/core/spec/subscribers/spree/report_subscriber_spec.rbnew file mode 100644index 0000000000..eb8338f510--- /dev/null+++ b/core/spec/subscribers/spree/report_subscriber_spec.rb@@ -0,0 +1,73 @@+# frozen_string_literal: true++require 'spec_helper'++RSpec.describe Spree::ReportSubscriber do+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }++ describe '.subscription_patterns' do+ it 'subscribes to report.create event' do+ expect(described_class.subscription_patterns).to include('report.create')+ end+ end++ describe '.event_handlers' do+ it 'routes report.create to generate_report_async' do+ expect(described_class.event_handlers['report.create']).to eq(:generate_report_async)+ end+ end++ describe '#generate_report_async' do+ let(:store) { create(:store) }+ let(:user) { create(:admin_user) }++ it 'triggers report generation job when report is created' do+ expect(Spree::Reports::GenerateJob).to receive(:perform_later).with(kind_of(Integer))++ Spree::Reports::SalesTotal.create!(+ store: store,+ user: user,+ date_from: 1.month.ago,+ date_to: Time.current,+ currency: store.default_currency+ )+ end++ context 'with event payload' do+ let(:report) do+ create(:report,+ store: store,+ user: user,+ date_from: 1.month.ago,+ date_to: Time.current,+ currency: store.default_currency+ )+ end++ it 'extracts report_id from event payload' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'report.create',+ payload: { 'id' => report.id }+ )++ expect(Spree::Reports::GenerateJob).to receive(:perform_later).with(report.id)++ subscriber.generate_report_async(event)+ end++ it 'does not call job if report_id is missing' do+ subscriber = described_class.new+ event = Spree::Event.new(+ name: 'report.create',+ payload: {}+ )++ expect(Spree::Reports::GenerateJob).not_to receive(:perform_later)++ subscriber.generate_report_async(event)+ end+ end+ end+enddiff --git a/emails/lib/spree/emails/engine.rb b/emails/lib/spree/emails/engine.rbindex af75b5b937..df8472df01 100644--- a/emails/lib/spree/emails/engine.rb+++ b/emails/lib/spree/emails/engine.rb@@ -9,11 +9,13 @@ module Spree# Add app/subscribers to autoload pathsconfig.paths.add 'app/subscribers', eager_load: true- # Register email subscribers after initialization+ # Add email event subscribersconfig.after_initialize do- Spree::OrderEmailSubscriber.register!- Spree::ShipmentEmailSubscriber.register!- Spree::ReimbursementEmailSubscriber.register!+ Spree.subscribers.concat [+ Spree::OrderEmailSubscriber,+ Spree::ShipmentEmailSubscriber,+ Spree::ReimbursementEmailSubscriber+ ]endendenddiff --git a/emails/spec/models/spree/order_spec.rb b/emails/spec/models/spree/order_spec.rbindex 83f982db33..ffa4541a87 100644--- a/emails/spec/models/spree/order_spec.rb+++ b/emails/spec/models/spree/order_spec.rb@@ -7,15 +7,8 @@ describe Spree::Order, type: :model dolet(:user) { create(:user) }let(:order) { create(:order, user: user, store: store) }- before do- # Ensure subscriber is registered- Spree::OrderEmailSubscriber.unregister!- Spree::OrderEmailSubscriber.register!- end-- after do- Spree::OrderEmailSubscriber.unregister!- end+ before { Spree::Events.activate! }+ after { Spree::Events.reset! }context '#finalize!' dolet(:order) { create(:order, email: '[email protected]', store: store) }diff --git a/emails/spec/models/spree/reimbursement_spec.rb b/emails/spec/models/spree/reimbursement_spec.rbindex bb1c33abc3..bff25f28e6 100644--- a/emails/spec/models/spree/reimbursement_spec.rb+++ b/emails/spec/models/spree/reimbursement_spec.rb@@ -34,15 +34,10 @@ describe Spree::Reimbursement, type: :model dobefore docustomer_return.save!return_item.accept!-- # Ensure subscriber is registered- Spree::ReimbursementEmailSubscriber.unregister!- Spree::ReimbursementEmailSubscriber.register!+ Spree::Events.activate!end- after do- Spree::ReimbursementEmailSubscriber.unregister!- end+ after { Spree::Events.reset! }it 'triggers the reimbursement mailer to be sent via subscriber' doexpect(Spree::ReimbursementMailer).to receive(:reimbursement_email).with(reimbursement.id) { double(deliver_later: true) }diff --git a/emails/spec/models/spree/shipment_spec.rb b/emails/spec/models/spree/shipment_spec.rbindex 6e23ade148..350e96147d 100644--- a/emails/spec/models/spree/shipment_spec.rb+++ b/emails/spec/models/spree/shipment_spec.rb@@ -16,14 +16,10 @@ describe Spree::Shipment, type: :model doallow(shipment).to receive_messages shipping_method: shipping_method- # Ensure subscriber is registered- Spree::ShipmentEmailSubscriber.unregister!- Spree::ShipmentEmailSubscriber.register!+ Spree::Events.activate!end- after do- Spree::ShipmentEmailSubscriber.unregister!- end+ after { Spree::Events.reset! }['ready', 'canceled'].each do |state|context "from #{state}" dodiff --git a/emails/spec/subscribers/spree/order_email_subscriber_spec.rb b/emails/spec/subscribers/spree/order_email_subscriber_spec.rbindex 681842e58c..a52257e085 100644--- a/emails/spec/subscribers/spree/order_email_subscriber_spec.rb+++ b/emails/spec/subscribers/spree/order_email_subscriber_spec.rb@@ -19,14 +19,10 @@ RSpec.describe Spree::OrderEmailSubscriber dobefore dostore.update!(preferences: store.preferences.merge(send_consumer_transactional_emails: true))- # Unregister first to avoid duplicate subscriptions from engine initialization- described_class.unregister!- described_class.register!+ Spree::Events.activate!end- after do- described_class.unregister!- end+ after { Spree::Events.reset! }describe 'order.complete event' doit 'sends confirmation email' dodiff --git a/emails/spec/subscribers/spree/reimbursement_email_subscriber_spec.rb b/emails/spec/subscribers/spree/reimbursement_email_subscriber_spec.rbindex 8481e0bfc5..d316292d92 100644--- a/emails/spec/subscribers/spree/reimbursement_email_subscriber_spec.rb+++ b/emails/spec/subscribers/spree/reimbursement_email_subscriber_spec.rb@@ -19,14 +19,10 @@ RSpec.describe Spree::ReimbursementEmailSubscriber dobefore dostore.update!(preferences: store.preferences.merge(send_consumer_transactional_emails: true))- # Unregister first to avoid duplicate subscriptions from engine initialization- described_class.unregister!- described_class.register!+ Spree::Events.activate!end- after do- described_class.unregister!- end+ after { Spree::Events.reset! }describe 'reimbursement.reimbursed event' doit 'sends reimbursement email' dodiff --git a/emails/spec/subscribers/spree/shipment_email_subscriber_spec.rb b/emails/spec/subscribers/spree/shipment_email_subscriber_spec.rbindex 7941c75f1f..731003b415 100644--- a/emails/spec/subscribers/spree/shipment_email_subscriber_spec.rb+++ b/emails/spec/subscribers/spree/shipment_email_subscriber_spec.rb@@ -20,14 +20,10 @@ RSpec.describe Spree::ShipmentEmailSubscriber dobefore dostore.update!(preferences: store.preferences.merge(send_consumer_transactional_emails: true))- # Unregister first to avoid duplicate subscriptions from engine initialization- described_class.unregister!- described_class.register!+ Spree::Events.activate!end- after do- described_class.unregister!- end+ after { Spree::Events.reset! }describe 'shipment.ship event' doit 'sends shipped email' do