nats_wave 1.1.0

data/lib/nats_wave/model_registry.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module NatsWave
+    class ModelRegistry
+        @mappings = {}
+        @reverse_mappings = {}
+        @subscriptions = []
+        
+        class << self
+            # Register a mapping from local model to external models
+            def register_mapping(local_model, external_mappings)
+                @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)
+                @reverse_mappings[external_model] ||= {}
+                @reverse_mappings[external_model][local_model] = mapping_config
+            end
+            
+            # Register a subscription
+            def register_subscription(subjects:, model:, external_model: nil, handler: nil, queue_group: nil)
+                subscription = {
+                        subjects: Array(subjects),
+                        model: model,
+                        external_model: external_model,
+                        handler: handler,
+                        queue_group: queue_group,
+                        registered_at: Time.current
+                }
+                
+                @subscriptions << subscription
+                
+                Rails.logger.debug "📡 Registered subscription: #{model} -> #{subjects.join(', ')}" if defined?(Rails)
+            end
+            
+            # Get all registered subscriptions
+            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 = {}
+                
+                @subscriptions.each do |subscription|
+                    subscription[:subjects].each do |subject|
+                        handlers[subject] ||= []
+                        handlers[subject] << {
+                                model: subscription[:model],
+                                external_model: subscription[:external_model],
+                                handler: subscription[:handler],
+                                queue_group: subscription[:queue_group]
+                        }
+                    end
+                end
+                
+                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,
+                        external_to_local: @reverse_mappings
+                }
+            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 multiple mappings, try to find the best match based on conditions
+                local_mappings.each do |local_model, config|
+                    conditions = config[:conditions] || {}
+                    
+                    if conditions.empty? || evaluate_conditions(conditions, data)
+                        return local_model
+                    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,
+                        unique_subjects: all_subscription_subjects.size,
+                        models_with_subscriptions: @subscriptions.map { |s| s[:model] }.uniq.size,
+                        subscription_breakdown: @subscriptions.group_by { |s| s[:model] }.transform_values(&:size)
+                }
+            end
+            
+            private
+            
+            def evaluate_conditions(conditions, data)
+                conditions.all? do |field, expected_value|
+                    case expected_value
+                        when Proc
+                            expected_value.call(data[field])
+                        when Regexp
+                            expected_value.match?(data[field].to_s)
+                        when Array
+                            expected_value.include?(data[field])
+                        else
+                            data[field] == expected_value
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/nats_wave/publisher.rb

@@ -0,0 +1,151 @@
+# 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
+
+module NatsWave
+    class Publisher
+        attr_reader :config, :nats_client
+        
+        def initialize(config, nats_client, middleware_stack)
+            @config = config
+            @nats_client = nats_client
+            @middleware_stack = middleware_stack
+            @message_transformer = MessageTransformer.new(config)
+            @dead_letter_queue = DeadLetterQueue.new(config) if config.dead_letter_queue
+        end
+        
+        def publish(subject:, model:, action:, data:, metadata: {})
+            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)
+            else
+                publish_sync(full_subject, processed_message)
+            end
+            
+            Metrics.increment_published_messages(full_subject)
+            NatsWave.logger.debug("Published message to #{full_subject}")
+        rescue => e
+            NatsWave.logger.error("Failed to publish message: #{e.message}")
+            @dead_letter_queue&.store_failed_message(message, e, 0)
+            raise PublishError, "Failed to publish message: #{e.message}"
+        end
+        
+        def publish_batch(events)
+            batch_message = {
+                    batch_id: SecureRandom.uuid,
+                    events: events,
+                    timestamp: Time.current.iso8601,
+                    source: build_source_info
+            }
+            
+            processed_message = apply_middleware(batch_message)
+            subject = "#{@config.default_subject_prefix}.batch"
+            
+            @nats_client.publish(subject, processed_message.to_json)
+            
+            Metrics.increment_published_messages(subject)
+            NatsWave.logger.info("Published batch with #{events.size} events")
+        end
+        
+        def connected?
+            @nats_client&.connected?
+        end
+        
+        def disconnect
+            # Publisher cleanup if needed
+        end
+        
+        private
+        
+        def build_message(subject, model, action, data, metadata)
+            @message_transformer.build_standard_message(
+                    subject: subject,
+                    model: model,
+                    action: action,
+                    data: data,
+                    metadata: metadata,
+                    source: build_source_info
+            )
+        end
+        
+        def build_source_info
+            {
+                    service: @config.service_name,
+                    version: @config.version,
+                    instance_id: @config.instance_id,
+                    environment: defined?(Rails) ? Rails.env : 'test'
+            }
+        end
+        
+        def build_full_subject(subject)
+            if @config.default_subject_prefix && !subject.start_with?(@config.default_subject_prefix)
+                "#{@config.default_subject_prefix}.#{subject}"
+            else
+                subject
+            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)
+        end
+        
+        def publish_async(subject, message)
+            if defined?(Concurrent)
+                Concurrent::Future.execute do
+                    @nats_client.publish(subject, message.to_json)
+                end
+            else
+                publish_sync(subject, message)
+            end
+        end
+    end
+end

data/lib/nats_wave/railtie.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module NatsWave
+    class Railtie < Rails::Railtie
+        config.nats_wave = ActiveSupport::OrderedOptions.new
+        
+        initializer "nats_wave.configure" do |app|
+            # Load configuration from Rails config
+            if app.config.respond_to?(:nats_wave)
+                NatsWave.configure do |config|
+                    app.config.nats_wave.each do |key, value|
+                        config.send("#{key}=", value) if config.respond_to?("#{key}=")
+                    end
+                end
+            end
+            
+            # Load YAML configuration if it exists
+            config_file = Rails.root.join('config', 'nats_wave.yml')
+            if File.exist?(config_file)
+                begin
+                    yaml_config = YAML.load_file(config_file)[Rails.env]
+                    
+                    NatsWave.configure do |config|
+                        # NATS Configuration
+                        config.nats_url = yaml_config.dig('nats', 'url') if yaml_config.dig('nats', 'url')
+                        config.connection_pool_size = yaml_config.dig('nats', 'connection_pool_size') if yaml_config.dig('nats', 'connection_pool_size')
+                        config.timeout = yaml_config.dig('nats', 'timeout') if yaml_config.dig('nats', 'timeout')
+                        config.reconnect_attempts = yaml_config.dig('nats', 'reconnect_attempts') if yaml_config.dig('nats', 'reconnect_attempts')
+                        
+                        # Service Configuration
+                        config.service_name = yaml_config.dig('publishing', 'default_subject_prefix') if yaml_config.dig('publishing', 'default_subject_prefix')
+                        config.version = Rails.application.class.parent_name.underscore if defined?(Rails.application.class.parent_name)
+                        
+                        # Publishing Configuration
+                        config.publishing_enabled = yaml_config.dig('publishing', 'enabled') unless yaml_config.dig('publishing', 'enabled').nil?
+                        config.default_subject_prefix = yaml_config.dig('publishing', 'default_subject_prefix') if yaml_config.dig('publishing', 'default_subject_prefix')
+                        config.batch_size = yaml_config.dig('publishing', 'batch_size') if yaml_config.dig('publishing', 'batch_size')
+                        config.async_publishing = yaml_config.dig('publishing', 'async') unless yaml_config.dig('publishing', 'async').nil?
+                        
+                        # Subscription Configuration
+                        config.subscription_enabled = yaml_config.dig('subscription', 'enabled') unless yaml_config.dig('subscription', 'enabled').nil?
+                        config.queue_group = yaml_config.dig('subscription', 'queue_group') if yaml_config.dig('subscription', 'queue_group')
+                        
+                        # Middleware Configuration
+                        config.middleware_authentication_enabled = yaml_config.dig('middleware', 'authentication', 'enabled') unless yaml_config.dig('middleware', 'authentication', 'enabled').nil?
+                        config.middleware_validation_enabled = yaml_config.dig('middleware', 'validation', 'enabled') unless yaml_config.dig('middleware', 'validation', 'enabled').nil?
+                        config.middleware_logging_enabled = yaml_config.dig('middleware', 'logging', 'enabled') unless yaml_config.dig('middleware', 'logging', 'enabled').nil?
+                        config.auth_secret_key = yaml_config.dig('middleware', 'authentication', 'secret_key') if yaml_config.dig('middleware', 'authentication', 'secret_key')
+                        config.schema_registry_url = yaml_config.dig('middleware', 'validation', 'schema_registry') if yaml_config.dig('middleware', 'validation', 'schema_registry')
+                        config.log_level = yaml_config.dig('middleware', 'logging', 'level') if yaml_config.dig('middleware', 'logging', 'level')
+                        
+                        # Error Handling Configuration
+                        config.max_retries = yaml_config.dig('error_handling', 'max_retries') if yaml_config.dig('error_handling', 'max_retries')
+                        config.retry_delay = yaml_config.dig('error_handling', 'retry_delay') if yaml_config.dig('error_handling', 'retry_delay')
+                        config.dead_letter_queue = yaml_config.dig('error_handling', 'dead_letter_queue') if yaml_config.dig('error_handling', 'dead_letter_queue')
+                    end
+                rescue => e
+                    Rails.logger.warn "Failed to load NATS Wave YAML configuration: #{e.message}"
+                end
+                
+                # Environment-specific overrides
+                if Rails.env.development?
+                    NatsWave.configure do |config|
+                        config.log_level = "debug"
+                        config.middleware_authentication_enabled = false
+                    end
+                elsif Rails.env.test?
+                    NatsWave.configure do |config|
+                        config.publishing_enabled = false
+                        config.subscription_enabled = false
+                    end
+                end
+            end
+        end
+        
+        initializer "nats_wave.active_record" do
+            ActiveSupport.on_load(:active_record) do
+                require 'nats_wave/concerns/publishable'
+                include NatsWave::ActiveRecordExtension
+            end
+        end
+        
+        rake_tasks do
+            load "tasks/nats_wave.rake"
+        end
+        
+        generators do
+            require 'generators/nats_wave/install_generator'
+        end
+        
+        # Initialize client on Rails boot
+        initializer "nats_wave.initialize_client", after: :load_config_initializers do
+            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
+                        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
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/nats_wave/schema_registry.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module NatsWave
+    class SchemaRegistry
+        def initialize(registry_url)
+            @registry_url = registry_url
+            @schemas = {}
+            @uri = URI.parse(registry_url) if registry_url
+        end
+        
+        def validate_message(message, schema_version)
+            return true unless @uri
+            
+            schema = get_schema(schema_version)
+            return true unless schema
+            
+            JSON::Validator.validate(schema, message)
+        end
+        
+        def register_schema(model, version, schema)
+            return false unless @uri
+            
+            endpoint = "/schemas/#{model}/#{version}"
+            response = make_request(:post, endpoint, schema.to_json)
+            
+            if response.code == '200'
+                NatsWave.logger.info("Registered schema for #{model} v#{version}")
+                true
+            else
+                NatsWave.logger.error("Failed to register schema: #{response.body}")
+                false
+            end
+        end
+        
+        def get_schema(schema_version)
+            return @schemas[schema_version] if @schemas[schema_version]
+            
+            endpoint = "/schemas/#{schema_version}"
+            response = make_request(:get, endpoint)
+            
+            if response.code == '200'
+                @schemas[schema_version] = JSON.parse(response.body)
+            else
+                NatsWave.logger.warn("Schema not found: #{schema_version}")
+                nil
+            end
+        rescue StandardError => e
+            NatsWave.logger.error("Failed to fetch schema #{schema_version}: #{e.message}")
+            nil
+        end
+        
+        private
+        
+        def make_request(method, endpoint, body = nil)
+            return nil unless @uri
+            
+            http = Net::HTTP.new(@uri.host, @uri.port)
+            http.use_ssl = @uri.scheme == 'https'
+            
+            request = case method
+                          when :get
+                              Net::HTTP::Get.new(endpoint)
+                          when :post
+                              Net::HTTP::Post.new(endpoint)
+                      end
+            
+            request['Content-Type'] = 'application/json'
+            request.body = body if body
+            
+            http.request(request)
+        end
+    end
+end

data/lib/nats_wave/subscriber.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module NatsWave
+    class Subscriber
+        attr_reader :config, :nats_client
+        
+        def initialize(config, nats_client, middleware_stack)
+            @config = config
+            @nats_client = nats_client
+            @middleware_stack = middleware_stack
+            @database_connector = DatabaseConnector.new(config)
+            @model_mapper = ModelMapper.new(config)
+            @message_transformer = MessageTransformer.new(config)
+            @dead_letter_queue = DeadLetterQueue.new(config)
+            @subscriptions = []
+            @running = false
+        end
+        
+        def start
+            return if @running
+            return unless @config.subscription_enabled
+            
+            @running = true
+            NatsWave.logger.info "Starting NATS subscriber for #{@config.service_name}"
+            
+            @config.subscriptions.each do |subscription|
+                subscribe_to_subject(subscription[:subject],
+                                     subscription[:handler])
+            end
+            
+            NatsWave.logger.info "Subscribed to #{@config.subscriptions.size} subjects"
+        end
+        
+        def subscribe(subjects:, model_mappings: {}, handler: nil)
+            subjects = Array(subjects)
+            
+            subjects.each do |subject|
+                subscribe_to_subject(subject, handler,
+                                     model_mappings)
+            end
+        end
+        
+        def unsubscribe_all
+            @subscriptions.each(&:unsubscribe)
+            @subscriptions.clear
+            @running = false
+        end
+        
+        def database_connected?
+            @database_connector.connected?
+        end
+        
+        def disconnect
+            unsubscribe_all
+        end
+        
+        private
+        
+        def subscribe_to_subject(subject_pattern, custom_handler = nil, model_mappings = {})
+            NatsWave.logger.info "Subscribing to: #{subject_pattern}"
+            
+            subscription = @nats_client.subscribe(
+                    subject_pattern,
+                    queue: @config.queue_group
+            ) do |msg|
+                process_message(msg,
+                                custom_handler, model_mappings)
+            end
+            
+            @subscriptions << subscription
+        end
+        
+        def process_message(raw_message, custom_handler, model_mappings)
+            return unless should_process_message?(raw_message)
+            
+            Metrics.track_processing_time(raw_message) do
+                message = parse_message(raw_message)
+                processed_message = apply_middleware(message)
+                
+                if custom_handler
+                    custom_handler.call(processed_message)
+                else
+                    handle_model_sync(
+                            processed_message, model_mappings
+                    )
+                end
+            end
+            
+            NatsWave.logger.debug('Successfully processed message')
+        rescue StandardError => e
+            handle_error(e, raw_message, message)
+        end
+        
+        def should_process_message?(raw_message)
+            # Skip messages from same service instance
+            message = JSON.parse(raw_message)
+            source = message['source'] || {}
+            
+            return false if source['service'] == @config.service_name &&
+                    source['instance_id'] == @config.instance_id
+            
+            true
+        rescue JSON::ParserError
+            false
+        end
+        
+        def parse_message(raw_message)
+            @message_transformer.parse_message(raw_message)
+        end
+        
+        def apply_middleware(message)
+            @middleware_stack.reduce(message) do |msg, middleware|
+                middleware.call(msg)
+            end
+        end
+        
+        def handle_model_sync(message, model_mappings)
+            source_model = message['model']
+            mapping = model_mappings[source_model] || @config.model_mappings[source_model]
+            
+            return unless mapping
+            
+            target_model = mapping[:target_model]
+            field_mappings = mapping[:field_mappings] || {}
+            transformations = mapping[:transformations] || {}
+            
+            # Transform the data
+            transformed_data = @model_mapper.transform_data(
+                    message['data'],
+                    field_mappings,
+                    transformations
+            )
+            
+            # Apply to database
+            @database_connector.apply_change(
+                    model: target_model,
+                    action: message['action'],
+                    data: transformed_data,
+                    metadata: message['metadata']
+            )
+            
+            NatsWave.logger.info "Synced #{source_model} -> #{target_model}: #{message['action']}"
+        end
+        
+        def handle_error(error, raw_message, parsed_message = nil)
+            event_id = parsed_message&.dig('event_id') || 'unknown'
+            subject = parsed_message&.dig('subject') || 'unknown'
+            
+            NatsWave.logger.error("Error processing message #{event_id} from #{subject}: #{error.message}")
+            
+            # Send to dead letter queue
+            @dead_letter_queue.store_failed_message(
+                    parsed_message || raw_message,
+                    error,
+                    0 # retry count
+            )
+            
+            # Continue processing - don't raise to avoid breaking subscription
+        end
+    end
+end

data/lib/nats_wave/version.rb

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