nats_wave 1.1.14 → 1.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7355520886942caba83b3eb8b9bc59e086639036d403b72011f153e2eb626020
-  data.tar.gz: 7c1fe995248ee6c591efecb6725d25c562d6b4b61e897a319383c284e11dd919
+  metadata.gz: 70b9abe2ec70949d2ffd0b97d0d2e33688590d8d4bc5c01baa2a555cb0b355e4
+  data.tar.gz: cbef4f7b640670744b71626606a0ad62de313012bfb524e7e406594ff0b31e9c
 SHA512:
-  metadata.gz: e2817cea70331047fb86a41d952b889afb20a6525a3b3cb581af60d12d1d03b28d7d4628b5aca11de313e9c222b0e3e1ecfbb138a5281ba6e3878973c948573d
-  data.tar.gz: 3b75a4d981dda6c4744ef16eb6a4f6eb55bee2c27bf925f2fc44f6a6a28310587ecf4385d47e90a4ed127890f267eb9be552f5e0a9011cc93648fa86702f38c8
+  metadata.gz: 552e1c4272994c73ab29ed2c714aa7d9e776ef6cd81431a97da99af9609669815ad8af64651a12278154609033f1a1e82c37a9fa921ce400770a2228f56078bb
+  data.tar.gz: 6c2f1a722122a2de176186b58835158764ff0ba4a5913c7d15e0b15b8b15feaba6b053fd12a97acc8d0699b3b2db7f701797679efe5322574e43c1b86b4cd6fd

data/.idea/nats_wave.iml

@@ -129,21 +129,21 @@
     <option name="myRootTask">
       <RakeTaskImpl id="rake">
         <subtasks>
-          <RakeTaskImpl description="Build nats_wave-1.1.6.gem into the pkg directory" fullCommand="build" id="build" />
+          <RakeTaskImpl description="Build nats_wave-1.1.14.gem into the pkg directory" fullCommand="build" id="build" />
           <RakeTaskImpl id="build">
             <subtasks>
-              <RakeTaskImpl description="Generate SHA512 checksum of nats_wave-1.1.6.gem into the checksums directory" fullCommand="build:checksum" id="checksum" />
+              <RakeTaskImpl description="Generate SHA512 checksum of nats_wave-1.1.14.gem into the checksums directory" fullCommand="build:checksum" id="checksum" />
             </subtasks>
           </RakeTaskImpl>
           <RakeTaskImpl description="Remove any temporary products" fullCommand="clean" id="clean" />
           <RakeTaskImpl description="Remove any generated files" fullCommand="clobber" id="clobber" />
-          <RakeTaskImpl description="Build and install nats_wave-1.1.6.gem into system gems" fullCommand="install" id="install" />
+          <RakeTaskImpl description="Build and install nats_wave-1.1.14.gem into system gems" fullCommand="install" id="install" />
           <RakeTaskImpl id="install">
             <subtasks>
-              <RakeTaskImpl description="Build and install nats_wave-1.1.6.gem into system gems without network access" fullCommand="install:local" id="local" />
+              <RakeTaskImpl description="Build and install nats_wave-1.1.14.gem into system gems without network access" fullCommand="install:local" id="local" />
             </subtasks>
           </RakeTaskImpl>
-          <RakeTaskImpl description="Create tag v1.1.6 and build and push nats_wave-1.1.6.gem to https://rubygems.org" fullCommand="release[remote]" id="release[remote]" />
+          <RakeTaskImpl description="Create tag v1.1.14 and build and push nats_wave-1.1.14.gem to https://rubygems.org" fullCommand="release[remote]" id="release[remote]" />
           <RakeTaskImpl description="Run RuboCop" fullCommand="rubocop" id="rubocop" />
           <RakeTaskImpl id="rubocop">
             <subtasks>

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nats_wave (1.1.14)
+    nats_wave (1.1.16)
       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.14'
+                        version: ENV['APP_VERSION'] || '1.1.16'
                 }
             end
             

data/lib/nats_wave/concerns/mappable.rb

@@ -1,3 +1,989 @@
+# # # 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
@@ -51,7 +1037,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
@@ -76,7 +1062,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
@@ -89,58 +1075,6 @@ module NatsWave
                     nats_wave_publishing_config
                 end
                 
-                private
-                
-                # Setup ActiveRecord callbacks for auto-publishing (only once per model)
-                def setup_publishing_callbacks_once
-                    # Only add callbacks if we're in ActiveRecord and haven't added them yet
-                    return unless defined?(ActiveRecord::Base) && self < ActiveRecord::Base
-                    return if @nats_wave_callbacks_added
-                    
-                    after_commit :trigger_nats_wave_auto_publish_on_create, on: :create
-                    after_commit :trigger_nats_wave_auto_publish_on_update, on: :update
-                    after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
-                    
-                    @nats_wave_callbacks_added = true
-                    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 = {}
@@ -274,6 +1208,73 @@ module NatsWave
                     return nil if conditions.empty?
                     self.find_by(conditions)
                 end
+                
+                private
+                
+                # Setup ActiveRecord callbacks for auto-publishing (only once per model)
+                def setup_publishing_callbacks_once
+                    # Only add callbacks if we're in ActiveRecord and haven't added them yet
+                    return unless defined?(ActiveRecord::Base) && self < ActiveRecord::Base
+                    return if @nats_wave_callbacks_added
+                    
+                    after_commit :trigger_nats_wave_auto_publish_on_create, on: :create
+                    after_commit :trigger_nats_wave_auto_publish_on_update, on: :update
+                    after_commit :trigger_nats_wave_auto_publish_on_destroy, on: :destroy
+                    
+                    @nats_wave_callbacks_added = true
+                    NatsWave.logger.debug "⚙️#{self.name}: Added publishing callbacks"
+                end
+                
+                # Create a subscription handler that processes data and calls custom handler AFTER auto-sync
+                def create_subscription_handler(config)
+                    model_class = self
+                    
+                    lambda do |message|
+                        begin
+                            NatsWave.logger.debug "⚙️Processing subscription message for #{model_class.name}"
+                            
+                            # Extract the raw data
+                            raw_data = message['data'] || {}
+                            model_name = message['model']
+                            action = message['action']
+                            
+                            # If action is empty, try to extract from subject
+                            if action.blank? && message['subject']
+                                # Extract action from subject like "ims.item.create" -> "create"
+                                subject_parts = message['subject'].split('.')
+                                action = subject_parts.last if subject_parts.any?
+                            end
+                            
+                            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"
+                            end
+                            
+                            # 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
@@ -286,7 +1287,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
                     
@@ -314,7 +1315,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.14"
+            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.16"
             @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.14'
+    VERSION = '1.1.16'
 end

metadata

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