nats_wave 1.1.0

data/lib/nats_wave.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+require 'logger'
+require 'socket'
+require 'json'
+require 'securerandom'
+
+require_relative "nats_wave/version"
+require_relative "nats_wave/errors"
+require_relative "nats_wave/configuration"
+require_relative "nats_wave/client"
+require_relative "nats_wave/publisher"
+require_relative "nats_wave/subscriber"
+require_relative "nats_wave/message_transformer"
+require_relative "nats_wave/model_mapper"
+require_relative "nats_wave/model_registry"
+require_relative "nats_wave/concerns/mappable"
+require_relative "nats_wave/adapters/datadog_metrics"
+require_relative "nats_wave/database_connector"
+require_relative "nats_wave/schema_registry"
+require_relative "nats_wave/dead_letter_queue"
+require_relative "nats_wave/metrics"
+
+# Middleware
+require_relative "nats_wave/middleware/base"
+require_relative "nats_wave/middleware/authentication"
+require_relative "nats_wave/middleware/validation"
+require_relative "nats_wave/middleware/logging"
+
+# Adapters
+require_relative "nats_wave/adapters/active_record"
+
+# Rails integration
+require_relative "nats_wave/railtie" if defined?(Rails)
+
+module NatsWave
+    class << self
+        attr_accessor :configuration
+        
+        def client
+            @client ||= Client.new
+        end
+        
+        def configure
+            self.configuration ||= Configuration.new
+            yield(configuration) if block_given?
+            reset_client!
+            configuration
+        end
+        
+        def reset_client!
+            @client = nil
+        end
+        
+        def logger
+            @logger ||= begin
+                            if defined?(Rails) && Rails.logger
+                                Rails.logger
+                            else
+                                Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+                            end
+                        end
+        end
+        
+        def logger=(logger)
+            @logger = logger
+        end
+        
+        # Convenience methods
+        def publish(subject:, model:, action:, data:, metadata: {})
+            client.publish(
+                    subject: subject,
+                    model: model,
+                    action: action,
+                    data: data,
+                    metadata: metadata
+            )
+        end
+        
+        def subscribe(subjects:, model_mappings: {}, &block)
+            client.subscribe(
+                    subjects: subjects,
+                    model_mappings: model_mappings,
+                    handler: block
+            )
+        end
+        
+        def start_subscriber
+            client.start_subscriber
+        end
+        
+        def health_check
+            client.health_check
+        end
+    end
+end

data/lib/tasks/nats_wave.rake

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+namespace :nats_wave do
+    desc 'Check NATS Wave health'
+    task health: :environment do
+        health = NatsWave.health_check
+        puts 'NATS Wave Health Check:'
+        puts '================================'
+        puts "NATS Connected: #{health[:nats_connected]}"
+        puts "Database Connected: #{health[:database_connected]}"
+        puts "Service: #{health[:service_name]}"
+        puts "Version: #{health[:version]}"
+        puts "Instance ID: #{health[:instance_id]}"
+        puts "NATS Server URL: #{health[:nats_server_url]}"
+        puts "Published Subjects: #{health[:published_subjects].join(', ')}"
+        puts "Timestamp: #{health[:timestamp]}"
+        
+        exit(1) unless health[:nats_connected] && health[:database_connected]
+    rescue StandardError => e
+        puts "Health check failed: #{e.message}"
+        exit(1)
+    end
+    
+    desc 'Show NATS Wave configuration'
+    task config: :environment do
+        config = NatsWave.configuration
+        puts 'NatsWave Configuration:'
+        puts '======================'
+        puts "Service Name: #{config.service_name}"
+        puts "NATS URL: #{config.nats_url}"
+        puts "Subject Patterns: #{config.subject_patterns.join(', ')}"
+        puts "NATS Server URL for others: #{config.nats_server_url}"
+        puts "Publishing Enabled: #{config.publishing_enabled}"
+        puts "Subscription Enabled: #{config.subscription_enabled}"
+        puts "Queue Group: #{config.queue_group}"
+    end
+    
+    desc 'Test NATS connectivity'
+    task test: :environment do
+        test_subject = "#{NatsWave.configuration.default_subject_prefix}.test.#{SecureRandom.hex(4)}"
+        test_data = {
+                message: 'Hello NATS!',
+                timestamp: Time.current.iso8601,
+                test_id: SecureRandom.uuid
+        }
+        
+        NatsWave.publish(
+                subject: test_subject,
+                model: 'TestModel',
+                action: 'test',
+                data: test_data,
+                metadata: { source: 'rake_task' }
+        )
+        
+        puts '✓ NATS connectivity test passed'
+        puts "  Published to: #{test_subject}"
+        puts "  Test data: #{test_data}"
+    rescue StandardError => e
+        puts "✗ NATS connectivity test failed: #{e.message}"
+        exit(1)
+    end
+    
+    desc 'Publish a test message'
+    task :publish_test, %i[subject model action] => :environment do |_t, args|
+        subject = args[:subject] || 'test.message'
+        model = args[:model] || 'TestModel'
+        action = args[:action] || 'create'
+        
+        data = {
+                id: 1,
+                name: 'Test Message',
+                timestamp: Time.current.iso8601
+        }
+        
+        NatsWave.client.publish(
+                subject: subject,
+                model: model,
+                action: action,
+                data: data,
+                metadata: { source: 'rake_task' }
+        )
+        
+        puts "Published test message to #{subject}"
+    end
+    
+    desc 'Subscribe to test messages'
+    task :subscribe_test, [:subject] => :environment do |_t, args|
+        subject = args[:subject] || 'test.*'
+        
+        puts "Subscribing to #{subject}..."
+        puts 'Press Ctrl+C to stop'
+        
+        NatsWave.client.subscribe(
+                subjects: [subject]
+        ) do |message|
+            puts 'Received message:'
+            puts "Subject: #{message['subject']}"
+            puts "Model: #{message['model']}"
+            puts "Action: #{message['action']}"
+            puts "Data: #{message['data']}"
+            puts "Metadata: #{message['metadata']}"
+            puts '---'
+        end
+        
+        # Keep the task running
+        sleep
+    end
+    
+    desc 'Start NATS Wave subscriber'
+    task start: :environment do
+        puts 'Starting NatsWave subscriber...'
+        
+        begin
+            NatsWave.start_subscriber
+            puts 'NatsWave subscriber started successfully'
+            puts 'Press Ctrl+C to stop'
+            
+            # Keep the process alive
+            trap('INT') do
+                puts "\nShutting down NatsWave subscriber..."
+                NatsWave.client.disconnect!
+                exit(0)
+            end
+            
+            sleep
+        rescue StandardError => e
+            puts "Failed to start NatsWave subscriber: #{e.message}"
+            exit(1)
+        end
+    end
+    
+    desc 'Retry failed messages in dead letter queue'
+    task retry_failed: :environment do
+        dlq = NatsWave::DeadLetterQueue.new(NatsWave.configuration)
+        
+        puts 'Retrying failed NatsWave messages...'
+        before_count = dlq.pending_retries_count
+        
+        dlq.retry_failed_messages
+        
+        after_count = dlq.pending_retries_count
+        processed = before_count - after_count
+        
+        puts "Processed #{processed} failed messages"
+        puts "Remaining pending retries: #{after_count}"
+    end
+    
+    desc 'Show failed messages in dead letter queue'
+    task show_failed: :environment do
+        dlq = NatsWave::DeadLetterQueue.new(NatsWave.configuration)
+        messages = dlq.get_failed_messages
+        
+        if messages.empty?
+            puts 'No failed messages in queue'
+        else
+            puts 'Failed Messages:'
+            puts '================'
+            messages.each do |msg|
+                puts "ID: #{msg[:id]}"
+                puts "Subject: #{
+                        begin
+                            msg[:subject]
+                        rescue StandardError
+                            'Unknown'
+                        end}"
+                puts "Error: #{msg[:error]}"
+                puts "Error Class: #{msg[:error_class]}"
+                puts "Retry Count: #{msg[:retry_count]}"
+                puts "Next Retry: #{msg[:next_retry]}"
+                puts "Created: #{msg[:timestamp]}"
+                puts '---'
+            end
+            
+            puts "\nSummary:"
+            puts "Total failed messages: #{messages.size}"
+            puts "Pending retries: #{dlq.pending_retries_count}"
+            puts "Permanent failures: #{dlq.permanent_failures_count}"
+        end
+    end
+    
+    desc 'Show NATS Wave statistics'
+    task stats: :environment do
+        puts "\n=== NATS Wave Statistics ==="
+        
+        if defined?(NatsWaveFailedMessage)
+            puts "Failed Publications: #{NatsWaveFailedMessage.count}"
+            puts "Pending Publication Retries: #{NatsWaveFailedMessage.where('retry_count < ? AND next_retry_at <= ?', 3,
+                                                                             Time.current).count}"
+        end
+        
+        if defined?(NatsWaveFailedSubscription)
+            puts "Failed Subscriptions: #{NatsWaveFailedSubscription.count}"
+            puts "Pending Subscription Retries: #{NatsWaveFailedSubscription.where('retry_count < ? AND next_retry_at <= ?',
+                                                                                   3, Time.current).count}"
+        end
+        
+        begin
+            health = NatsWave.health_check
+            puts "NATS Connected: #{health[:nats_connected]}"
+            puts "Database Connected: #{health[:database_connected]}"
+        rescue StandardError => e
+            puts "Health check failed: #{e.message}"
+        end
+        
+        puts "============================\n"
+    end
+    
+    desc 'Clear all failed messages'
+    task clear_failed: :environment do
+        print 'Are you sure you want to clear all failed messages? [y/N]: '
+        response = $stdin.gets.chomp.downcase
+        
+        if %w[y yes].include?(response)
+            dlq = NatsWave::DeadLetterQueue.new(NatsWave.configuration)
+            
+            # Clear in-memory storage
+            cleared_memory = dlq.get_failed_messages.size
+            dlq.get_failed_messages.each do |msg|
+                dlq.remove_failed_message(msg[:id])
+            end
+            
+            # Clear database storage if tables exist
+            cleared_db = 0
+            if defined?(NatsWaveFailedMessage)
+                cleared_db += NatsWaveFailedMessage.count
+                NatsWaveFailedMessage.delete_all
+            end
+            
+            if defined?(NatsWaveFailedSubscription)
+                cleared_db += NatsWaveFailedSubscription.count
+                NatsWaveFailedSubscription.delete_all
+            end
+            
+            puts "Cleared #{cleared_memory} messages from memory storage"
+            puts "Cleared #{cleared_db} messages from database storage"
+        else
+            puts 'Operation cancelled'
+        end
+    end
+    
+    desc 'Monitor NATS Wave activity'
+    task monitor: :environment do
+        puts 'Monitoring NatsWave activity...'
+        puts 'Press Ctrl+C to stop'
+        
+        # Subscribe to all messages for monitoring
+        NatsWave.client.subscribe(
+                subjects: ['*', '*.>', 'rails.*', 'external.*']
+        ) do |message|
+            timestamp = Time.current.strftime('%H:%M:%S')
+            source_service = message.dig('source', 'service') || 'unknown'
+            
+            puts "[#{timestamp}] #{message['subject']} | #{message['model']}##{message['action']} | from: #{source_service}"
+            
+            if ENV['VERBOSE']
+                puts "  Data: #{message['data']}"
+                puts "  Metadata: #{message['metadata']}"
+                puts '  ---'
+            end
+        end
+        
+        sleep
+    end
+    
+    desc "Show all model subscriptions"
+    task model_subscriptions: :environment do
+        puts "\n=== NatsWave Model Subscriptions ==="
+        
+        stats = NatsWave::ModelRegistry.subscription_stats
+        
+        puts "\nOverview:"
+        puts "  Total Subscriptions: #{stats[:total_subscriptions]}"
+        puts "  Unique Subjects: #{stats[:unique_subjects]}"
+        puts "  Models with Subscriptions: #{stats[:models_with_subscriptions]}"
+        
+        puts "\nModel Breakdown:"
+        stats[:subscription_breakdown].each do |model, count|
+            puts "  #{model}: #{count} subscription(s)"
+            
+            # Show details for each model
+            subscriptions = NatsWave::ModelRegistry.subscriptions_for_model(model)
+            subscriptions.each do |sub|
+                puts "    Subjects: #{sub[:subjects].join(', ')}"
+                puts "    External Model: #{sub[:external_model] || 'Custom Handler'}"
+                puts "    Handler: #{sub[:handler] ? 'Custom' : 'Auto-Sync'}"
+                puts "    ---"
+            end
+        end
+        
+        puts "\nAll Subscription Subjects:"
+        NatsWave::ModelRegistry.all_subscription_subjects.sort.each do |subject|
+            puts "  #{subject}"
+        end
+        
+        puts "================================\n"
+    end
+    
+    desc "Test model auto-registration"
+    task test_registration: :environment do
+        puts "Testing NatsWave model auto-registration..."
+        
+        begin
+            NatsWave::AutoRegistration.register_all_models!
+            puts "✅ Auto-registration completed successfully"
+            
+            # Show what was registered
+            Rake::Task['nats_wave:model_subscriptions'].invoke
+        rescue => e
+            puts "❌ Auto-registration failed: #{e.message}"
+            puts e.backtrace.first(5)
+            exit(1)
+        end
+    end
+    
+    desc "Validate model configurations"
+    task validate_models: :environment do
+        puts "Validating NatsWave model configurations..."
+        
+        errors = []
+        
+        ActiveRecord::Base.descendants.each do |model_class|
+            next unless model_class.respond_to?(:nats_wave_external_models)
+            
+            begin
+                # Check if model has valid mappings
+                model_class.nats_wave_external_models.each do |external_model|
+                    mapping = model_class.nats_wave_mapping_for(external_model)
+                    
+                    # Validate field mappings reference real fields
+                    if mapping[:field_mappings]
+                        mapping[:field_mappings].values.each do |local_field|
+                            unless model_class.column_names.include?(local_field.to_s)
+                                errors << "#{model_class.name}: Field '#{local_field}' not found in #{external_model} mapping"
+                            end
+                        end
+                    end
+                    
+                    # Validate unique fields exist
+                    if mapping[:unique_fields]
+                        mapping[:unique_fields].each do |field|
+                            unless model_class.column_names.include?(field.to_s)
+                                errors << "#{model_class.name}: Unique field '#{field}' not found in #{external_model} mapping"
+                            end
+                        end
+                    end
+                end
+            rescue => e
+                errors << "#{model_class.name}: Configuration error - #{e.message}"
+            end
+        end
+        
+        if errors.empty?
+            puts "✅ All model configurations are valid"
+        else
+            puts "❌ Found #{errors.size} configuration errors:"
+            errors.each { |error| puts "  - #{error}" }
+            exit(1)
+        end
+    end
+end

data/sig/nats_wave.rbs

@@ -0,0 +1,5 @@
+module NatsWave
+    VERSION: String
+
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end