nats_wave 1.1.13 → 1.1.14

data/lib/nats_wave/concerns/mappable.rb

@@ -1,1309 +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
-# #     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
-#     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)
-#
-#                     # Custom handler is now optional and runs AFTER default behavior
-#                     custom_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,
-#                             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
-#                     }
-#
-#                     # 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)
-#
-#                     # Custom handler is now optional and runs AFTER default behavior
-#                     custom_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],
-#                             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
-#                     }
-#
-#                     # 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
-#
-#                 # 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
-#
-#                 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 = 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)
-#                 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)
-#
-#                     # 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
-#                 Rails.logger.error("Failed to publish: #{e.message}") if defined?(Rails)
-#                 # 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
-#                 # 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]
-#                 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
-#                         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
@@ -1320,7 +14,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 +46,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 +65,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 +76,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
@@ -1407,7 +102,7 @@ module NatsWave
                     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)
+                    NatsWave.logger.debug "📤 #{self.name}: Added publishing callbacks"
                 end
                 
                 # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
@@ -1416,7 +111,7 @@ module NatsWave
                     
                     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'] || {}
@@ -1428,19 +123,19 @@ module NatsWave
                             
                             # Always perform auto-sync first (if enabled)
                             if config[:auto_sync]
-                                Rails.logger.debug "📨 Performing auto-sync first" if defined?(Rails)
+                                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]
-                                Rails.logger.debug "📨 Calling custom subscription handler after auto-sync" if defined?(Rails)
+                                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
@@ -1491,7 +186,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 +207,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 +217,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 +235,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 +251,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
                 
@@ -1591,7 +286,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 +309,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 +328,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 +338,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 +348,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 +377,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 +439,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