nats_wave 1.1.19 → 1.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b52406b98b5156e9768ed65c62a10231ad0ab91a18ff73d61204e4ff5cb6749b
-  data.tar.gz: 6d4e71c9e9c91ed92644a61f9a2a1ca3ef1a92f7f7de193c86c58a34d3cfb445
+  metadata.gz: 56f43d30e884588fb8db2ecbf73b1c7e39aa7d63fbfbec563c156f6f13f9ee0c
+  data.tar.gz: c07acd7e6f1e7acc05a72d13eee5640c7fa5cdda91adc135fe81f4eb51262ae3
 SHA512:
-  metadata.gz: 2b72a3a616956bf8175c19f7fea105ef5f7f2684fddcc17027a256c05331af7f02fd858e502079b40da46964bd6d4b665b6c3ffd628320b43d695fbd194135ad
-  data.tar.gz: d3ea18ccf932f8800a2a061244c4a4012a256f4505b4426f951544d03c4d4b1bd03344a1d6b0190df144e3d912a333dddea72152faf59544e017cf22f71339c9
+  metadata.gz: 07dbf0eec97fbed551525feb102d4c101f7cfc6dd2f608ccb635e8a0b9248d64b8b66d610df63ae3f9b6a6d2cb9e66c2293485522230f5653ab9e0ae212b2451
+  data.tar.gz: 855b54e2f045c8d0c12dbad5bb0a553a44e9ef8d0c7b6ba33997c25f25997bee9a397276a61ea8ca510f0500c5138048c233fc65169a6133d90133e8925636d2

data/Gemfile.lock

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

data/README.md

@@ -174,7 +174,7 @@ rails console
 # This automatically publishes via nats_wave_publishes_to
 ```
 
-## ⚙️   Configuration
+## ⚙️  Configuration
 
 ### Environment Variables
 

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.19'
+                        version: ENV['APP_VERSION'] || '1.1.20'
                 }
             end
             

data/lib/nats_wave/concerns/mappable.rb

@@ -1,989 +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)
-# #                     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
-# #
-# #                     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]
-# #                     )
-# #
-# #                     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)
-# #                     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
-# #
-# #                     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
-# #                     }
-# #
-# #                     # 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
-# #
-# #                     NatsWave.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}"
-# #                 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
-# #                     NatsWave.logger.debug "📤 #{self.name}: Added publishing callbacks"
-# #                 end
-# #
-# #                 # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
-# #                 def create_subscription_handler(config)
-# #                     model_class = self
-# #
-# #                     lambda do |message|
-# #                         begin
-# #                             NatsWave.logger.debug "📨 Processing subscription message for #{model_class.name}"
-# #
-# #                             # Extract the raw data
-# #                             raw_data = message['data'] || {}
-# #                             model_name = message['model']
-# #                             action = message['action']
-# #
-# #                             # Process the data through mappings and transformations
-# #                             processed_data = model_class.process_subscription_data(raw_data, config)
-# #
-# #                             # Always perform auto-sync first (if enabled)
-# #                             if config[:auto_sync]
-# #                                 NatsWave.logger.debug "📨 Performing auto-sync first"
-# #                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
-# #                             end
-# #
-# #                             # Then call custom handler if provided (optional)
-# #                             if config[:custom_handler]
-# #                                 NatsWave.logger.debug "📨 Calling custom subscription handler after auto-sync"
-# #                                 config[:custom_handler].call(model_name, action, processed_data, message)
-# #                             end
-# #
-# #                         rescue => e
-# #                             NatsWave.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}"
-# #                             NatsWave.logger.error e.backtrace.join("\n")
-# #                             raise
-# #                         end
-# #                     end
-# #                 end
-# #
-# #                 # Process subscription data through field mappings and transformations (PUBLIC CLASS METHOD)
-# #                 def process_subscription_data(raw_data, config)
-# #                     processed_data = {}
-# #                     field_mappings = config[:field_mappings]
-# #                     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 (external -> local)
-# #                         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 (PUBLIC 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
-# #                                 NatsWave.logger.warn "Transformation method #{transformation} not found"
-# #                                 value
-# #                             end
-# #                         else
-# #                             value
-# #                     end
-# #                 end
-# #
-# #                 # Default auto-sync behavior (PUBLIC CLASS METHOD)
-# #                 def perform_auto_sync(model_name, action, processed_data, config)
-# #                     unique_fields = config[:unique_fields]
-# #                     sync_strategy = config[:sync_strategy]
-# #
-# #                     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
-# #                             NatsWave.logger.warn "Unknown action for auto-sync: #{action}"
-# #                     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)
-# #                                 NatsWave.logger.info "✅ Updated existing #{self.name}: #{existing.id}"
-# #                             else
-# #                                 record = self.create!(data)
-# #                                 NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
-# #                             end
-# #                         when :create_only
-# #                             record = self.create!(data)
-# #                             NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
-# #                     end
-# #                 rescue => e
-# #                     NatsWave.logger.error "❌ Failed to create #{self.name}: #{e.message}"
-# #                     raise
-# #                 end
-# #
-# #                 def handle_auto_update(data, unique_fields, sync_strategy)
-# #                     existing = find_by_unique_fields(data, unique_fields)
-# #                     if existing
-# #                         existing.update!(data)
-# #                         NatsWave.logger.info "✅ Updated #{self.name}: #{existing.id}"
-# #                     elsif sync_strategy == :upsert
-# #                         record = self.create!(data)
-# #                         NatsWave.logger.info "✅ Created new #{self.name} during update: #{record.id}"
-# #                     else
-# #                         NatsWave.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}"
-# #                     end
-# #                 rescue => e
-# #                     NatsWave.logger.error "❌ Failed to update #{self.name}: #{e.message}"
-# #                     raise
-# #                 end
-# #
-# #                 def handle_auto_delete(data, unique_fields)
-# #                     existing = find_by_unique_fields(data, unique_fields)
-# #                     if existing
-# #                         existing.destroy!
-# #                         NatsWave.logger.info "✅ Deleted #{self.name}: #{existing.id}"
-# #                     else
-# #                         NatsWave.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}"
-# #                     end
-# #                 rescue => e
-# #                     NatsWave.logger.error "❌ Failed to delete #{self.name}: #{e.message}"
-# #                     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])
-# #                         NatsWave.logger.debug "📤 Skipping publish - conditions not met"
-# #                         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
-# #                         )
-# #
-# #                         NatsWave.logger.info "📤 Published #{self.class.name} to #{subject}"
-# #                     end
-# #
-# #                     # Then call custom handler if provided (optional)
-# #                     if config[:custom_handler]
-# #                         NatsWave.logger.debug "📤 Calling custom publishing handler after publishing"
-# #                         config[:custom_handler].call(self.class.name, action, processed_data, self)
-# #                     end
-# #                 end
-# #             rescue StandardError => e
-# #                 NatsWave.logger.error("Failed to publish: #{e.message}")
-# #                 # 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
-# #
-# #                 NatsWave.logger.debug "🚀 Auto-publishing on create"
-# #                 nats_wave_publish('create')
-# #
-# #                 @nats_wave_publishing_in_progress = false
-# #             end
-# #
-# #             def trigger_nats_wave_auto_publish_on_update
-# #                 return if @nats_wave_publishing_in_progress
-# #                 @nats_wave_publishing_in_progress = true
-# #
-# #                 NatsWave.logger.debug "🚀 Auto-publishing on update"
-# #                 nats_wave_publish('update')
-# #
-# #                 @nats_wave_publishing_in_progress = false
-# #             end
-# #
-# #             def trigger_nats_wave_auto_publish_on_destroy
-# #                 return if @nats_wave_publishing_in_progress
-# #                 @nats_wave_publishing_in_progress = true
-# #
-# #                 NatsWave.logger.debug "🚀 Auto-publishing on destroy"
-# #                 nats_wave_publish('destroy')
-# #
-# #                 @nats_wave_publishing_in_progress = false
-# #             end
-# #
-# #             private
-# #
-# #             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 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 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
-# #
-# #             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
-# #                             NatsWave.logger.warn "Publishing transformation method #{transformation} not found"
-# #                             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
-#     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)
-#                     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
-#
-#                     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]
-#                     )
-#
-#                     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)
-#                     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
-#
-#                     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] # Changed: don't 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 (only once per model)
-#                     setup_publishing_callbacks_once
-#
-#                     NatsWave.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}"
-#                 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
-#
-#                 # PUBLIC METHODS - These need to be accessible from lambda context
-#
-#                 # Process subscription data through field mappings and transformations
-#                 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 (external -> local)
-#                         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
-#                                 NatsWave.logger.warn "Transformation method #{transformation} not found"
-#                                 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
-#                             NatsWave.logger.warn "Unknown action for auto-sync: #{action}"
-#                     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)
-#                                 NatsWave.logger.info "✅ Updated existing #{self.name}: #{existing.id}"
-#                             else
-#                                 record = self.create!(data)
-#                                 NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
-#                             end
-#                         when :create_only
-#                             record = self.create!(data)
-#                             NatsWave.logger.info "✅ Created new #{self.name}: #{record.id}"
-#                     end
-#                 rescue => e
-#                     NatsWave.logger.error "❌ Failed to create #{self.name}: #{e.message}"
-#                     raise
-#                 end
-#
-#                 def handle_auto_update(data, unique_fields, sync_strategy)
-#                     existing = find_by_unique_fields(data, unique_fields)
-#                     if existing
-#                         existing.update!(data)
-#                         NatsWave.logger.info "✅ Updated #{self.name}: #{existing.id}"
-#                     elsif sync_strategy == :upsert
-#                         record = self.create!(data)
-#                         NatsWave.logger.info "✅ Created new #{self.name} during update: #{record.id}"
-#                     else
-#                         NatsWave.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}"
-#                     end
-#                 rescue => e
-#                     NatsWave.logger.error "❌ Failed to update #{self.name}: #{e.message}"
-#                     raise
-#                 end
-#
-#                 def handle_auto_delete(data, unique_fields)
-#                     existing = find_by_unique_fields(data, unique_fields)
-#                     if existing
-#                         existing.destroy!
-#                         NatsWave.logger.info "✅ Deleted #{self.name}: #{existing.id}"
-#                     else
-#                         NatsWave.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}"
-#                     end
-#                 rescue => e
-#                     NatsWave.logger.error "❌ Failed to delete #{self.name}: #{e.message}"
-#                     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
-#
-#                 private
-#
-#                 # Setup ActiveRecord callbacks for auto-publishing (only once per model)
-#                 def setup_publishing_callbacks_once
-#                     # Only add callbacks if we're in ActiveRecord and haven't added them yet
-#                     return unless defined?(ActiveRecord::Base) && self < ActiveRecord::Base
-#                     return if @nats_wave_callbacks_added
-#
-#                     after_commit :trigger_nats_wave_auto_publish_on_create, on: :create
-#                     after_commit :trigger_nats_wave_auto_publish_on_update, on: :update
-#                     after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
-#
-#                     @nats_wave_callbacks_added = true
-#                     NatsWave.logger.debug "📤 #{self.name}: Added publishing callbacks"
-#                 end
-#
-#                 # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
-#                 def create_subscription_handler(config)
-#                     model_class = self
-#
-#                     lambda do |message|
-#                         begin
-#                             NatsWave.logger.debug "📨 Processing subscription message for #{model_class.name}"
-#
-#                             # Extract the raw data
-#                             raw_data = message['data'] || {}
-#                             model_name = message['model']
-#                             action = message['action']
-#
-#                             # Process the data through mappings and transformations
-#                             processed_data = model_class.process_subscription_data(raw_data, config)
-#
-#                             # Always perform auto-sync first (if enabled)
-#                             if config[:auto_sync]
-#                                 NatsWave.logger.debug "📨 Performing auto-sync first"
-#                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
-#                             end
-#
-#                             # Then call custom handler if provided (optional)
-#                             if config[:custom_handler]
-#                                 NatsWave.logger.debug "📨 Calling custom subscription handler after auto-sync"
-#                                 config[:custom_handler].call(model_name, action, processed_data, message)
-#                             end
-#
-#                         rescue => e
-#                             NatsWave.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}"
-#                             NatsWave.logger.error e.backtrace.join("\n")
-#                             raise
-#                         end
-#                     end
-#                 end
-#             end
-#
-#             # Instance methods for publishing
-#             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])
-#                         NatsWave.logger.debug "📤 Skipping publish - conditions not met"
-#                         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
-#                         )
-#
-#                         NatsWave.logger.info "📤 Published #{self.class.name} to #{subject}"
-#                     end
-#
-#                     # Then call custom handler if provided (optional)
-#                     if config[:custom_handler]
-#                         NatsWave.logger.debug "📤 Calling custom publishing handler after publishing"
-#                         config[:custom_handler].call(self.class.name, action, processed_data, self)
-#                     end
-#                 end
-#             rescue StandardError => e
-#                 NatsWave.logger.error("Failed to publish: #{e.message}")
-#                 # 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
-#
-#                 NatsWave.logger.debug "🚀 Auto-publishing on create"
-#                 nats_wave_publish('create')
-#
-#                 @nats_wave_publishing_in_progress = false
-#             end
-#
-#             def trigger_nats_wave_auto_publish_on_update
-#                 return if @nats_wave_publishing_in_progress
-#                 @nats_wave_publishing_in_progress = true
-#
-#                 NatsWave.logger.debug "🚀 Auto-publishing on update"
-#                 nats_wave_publish('update')
-#
-#                 @nats_wave_publishing_in_progress = false
-#             end
-#
-#             def trigger_nats_wave_auto_publish_on_destroy
-#                 return if @nats_wave_publishing_in_progress
-#                 @nats_wave_publishing_in_progress = true
-#
-#                 NatsWave.logger.debug "🚀 Auto-publishing on destroy"
-#                 nats_wave_publish('destroy')
-#
-#                 @nats_wave_publishing_in_progress = false
-#             end
-#
-#             private
-#
-#             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 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 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
-#
-#             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
-#                             NatsWave.logger.warn "Publishing transformation method #{transformation} not found"
-#                             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
@@ -1038,7 +52,7 @@ module NatsWave
                 
                 # Configure publishing with optional custom handler AND auto-publishing callbacks
                 def nats_wave_publishes_to(*subjects, **options, &block)
-                    NatsWave.logger.debug "⚙️  #{self.name}: Setting up publishing to subjects: #{subjects.inspect}"
+                    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
@@ -1063,7 +77,7 @@ module NatsWave
                     # Add ActiveRecord callbacks for auto-publishing (only once per model)
                     setup_publishing_callbacks_once
                     
-                    NatsWave.logger.debug "⚙️  #{self.name}: Registered publishing config for subjects: #{subjects}"
+                    NatsWave.logger.debug "⚙️ #{self.name}: Registered publishing config for subjects: #{subjects}"
                 end
                 
                 # Get all subscription configurations
@@ -1085,7 +99,7 @@ module NatsWave
                     
                     # If only_mapped_fields is true, only process fields that have explicit mappings
                     if only_mapped_fields && field_mappings.any?
-                        NatsWave.logger.debug "⚙️  Only processing mapped fields: #{field_mappings.keys}"
+                        NatsWave.logger.debug "⚙️ Only processing mapped fields: #{field_mappings.keys}"
                         
                         field_mappings.each do |external_field, local_field|
                             external_field_str = external_field.to_s
@@ -1241,7 +255,7 @@ module NatsWave
                     after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
                     
                     @nats_wave_callbacks_added = true
-                    NatsWave.logger.debug "⚙️  #{self.name}: Added publishing callbacks"
+                    NatsWave.logger.debug "⚙️ #{self.name}: Added publishing callbacks"
                 end
                 
                 # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
@@ -1250,7 +264,7 @@ module NatsWave
                     
                     lambda do |message|
                         begin
-                            NatsWave.logger.debug "⚙️  Processing subscription message for #{model_class.name}"
+                            NatsWave.logger.debug "⚙️ Processing subscription message for #{model_class.name}"
                             
                             # Extract the raw data
                             raw_data = message['data'] || {}
@@ -1264,12 +278,12 @@ module NatsWave
                                 action = subject_parts.last if subject_parts.any?
                             end
                             
-                            NatsWave.logger.debug "✅  Extracted action: '#{action}' from message"
+                            NatsWave.logger.debug "✅ Extracted action: '#{action}' from message"
                             
                             # Handle nested data structure
                             if raw_data['data'].is_a?(Hash)
                                 raw_data = raw_data['data']
-                                NatsWave.logger.debug "⚙️  Using nested data structure"
+                                NatsWave.logger.debug "⚙️ Using nested data structure"
                             end
                             
                             # Process the data through mappings and transformations
@@ -1277,13 +291,13 @@ module NatsWave
                             
                             # Always perform auto-sync first (if enabled)
                             if config[:auto_sync]
-                                NatsWave.logger.debug "⚙️  Performing auto-sync first"
+                                NatsWave.logger.debug "⚙️ Performing auto-sync first with  #{processed_data}"
                                 model_class.perform_auto_sync(model_name, action, processed_data, config)
                             end
                             
                             # Then call custom handler if provided (optional)
                             if config[:custom_handler]
-                                NatsWave.logger.debug "⚙️  Calling custom subscription handler after auto-sync"
+                                NatsWave.logger.debug "⚙️ Calling custom subscription handler after auto-sync"
                                 config[:custom_handler].call(model_name, action, processed_data, message)
                             end
                         
@@ -1306,7 +320,7 @@ module NatsWave
                     
                     # Check conditions (only for publishing)
                     if config[:conditions].any? && !evaluate_conditions(config[:conditions])
-                        NatsWave.logger.debug "⚙️  Skipping publish - conditions not met"
+                        NatsWave.logger.debug "⚙️ Skipping publish - conditions not met"
                         next
                     end
                     
@@ -1334,7 +348,7 @@ module NatsWave
                     
                     # Then call custom handler if provided (optional)
                     if config[:custom_handler]
-                        NatsWave.logger.debug "⚙️  Calling custom publishing handler after publishing"
+                        NatsWave.logger.debug "⚙️ Calling custom publishing handler after publishing"
                         config[:custom_handler].call(self.class.name, action, processed_data, self)
                     end
                 end

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.19"
+            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.20"
             @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.19'
+    VERSION = '1.1.20'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats_wave
 version: !ruby/object:Gem::Version
-  version: 1.1.19
+  version: 1.1.20
 platform: ruby
 authors:
 - Jeffrey Dabo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-28 00:00:00.000000000 Z
+date: 2025-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nats-pure