nats_wave 1.1.13 → 1.1.15

data/lib/nats_wave/concerns/mappable.rb

@@ -1,367 +1,3 @@
-# # # # 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
@@ -378,9 +14,10 @@
 # #             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)
+# #                     NatsWave.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}"
 # #
-# #                     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 +26,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
 # #                     }
@@ -409,14 +46,15 @@
 # #                             queue_group: subscription_config[:queue_group]
 # #                     )
 # #
-# #                     Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
+# #                     NatsWave.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}"
 # #                 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)
+# #                     NatsWave.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}"
 # #
-# #                     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,19 +63,20 @@
 # #                             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
 # #                     }
 # #
 # #                     # 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)
+# #                     # 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)
+# #                     NatsWave.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}"
 # #                 end
 # #
 # #                 # Get all subscription configurations
@@ -450,45 +89,29 @@
 # #                     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]
-# #
-# #                     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
+# #                     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?(:destroy)
-# #                         after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
-# #                     end
+# #                     @nats_wave_callbacks_added = true
+# #                     NatsWave.logger.debug "📤 #{self.name}: Added publishing callbacks"
 # #                 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
 # #
 # #                     lambda do |message|
 # #                         begin
-# #                             Rails.logger.debug "📨 Processing subscription message for #{model_class.name}" if defined?(Rails)
+# #                             NatsWave.logger.debug "📨 Processing subscription message for #{model_class.name}"
 # #
 # #                             # Extract the raw data
 # #                             raw_data = message['data'] || {}
@@ -496,29 +119,29 @@
 # #                             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
+# #                             processed_data = model_class.process_subscription_data(raw_data, config)
+# #
+# #                             # Always perform auto-sync first (if enabled)
+# #                             if config[:auto_sync]
+# #                                 NatsWave.logger.debug "📨 Performing auto-sync first"
 # #                                 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]
+# #                                 NatsWave.logger.debug "📨 Calling custom subscription handler after auto-sync"
+# #                                 config[:custom_handler].call(model_name, action, processed_data, message)
 # #                             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)
+# #                             NatsWave.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}"
+# #                             NatsWave.logger.error e.backtrace.join("\n")
 # #                             raise
 # #                         end
 # #                     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 +155,7 @@
 # #                         # 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 +169,7 @@
 # #                     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]
 # #
@@ -563,7 +186,7 @@
 # #                             elsif value.respond_to?(transformation)
 # #                                 value.send(transformation)
 # #                             else
-# #                                 Rails.logger.warn "Transformation method #{transformation} not found" if defined?(Rails)
+# #                                 NatsWave.logger.warn "Transformation method #{transformation} not found"
 # #                                 value
 # #                             end
 # #                         else
@@ -571,7 +194,7 @@
 # #                     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]
@@ -584,7 +207,7 @@
 # #                         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)
+# #                             NatsWave.logger.warn "Unknown action for auto-sync: #{action}"
 # #                     end
 # #                 end
 # #
@@ -594,17 +217,17 @@
 # #                             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)
+# #                                 NatsWave.logger.info "✅ Updated existing #{self.name}: #{existing.id}"
 # #                             else
 # #                                 record = self.create!(data)
-# #                                 Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+# #                                 NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
 # #                             end
 # #                         when :create_only
 # #                             record = self.create!(data)
-# #                             Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+# #                             NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
 # #                     end
 # #                 rescue => e
-# #                     Rails.logger.error "❌ Failed to create #{self.name}: #{e.message}" if defined?(Rails)
+# #                     NatsWave.logger.error "❌ Failed to create #{self.name}: #{e.message}"
 # #                     raise
 # #                 end
 # #
@@ -612,15 +235,15 @@
 # #                     existing = find_by_unique_fields(data, unique_fields)
 # #                     if existing
 # #                         existing.update!(data)
-# #                         Rails.logger.info "✅ Updated #{self.name}: #{existing.id}" if defined?(Rails)
+# #                         NatsWave.logger.info "✅ Updated #{self.name}: #{existing.id}"
 # #                     elsif sync_strategy == :upsert
 # #                         record = self.create!(data)
-# #                         Rails.logger.info "✅ Created new #{self.name} during update: #{record.id}" if defined?(Rails)
+# #                         NatsWave.logger.info "✅ Created new #{self.name} during update: #{record.id}"
 # #                     else
-# #                         Rails.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+# #                         NatsWave.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}"
 # #                     end
 # #                 rescue => e
-# #                     Rails.logger.error "❌ Failed to update #{self.name}: #{e.message}" if defined?(Rails)
+# #                     NatsWave.logger.error "❌ Failed to update #{self.name}: #{e.message}"
 # #                     raise
 # #                 end
 # #
@@ -628,12 +251,12 @@
 # #                     existing = find_by_unique_fields(data, unique_fields)
 # #                     if existing
 # #                         existing.destroy!
-# #                         Rails.logger.info "✅ Deleted #{self.name}: #{existing.id}" if defined?(Rails)
+# #                         NatsWave.logger.info "✅ Deleted #{self.name}: #{existing.id}"
 # #                     else
-# #                         Rails.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+# #                         NatsWave.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}"
 # #                     end
 # #                 rescue => e
-# #                     Rails.logger.error "❌ Failed to delete #{self.name}: #{e.message}" if defined?(Rails)
+# #                     NatsWave.logger.error "❌ Failed to delete #{self.name}: #{e.message}"
 # #                     raise
 # #                 end
 # #
@@ -663,7 +286,7 @@
 # #
 # #                     # Check conditions (only for publishing)
 # #                     if config[:conditions].any? && !evaluate_conditions(config[:conditions])
-# #                         Rails.logger.debug "📤 Skipping publish - conditions not met" if defined?(Rails)
+# #                         NatsWave.logger.debug "📤 Skipping publish - conditions not met"
 # #                         next
 # #                     end
 # #
@@ -673,44 +296,62 @@
 # #                     # 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
+# #                         )
+# #
+# #                         NatsWave.logger.info "📤 Published #{self.class.name} to #{subject}"
+# #                     end
+# #
+# #                     # Then call custom handler if provided (optional)
+# #                     if config[:custom_handler]
+# #                         NatsWave.logger.debug "📤 Calling custom publishing handler after publishing"
+# #                         config[:custom_handler].call(self.class.name, action, processed_data, self)
 # #                     end
 # #                 end
 # #             rescue StandardError => e
-# #                 Rails.logger.error("Failed to publish: #{e.message}") if defined?(Rails)
+# #                 NatsWave.logger.error("Failed to publish: #{e.message}")
 # #                 # 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
-# #                 Rails.logger.debug "🚀 Auto-publishing on create" if defined?(Rails)
+# #                 return if @nats_wave_publishing_in_progress
+# #                 @nats_wave_publishing_in_progress = true
+# #
+# #                 NatsWave.logger.debug "🚀 Auto-publishing on create"
 # #                 nats_wave_publish('create')
+# #
+# #                 @nats_wave_publishing_in_progress = false
 # #             end
 # #
 # #             def trigger_nats_wave_auto_publish_on_update
-# #                 Rails.logger.debug "🚀 Auto-publishing on update" if defined?(Rails)
+# #                 return if @nats_wave_publishing_in_progress
+# #                 @nats_wave_publishing_in_progress = true
+# #
+# #                 NatsWave.logger.debug "🚀 Auto-publishing on update"
 # #                 nats_wave_publish('update')
+# #
+# #                 @nats_wave_publishing_in_progress = false
 # #             end
 # #
 # #             def trigger_nats_wave_auto_publish_on_destroy
-# #                 Rails.logger.debug "🚀 Auto-publishing on destroy" if defined?(Rails)
+# #                 return if @nats_wave_publishing_in_progress
+# #                 @nats_wave_publishing_in_progress = true
+# #
+# #                 NatsWave.logger.debug "🚀 Auto-publishing on destroy"
 # #                 nats_wave_publish('destroy')
+# #
+# #                 @nats_wave_publishing_in_progress = false
 # #             end
 # #
 # #             private
@@ -736,31 +377,49 @@
 # #                 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]
+# #                 field_mappings = config[:field_mappings] || {}
+# #                 transformations = config[:transformations] || {}
+# #                 skip_fields = config[:skip_fields] || []
+# #                 only_mapped_fields = config[:only_mapped_fields]
 # #
-# #                 raw_data.each do |field, value|
-# #                     field_str = field.to_s
-# #                     field_sym = field.to_sym
+# #                 # If only_mapped_fields is true, only process fields that have explicit mappings
+# #                 if only_mapped_fields && field_mappings.any?
+# #                     field_mappings.each do |local_field, external_field|
+# #                         local_field_str = local_field.to_s
 # #
-# #                     # Skip if in skip_fields
-# #                     next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
+# #                         # Skip if this field is in skip_fields
+# #                         next if skip_fields.include?(local_field_str) || skip_fields.include?(local_field.to_sym)
 # #
-# #                     # Apply field mapping (local -> external)
-# #                     mapped_field = field_mappings[field_str] ||
-# #                             field_mappings[field_sym] ||
-# #                             field
+# #                         # Get the value from raw_data
+# #                         value = raw_data[local_field_str] || raw_data[local_field.to_sym]
 # #
-# #                     # Apply transformation if any
-# #                     transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
+# #                         # Apply transformation if any (use external field name for transformation lookup)
+# #                         transformed_value = apply_publishing_transformation(value, external_field, transformations, raw_data)
 # #
-# #                     processed_data[mapped_field.to_s] = transformed_value
-# #                 end
+# #                         processed_data[external_field.to_s] = transformed_value
+# #                     end
+# #                 else
+# #                     # Original behavior - process all 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) - ONLY if mapping exists
+# #                         mapped_field = field_mappings[field_str] ||
+# #                                 field_mappings[field_sym] ||
+# #                                 field  # Use original field name if no mapping
+# #
+# #                         # Apply transformation if any
+# #                         transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
+# #
+# #                         processed_data[mapped_field.to_s] = transformed_value
+# #                     end
+# #                 end
 # #                 processed_data
 # #             end
 # #
@@ -780,7 +439,7 @@
 # #                         elsif value.respond_to?(transformation)
 # #                             value.send(transformation)
 # #                         else
-# #                             Rails.logger.warn "Publishing transformation method #{transformation} not found" if defined?(Rails)
+# #                             NatsWave.logger.warn "Publishing transformation method #{transformation} not found"
 # #                             value
 # #                         end
 # #                     else
@@ -788,6 +447,20 @@
 # #                 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
@@ -833,7 +506,7 @@
 #             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)
+#                     NatsWave.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}"
 #
 #                     # Custom handler is now optional and runs AFTER default behavior
 #                     custom_handler = options[:handler] || block
@@ -865,12 +538,12 @@
 #                             queue_group: subscription_config[:queue_group]
 #                     )
 #
-#                     Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
+#                     NatsWave.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}"
 #                 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)
+#                     NatsWave.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}"
 #
 #                     # Custom handler is now optional and runs AFTER default behavior
 #                     custom_handler = options[:handler] || block
@@ -885,7 +558,7 @@
 #                             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
-#                             only_mapped_fields: options[:only_mapped_fields] != false # Default to true - only send mapped fields
+#                             only_mapped_fields: options[:only_mapped_fields] # Changed: don't default to true
 #                     }
 #
 #                     # Store the config
@@ -895,7 +568,7 @@
 #                     # 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)
+#                     NatsWave.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}"
 #                 end
 #
 #                 # Get all subscription configurations
@@ -908,59 +581,9 @@
 #                     nats_wave_publishing_config
 #                 end
 #
-#                 private
-#
-#                 # 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
-#
-#                     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
-#
-#                     @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
+#                 # PUBLIC METHODS - These need to be accessible from lambda context
 #
-#                     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)
-#
-#                             # 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)
-#                             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
-#                             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)
+#                 # Process subscription data through field mappings and transformations
 #                 def process_subscription_data(raw_data, config)
 #                     processed_data = {}
 #                     field_mappings = config[:field_mappings]
@@ -974,7 +597,7 @@
 #                         # 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
@@ -988,7 +611,7 @@
 #                     processed_data
 #                 end
 #
-#                 # Apply transformations to field values (CLASS METHOD)
+#                 # Apply transformations to field values
 #                 def apply_transformation(value, field, transformations, full_record)
 #                     transformation = transformations[field] || transformations[field.to_sym]
 #
@@ -1005,7 +628,7 @@
 #                             elsif value.respond_to?(transformation)
 #                                 value.send(transformation)
 #                             else
-#                                 Rails.logger.warn "Transformation method #{transformation} not found" if defined?(Rails)
+#                                 NatsWave.logger.warn "Transformation method #{transformation} not found"
 #                                 value
 #                             end
 #                         else
@@ -1013,7 +636,7 @@
 #                     end
 #                 end
 #
-#                 # Default auto-sync behavior (CLASS METHOD)
+#                 # Default auto-sync behavior
 #                 def perform_auto_sync(model_name, action, processed_data, config)
 #                     unique_fields = config[:unique_fields]
 #                     sync_strategy = config[:sync_strategy]
@@ -1026,7 +649,7 @@
 #                         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)
+#                             NatsWave.logger.warn "Unknown action for auto-sync: #{action}"
 #                     end
 #                 end
 #
@@ -1036,17 +659,17 @@
 #                             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)
+#                                 NatsWave.logger.info "✅ Updated existing #{self.name}: #{existing.id}"
 #                             else
 #                                 record = self.create!(data)
-#                                 Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+#                                 NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
 #                             end
 #                         when :create_only
 #                             record = self.create!(data)
-#                             Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+#                             NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
 #                     end
 #                 rescue => e
-#                     Rails.logger.error "❌ Failed to create #{self.name}: #{e.message}" if defined?(Rails)
+#                     NatsWave.logger.error "❌ Failed to create #{self.name}: #{e.message}"
 #                     raise
 #                 end
 #
@@ -1054,15 +677,15 @@
 #                     existing = find_by_unique_fields(data, unique_fields)
 #                     if existing
 #                         existing.update!(data)
-#                         Rails.logger.info "✅ Updated #{self.name}: #{existing.id}" if defined?(Rails)
+#                         NatsWave.logger.info "✅ Updated #{self.name}: #{existing.id}"
 #                     elsif sync_strategy == :upsert
 #                         record = self.create!(data)
-#                         Rails.logger.info "✅ Created new #{self.name} during update: #{record.id}" if defined?(Rails)
+#                         NatsWave.logger.info "✅ Created new #{self.name} during update: #{record.id}"
 #                     else
-#                         Rails.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+#                         NatsWave.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}"
 #                     end
 #                 rescue => e
-#                     Rails.logger.error "❌ Failed to update #{self.name}: #{e.message}" if defined?(Rails)
+#                     NatsWave.logger.error "❌ Failed to update #{self.name}: #{e.message}"
 #                     raise
 #                 end
 #
@@ -1070,12 +693,12 @@
 #                     existing = find_by_unique_fields(data, unique_fields)
 #                     if existing
 #                         existing.destroy!
-#                         Rails.logger.info "✅ Deleted #{self.name}: #{existing.id}" if defined?(Rails)
+#                         NatsWave.logger.info "✅ Deleted #{self.name}: #{existing.id}"
 #                     else
-#                         Rails.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+#                         NatsWave.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}"
 #                     end
 #                 rescue => e
-#                     Rails.logger.error "❌ Failed to delete #{self.name}: #{e.message}" if defined?(Rails)
+#                     NatsWave.logger.error "❌ Failed to delete #{self.name}: #{e.message}"
 #                     raise
 #                 end
 #
@@ -1093,6 +716,58 @@
 #                     return nil if conditions.empty?
 #                     self.find_by(conditions)
 #                 end
+#
+#                 private
+#
+#                 # 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
+#
+#                     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
+#
+#                     @nats_wave_callbacks_added = true
+#                     NatsWave.logger.debug "📤 #{self.name}: Added publishing callbacks"
+#                 end
+#
+#                 # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
+#                 def create_subscription_handler(config)
+#                     model_class = self
+#
+#                     lambda do |message|
+#                         begin
+#                             NatsWave.logger.debug "📨 Processing subscription message for #{model_class.name}"
+#
+#                             # 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_subscription_data(raw_data, config)
+#
+#                             # Always perform auto-sync first (if enabled)
+#                             if config[:auto_sync]
+#                                 NatsWave.logger.debug "📨 Performing auto-sync first"
+#                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
+#                             end
+#
+#                             # Then call custom handler if provided (optional)
+#                             if config[:custom_handler]
+#                                 NatsWave.logger.debug "📨 Calling custom subscription handler after auto-sync"
+#                                 config[:custom_handler].call(model_name, action, processed_data, message)
+#                             end
+#
+#                         rescue => e
+#                             NatsWave.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}"
+#                             NatsWave.logger.error e.backtrace.join("\n")
+#                             raise
+#                         end
+#                     end
+#                 end
 #             end
 #
 #             # Instance methods for publishing
@@ -1105,7 +780,7 @@
 #
 #                     # Check conditions (only for publishing)
 #                     if config[:conditions].any? && !evaluate_conditions(config[:conditions])
-#                         Rails.logger.debug "📤 Skipping publish - conditions not met" if defined?(Rails)
+#                         NatsWave.logger.debug "📤 Skipping publish - conditions not met"
 #                         next
 #                     end
 #
@@ -1128,17 +803,17 @@
 #                                 metadata: build_publishing_metadata
 #                         )
 #
-#                         Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
+#                         NatsWave.logger.info "📤 Published #{self.class.name} to #{subject}"
 #                     end
 #
 #                     # Then call custom handler if provided (optional)
 #                     if config[:custom_handler]
-#                         Rails.logger.debug "📤 Calling custom publishing handler after publishing" if defined?(Rails)
+#                         NatsWave.logger.debug "📤 Calling custom publishing handler after publishing"
 #                         config[:custom_handler].call(self.class.name, action, processed_data, self)
 #                     end
 #                 end
 #             rescue StandardError => e
-#                 Rails.logger.error("Failed to publish: #{e.message}") if defined?(Rails)
+#                 NatsWave.logger.error("Failed to publish: #{e.message}")
 #                 # Don't re-raise to avoid breaking transactions
 #             end
 #
@@ -1147,7 +822,7 @@
 #                 return if @nats_wave_publishing_in_progress
 #                 @nats_wave_publishing_in_progress = true
 #
-#                 Rails.logger.debug "🚀 Auto-publishing on create" if defined?(Rails)
+#                 NatsWave.logger.debug "🚀 Auto-publishing on create"
 #                 nats_wave_publish('create')
 #
 #                 @nats_wave_publishing_in_progress = false
@@ -1157,7 +832,7 @@
 #                 return if @nats_wave_publishing_in_progress
 #                 @nats_wave_publishing_in_progress = true
 #
-#                 Rails.logger.debug "🚀 Auto-publishing on update" if defined?(Rails)
+#                 NatsWave.logger.debug "🚀 Auto-publishing on update"
 #                 nats_wave_publish('update')
 #
 #                 @nats_wave_publishing_in_progress = false
@@ -1167,7 +842,7 @@
 #                 return if @nats_wave_publishing_in_progress
 #                 @nats_wave_publishing_in_progress = true
 #
-#                 Rails.logger.debug "🚀 Auto-publishing on destroy" if defined?(Rails)
+#                 NatsWave.logger.debug "🚀 Auto-publishing on destroy"
 #                 nats_wave_publish('destroy')
 #
 #                 @nats_wave_publishing_in_progress = false
@@ -1196,45 +871,49 @@
 #                 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]
+#                 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
+#                 # If only_mapped_fields is true, only process fields that have explicit mappings
+#                 if only_mapped_fields && field_mappings.any?
+#                     field_mappings.each do |local_field, external_field|
+#                         local_field_str = local_field.to_s
 #
-#                                         raw_data.select { |field, _| all_relevant_fields.include?(field.to_s) }
-#                                     else
-#                                         # Process all fields (existing behavior)
-#                                         raw_data
-#                                     end
+#                         # Skip if this field is in skip_fields
+#                         next if skip_fields.include?(local_field_str) || skip_fields.include?(local_field.to_sym)
 #
-#                 fields_to_process.each do |field, value|
-#                     field_str = field.to_s
-#                     field_sym = field.to_sym
+#                         # Get the value from raw_data
+#                         value = raw_data[local_field_str] || raw_data[local_field.to_sym]
 #
-#                     # Skip if in skip_fields
-#                     next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
+#                         # Apply transformation if any (use external field name for transformation lookup)
+#                         transformed_value = apply_publishing_transformation(value, external_field, transformations, raw_data)
 #
-#                     # Apply field mapping (local -> external)
-#                     mapped_field = field_mappings[field_str] ||
-#                             field_mappings[field_sym] ||
-#                             field
+#                         processed_data[external_field.to_s] = transformed_value
+#                     end
+#                 else
+#                     # Original behavior - process all fields
+#                     raw_data.each do |field, value|
+#                         field_str = field.to_s
+#                         field_sym = field.to_sym
 #
-#                     # Apply transformation if any
-#                     transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
+#                         # Skip if in skip_fields
+#                         next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
 #
-#                     processed_data[mapped_field.to_s] = transformed_value
-#                 end
+#                         # Apply field mapping (local -> external) - ONLY if mapping exists
+#                         mapped_field = field_mappings[field_str] ||
+#                                 field_mappings[field_sym] ||
+#                                 field  # Use original field name if no mapping
+#
+#                         # Apply transformation if any
+#                         transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
 #
+#                         processed_data[mapped_field.to_s] = transformed_value
+#                     end
+#                 end
 #                 processed_data
 #             end
 #
@@ -1254,7 +933,7 @@
 #                         elsif value.respond_to?(transformation)
 #                             value.send(transformation)
 #                         else
-#                             Rails.logger.warn "Publishing transformation method #{transformation} not found" if defined?(Rails)
+#                             NatsWave.logger.warn "Publishing transformation method #{transformation} not found"
 #                             value
 #                         end
 #                     else
@@ -1304,6 +983,7 @@
 #         end
 #     end
 # end
+
 # frozen_string_literal: true
 
 module NatsWave
@@ -1320,7 +1000,7 @@ module NatsWave
             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)
+                    NatsWave.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}"
                     
                     # Custom handler is now optional and runs AFTER default behavior
                     custom_handler = options[:handler] || block
@@ -1352,12 +1032,12 @@ module NatsWave
                             queue_group: subscription_config[:queue_group]
                     )
                     
-                    Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
+                    NatsWave.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}"
                 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)
+                    NatsWave.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}"
                     
                     # Custom handler is now optional and runs AFTER default behavior
                     custom_handler = options[:handler] || block
@@ -1371,7 +1051,8 @@ module NatsWave
                             actions: options[:actions] || [:create, :update, :destroy],
                             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
                     }
                     
                     # Store the config
@@ -1381,7 +1062,7 @@ module NatsWave
                     # 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)
+                    NatsWave.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}"
                 end
                 
                 # Get all subscription configurations
@@ -1394,58 +1075,6 @@ module NatsWave
                     nats_wave_publishing_config
                 end
                 
-                private
-                
-                # 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
-                    
-                    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
-                    
-                    @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
-                    
-                    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_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)
-                            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
-                            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 (PUBLIC CLASS METHOD)
                 def process_subscription_data(raw_data, config)
                     processed_data = {}
@@ -1491,7 +1120,7 @@ module NatsWave
                             elsif value.respond_to?(transformation)
                                 value.send(transformation)
                             else
-                                Rails.logger.warn "Transformation method #{transformation} not found" if defined?(Rails)
+                                NatsWave.logger.warn "Transformation method #{transformation} not found"
                                 value
                             end
                         else
@@ -1512,7 +1141,7 @@ module NatsWave
                         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)
+                            NatsWave.logger.warn "Unknown action for auto-sync: #{action}"
                     end
                 end
                 
@@ -1522,17 +1151,17 @@ module NatsWave
                             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)
+                                NatsWave.logger.info "✅ Updated existing #{self.name}: #{existing.id}"
                             else
                                 record = self.create!(data)
-                                Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+                                NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
                             end
                         when :create_only
                             record = self.create!(data)
-                            Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+                            NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
                     end
                 rescue => e
-                    Rails.logger.error "❌ Failed to create #{self.name}: #{e.message}" if defined?(Rails)
+                    NatsWave.logger.error "❌ Failed to create #{self.name}: #{e.message}"
                     raise
                 end
                 
@@ -1540,15 +1169,15 @@ module NatsWave
                     existing = find_by_unique_fields(data, unique_fields)
                     if existing
                         existing.update!(data)
-                        Rails.logger.info "✅ Updated #{self.name}: #{existing.id}" if defined?(Rails)
+                        NatsWave.logger.info "✅ Updated #{self.name}: #{existing.id}"
                     elsif sync_strategy == :upsert
                         record = self.create!(data)
-                        Rails.logger.info "✅ Created new #{self.name} during update: #{record.id}" if defined?(Rails)
+                        NatsWave.logger.info "✅ Created new #{self.name} during update: #{record.id}"
                     else
-                        Rails.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+                        NatsWave.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}"
                     end
                 rescue => e
-                    Rails.logger.error "❌ Failed to update #{self.name}: #{e.message}" if defined?(Rails)
+                    NatsWave.logger.error "❌ Failed to update #{self.name}: #{e.message}"
                     raise
                 end
                 
@@ -1556,12 +1185,12 @@ module NatsWave
                     existing = find_by_unique_fields(data, unique_fields)
                     if existing
                         existing.destroy!
-                        Rails.logger.info "✅ Deleted #{self.name}: #{existing.id}" if defined?(Rails)
+                        NatsWave.logger.info "✅ Deleted #{self.name}: #{existing.id}"
                     else
-                        Rails.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+                        NatsWave.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}"
                     end
                 rescue => e
-                    Rails.logger.error "❌ Failed to delete #{self.name}: #{e.message}" if defined?(Rails)
+                    NatsWave.logger.error "❌ Failed to delete #{self.name}: #{e.message}"
                     raise
                 end
                 
@@ -1579,6 +1208,58 @@ module NatsWave
                     return nil if conditions.empty?
                     self.find_by(conditions)
                 end
+                
+                private
+                
+                # 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
+                    
+                    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
+                    
+                    @nats_wave_callbacks_added = true
+                    NatsWave.logger.debug "📤 #{self.name}: Added publishing callbacks"
+                end
+                
+                # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
+                def create_subscription_handler(config)
+                    model_class = self
+                    
+                    lambda do |message|
+                        begin
+                            NatsWave.logger.debug "📨 Processing subscription message for #{model_class.name}"
+                            
+                            # 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_subscription_data(raw_data, config)
+                            
+                            # Always perform auto-sync first (if enabled)
+                            if config[:auto_sync]
+                                NatsWave.logger.debug "📨 Performing auto-sync first"
+                                model_class.perform_auto_sync(model_name, action, processed_data, config)
+                            end
+                            
+                            # Then call custom handler if provided (optional)
+                            if config[:custom_handler]
+                                NatsWave.logger.debug "📨 Calling custom subscription handler after auto-sync"
+                                config[:custom_handler].call(model_name, action, processed_data, message)
+                            end
+                        
+                        rescue => e
+                            NatsWave.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}"
+                            NatsWave.logger.error e.backtrace.join("\n")
+                            raise
+                        end
+                    end
+                end
             end
             
             # Instance methods for publishing
@@ -1591,7 +1272,7 @@ module NatsWave
                     
                     # Check conditions (only for publishing)
                     if config[:conditions].any? && !evaluate_conditions(config[:conditions])
-                        Rails.logger.debug "📤 Skipping publish - conditions not met" if defined?(Rails)
+                        NatsWave.logger.debug "📤 Skipping publish - conditions not met"
                         next
                     end
                     
@@ -1614,17 +1295,17 @@ module NatsWave
                                 metadata: build_publishing_metadata
                         )
                         
-                        Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
+                        NatsWave.logger.info "📤 Published #{self.class.name} to #{subject}"
                     end
                     
                     # Then call custom handler if provided (optional)
                     if config[:custom_handler]
-                        Rails.logger.debug "📤 Calling custom publishing handler after publishing" if defined?(Rails)
+                        NatsWave.logger.debug "📤 Calling custom publishing handler after publishing"
                         config[:custom_handler].call(self.class.name, action, processed_data, self)
                     end
                 end
             rescue StandardError => e
-                Rails.logger.error("Failed to publish: #{e.message}") if defined?(Rails)
+                NatsWave.logger.error("Failed to publish: #{e.message}")
                 # Don't re-raise to avoid breaking transactions
             end
             
@@ -1633,7 +1314,7 @@ module NatsWave
                 return if @nats_wave_publishing_in_progress
                 @nats_wave_publishing_in_progress = true
                 
-                Rails.logger.debug "🚀 Auto-publishing on create" if defined?(Rails)
+                NatsWave.logger.debug "🚀 Auto-publishing on create"
                 nats_wave_publish('create')
                 
                 @nats_wave_publishing_in_progress = false
@@ -1643,7 +1324,7 @@ module NatsWave
                 return if @nats_wave_publishing_in_progress
                 @nats_wave_publishing_in_progress = true
                 
-                Rails.logger.debug "🚀 Auto-publishing on update" if defined?(Rails)
+                NatsWave.logger.debug "🚀 Auto-publishing on update"
                 nats_wave_publish('update')
                 
                 @nats_wave_publishing_in_progress = false
@@ -1653,7 +1334,7 @@ module NatsWave
                 return if @nats_wave_publishing_in_progress
                 @nats_wave_publishing_in_progress = true
                 
-                Rails.logger.debug "🚀 Auto-publishing on destroy" if defined?(Rails)
+                NatsWave.logger.debug "🚀 Auto-publishing on destroy"
                 nats_wave_publish('destroy')
                 
                 @nats_wave_publishing_in_progress = false
@@ -1682,31 +1363,49 @@ module NatsWave
                 end
             end
             
-            # Process publishing data - much simpler now! (INSTANCE METHOD)
             def process_publishing_data(raw_data, config)
                 processed_data = {}
-                field_mappings = config[:field_mappings]
-                transformations = config[:transformations]
-                skip_fields = config[:skip_fields]
+                field_mappings = config[:field_mappings] || {}
+                transformations = config[:transformations] || {}
+                skip_fields = config[:skip_fields] || []
+                only_mapped_fields = config[:only_mapped_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) - ONLY if mapping exists
-                    mapped_field = field_mappings[field_str] ||
-                            field_mappings[field_sym] ||
-                            field  # Use original field name if no mapping
-                    
-                    # Apply transformation if any
-                    transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
-                    
-                    processed_data[mapped_field.to_s] = transformed_value
+                # If only_mapped_fields is true, only process fields that have explicit mappings
+                if only_mapped_fields && field_mappings.any?
+                    field_mappings.each do |local_field, external_field|
+                        local_field_str = local_field.to_s
+                        
+                        # Skip if this field is in skip_fields
+                        next if skip_fields.include?(local_field_str) || skip_fields.include?(local_field.to_sym)
+                        
+                        # Get the value from raw_data
+                        value = raw_data[local_field_str] || raw_data[local_field.to_sym]
+                        
+                        # Apply transformation if any (use external field name for transformation lookup)
+                        transformed_value = apply_publishing_transformation(value, external_field, transformations, raw_data)
+                        
+                        processed_data[external_field.to_s] = transformed_value
+                    end
+                else
+                    # Original behavior - process all 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) - ONLY if mapping exists
+                        mapped_field = field_mappings[field_str] ||
+                                field_mappings[field_sym] ||
+                                field  # Use original field name if no mapping
+                        
+                        # Apply transformation if any
+                        transformed_value = apply_publishing_transformation(value, mapped_field, transformations, raw_data)
+                        
+                        processed_data[mapped_field.to_s] = transformed_value
+                    end
                 end
-                
                 processed_data
             end
             
@@ -1726,7 +1425,7 @@ module NatsWave
                         elsif value.respond_to?(transformation)
                             value.send(transformation)
                         else
-                            Rails.logger.warn "Publishing transformation method #{transformation} not found" if defined?(Rails)
+                            NatsWave.logger.warn "Publishing transformation method #{transformation} not found"
                             value
                         end
                     else