nats_wave 1.1.5 → 1.1.7

data/lib/nats_wave/concerns/mappable.rb

@@ -22,6 +22,8 @@ module NatsWave
                 
                 # Configure how external models map to this model AND what subjects to subscribe to
                 def nats_wave_maps_from(external_model, options = {})
+                    Rails.logger.debug "🔄 #{self.name}: Setting up mapping from #{external_model} with options: #{options.inspect}" if defined?(Rails)
+                    
                     mapping = {
                             field_mappings: options[:field_mappings] || {},
                             transformations: options[:transformations] || {},
@@ -29,7 +31,6 @@ module NatsWave
                             sync_strategy: options[:sync_strategy] || :upsert,
                             unique_fields: options[:unique_fields] || [:id],
                             skip_fields: options[:skip_fields] || [],
-                            # NEW: Subscription configuration
                             subjects: options[:subjects] || [],
                             handler: options[:handler],
                             queue_group: options[:queue_group]
@@ -37,11 +38,12 @@ module NatsWave
                     
                     self.nats_wave_mapping_config[external_model] = mapping
                     
-                    # Register this mapping globally
+                    Rails.logger.debug "🔄 #{self.name}: Registering reverse mapping for #{external_model}" if defined?(Rails)
                     NatsWave::ModelRegistry.register_reverse_mapping(external_model, self.name, mapping)
                     
                     # Register subscription if subjects are provided
                     if mapping[:subjects].any?
+                        Rails.logger.debug "🔄 #{self.name}: Registering subscription for subjects: #{mapping[:subjects]}" if defined?(Rails)
                         NatsWave::ModelRegistry.register_subscription(
                                 subjects: mapping[:subjects],
                                 model: self.name,
@@ -49,6 +51,8 @@ module NatsWave
                                 handler: mapping[:handler],
                                 queue_group: mapping[:queue_group]
                         )
+                    else
+                        Rails.logger.debug "🔄 #{self.name}: No subjects provided, skipping subscription registration" if defined?(Rails)
                     end
                 end
                 
@@ -56,6 +60,8 @@ module NatsWave
                 def nats_wave_subscribes_to(*subjects, handler: nil, queue_group: nil, &block)
                     handler ||= block
                     
+                    Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
+                    
                     subscription_config = {
                             subjects: subjects.flatten,
                             handler: handler,
@@ -65,7 +71,7 @@ module NatsWave
                     
                     self.nats_wave_subscription_config[:custom] = subscription_config
                     
-                    # Register subscription
+                    Rails.logger.debug "📡 #{self.name}: Registering subscription in ModelRegistry" if defined?(Rails)
                     NatsWave::ModelRegistry.register_subscription(
                             subjects: subjects.flatten,
                             model: self.name,

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.5"
+            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.7"
             @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
@@ -71,7 +71,7 @@ module NatsWave
             }
         end
         
-        def add_publication(model_class, actions = [:create, :update, :destroy])
+        def add_publication(model_class, actions = %i[create update destroy])
             @publications << {
                     model: model_class,
                     actions: Array(actions)

data/lib/nats_wave/dead_letter_queue.rb

@@ -58,7 +58,7 @@ module NatsWave
         private
         
         def setup_storage
-            # For production, you'd want to use Redis, database, or file storage
+            # For production, we'd want to use Redis, database, or file storage
             # For now, use in-memory storage
             InMemoryStorage.new
         end
@@ -70,11 +70,11 @@ module NatsWave
         end
         
         def retry_message(failed_message)
-            # This would need to be implemented based on your retry strategy
+            # This would need to be implemented based on wer retry strategy
             # For now, just log that we would retry
             NatsWave.logger.info("Retrying message: #{failed_message[:id]}")
             
-            # In a real implementation, you would:
+            # In a real implementation, we would:
             # 1. Re-parse the message
             # 2. Re-apply middleware
             # 3. Re-process the message
@@ -138,7 +138,7 @@ module NatsWave
             end
             
             def mark_permanent_failure(message)
-                # In a real implementation, you might move this to a different storage
+                # In a real implementation, we might move this to a different storage
                 update(message)
             end
         end

data/lib/nats_wave/model_mapper.rb

@@ -122,4 +122,4 @@ module NatsWave
             end
         end
     end
-end
+end

data/lib/nats_wave/model_registry.rb

@@ -9,11 +9,13 @@ module NatsWave
         class << self
             # Register a mapping from local model to external models
             def register_mapping(local_model, external_mappings)
+                Rails.logger.debug "🗂️  Registering mapping: #{local_model} -> #{external_mappings.inspect}" if defined?(Rails)
                 @mappings[local_model] = external_mappings
             end
             
             # Register a reverse mapping from external model to local model
             def register_reverse_mapping(external_model, local_model, mapping_config)
+                Rails.logger.debug "🔄 Registering reverse mapping: #{external_model} -> #{local_model} with config: #{mapping_config.inspect}" if defined?(Rails)
                 @reverse_mappings[external_model] ||= {}
                 @reverse_mappings[external_model][local_model] = mapping_config
             end
@@ -34,22 +36,52 @@ module NatsWave
                 Rails.logger.debug "📡 Registered subscription: #{model} -> #{subjects.join(', ')}" if defined?(Rails)
             end
             
-            # Get all registered subscriptions
+            # Debug method to show all registrations
+            def debug_registrations
+                puts "\n" + "="*80
+                puts "🔍 NATS WAVE DEBUG - ALL REGISTRATIONS"
+                puts "="*80
+                
+                puts "\n📡 SUBSCRIPTIONS (#{@subscriptions.size}):"
+                @subscriptions.each_with_index do |sub, i|
+                    puts "  #{i+1}. Model: #{sub[:model]}"
+                    puts "     Subjects: #{sub[:subjects].join(', ')}"
+                    puts "     External Model: #{sub[:external_model] || 'N/A'}"
+                    puts "     Handler: #{sub[:handler] ? 'Yes' : 'No'}"
+                    puts "     Queue Group: #{sub[:queue_group] || 'Default'}"
+                    puts "     Registered: #{sub[:registered_at]}"
+                    puts ""
+                end
+                
+                puts "\n🗂️  MAPPINGS (#{@mappings.size}):"
+                @mappings.each do |local_model, external_mappings|
+                    puts "  #{local_model} -> #{external_mappings.inspect}"
+                end
+                
+                puts "\n🔄 REVERSE MAPPINGS (#{@reverse_mappings.size}):"
+                @reverse_mappings.each do |external_model, local_mappings|
+                    puts "  #{external_model}:"
+                    local_mappings.each do |local_model, config|
+                        puts "    -> #{local_model}: #{config.keys.join(', ')}"
+                    end
+                end
+                
+                puts "="*80 + "\n"
+            end
+            
+            # Rest of your existing methods...
             def subscriptions
                 @subscriptions
             end
             
-            # Get subscriptions for a specific model
             def subscriptions_for_model(model_name)
                 @subscriptions.select { |sub| sub[:model] == model_name }
             end
             
-            # Get all unique subjects to subscribe to
             def all_subscription_subjects
                 @subscriptions.flat_map { |sub| sub[:subjects] }.uniq
             end
             
-            # Get subscription handlers grouped by subject pattern
             def subscription_handlers
                 handlers = {}
                 
@@ -68,22 +100,18 @@ module NatsWave
                 handlers
             end
             
-            # Get local model mappings for an external model
             def local_models_for(external_model)
                 @reverse_mappings[external_model] || {}
             end
             
-            # Get external model mappings for a local model
             def external_models_for(local_model)
                 @mappings[local_model] || {}
             end
             
-            # Check if an external model can be synced
             def can_sync_external_model?(external_model)
                 @reverse_mappings.key?(external_model)
             end
             
-            # Get all registered mappings
             def all_mappings
                 {
                         local_to_external: @mappings,
@@ -91,15 +119,14 @@ module NatsWave
                 }
             end
             
-            # Find the best local model for an external model
             def best_local_model_for(external_model, data = {})
                 local_mappings = local_models_for(external_model)
                 return nil if local_mappings.empty?
                 
-                # If only one mapping, use it
-                return local_mappings.keys.first if local_mappings.size == 1
+                if local_mappings.size == 1
+                    return local_mappings.keys.first
+                end
                 
-                # If multiple mappings, try to find the best match based on conditions
                 local_mappings.each do |local_model, config|
                     conditions = config[:conditions] || {}
                     
@@ -108,18 +135,15 @@ module NatsWave
                     end
                 end
                 
-                # Fallback to first available
                 local_mappings.keys.first
             end
             
-            # Clear all mappings and subscriptions (useful for testing)
             def clear!
                 @mappings.clear
                 @reverse_mappings.clear
                 @subscriptions.clear
             end
             
-            # Get subscription statistics
             def subscription_stats
                 {
                         total_subscriptions: @subscriptions.size,

data/lib/nats_wave/publisher.rb

@@ -1,52 +1,55 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-require 'json'
+# # frozen_string_literal: true
+#
+# require 'securerandom'
+# require 'json'
+#
+# # begin
+# #     require 'nats/client'
+# # rescue LoadError
+# #     # NATS not available - define a mock for testing
+# #     module NATS
+# #         def self.connect(url, options = {})
+# #             NatsClient.new
+# #         end
+# #
+# #         class NatsClient
+# #             def connected?
+# #                 false
+# #             end
+# #
+# #             def publish(subject, message)
+# #                 puts "NATS: Publishing to #{subject}: #{message}"
+# #             end
+# #
+# #             def subscribe(subject, options = {})
+# #                 puts "NATS: Subscribing to #{subject}"
+# #                 yield('{"mock": "message"}') if block_given?
+# #                 Subscription.new
+# #             end
+# #
+# #             def close
+# #                 true
+# #             end
+# #         end
+# #
+# #         class Subscription
+# #             def unsubscribe
+# #                 true
+# #             end
+# #         end
+# #     end
+# # end
+#
 
-begin
-    require 'nats/client'
-rescue LoadError
-    # NATS not available - define a mock for testing
-    module NATS
-        def self.connect(url, options = {})
-            NatsClient.new
-        end
-        
-        class NatsClient
-            def connected?
-                false
-            end
-            
-            def publish(subject, message)
-                puts "NATS: Publishing to #{subject}: #{message}"
-            end
-            
-            def subscribe(subject, options = {})
-                puts "NATS: Subscribing to #{subject}"
-                yield('{"mock": "message"}') if block_given?
-                Subscription.new
-            end
-            
-            def close
-                true
-            end
-        end
-        
-        class Subscription
-            def unsubscribe
-                true
-            end
-        end
-    end
-end
+# frozen_string_literal: true
 
 module NatsWave
     class Publisher
-        attr_reader :config, :nats_client
+        attr_reader :config, :client
         
-        def initialize(config, nats_client, middleware_stack = [])
+        def initialize(config, client, middleware_stack = [])
             @config = config
-            @nats_client = nats_client
+            @client = client
             @message_transformer = MessageTransformer.new(config)
             @dead_letter_queue = DeadLetterQueue.new(config) if config.dead_letter_queue
         end
@@ -80,14 +83,14 @@ module NatsWave
             
             subject = "#{@config.default_subject_prefix}.batch"
             
-            @nats_client.publish(subject, batch_message.to_json)
+            @client.publish(subject, batch_message.to_json)
             
             # Metrics.increment_published_messages(subject)
             NatsWave.logger.info("Published batch with #{events.size} events")
         end
         
         def connected?
-            @nats_client&.connected?
+            @client&.connected?
         end
         
         def disconnect
@@ -125,14 +128,14 @@ module NatsWave
         end
         
         def publish_sync(subject, message)
-            @nats_client.publish(subject, message.to_json)
+            @client.publish(subject, message.to_json)
             NatsWave.logger.debug("Published sync message to #{subject}")
         end
         
         def publish_async(subject, message)
             if defined?(Concurrent)
                 Concurrent::Future.execute do
-                    @nats_client.publish(subject, message.to_json)
+                    @client.publish(subject, message.to_json)
                     NatsWave.logger.debug("Published async message to #{subject}")
                 end
             else

data/lib/nats_wave/subscriber.rb

@@ -2,27 +2,29 @@
 
 module NatsWave
     class Subscriber
-        attr_reader :config, :nats_client
+        attr_reader :config, :client
         
-        def initialize(config, nats_client, middleware_stack = [])
+        def initialize(config, client, middleware_stack = [])
             @config = config
-            @nats_client = nats_client
+            @client = client
             @database_connector = DatabaseConnector.new(config)
             @model_mapper = ModelMapper.new(config)
             @message_transformer = MessageTransformer.new(config)
             @dead_letter_queue = DeadLetterQueue.new(config)
             
-            # Separate the two types of subscriptions
-            @registry_subscriptions = ModelRegistry.subscriptions  # Hash objects
-            @nats_subscriptions = []                               # NATS::Subscription objects
+            @registry_subscriptions = ModelRegistry.subscriptions
+            @nats_subscriptions = [] # NATS::Subscription objects
             @running = false
+            @shutdown = false
         end
         
-        def start
-            return if @running
+        def begin
+            return if @running || @shutdown
             return unless @config.subscription_enabled
             
             @running = true
+            @shutdown = false
+            
             NatsWave.logger.info "Starting NATS subscriber for #{@config.service_name}"
             
             # Use ModelRegistry subscriptions
@@ -32,10 +34,13 @@ module NatsWave
                 end
             end
             
-            NatsWave.logger.info "Started #{@registry_subscriptions.size} subscriptions from ModelRegistry"
+            NatsWave.logger.info "Started #{@registry_subscriptions.size} subscriptions from Model Registry"
+            
+            # Keep the subscriber alive
+            keep_alive
         end
         
-        def subscribe(subjects:, model_mappings: {}, handler: nil)
+        def listen(subjects:, model_mappings: {}, handler: nil)
             subjects = Array(subjects)
             
             subjects.each do |subject|
@@ -44,11 +49,27 @@ module NatsWave
             end
         end
         
-        def unsubscribe_all
-            # Unsubscribe from NATS subscriptions (the actual NATS::Subscription objects)
-            @nats_subscriptions.each(&:unsubscribe)
-            @nats_subscriptions.clear
+        def reset
+            @shutdown = true
             @running = false
+            
+            # Stop keep alive thread
+            if @keep_alive_thread&.alive?
+                @keep_alive_thread.kill
+                @keep_alive_thread = nil
+            end
+            
+            # Unsubscribe from all subscriptions
+            @nats_subscriptions.each do |subscription|
+                begin
+                    subscription.unsubscribe if subscription.respond_to?(:unsubscribe)
+                rescue => e
+                    NatsWave.logger.error "Error unsubscribing: #{e.message}"
+                end
+            end
+            @nats_subscriptions.clear
+            
+            NatsWave.logger.info "🛑 Subscriber shutdown complete"
         end
         
         def database_connected?
@@ -56,7 +77,7 @@ module NatsWave
         end
         
         def disconnect
-            unsubscribe_all
+            reset
         end
         
         private
@@ -65,20 +86,30 @@ module NatsWave
             NatsWave.logger.info "🔍 Attempting to subscribe to: #{subject_pattern}"
             
             # Create the NATS subscription
-            nats_subscription = @nats_client.subscribe(
+            nats_subscription = @client.subscribe(
                     subject_pattern,
                     queue: @config.queue_group
             ) do |msg|
-                NatsWave.logger.info "📨 Received message on #{msg.subject}: #{msg.data}"
-                process_message(msg.data, custom_handler, model_mappings)
+                begin
+                    NatsWave.logger.debug "📨 Received message on #{msg.subject}"
+                    process_message(msg.data, custom_handler, model_mappings)
+                rescue => e
+                    NatsWave.logger.error "Error in subscription handler: #{e.message}"
+                    NatsWave.logger.error e.backtrace.join("\n")
+                    # Don't re-raise - this would kill the subscription
+                end
             end
             
-            # Add to NATS subscriptions array (not the registry subscriptions)
+            # Add to NATS subscriptions array
             @nats_subscriptions << nats_subscription
             NatsWave.logger.info "✅ Successfully subscribed to #{subject_pattern} (total: #{@nats_subscriptions.size})"
         end
         
         def process_message(raw_message, custom_handler, model_mappings)
+            return unless should_process_message?(raw_message)
+            
+            NatsWave.logger.debug "🔄 Processing message: #{raw_message[0..200]}..."
+            
             message = parse_message(raw_message)
             
             if custom_handler
@@ -87,11 +118,78 @@ module NatsWave
                 handle_model_sync(message, model_mappings)
             end
             
-            NatsWave.logger.debug('Successfully processed message')
+            NatsWave.logger.debug('✅ Successfully processed message')
         rescue StandardError => e
             handle_error(e, raw_message, message)
+            # Don't re-raise - this would kill the subscription
+        end
+        
+        def should_process_message?(raw_message_data)
+            message = JSON.parse(raw_message_data)
+            source = message['source'] || {}
+            
+            # Skip messages from same service instance
+            if source['service'] == @config.service_name && source['instance_id'] == @config.instance_id
+                NatsWave.logger.debug "🔄 Skipping message from same service instance"
+                return false
+            end
+            
+            true
+        rescue JSON::ParserError => e
+            NatsWave.logger.error "Failed to parse message for filtering: #{e.message}"
+            false
+        end
+        
+        def keep_alive
+            Rails.logger.info "🔄 Starting keep-alive thread for persistent JetStream connection"
+            
+            @keep_alive_thread = Thread.new do
+                while @running && !@shutdown
+                    begin
+                        sleep 30 # Check every 30 seconds
+                        
+                        if @client&.connected?
+                            Rails.logger.debug "💓 Subscriber connection healthy - #{@nats_subscriptions.size} active subscriptions"
+                        else
+                            Rails.logger.error "❌ Subscriber connection lost! Attempting reconnection..."
+                            attempt_reconnection
+                        end
+                    
+                    rescue => e
+                        Rails.logger.error "Error in keep_alive thread: #{e.message}"
+                        sleep 10
+                    end
+                end
+                
+                Rails.logger.info "🛑 Keep-alive thread shutting down"
+            end
+        end
+        
+        def attempt_reconnection
+            return if @shutdown
+            
+            NatsWave.logger.info "🔄 Attempting to reconnect to NATS..."
+            
+            # Reset subscriptions
+            @nats_subscriptions.clear
+            
+            # Try to reestablish subscriptions
+            sleep 5 # Wait before reconnecting
+            
+            if @client&.connected?
+                NatsWave.logger.info "✅ NATS reconnected, reestablishing subscriptions"
+                
+                @registry_subscriptions.each do |subscription|
+                    subscription[:subjects].each do |subject|
+                        subscribe_to_subject(subject, subscription[:handler])
+                    end
+                end
+            end
+        rescue => e
+            NatsWave.logger.error "Failed to reconnect: #{e.message}"
         end
         
+        # ... rest of your existing methods (parse_message, handle_model_sync, handle_error)
         def parse_message(raw_message)
             @message_transformer.parse_message(raw_message)
         end

data/lib/nats_wave/version.rb

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

metadata

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