nats_wave 1.1.10 → 1.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f2a585b3596818bf6c2af016223d821cdbd3560a9fb6442b5ce42f6553d7f8b
-  data.tar.gz: 18d69e19889c450d47c30930cf7cf7f0e42a27855380c2cfa94f2d2765d2937a
+  metadata.gz: b32810b1ec7cd1601ddb675015fb161fce6d6bb5749dd19c40b0b928a94d0f5c
+  data.tar.gz: 4820121ee244b4192c372f0baa5abc2533f0b676b5066e48892ebcd305571b23
 SHA512:
-  metadata.gz: 77dc3cbedd4d2415d2963d29ccad155e50ed1f93ee5ca7b984f6455217a27e24b0104422e2bd36f65cb498fea0576d4624f135042efecb4d75d5b9d49173e711
-  data.tar.gz: e23ae34f7c8bab0ce7c1bc5483734a9d034f979ad7043c2d5112a638c6d80b94a31ec6ab4d1ee702d73997bbc675f69028c83ec8c4f36e35d9848f0fea2c3510
+  metadata.gz: bd66a5824fb58bc9abc27ce9f86aaa6ebd9ec95eb012c146ea2016b2a167c52ff1fbc596aa353167c4d66851aee352e9c534fe46259d9b4efdfd4fca01b9ddd2
+  data.tar.gz: a7413067598f7e155f38bc1a7ebadef0b24ba9bb2e3f3f146fbb9c34ef9bf6b99d4102a62698bdb6bc6042e8d861e86b9927659e432c35a8f996af100b6e02f8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nats_wave (1.1.10)
+    nats_wave (1.1.11)
       activerecord (>= 6.1, < 8.0)
       activesupport (>= 6.1, < 8.0)
       concurrent-ruby (~> 1.1)

data/lib/nats_wave/adapters/datadog_metrics.rb

@@ -77,7 +77,7 @@ module NatsWave
                 {
                         service: @service_name,
                         environment: ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'unknown',
-                        version: ENV['APP_VERSION'] || '1.1.10'
+                        version: ENV['APP_VERSION'] || '1.1.11'
                 }
             end
             

data/lib/nats_wave/concerns/mappable.rb

@@ -6,173 +6,358 @@
 #             extend ActiveSupport::Concern
 #
 #             included do
-#                 class_attribute :nats_wave_mapping_config, :nats_wave_subscription_config
-#                 self.nats_wave_mapping_config = {}
+#                 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 how this model maps to external models
-#                 def nats_wave_maps_to(external_models)
-#                     self.nats_wave_mapping_config = external_models
-#
-#                     # Register this mapping globally
-#                     NatsWave::ModelRegistry.register_mapping(self.name, external_models)
-#                 end
+#                 # 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)
 #
-#                 # Configure how external models map to this model AND what subjects to subscribe to
-#                 def nats_wave_maps_from(external_model, options = {})
-#                     Rails.logger.debug "🔄 #{self.name}: Setting up mapping from #{external_model} with options: #{options.inspect}" if defined?(Rails)
+#                     handler = options[:handler] || block
 #
-#                     mapping = {
+#                     subscription_config = {
+#                             subjects: subjects.flatten,
 #                             field_mappings: options[:field_mappings] || {},
 #                             transformations: options[:transformations] || {},
-#                             conditions: options[:conditions] || {},
-#                             sync_strategy: options[:sync_strategy] || :upsert,
-#                             unique_fields: options[:unique_fields] || [:id],
 #                             skip_fields: options[:skip_fields] || [],
-#                             subjects: options[:subjects] || [],
-#                             handler: options[:handler],
-#                             queue_group: options[:queue_group]
+#                             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
 #                     }
 #
-#                     self.nats_wave_mapping_config[external_model] = mapping
-#
-#                     Rails.logger.debug "🔄 #{self.name}: Registering reverse mapping for #{external_model}" if defined?(Rails)
-#                     NatsWave::ModelRegistry.register_reverse_mapping(external_model, self.name, mapping)
-#
-#                     # Register subscription if subjects are provided
-#                     if mapping[:subjects].any?
-#                         Rails.logger.debug "🔄 #{self.name}: Registering subscription for subjects: #{mapping[:subjects]}" if defined?(Rails)
-#                         NatsWave::ModelRegistry.register_subscription(
-#                                 subjects: mapping[:subjects],
-#                                 model: self.name,
-#                                 external_model: external_model,
-#                                 handler: mapping[:handler],
-#                                 queue_group: mapping[:queue_group]
-#                         )
-#                     else
-#                         Rails.logger.debug "🔄 #{self.name}: No subjects provided, skipping subscription registration" if defined?(Rails)
-#                     end
+#                     # 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 subscriptions without model mapping (for custom handlers)
-#                 def nats_wave_subscribes_to(*subjects, handler: nil, queue_group: nil, &block)
-#                     handler ||= block
+#                 # 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)
 #
-#                     Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
+#                     handler = options[:handler] || block
 #
-#                     subscription_config = {
+#                     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,
-#                             queue_group: queue_group,
-#                             model: self.name
+#                             async: options[:async] != false, # Default to true
+#                             enabled: options[:enabled] != false # Default to true
 #                     }
 #
-#                     self.nats_wave_subscription_config[:custom] = subscription_config
+#                     # Store the config
+#                     config_key = subjects.join(',')
+#                     self.nats_wave_publishing_config[config_key] = publishing_config
 #
-#                     Rails.logger.debug "📡 #{self.name}: Registering subscription in ModelRegistry" if defined?(Rails)
-#                     NatsWave::ModelRegistry.register_subscription(
-#                             subjects: subjects.flatten,
-#                             model: self.name,
-#                             handler: handler,
-#                             queue_group: queue_group
-#                     )
+#                     Rails.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}" if defined?(Rails)
 #                 end
 #
-#                 # Auto-generate subjects based on external model pattern
-#                 def nats_wave_auto_subjects_for(external_model, service_prefix: nil, actions: [:create, :update, :destroy])
-#                     model_name = external_model.underscore
+#                 # Get all subscription configurations
+#                 def nats_wave_subscription_configs
+#                     nats_wave_subscription_config
+#                 end
 #
-#                     if service_prefix
-#                         subjects = actions.map { |action| "#{service_prefix}.#{model_name}.#{action}" }
-#                         subjects << "#{service_prefix}.#{model_name}.*" # Wildcard for all actions
-#                     else
-#                         # Try to infer from common patterns
-#                         subjects = [
-#                                 "#{model_name}.*", # Simple pattern
-#                                 "events.#{model_name}.*", # Events pattern
-#                                 "*.#{model_name}.*", # Service.model pattern
-#                                 "*.events.#{model_name}.*" # Service.events.model pattern
-#                         ]
+#                 # 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
 #
-#                     subjects
+#                     processed_data
 #                 end
 #
-#                 # Get mapping configuration for an external model
-#                 def nats_wave_mapping_for(external_model)
-#                     nats_wave_mapping_config[external_model]
+#                 # 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
 #
-#                 # Check if this model can sync from an external model
-#                 def nats_wave_can_sync_from?(external_model)
-#                     nats_wave_mapping_config.key?(external_model)
+#                 # 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
 #
-#                 # Get all external models this model can sync from
-#                 def nats_wave_external_models
-#                     nats_wave_mapping_config.keys
+#                 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
 #
-#                 # Get all subjects this model subscribes to
-#                 def nats_wave_subscribed_subjects
-#                     subjects = []
+#                 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
 #
-#                     # From model mappings
-#                     nats_wave_mapping_config.each do |_, config|
-#                         subjects.concat(config[:subjects] || [])
+#                 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
 #
-#                     # From custom subscriptions
-#                     if nats_wave_subscription_config[:custom]
-#                         subjects.concat(nats_wave_subscription_config[:custom][:subjects] || [])
+#                 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
 #
-#                     subjects.uniq
+#                     return nil if conditions.empty?
+#                     self.find_by(conditions)
 #                 end
 #             end
 #
-#             # Instance methods remain the same...
-#             def nats_wave_mapped_attributes_for(target_model)
-#                 mapping = self.class.nats_wave_mapping_config[target_model]
-#                 return attributes unless mapping
-#
-#                 mapped_attrs = {}
-#                 field_mappings = mapping[:field_mappings] || {}
-#                 skip_fields = mapping[:skip_fields] || []
+#             # Instance methods for publishing
+#             def nats_wave_publish(action = nil)
+#                 action ||= determine_action_from_context
 #
-#                 attributes.each do |key, value|
-#                     next if skip_fields.include?(key.to_s) || skip_fields.include?(key.to_sym)
+#                 self.class.nats_wave_publishing_configs.each do |subjects_key, config|
+#                     next unless config[:enabled]
+#                     next unless config[:actions].include?(action.to_sym)
 #
-#                     mapped_key = field_mappings[key] || field_mappings[key.to_sym] || key
-#                     mapped_attrs[mapped_key] = transform_value(value, mapped_key, mapping[:transformations] || {})
-#                 end
+#                     # 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
 #
-#                 mapped_attrs
-#             end
+#                     # Get the raw data (current model attributes)
+#                     raw_data = get_raw_attributes
 #
-#             def nats_wave_unique_identifier_for(external_model)
-#                 mapping = self.class.nats_wave_mapping_config[external_model]
-#                 unique_fields = mapping&.dig(:unique_fields) || [:id]
+#                     # Process the data through mappings and transformations (same as subscription)
+#                     processed_data = self.class.process_data(raw_data, config)
 #
-#                 unique_fields.map { |field| [field, send(field)] }.to_h
+#                     # 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 transform_value(value, field, transformations)
-#                 transformation = transformations[field] || transformations[field.to_sym]
+#             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
 #
-#                 case transformation
-#                     when Proc
-#                         transformation.call(value)
-#                     when Symbol
-#                         send(transformation, value) if respond_to?(transformation, true)
-#                     else
-#                         value
+#                 '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
@@ -227,7 +412,7 @@ module NatsWave
                     Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
                 end
                 
-                # Configure publishing with optional custom handler
+                # Configure publishing with optional custom handler AND auto-publishing callbacks
                 def nats_wave_publishes_to(*subjects, **options, &block)
                     Rails.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}" if defined?(Rails)
                     
@@ -249,6 +434,9 @@ module NatsWave
                     config_key = subjects.join(',')
                     self.nats_wave_publishing_config[config_key] = publishing_config
                     
+                    # Add ActiveRecord callbacks for auto-publishing
+                    setup_publishing_callbacks(publishing_config)
+                    
                     Rails.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}" if defined?(Rails)
                 end
                 
@@ -274,6 +462,26 @@ module NatsWave
                 
                 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
@@ -288,7 +496,7 @@ module NatsWave
                             action = message['action']
                             
                             # Process the data through mappings and transformations
-                            processed_data = model_class.process_data(raw_data, config)
+                            processed_data = process_subscription_data(raw_data, config)
                             
                             # If custom handler is provided, call it with model_name, action, processed_data
                             if config[:handler]
@@ -310,8 +518,8 @@ module NatsWave
                     end
                 end
                 
-                # Process data through field mappings and transformations (used by both subscription and publishing)
-                def process_data(raw_data, config)
+                # Process subscription data through field mappings and transformations (CLASS METHOD)
+                def process_subscription_data(raw_data, config)
                     processed_data = {}
                     field_mappings = config[:field_mappings]
                     transformations = config[:transformations]
@@ -338,7 +546,7 @@ module NatsWave
                     processed_data
                 end
                 
-                # Apply transformations to field values
+                # Apply transformations to field values (CLASS METHOD)
                 def apply_transformation(value, field, transformations, full_record)
                     transformation = transformations[field] || transformations[field.to_sym]
                     
@@ -363,7 +571,7 @@ module NatsWave
                     end
                 end
                 
-                # Default auto-sync behavior
+                # Default auto-sync behavior (CLASS METHOD)
                 def perform_auto_sync(model_name, action, processed_data, config)
                     unique_fields = config[:unique_fields]
                     sync_strategy = config[:sync_strategy]
@@ -462,8 +670,8 @@ module NatsWave
                     # Get the raw data (current model attributes)
                     raw_data = get_raw_attributes
                     
-                    # Process the data through mappings and transformations (same as subscription)
-                    processed_data = self.class.process_data(raw_data, config)
+                    # Process the data through mappings and transformations
+                    processed_data = process_publishing_data(raw_data, config)
                     
                     # If custom handler is provided, call it
                     if config[:handler]
@@ -489,6 +697,22 @@ module NatsWave
                 # 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
@@ -512,6 +736,58 @@ module NatsWave
                 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

data/lib/nats_wave/configuration.rb

@@ -18,7 +18,7 @@ module NatsWave
         def initialize(options = {})
             @nats_url = ENV['NATS_URL'] || "nats://localhost:4222"
             @service_name = ENV['NATS_SERVICE_NAME'] || "purplewave"
-            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.10"
+            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.11"
             @instance_id = ENV['NATS_INSTANCE_ID'] || Socket.gethostname
             @database_url = ENV['NATS_DATABASE_URL'] || nil
             @connection_pool_size = (ENV['NATS_CONNECTION_POOL_SIZE'] || 10).to_i

data/lib/nats_wave/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NatsWave
-    VERSION = '1.1.10'
+    VERSION = '1.1.11'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nats_wave
 version: !ruby/object:Gem::Version
-  version: 1.1.10
+  version: 1.1.11
 platform: ruby
 authors:
 - Jeffrey Dabo