nats_wave 1.1.4 → 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

@@ -16,9 +16,9 @@ module NatsWave
                       :subscriptions, :publications
         
         def initialize(options = {})
-            @nats_url = ENV['NATS_URL']
-            @service_name = ENV['NATS_NATS_SERVICE_NAME']
-            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.4"
+            @nats_url = ENV['NATS_URL'] || "nats://localhost:4222"
+            @service_name = ENV['NATS_SERVICE_NAME'] || "purplewave"
+            @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)
@@ -80,6 +80,7 @@ module NatsWave
         
         def nats_server_url
             # This is the URL other teams can use to subscribe to your events
+            return nil if @nats_url.nil?
             uri = URI.parse(@nats_url)
             "#{uri.scheme}://#{uri.host}:#{uri.port}"
         end

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,53 +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
-            @middleware_stack = middleware_stack
+            @client = client
             @message_transformer = MessageTransformer.new(config)
             @dead_letter_queue = DeadLetterQueue.new(config) if config.dead_letter_queue
         end
@@ -56,17 +58,15 @@ module NatsWave
             return unless @config.publishing_enabled
             
             message = build_message(subject, model, action, data, metadata)
-            processed_message = apply_middleware(message)
             full_subject = build_full_subject(subject)
             
             if @config.async_publishing && defined?(Concurrent)
-                publish_async(full_subject, processed_message)
+                publish_async(full_subject, message)
             else
-                publish_sync(full_subject, processed_message)
+                publish_sync(full_subject, message)
             end
             
-            Metrics.increment_published_messages(full_subject)
-            NatsWave.logger.debug("Published message to #{full_subject}")
+            # Metrics.increment_published_messages(full_subject)
         rescue => e
             NatsWave.logger.error("Failed to publish message: #{e.message}")
             @dead_letter_queue&.store_failed_message(message, e, 0)
@@ -81,17 +81,16 @@ module NatsWave
                     source: build_source_info
             }
             
-            processed_message = apply_middleware(batch_message)
             subject = "#{@config.default_subject_prefix}.batch"
             
-            @nats_client.publish(subject, processed_message.to_json)
+            @client.publish(subject, batch_message.to_json)
             
-            Metrics.increment_published_messages(subject)
+            # 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
@@ -128,20 +127,16 @@ module NatsWave
             end
         end
         
-        def apply_middleware(message)
-            @middleware_stack.reduce(message) do |msg, middleware|
-                middleware.call(msg)
-            end
-        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
                 publish_sync(subject, message)

data/lib/nats_wave/railtie.rb

@@ -20,7 +20,9 @@ module NatsWave
             config_file = Rails.root.join('config', 'nats_wave.yml')
             if File.exist?(config_file)
                 begin
-                    yaml_config = YAML.load_file(config_file)[Rails.env]
+                    erb_content = ERB.new(File.read(config_file)).result
+                    yaml_data = YAML.safe_load(erb_content)
+                    yaml_config = yaml_data&.dig(Rails.env.to_s) || yaml_data&.dig(Rails.env) || {}
                     
                     NatsWave.configure do |config|
                         # NATS Configuration
@@ -95,11 +97,10 @@ module NatsWave
             Rails.application.config.after_initialize do
                 if NatsWave.configuration&.publishing_enabled || NatsWave.configuration&.subscription_enabled
                     Thread.new do
-                        sleep 1 # Give Rails time to fully boot
+                        sleep 2 # Give Rails time to fully boot
                         begin
                             NatsWave.client
                             NatsWave.logger.info "NatsWave client initialized"
-                            NatsWave.logger.info "NATS URL #{@nats_url}"
                         rescue => e
                             NatsWave.logger.error "Failed to initialize NatsWave client: #{e.message}"
                         end