nats_wave 1.1.11 → 1.1.13

data/lib/nats_wave/concerns/mappable.rb

@@ -1,3 +1,822 @@
+# # # # frozen_string_literal: true
+# # #
+# # # module NatsWave
+# # #     module Concerns
+# # #         module Mappable
+# # #             extend ActiveSupport::Concern
+# # #
+# # #             included do
+# # #                 class_attribute :nats_wave_subscription_config, :nats_wave_publishing_config
+# # #                 self.nats_wave_subscription_config = {}
+# # #                 self.nats_wave_publishing_config = {}
+# # #             end
+# # #
+# # #             class_methods do
+# # #                 # Configure subscriptions with optional custom handler
+# # #                 def nats_wave_subscribes_to(*subjects, **options, &block)
+# # #                     Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
+# # #
+# # #                     handler = options[:handler] || block
+# # #
+# # #                     subscription_config = {
+# # #                             subjects: subjects.flatten,
+# # #                             field_mappings: options[:field_mappings] || {},
+# # #                             transformations: options[:transformations] || {},
+# # #                             skip_fields: options[:skip_fields] || [],
+# # #                             unique_fields: options[:unique_fields] || [:id],
+# # #                             sync_strategy: options[:sync_strategy] || :upsert,
+# # #                             handler: handler,
+# # #                             queue_group: options[:queue_group],
+# # #                             auto_sync: options[:auto_sync] != false # Default to true, can be disabled
+# # #                     }
+# # #
+# # #                     # Store the config
+# # #                     config_key = subjects.join(',')
+# # #                     self.nats_wave_subscription_config[config_key] = subscription_config
+# # #
+# # #                     # Create the subscription handler
+# # #                     processed_handler = create_subscription_handler(subscription_config)
+# # #
+# # #                     # Register the subscription
+# # #                     NatsWave::ModelRegistry.register_subscription(
+# # #                             subjects: subjects.flatten,
+# # #                             model: self.name,
+# # #                             handler: processed_handler,
+# # #                             queue_group: subscription_config[:queue_group]
+# # #                     )
+# # #
+# # #                     Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
+# # #                 end
+# # #
+# # #                 # Configure publishing with optional custom handler
+# # #                 def nats_wave_publishes_to(*subjects, **options, &block)
+# # #                     Rails.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}" if defined?(Rails)
+# # #
+# # #                     handler = options[:handler] || block
+# # #
+# # #                     publishing_config = {
+# # #                             subjects: subjects.flatten,
+# # #                             field_mappings: options[:field_mappings] || {},
+# # #                             transformations: options[:transformations] || {},
+# # #                             skip_fields: options[:skip_fields] || [],
+# # #                             conditions: options[:conditions] || {},
+# # #                             actions: options[:actions] || [:create, :update, :destroy],
+# # #                             handler: handler,
+# # #                             async: options[:async] != false, # Default to true
+# # #                             enabled: options[:enabled] != false # Default to true
+# # #                     }
+# # #
+# # #                     # Store the config
+# # #                     config_key = subjects.join(',')
+# # #                     self.nats_wave_publishing_config[config_key] = publishing_config
+# # #
+# # #                     Rails.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}" if defined?(Rails)
+# # #                 end
+# # #
+# # #                 # Get all subscription configurations
+# # #                 def nats_wave_subscription_configs
+# # #                     nats_wave_subscription_config
+# # #                 end
+# # #
+# # #                 # Get all publishing configurations
+# # #                 def nats_wave_publishing_configs
+# # #                     nats_wave_publishing_config
+# # #                 end
+# # #
+# # #                 # Get all subjects this model subscribes to
+# # #                 def nats_wave_subscribed_subjects
+# # #                     nats_wave_subscription_config.values.flat_map { |config| config[:subjects] }.uniq
+# # #                 end
+# # #
+# # #                 # Get all subjects this model publishes to
+# # #                 def nats_wave_published_subjects
+# # #                     nats_wave_publishing_config.values.flat_map { |config| config[:subjects] }.uniq
+# # #                 end
+# # #
+# # #                 private
+# # #
+# # #                 # Create a subscription handler that processes data and calls custom handler or auto-sync
+# # #                 def create_subscription_handler(config)
+# # #                     model_class = self
+# # #
+# # #                     lambda do |message|
+# # #                         begin
+# # #                             Rails.logger.debug "📨 Processing subscription message for #{model_class.name}" if defined?(Rails)
+# # #
+# # #                             # Extract the raw data
+# # #                             raw_data = message['data'] || {}
+# # #                             model_name = message['model']
+# # #                             action = message['action']
+# # #
+# # #                             # Process the data through mappings and transformations
+# # #                             processed_data = model_class.process_data(raw_data, config)
+# # #
+# # #                             # If custom handler is provided, call it with model_name, action, processed_data
+# # #                             if config[:handler]
+# # #                                 Rails.logger.debug "📨 Calling custom subscription handler" if defined?(Rails)
+# # #                                 config[:handler].call(model_name, action, processed_data, message)
+# # #                             elsif config[:auto_sync]
+# # #                                 Rails.logger.debug "📨 Performing auto-sync" if defined?(Rails)
+# # #                                 # Default auto-sync behavior
+# # #                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
+# # #                             else
+# # #                                 Rails.logger.debug "📨 No handler provided and auto_sync disabled" if defined?(Rails)
+# # #                             end
+# # #
+# # #                         rescue => e
+# # #                             Rails.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}" if defined?(Rails)
+# # #                             Rails.logger.error e.backtrace.join("\n") if defined?(Rails)
+# # #                             raise
+# # #                         end
+# # #                     end
+# # #                 end
+# # #
+# # #                 # Process data through field mappings and transformations (used by both subscription and publishing)
+# # #                 def process_data(raw_data, config)
+# # #                     processed_data = {}
+# # #                     field_mappings = config[:field_mappings]
+# # #                     transformations = config[:transformations]
+# # #                     skip_fields = config[:skip_fields]
+# # #
+# # #                     raw_data.each do |field, value|
+# # #                         field_str = field.to_s
+# # #                         field_sym = field.to_sym
+# # #
+# # #                         # Skip if in skip_fields
+# # #                         next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
+# # #
+# # #                         # Apply field mapping
+# # #                         mapped_field = field_mappings[field_str] ||
+# # #                                 field_mappings[field_sym] ||
+# # #                                 field
+# # #
+# # #                         # Apply transformation if any
+# # #                         transformed_value = apply_transformation(value, mapped_field, transformations, raw_data)
+# # #
+# # #                         processed_data[mapped_field.to_s] = transformed_value
+# # #                     end
+# # #
+# # #                     processed_data
+# # #                 end
+# # #
+# # #                 # Apply transformations to field values
+# # #                 def apply_transformation(value, field, transformations, full_record)
+# # #                     transformation = transformations[field] || transformations[field.to_sym]
+# # #
+# # #                     case transformation
+# # #                         when Proc
+# # #                             if transformation.arity == 2 || transformation.arity < 0
+# # #                                 transformation.call(value, full_record)
+# # #                             else
+# # #                                 transformation.call(value)
+# # #                             end
+# # #                         when Symbol
+# # #                             if self.respond_to?(transformation, true)
+# # #                                 self.send(transformation, value)
+# # #                             elsif value.respond_to?(transformation)
+# # #                                 value.send(transformation)
+# # #                             else
+# # #                                 Rails.logger.warn "Transformation method #{transformation} not found" if defined?(Rails)
+# # #                                 value
+# # #                             end
+# # #                         else
+# # #                             value
+# # #                     end
+# # #                 end
+# # #
+# # #                 # Default auto-sync behavior
+# # #                 def perform_auto_sync(model_name, action, processed_data, config)
+# # #                     unique_fields = config[:unique_fields]
+# # #                     sync_strategy = config[:sync_strategy]
+# # #
+# # #                     case action.to_s.downcase
+# # #                         when 'create', 'created'
+# # #                             handle_auto_create(processed_data, unique_fields, sync_strategy)
+# # #                         when 'update', 'updated'
+# # #                             handle_auto_update(processed_data, unique_fields, sync_strategy)
+# # #                         when 'delete', 'deleted', 'destroy', 'destroyed'
+# # #                             handle_auto_delete(processed_data, unique_fields)
+# # #                         else
+# # #                             Rails.logger.warn "Unknown action for auto-sync: #{action}" if defined?(Rails)
+# # #                     end
+# # #                 end
+# # #
+# # #                 def handle_auto_create(data, unique_fields, sync_strategy)
+# # #                     case sync_strategy
+# # #                         when :upsert
+# # #                             existing = find_by_unique_fields(data, unique_fields)
+# # #                             if existing
+# # #                                 existing.update!(data)
+# # #                                 Rails.logger.info "✅ Updated existing #{self.name}: #{existing.id}" if defined?(Rails)
+# # #                             else
+# # #                                 record = self.create!(data)
+# # #                                 Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+# # #                             end
+# # #                         when :create_only
+# # #                             record = self.create!(data)
+# # #                             Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+# # #                     end
+# # #                 rescue => e
+# # #                     Rails.logger.error "❌ Failed to create #{self.name}: #{e.message}" if defined?(Rails)
+# # #                     raise
+# # #                 end
+# # #
+# # #                 def handle_auto_update(data, unique_fields, sync_strategy)
+# # #                     existing = find_by_unique_fields(data, unique_fields)
+# # #                     if existing
+# # #                         existing.update!(data)
+# # #                         Rails.logger.info "✅ Updated #{self.name}: #{existing.id}" if defined?(Rails)
+# # #                     elsif sync_strategy == :upsert
+# # #                         record = self.create!(data)
+# # #                         Rails.logger.info "✅ Created new #{self.name} during update: #{record.id}" if defined?(Rails)
+# # #                     else
+# # #                         Rails.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+# # #                     end
+# # #                 rescue => e
+# # #                     Rails.logger.error "❌ Failed to update #{self.name}: #{e.message}" if defined?(Rails)
+# # #                     raise
+# # #                 end
+# # #
+# # #                 def handle_auto_delete(data, unique_fields)
+# # #                     existing = find_by_unique_fields(data, unique_fields)
+# # #                     if existing
+# # #                         existing.destroy!
+# # #                         Rails.logger.info "✅ Deleted #{self.name}: #{existing.id}" if defined?(Rails)
+# # #                     else
+# # #                         Rails.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+# # #                     end
+# # #                 rescue => e
+# # #                     Rails.logger.error "❌ Failed to delete #{self.name}: #{e.message}" if defined?(Rails)
+# # #                     raise
+# # #                 end
+# # #
+# # #                 def find_by_unique_fields(data, unique_fields)
+# # #                     conditions = {}
+# # #                     unique_fields.each do |field|
+# # #                         field_str = field.to_s
+# # #                         if data.key?(field_str)
+# # #                             conditions[field] = data[field_str]
+# # #                         elsif data.key?(field.to_sym)
+# # #                             conditions[field] = data[field.to_sym]
+# # #                         end
+# # #                     end
+# # #
+# # #                     return nil if conditions.empty?
+# # #                     self.find_by(conditions)
+# # #                 end
+# # #             end
+# # #
+# # #             # Instance methods for publishing
+# # #             def nats_wave_publish(action = nil)
+# # #                 action ||= determine_action_from_context
+# # #
+# # #                 self.class.nats_wave_publishing_configs.each do |subjects_key, config|
+# # #                     next unless config[:enabled]
+# # #                     next unless config[:actions].include?(action.to_sym)
+# # #
+# # #                     # Check conditions (only for publishing)
+# # #                     if config[:conditions].any? && !evaluate_conditions(config[:conditions])
+# # #                         Rails.logger.debug "📤 Skipping publish - conditions not met" if defined?(Rails)
+# # #                         next
+# # #                     end
+# # #
+# # #                     # Get the raw data (current model attributes)
+# # #                     raw_data = get_raw_attributes
+# # #
+# # #                     # Process the data through mappings and transformations (same as subscription)
+# # #                     processed_data = self.class.process_data(raw_data, config)
+# # #
+# # #                     # If custom handler is provided, call it
+# # #                     if config[:handler]
+# # #                         Rails.logger.debug "📤 Calling custom publishing handler" if defined?(Rails)
+# # #                         config[:handler].call(self.class.name, action, processed_data, self)
+# # #                     else
+# # #                         # Default publishing behavior - publish the processed data
+# # #                         config[:subjects].each do |subject|
+# # #                             NatsWave.client.publish(
+# # #                                     subject: subject,
+# # #                                     model: self.class.name,
+# # #                                     action: action,
+# # #                                     data: processed_data, # This is the processed data, not raw attributes
+# # #                                     metadata: build_publishing_metadata
+# # #                             )
+# # #
+# # #                             Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
+# # #                         end
+# # #                     end
+# # #                 end
+# # #             rescue StandardError => e
+# # #                 Rails.logger.error("Failed to publish: #{e.message}") if defined?(Rails)
+# # #                 # Don't re-raise to avoid breaking transactions
+# # #             end
+# # #
+# # #             private
+# # #
+# # #             def determine_action_from_context
+# # #                 # Try to determine action from ActiveRecord context
+# # #                 if defined?(ActiveRecord) && is_a?(ActiveRecord::Base)
+# # #                     return 'create' if previously_new_record?
+# # #                     return 'update' if saved_changes.any?
+# # #                     return 'destroy' if destroyed?
+# # #                 end
+# # #
+# # #                 'update' # Default fallback
+# # #             end
+# # #
+# # #             def get_raw_attributes
+# # #                 # Get attributes (works for both ActiveRecord and other objects)
+# # #                 if respond_to?(:attributes)
+# # #                     attributes
+# # #                 else
+# # #                     # For non-ActiveRecord objects, get instance variables
+# # #                     instance_variables.map { |v| [v.to_s.delete('@'), instance_variable_get(v)] }.to_h
+# # #                 end
+# # #             end
+# # #
+# # #             def evaluate_conditions(conditions)
+# # #                 conditions.all? do |condition, expected_value|
+# # #                     case condition
+# # #                         when Proc
+# # #                             condition.call(self)
+# # #                         when Symbol, String
+# # #                             if respond_to?(condition, true)
+# # #                                 result = send(condition)
+# # #                                 expected_value.nil? ? result : result == expected_value
+# # #                             else
+# # #                                 false
+# # #                             end
+# # #                         else
+# # #                             false
+# # #                     end
+# # #                 end
+# # #             end
+# # #
+# # #             def build_publishing_metadata
+# # #                 {
+# # #                         source_model: self.class.name,
+# # #                         source_id: respond_to?(:id) ? id : object_id,
+# # #                         published_at: Time.current.iso8601
+# # #                 }
+# # #             end
+# # #         end
+# # #     end
+# # # end
+# #
+# # # frozen_string_literal: true
+# #
+# # module NatsWave
+# #     module Concerns
+# #         module Mappable
+# #             extend ActiveSupport::Concern
+# #
+# #             included do
+# #                 class_attribute :nats_wave_subscription_config, :nats_wave_publishing_config
+# #                 self.nats_wave_subscription_config = {}
+# #                 self.nats_wave_publishing_config = {}
+# #             end
+# #
+# #             class_methods do
+# #                 # Configure subscriptions with optional custom handler
+# #                 def nats_wave_subscribes_to(*subjects, **options, &block)
+# #                     Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
+# #
+# #                     handler = options[:handler] || block
+# #
+# #                     subscription_config = {
+# #                             subjects: subjects.flatten,
+# #                             field_mappings: options[:field_mappings] || {},
+# #                             transformations: options[:transformations] || {},
+# #                             skip_fields: options[:skip_fields] || [],
+# #                             unique_fields: options[:unique_fields] || [:id],
+# #                             sync_strategy: options[:sync_strategy] || :upsert,
+# #                             handler: handler,
+# #                             queue_group: options[:queue_group],
+# #                             auto_sync: options[:auto_sync] != false # Default to true, can be disabled
+# #                     }
+# #
+# #                     # Store the config
+# #                     config_key = subjects.join(',')
+# #                     self.nats_wave_subscription_config[config_key] = subscription_config
+# #
+# #                     # Create the subscription handler
+# #                     processed_handler = create_subscription_handler(subscription_config)
+# #
+# #                     # Register the subscription
+# #                     NatsWave::ModelRegistry.register_subscription(
+# #                             subjects: subjects.flatten,
+# #                             model: self.name,
+# #                             handler: processed_handler,
+# #                             queue_group: subscription_config[:queue_group]
+# #                     )
+# #
+# #                     Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
+# #                 end
+# #
+# #                 # Configure publishing with optional custom handler AND auto-publishing callbacks
+# #                 def nats_wave_publishes_to(*subjects, **options, &block)
+# #                     Rails.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}" if defined?(Rails)
+# #
+# #                     handler = options[:handler] || block
+# #
+# #                     publishing_config = {
+# #                             subjects: subjects.flatten,
+# #                             field_mappings: options[:field_mappings] || {},
+# #                             transformations: options[:transformations] || {},
+# #                             skip_fields: options[:skip_fields] || [],
+# #                             conditions: options[:conditions] || {},
+# #                             actions: options[:actions] || [:create, :update, :destroy],
+# #                             handler: handler,
+# #                             async: options[:async] != false, # Default to true
+# #                             enabled: options[:enabled] != false # Default to true
+# #                     }
+# #
+# #                     # Store the config
+# #                     config_key = subjects.join(',')
+# #                     self.nats_wave_publishing_config[config_key] = publishing_config
+# #
+# #                     # Add ActiveRecord callbacks for auto-publishing
+# #                     setup_publishing_callbacks(publishing_config)
+# #
+# #                     Rails.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}" if defined?(Rails)
+# #                 end
+# #
+# #                 # Get all subscription configurations
+# #                 def nats_wave_subscription_configs
+# #                     nats_wave_subscription_config
+# #                 end
+# #
+# #                 # Get all publishing configurations
+# #                 def nats_wave_publishing_configs
+# #                     nats_wave_publishing_config
+# #                 end
+# #
+# #                 # Get all subjects this model subscribes to
+# #                 def nats_wave_subscribed_subjects
+# #                     nats_wave_subscription_config.values.flat_map { |config| config[:subjects] }.uniq
+# #                 end
+# #
+# #                 # Get all subjects this model publishes to
+# #                 def nats_wave_published_subjects
+# #                     nats_wave_publishing_config.values.flat_map { |config| config[:subjects] }.uniq
+# #                 end
+# #
+# #                 private
+# #
+# #                 # Setup ActiveRecord callbacks for auto-publishing
+# #                 def setup_publishing_callbacks(config)
+# #                     # Only add callbacks if we're in ActiveRecord and actions are specified
+# #                     return unless defined?(ActiveRecord::Base) && self < ActiveRecord::Base
+# #
+# #                     actions = config[:actions]
+# #
+# #                     if actions.include?(:create)
+# #                         after_commit :trigger_nats_wave_auto_publish_on_create, on: :create
+# #                     end
+# #
+# #                     if actions.include?(:update)
+# #                         after_commit :trigger_nats_wave_auto_publish_on_update, on: :update
+# #                     end
+# #
+# #                     if actions.include?(:destroy)
+# #                         after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
+# #                     end
+# #                 end
+# #
+# #                 # Create a subscription handler that processes data and calls custom handler or auto-sync
+# #                 def create_subscription_handler(config)
+# #                     model_class = self
+# #
+# #                     lambda do |message|
+# #                         begin
+# #                             Rails.logger.debug "📨 Processing subscription message for #{model_class.name}" if defined?(Rails)
+# #
+# #                             # Extract the raw data
+# #                             raw_data = message['data'] || {}
+# #                             model_name = message['model']
+# #                             action = message['action']
+# #
+# #                             # Process the data through mappings and transformations
+# #                             processed_data = process_subscription_data(raw_data, config)
+# #
+# #                             # If custom handler is provided, call it with model_name, action, processed_data
+# #                             if config[:handler]
+# #                                 Rails.logger.debug "📨 Calling custom subscription handler" if defined?(Rails)
+# #                                 config[:handler].call(model_name, action, processed_data, message)
+# #                             elsif config[:auto_sync]
+# #                                 Rails.logger.debug "📨 Performing auto-sync" if defined?(Rails)
+# #                                 # Default auto-sync behavior
+# #                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
+# #                             else
+# #                                 Rails.logger.debug "📨 No handler provided and auto_sync disabled" if defined?(Rails)
+# #                             end
+# #
+# #                         rescue => e
+# #                             Rails.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}" if defined?(Rails)
+# #                             Rails.logger.error e.backtrace.join("\n") if defined?(Rails)
+# #                             raise
+# #                         end
+# #                     end
+# #                 end
+# #
+# #                 # Process subscription data through field mappings and transformations (CLASS METHOD)
+# #                 def process_subscription_data(raw_data, config)
+# #                     processed_data = {}
+# #                     field_mappings = config[:field_mappings]
+# #                     transformations = config[:transformations]
+# #                     skip_fields = config[:skip_fields]
+# #
+# #                     raw_data.each do |field, value|
+# #                         field_str = field.to_s
+# #                         field_sym = field.to_sym
+# #
+# #                         # Skip if in skip_fields
+# #                         next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
+# #
+# #                         # Apply field mapping
+# #                         mapped_field = field_mappings[field_str] ||
+# #                                 field_mappings[field_sym] ||
+# #                                 field
+# #
+# #                         # Apply transformation if any
+# #                         transformed_value = apply_transformation(value, mapped_field, transformations, raw_data)
+# #
+# #                         processed_data[mapped_field.to_s] = transformed_value
+# #                     end
+# #
+# #                     processed_data
+# #                 end
+# #
+# #                 # Apply transformations to field values (CLASS METHOD)
+# #                 def apply_transformation(value, field, transformations, full_record)
+# #                     transformation = transformations[field] || transformations[field.to_sym]
+# #
+# #                     case transformation
+# #                         when Proc
+# #                             if transformation.arity == 2 || transformation.arity < 0
+# #                                 transformation.call(value, full_record)
+# #                             else
+# #                                 transformation.call(value)
+# #                             end
+# #                         when Symbol
+# #                             if self.respond_to?(transformation, true)
+# #                                 self.send(transformation, value)
+# #                             elsif value.respond_to?(transformation)
+# #                                 value.send(transformation)
+# #                             else
+# #                                 Rails.logger.warn "Transformation method #{transformation} not found" if defined?(Rails)
+# #                                 value
+# #                             end
+# #                         else
+# #                             value
+# #                     end
+# #                 end
+# #
+# #                 # Default auto-sync behavior (CLASS METHOD)
+# #                 def perform_auto_sync(model_name, action, processed_data, config)
+# #                     unique_fields = config[:unique_fields]
+# #                     sync_strategy = config[:sync_strategy]
+# #
+# #                     case action.to_s.downcase
+# #                         when 'create', 'created'
+# #                             handle_auto_create(processed_data, unique_fields, sync_strategy)
+# #                         when 'update', 'updated'
+# #                             handle_auto_update(processed_data, unique_fields, sync_strategy)
+# #                         when 'delete', 'deleted', 'destroy', 'destroyed'
+# #                             handle_auto_delete(processed_data, unique_fields)
+# #                         else
+# #                             Rails.logger.warn "Unknown action for auto-sync: #{action}" if defined?(Rails)
+# #                     end
+# #                 end
+# #
+# #                 def handle_auto_create(data, unique_fields, sync_strategy)
+# #                     case sync_strategy
+# #                         when :upsert
+# #                             existing = find_by_unique_fields(data, unique_fields)
+# #                             if existing
+# #                                 existing.update!(data)
+# #                                 Rails.logger.info "✅ Updated existing #{self.name}: #{existing.id}" if defined?(Rails)
+# #                             else
+# #                                 record = self.create!(data)
+# #                                 Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+# #                             end
+# #                         when :create_only
+# #                             record = self.create!(data)
+# #                             Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+# #                     end
+# #                 rescue => e
+# #                     Rails.logger.error "❌ Failed to create #{self.name}: #{e.message}" if defined?(Rails)
+# #                     raise
+# #                 end
+# #
+# #                 def handle_auto_update(data, unique_fields, sync_strategy)
+# #                     existing = find_by_unique_fields(data, unique_fields)
+# #                     if existing
+# #                         existing.update!(data)
+# #                         Rails.logger.info "✅ Updated #{self.name}: #{existing.id}" if defined?(Rails)
+# #                     elsif sync_strategy == :upsert
+# #                         record = self.create!(data)
+# #                         Rails.logger.info "✅ Created new #{self.name} during update: #{record.id}" if defined?(Rails)
+# #                     else
+# #                         Rails.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+# #                     end
+# #                 rescue => e
+# #                     Rails.logger.error "❌ Failed to update #{self.name}: #{e.message}" if defined?(Rails)
+# #                     raise
+# #                 end
+# #
+# #                 def handle_auto_delete(data, unique_fields)
+# #                     existing = find_by_unique_fields(data, unique_fields)
+# #                     if existing
+# #                         existing.destroy!
+# #                         Rails.logger.info "✅ Deleted #{self.name}: #{existing.id}" if defined?(Rails)
+# #                     else
+# #                         Rails.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+# #                     end
+# #                 rescue => e
+# #                     Rails.logger.error "❌ Failed to delete #{self.name}: #{e.message}" if defined?(Rails)
+# #                     raise
+# #                 end
+# #
+# #                 def find_by_unique_fields(data, unique_fields)
+# #                     conditions = {}
+# #                     unique_fields.each do |field|
+# #                         field_str = field.to_s
+# #                         if data.key?(field_str)
+# #                             conditions[field] = data[field_str]
+# #                         elsif data.key?(field.to_sym)
+# #                             conditions[field] = data[field.to_sym]
+# #                         end
+# #                     end
+# #
+# #                     return nil if conditions.empty?
+# #                     self.find_by(conditions)
+# #                 end
+# #             end
+# #
+# #             # Instance methods for publishing
+# #             def nats_wave_publish(action = nil)
+# #                 action ||= determine_action_from_context
+# #
+# #                 self.class.nats_wave_publishing_configs.each do |subjects_key, config|
+# #                     next unless config[:enabled]
+# #                     next unless config[:actions].include?(action.to_sym)
+# #
+# #                     # Check conditions (only for publishing)
+# #                     if config[:conditions].any? && !evaluate_conditions(config[:conditions])
+# #                         Rails.logger.debug "📤 Skipping publish - conditions not met" if defined?(Rails)
+# #                         next
+# #                     end
+# #
+# #                     # Get the raw data (current model attributes)
+# #                     raw_data = get_raw_attributes
+# #
+# #                     # Process the data through mappings and transformations
+# #                     processed_data = process_publishing_data(raw_data, config)
+# #
+# #                     # If custom handler is provided, call it
+# #                     if config[:handler]
+# #                         Rails.logger.debug "📤 Calling custom publishing handler" if defined?(Rails)
+# #                         config[:handler].call(self.class.name, action, processed_data, self)
+# #                     else
+# #                         # Default publishing behavior - publish the processed data
+# #                         config[:subjects].each do |subject|
+# #                             NatsWave.client.publish(
+# #                                     subject: subject,
+# #                                     model: self.class.name,
+# #                                     action: action,
+# #                                     data: processed_data, # This is the processed data, not raw attributes
+# #                                     metadata: build_publishing_metadata
+# #                             )
+# #
+# #                             Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
+# #                         end
+# #                     end
+# #                 end
+# #             rescue StandardError => e
+# #                 Rails.logger.error("Failed to publish: #{e.message}") if defined?(Rails)
+# #                 # Don't re-raise to avoid breaking transactions
+# #             end
+# #
+# #             # Auto-publishing callback methods
+# #             def trigger_nats_wave_auto_publish_on_create
+# #                 Rails.logger.debug "🚀 Auto-publishing on create" if defined?(Rails)
+# #                 nats_wave_publish('create')
+# #             end
+# #
+# #             def trigger_nats_wave_auto_publish_on_update
+# #                 Rails.logger.debug "🚀 Auto-publishing on update" if defined?(Rails)
+# #                 nats_wave_publish('update')
+# #             end
+# #
+# #             def trigger_nats_wave_auto_publish_on_destroy
+# #                 Rails.logger.debug "🚀 Auto-publishing on destroy" if defined?(Rails)
+# #                 nats_wave_publish('destroy')
+# #             end
+# #
+# #             private
+# #
+# #             def determine_action_from_context
+# #                 # Try to determine action from ActiveRecord context
+# #                 if defined?(ActiveRecord) && is_a?(ActiveRecord::Base)
+# #                     return 'create' if previously_new_record?
+# #                     return 'update' if saved_changes.any?
+# #                     return 'destroy' if destroyed?
+# #                 end
+# #
+# #                 'update' # Default fallback
+# #             end
+# #
+# #             def get_raw_attributes
+# #                 # Get attributes (works for both ActiveRecord and other objects)
+# #                 if respond_to?(:attributes)
+# #                     attributes
+# #                 else
+# #                     # For non-ActiveRecord objects, get instance variables
+# #                     instance_variables.map { |v| [v.to_s.delete('@'), instance_variable_get(v)] }.to_h
+# #                 end
+# #             end
+# #
+# #             # Process publishing data through field mappings and transformations (INSTANCE METHOD)
+# #             def process_publishing_data(raw_data, config)
+# #                 processed_data = {}
+# #                 field_mappings = config[:field_mappings]
+# #                 transformations = config[:transformations]
+# #                 skip_fields = config[:skip_fields]
+# #
+# #                 raw_data.each do |field, value|
+# #                     field_str = field.to_s
+# #                     field_sym = field.to_sym
+# #
+# #                     # Skip if in skip_fields
+# #                     next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
+# #
+# #                     # Apply field mapping (local -> external)
+# #                     mapped_field = field_mappings[field_str] ||
+# #                             field_mappings[field_sym] ||
+# #                             field
+# #
+# #                     # Apply transformation if any
+# #                     transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
+# #
+# #                     processed_data[mapped_field.to_s] = transformed_value
+# #                 end
+# #
+# #                 processed_data
+# #             end
+# #
+# #             def apply_publishing_transformation(value, field, transformations, full_record)
+# #                 transformation = transformations[field] || transformations[field.to_sym]
+# #
+# #                 case transformation
+# #                     when Proc
+# #                         if transformation.arity == 2 || transformation.arity < 0
+# #                             transformation.call(value, full_record)
+# #                         else
+# #                             transformation.call(value)
+# #                         end
+# #                     when Symbol
+# #                         if self.respond_to?(transformation, true)
+# #                             self.send(transformation, value)
+# #                         elsif value.respond_to?(transformation)
+# #                             value.send(transformation)
+# #                         else
+# #                             Rails.logger.warn "Publishing transformation method #{transformation} not found" if defined?(Rails)
+# #                             value
+# #                         end
+# #                     else
+# #                         value
+# #                 end
+# #             end
+# #
+# #             def evaluate_conditions(conditions)
+# #                 conditions.all? do |condition, expected_value|
+# #                     case condition
+# #                         when Proc
+# #                             condition.call(self)
+# #                         when Symbol, String
+# #                             if respond_to?(condition, true)
+# #                                 result = send(condition)
+# #                                 expected_value.nil? ? result : result == expected_value
+# #                             else
+# #                                 false
+# #                             end
+# #                         else
+# #                             false
+# #                     end
+# #                 end
+# #             end
+# #
+# #             def build_publishing_metadata
+# #                 {
+# #                         source_model: self.class.name,
+# #                         source_id: respond_to?(:id) ? id : object_id,
+# #                         published_at: Time.current.iso8601
+# #                 }
+# #             end
+# #         end
+# #     end
+# # end
+#
 # # frozen_string_literal: true
 #
 # module NatsWave
@@ -16,7 +835,8 @@
 #                 def nats_wave_subscribes_to(*subjects, **options, &block)
 #                     Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
 #
-#                     handler = options[:handler] || block
+#                     # Custom handler is now optional and runs AFTER default behavior
+#                     custom_handler = options[:handler] || block
 #
 #                     subscription_config = {
 #                             subjects: subjects.flatten,
@@ -25,7 +845,7 @@
 #                             skip_fields: options[:skip_fields] || [],
 #                             unique_fields: options[:unique_fields] || [:id],
 #                             sync_strategy: options[:sync_strategy] || :upsert,
-#                             handler: handler,
+#                             custom_handler: custom_handler,  # Renamed to be clear it's optional
 #                             queue_group: options[:queue_group],
 #                             auto_sync: options[:auto_sync] != false # Default to true, can be disabled
 #                     }
@@ -48,11 +868,12 @@
 #                     Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
 #                 end
 #
-#                 # Configure publishing with optional custom handler
+#                 # Configure publishing with optional custom handler AND auto-publishing callbacks
 #                 def nats_wave_publishes_to(*subjects, **options, &block)
 #                     Rails.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}" if defined?(Rails)
 #
-#                     handler = options[:handler] || block
+#                     # Custom handler is now optional and runs AFTER default behavior
+#                     custom_handler = options[:handler] || block
 #
 #                     publishing_config = {
 #                             subjects: subjects.flatten,
@@ -61,15 +882,19 @@
 #                             skip_fields: options[:skip_fields] || [],
 #                             conditions: options[:conditions] || {},
 #                             actions: options[:actions] || [:create, :update, :destroy],
-#                             handler: handler,
+#                             custom_handler: custom_handler,  # Renamed to be clear it's optional
 #                             async: options[:async] != false, # Default to true
-#                             enabled: options[:enabled] != false # Default to true
+#                             enabled: options[:enabled] != false, # Default to true
+#                             only_mapped_fields: options[:only_mapped_fields] != false # Default to true - only send mapped fields
 #                     }
 #
 #                     # Store the config
 #                     config_key = subjects.join(',')
 #                     self.nats_wave_publishing_config[config_key] = publishing_config
 #
+#                     # Add ActiveRecord callbacks for auto-publishing (only once per model)
+#                     setup_publishing_callbacks_once
+#
 #                     Rails.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}" if defined?(Rails)
 #                 end
 #
@@ -83,19 +908,23 @@
 #                     nats_wave_publishing_config
 #                 end
 #
-#                 # Get all subjects this model subscribes to
-#                 def nats_wave_subscribed_subjects
-#                     nats_wave_subscription_config.values.flat_map { |config| config[:subjects] }.uniq
-#                 end
+#                 private
 #
-#                 # Get all subjects this model publishes to
-#                 def nats_wave_published_subjects
-#                     nats_wave_publishing_config.values.flat_map { |config| config[:subjects] }.uniq
-#                 end
+#                 # Setup ActiveRecord callbacks for auto-publishing (only once per model)
+#                 def setup_publishing_callbacks_once
+#                     # Only add callbacks if we're in ActiveRecord and haven't added them yet
+#                     return unless defined?(ActiveRecord::Base) && self < ActiveRecord::Base
+#                     return if @nats_wave_callbacks_added
 #
-#                 private
+#                     after_commit :trigger_nats_wave_auto_publish_on_create, on: :create
+#                     after_commit :trigger_nats_wave_auto_publish_on_update, on: :update
+#                     after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
 #
-#                 # Create a subscription handler that processes data and calls custom handler or auto-sync
+#                     @nats_wave_callbacks_added = true
+#                     Rails.logger.debug "📤 #{self.name}: Added publishing callbacks" if defined?(Rails)
+#                 end
+#
+#                 # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
 #                 def create_subscription_handler(config)
 #                     model_class = self
 #
@@ -109,18 +938,18 @@
 #                             action = message['action']
 #
 #                             # Process the data through mappings and transformations
-#                             processed_data = model_class.process_data(raw_data, config)
-#
-#                             # If custom handler is provided, call it with model_name, action, processed_data
-#                             if config[:handler]
-#                                 Rails.logger.debug "📨 Calling custom subscription handler" if defined?(Rails)
-#                                 config[:handler].call(model_name, action, processed_data, message)
-#                             elsif config[:auto_sync]
-#                                 Rails.logger.debug "📨 Performing auto-sync" if defined?(Rails)
-#                                 # Default auto-sync behavior
+#                             processed_data = process_subscription_data(raw_data, config)
+#
+#                             # Always perform auto-sync first (if enabled)
+#                             if config[:auto_sync]
+#                                 Rails.logger.debug "📨 Performing auto-sync first" if defined?(Rails)
 #                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
-#                             else
-#                                 Rails.logger.debug "📨 No handler provided and auto_sync disabled" if defined?(Rails)
+#                             end
+#
+#                             # Then call custom handler if provided (optional)
+#                             if config[:custom_handler]
+#                                 Rails.logger.debug "📨 Calling custom subscription handler after auto-sync" if defined?(Rails)
+#                                 config[:custom_handler].call(model_name, action, processed_data, message)
 #                             end
 #
 #                         rescue => e
@@ -131,8 +960,8 @@
 #                     end
 #                 end
 #
-#                 # Process data through field mappings and transformations (used by both subscription and publishing)
-#                 def process_data(raw_data, config)
+#                 # Process subscription data through field mappings and transformations (CLASS METHOD)
+#                 def process_subscription_data(raw_data, config)
 #                     processed_data = {}
 #                     field_mappings = config[:field_mappings]
 #                     transformations = config[:transformations]
@@ -159,7 +988,7 @@
 #                     processed_data
 #                 end
 #
-#                 # Apply transformations to field values
+#                 # Apply transformations to field values (CLASS METHOD)
 #                 def apply_transformation(value, field, transformations, full_record)
 #                     transformation = transformations[field] || transformations[field.to_sym]
 #
@@ -184,7 +1013,7 @@
 #                     end
 #                 end
 #
-#                 # Default auto-sync behavior
+#                 # Default auto-sync behavior (CLASS METHOD)
 #                 def perform_auto_sync(model_name, action, processed_data, config)
 #                     unique_fields = config[:unique_fields]
 #                     sync_strategy = config[:sync_strategy]
@@ -283,26 +1112,29 @@
 #                     # Get the raw data (current model attributes)
 #                     raw_data = get_raw_attributes
 #
-#                     # Process the data through mappings and transformations (same as subscription)
-#                     processed_data = self.class.process_data(raw_data, config)
+#                     # Process the data through mappings and transformations
+#                     processed_data = process_publishing_data(raw_data, config)
 #
-#                     # If custom handler is provided, call it
-#                     if config[:handler]
-#                         Rails.logger.debug "📤 Calling custom publishing handler" if defined?(Rails)
-#                         config[:handler].call(self.class.name, action, processed_data, self)
-#                     else
-#                         # Default publishing behavior - publish the processed data
-#                         config[:subjects].each do |subject|
-#                             NatsWave.client.publish(
-#                                     subject: subject,
-#                                     model: self.class.name,
-#                                     action: action,
-#                                     data: processed_data, # This is the processed data, not raw attributes
-#                                     metadata: build_publishing_metadata
-#                             )
-#
-#                             Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
-#                         end
+#                     # Determine which subjects to publish to based on action
+#                     subjects_to_publish = determine_subjects_for_action(config[:subjects], action)
+#
+#                     # Always publish first (default behavior)
+#                     subjects_to_publish.each do |subject|
+#                         NatsWave.client.publish(
+#                                 subject: subject,
+#                                 model: self.class.name,
+#                                 action: action,
+#                                 data: processed_data, # This is the processed data, not raw attributes
+#                                 metadata: build_publishing_metadata
+#                         )
+#
+#                         Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
+#                     end
+#
+#                     # Then call custom handler if provided (optional)
+#                     if config[:custom_handler]
+#                         Rails.logger.debug "📤 Calling custom publishing handler after publishing" if defined?(Rails)
+#                         config[:custom_handler].call(self.class.name, action, processed_data, self)
 #                     end
 #                 end
 #             rescue StandardError => e
@@ -310,6 +1142,37 @@
 #                 # Don't re-raise to avoid breaking transactions
 #             end
 #
+#             # Auto-publishing callback methods (only called once per action)
+#             def trigger_nats_wave_auto_publish_on_create
+#                 return if @nats_wave_publishing_in_progress
+#                 @nats_wave_publishing_in_progress = true
+#
+#                 Rails.logger.debug "🚀 Auto-publishing on create" if defined?(Rails)
+#                 nats_wave_publish('create')
+#
+#                 @nats_wave_publishing_in_progress = false
+#             end
+#
+#             def trigger_nats_wave_auto_publish_on_update
+#                 return if @nats_wave_publishing_in_progress
+#                 @nats_wave_publishing_in_progress = true
+#
+#                 Rails.logger.debug "🚀 Auto-publishing on update" if defined?(Rails)
+#                 nats_wave_publish('update')
+#
+#                 @nats_wave_publishing_in_progress = false
+#             end
+#
+#             def trigger_nats_wave_auto_publish_on_destroy
+#                 return if @nats_wave_publishing_in_progress
+#                 @nats_wave_publishing_in_progress = true
+#
+#                 Rails.logger.debug "🚀 Auto-publishing on destroy" if defined?(Rails)
+#                 nats_wave_publish('destroy')
+#
+#                 @nats_wave_publishing_in_progress = false
+#             end
+#
 #             private
 #
 #             def determine_action_from_context
@@ -333,6 +1196,86 @@
 #                 end
 #             end
 #
+#             # Process publishing data through field mappings and transformations (INSTANCE METHOD)
+#             def process_publishing_data(raw_data, config)
+#                 processed_data = {}
+#                 field_mappings = config[:field_mappings]
+#                 transformations = config[:transformations]
+#                 skip_fields = config[:skip_fields]
+#                 only_mapped_fields = config[:only_mapped_fields]
+#
+#                 # If only_mapped_fields is true, only process fields that have mappings or transformations
+#                 fields_to_process = if only_mapped_fields && field_mappings.any?
+#                                         # Only process fields that are explicitly mapped or have transformations
+#                                         mapped_source_fields = field_mappings.keys.map(&:to_s)
+#                                         transformation_fields = transformations.keys.map(&:to_s)
+#                                         all_relevant_fields = (mapped_source_fields + transformation_fields).uniq
+#
+#                                         raw_data.select { |field, _| all_relevant_fields.include?(field.to_s) }
+#                                     else
+#                                         # Process all fields (existing behavior)
+#                                         raw_data
+#                                     end
+#
+#                 fields_to_process.each do |field, value|
+#                     field_str = field.to_s
+#                     field_sym = field.to_sym
+#
+#                     # Skip if in skip_fields
+#                     next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
+#
+#                     # Apply field mapping (local -> external)
+#                     mapped_field = field_mappings[field_str] ||
+#                             field_mappings[field_sym] ||
+#                             field
+#
+#                     # Apply transformation if any
+#                     transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
+#
+#                     processed_data[mapped_field.to_s] = transformed_value
+#                 end
+#
+#                 processed_data
+#             end
+#
+#             def apply_publishing_transformation(value, field, transformations, full_record)
+#                 transformation = transformations[field] || transformations[field.to_sym]
+#
+#                 case transformation
+#                     when Proc
+#                         if transformation.arity == 2 || transformation.arity < 0
+#                             transformation.call(value, full_record)
+#                         else
+#                             transformation.call(value)
+#                         end
+#                     when Symbol
+#                         if self.respond_to?(transformation, true)
+#                             self.send(transformation, value)
+#                         elsif value.respond_to?(transformation)
+#                             value.send(transformation)
+#                         else
+#                             Rails.logger.warn "Publishing transformation method #{transformation} not found" if defined?(Rails)
+#                             value
+#                         end
+#                     else
+#                         value
+#                 end
+#             end
+#
+#             def determine_subjects_for_action(configured_subjects, action)
+#                 # If subjects contain placeholders like {action}, replace them
+#                 configured_subjects.map do |subject|
+#                     if subject.include?('{action}')
+#                         subject.gsub('{action}', action.to_s)
+#                     elsif subject.include?('*')
+#                         # Replace wildcard with specific action
+#                         subject.gsub('*', action.to_s)
+#                     else
+#                         subject
+#                     end
+#                 end
+#             end
+#
 #             def evaluate_conditions(conditions)
 #                 conditions.all? do |condition, expected_value|
 #                     case condition
@@ -361,7 +1304,6 @@
 #         end
 #     end
 # end
-
 # frozen_string_literal: true
 
 module NatsWave
@@ -380,7 +1322,8 @@ module NatsWave
                 def nats_wave_subscribes_to(*subjects, **options, &block)
                     Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
                     
-                    handler = options[:handler] || block
+                    # Custom handler is now optional and runs AFTER default behavior
+                    custom_handler = options[:handler] || block
                     
                     subscription_config = {
                             subjects: subjects.flatten,
@@ -389,7 +1332,7 @@ module NatsWave
                             skip_fields: options[:skip_fields] || [],
                             unique_fields: options[:unique_fields] || [:id],
                             sync_strategy: options[:sync_strategy] || :upsert,
-                            handler: handler,
+                            custom_handler: custom_handler,  # Renamed to be clear it's optional
                             queue_group: options[:queue_group],
                             auto_sync: options[:auto_sync] != false # Default to true, can be disabled
                     }
@@ -416,7 +1359,8 @@ module NatsWave
                 def nats_wave_publishes_to(*subjects, **options, &block)
                     Rails.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}" if defined?(Rails)
                     
-                    handler = options[:handler] || block
+                    # Custom handler is now optional and runs AFTER default behavior
+                    custom_handler = options[:handler] || block
                     
                     publishing_config = {
                             subjects: subjects.flatten,
@@ -425,7 +1369,7 @@ module NatsWave
                             skip_fields: options[:skip_fields] || [],
                             conditions: options[:conditions] || {},
                             actions: options[:actions] || [:create, :update, :destroy],
-                            handler: handler,
+                            custom_handler: custom_handler,  # Renamed to be clear it's optional
                             async: options[:async] != false, # Default to true
                             enabled: options[:enabled] != false # Default to true
                     }
@@ -434,8 +1378,8 @@ module NatsWave
                     config_key = subjects.join(',')
                     self.nats_wave_publishing_config[config_key] = publishing_config
                     
-                    # Add ActiveRecord callbacks for auto-publishing
-                    setup_publishing_callbacks(publishing_config)
+                    # Add ActiveRecord callbacks for auto-publishing (only once per model)
+                    setup_publishing_callbacks_once
                     
                     Rails.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}" if defined?(Rails)
                 end
@@ -450,39 +1394,23 @@ module NatsWave
                     nats_wave_publishing_config
                 end
                 
-                # Get all subjects this model subscribes to
-                def nats_wave_subscribed_subjects
-                    nats_wave_subscription_config.values.flat_map { |config| config[:subjects] }.uniq
-                end
-                
-                # Get all subjects this model publishes to
-                def nats_wave_published_subjects
-                    nats_wave_publishing_config.values.flat_map { |config| config[:subjects] }.uniq
-                end
-                
                 private
                 
-                # Setup ActiveRecord callbacks for auto-publishing
-                def setup_publishing_callbacks(config)
-                    # Only add callbacks if we're in ActiveRecord and actions are specified
+                # Setup ActiveRecord callbacks for auto-publishing (only once per model)
+                def setup_publishing_callbacks_once
+                    # Only add callbacks if we're in ActiveRecord and haven't added them yet
                     return unless defined?(ActiveRecord::Base) && self < ActiveRecord::Base
+                    return if @nats_wave_callbacks_added
                     
-                    actions = config[:actions]
+                    after_commit :trigger_nats_wave_auto_publish_on_create, on: :create
+                    after_commit :trigger_nats_wave_auto_publish_on_update, on: :update
+                    after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
                     
-                    if actions.include?(:create)
-                        after_commit :trigger_nats_wave_auto_publish_on_create, on: :create
-                    end
-                    
-                    if actions.include?(:update)
-                        after_commit :trigger_nats_wave_auto_publish_on_update, on: :update
-                    end
-                    
-                    if actions.include?(:destroy)
-                        after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
-                    end
+                    @nats_wave_callbacks_added = true
+                    Rails.logger.debug "📤 #{self.name}: Added publishing callbacks" if defined?(Rails)
                 end
                 
-                # Create a subscription handler that processes data and calls custom handler or auto-sync
+                # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
                 def create_subscription_handler(config)
                     model_class = self
                     
@@ -496,18 +1424,18 @@ module NatsWave
                             action = message['action']
                             
                             # Process the data through mappings and transformations
-                            processed_data = process_subscription_data(raw_data, config)
+                            processed_data = model_class.process_subscription_data(raw_data, config)
                             
-                            # If custom handler is provided, call it with model_name, action, processed_data
-                            if config[:handler]
-                                Rails.logger.debug "📨 Calling custom subscription handler" if defined?(Rails)
-                                config[:handler].call(model_name, action, processed_data, message)
-                            elsif config[:auto_sync]
-                                Rails.logger.debug "📨 Performing auto-sync" if defined?(Rails)
-                                # Default auto-sync behavior
+                            # Always perform auto-sync first (if enabled)
+                            if config[:auto_sync]
+                                Rails.logger.debug "📨 Performing auto-sync first" if defined?(Rails)
                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
-                            else
-                                Rails.logger.debug "📨 No handler provided and auto_sync disabled" if defined?(Rails)
+                            end
+                            
+                            # Then call custom handler if provided (optional)
+                            if config[:custom_handler]
+                                Rails.logger.debug "📨 Calling custom subscription handler after auto-sync" if defined?(Rails)
+                                config[:custom_handler].call(model_name, action, processed_data, message)
                             end
                         
                         rescue => e
@@ -518,7 +1446,7 @@ module NatsWave
                     end
                 end
                 
-                # Process subscription data through field mappings and transformations (CLASS METHOD)
+                # Process subscription data through field mappings and transformations (PUBLIC CLASS METHOD)
                 def process_subscription_data(raw_data, config)
                     processed_data = {}
                     field_mappings = config[:field_mappings]
@@ -532,7 +1460,7 @@ module NatsWave
                         # Skip if in skip_fields
                         next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
                         
-                        # Apply field mapping
+                        # Apply field mapping (external -> local)
                         mapped_field = field_mappings[field_str] ||
                                 field_mappings[field_sym] ||
                                 field
@@ -546,7 +1474,7 @@ module NatsWave
                     processed_data
                 end
                 
-                # Apply transformations to field values (CLASS METHOD)
+                # Apply transformations to field values (PUBLIC CLASS METHOD)
                 def apply_transformation(value, field, transformations, full_record)
                     transformation = transformations[field] || transformations[field.to_sym]
                     
@@ -571,7 +1499,7 @@ module NatsWave
                     end
                 end
                 
-                # Default auto-sync behavior (CLASS METHOD)
+                # Default auto-sync behavior (PUBLIC CLASS METHOD)
                 def perform_auto_sync(model_name, action, processed_data, config)
                     unique_fields = config[:unique_fields]
                     sync_strategy = config[:sync_strategy]
@@ -673,23 +1601,26 @@ module NatsWave
                     # Process the data through mappings and transformations
                     processed_data = process_publishing_data(raw_data, config)
                     
-                    # If custom handler is provided, call it
-                    if config[:handler]
-                        Rails.logger.debug "📤 Calling custom publishing handler" if defined?(Rails)
-                        config[:handler].call(self.class.name, action, processed_data, self)
-                    else
-                        # Default publishing behavior - publish the processed data
-                        config[:subjects].each do |subject|
-                            NatsWave.client.publish(
-                                    subject: subject,
-                                    model: self.class.name,
-                                    action: action,
-                                    data: processed_data, # This is the processed data, not raw attributes
-                                    metadata: build_publishing_metadata
-                            )
-                            
-                            Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
-                        end
+                    # Determine which subjects to publish to based on action
+                    subjects_to_publish = determine_subjects_for_action(config[:subjects], action)
+                    
+                    # Always publish first (default behavior)
+                    subjects_to_publish.each do |subject|
+                        NatsWave.client.publish(
+                                subject: subject,
+                                model: self.class.name,
+                                action: action,
+                                data: processed_data, # This is the processed data, not raw attributes
+                                metadata: build_publishing_metadata
+                        )
+                        
+                        Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
+                    end
+                    
+                    # Then call custom handler if provided (optional)
+                    if config[:custom_handler]
+                        Rails.logger.debug "📤 Calling custom publishing handler after publishing" if defined?(Rails)
+                        config[:custom_handler].call(self.class.name, action, processed_data, self)
                     end
                 end
             rescue StandardError => e
@@ -697,20 +1628,35 @@ module NatsWave
                 # Don't re-raise to avoid breaking transactions
             end
             
-            # Auto-publishing callback methods
+            # Auto-publishing callback methods (only called once per action)
             def trigger_nats_wave_auto_publish_on_create
+                return if @nats_wave_publishing_in_progress
+                @nats_wave_publishing_in_progress = true
+                
                 Rails.logger.debug "🚀 Auto-publishing on create" if defined?(Rails)
                 nats_wave_publish('create')
+                
+                @nats_wave_publishing_in_progress = false
             end
             
             def trigger_nats_wave_auto_publish_on_update
+                return if @nats_wave_publishing_in_progress
+                @nats_wave_publishing_in_progress = true
+                
                 Rails.logger.debug "🚀 Auto-publishing on update" if defined?(Rails)
                 nats_wave_publish('update')
+                
+                @nats_wave_publishing_in_progress = false
             end
             
             def trigger_nats_wave_auto_publish_on_destroy
+                return if @nats_wave_publishing_in_progress
+                @nats_wave_publishing_in_progress = true
+                
                 Rails.logger.debug "🚀 Auto-publishing on destroy" if defined?(Rails)
                 nats_wave_publish('destroy')
+                
+                @nats_wave_publishing_in_progress = false
             end
             
             private
@@ -736,7 +1682,7 @@ module NatsWave
                 end
             end
             
-            # Process publishing data through field mappings and transformations (INSTANCE METHOD)
+            # Process publishing data - much simpler now! (INSTANCE METHOD)
             def process_publishing_data(raw_data, config)
                 processed_data = {}
                 field_mappings = config[:field_mappings]
@@ -750,10 +1696,10 @@ module NatsWave
                     # Skip if in skip_fields
                     next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
                     
-                    # Apply field mapping (local -> external)
+                    # Apply field mapping (local -> external) - ONLY if mapping exists
                     mapped_field = field_mappings[field_str] ||
                             field_mappings[field_sym] ||
-                            field
+                            field  # Use original field name if no mapping
                     
                     # Apply transformation if any
                     transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
@@ -788,6 +1734,20 @@ module NatsWave
                 end
             end
             
+            def determine_subjects_for_action(configured_subjects, action)
+                # If subjects contain placeholders like {action}, replace them
+                configured_subjects.map do |subject|
+                    if subject.include?('{action}')
+                        subject.gsub('{action}', action.to_s)
+                    elsif subject.include?('*')
+                        # Replace wildcard with specific action
+                        subject.gsub('*', action.to_s)
+                    else
+                        subject
+                    end
+                end
+            end
+            
             def evaluate_conditions(conditions)
                 conditions.all? do |condition, expected_value|
                     case condition