nats_wave 1.1.8 → 1.1.10

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.8"
+            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.10"
             @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/database_connector.rb

@@ -1,3 +1,54 @@
+# # frozen_string_literal: true
+#
+# module NatsWave
+#     class DatabaseConnector
+#         def initialize(config)
+#             @config = config
+#             @adapter = determine_adapter
+#         end
+#
+#         def apply_change(model:, action:, data:, metadata:)
+#             case action.to_s.downcase
+#                 when 'create'
+#                     create_record(model, data, metadata)
+#                 when 'update'
+#                     update_record(model, data, metadata)
+#                 when 'delete', 'destroy'
+#                     delete_record(model, data, metadata)
+#                 else
+#                     NatsWave.logger.warn("Unknown action: #{action}")
+#             end
+#         rescue StandardError => e
+#             NatsWave.logger.error("Database operation failed: #{e.message}")
+#             raise DatabaseError, "Database operation failed: #{e.message}"
+#         end
+#
+#         def connected?
+#             @adapter.connected?
+#         end
+#
+#         private
+#
+#         def determine_adapter
+#             raise ConfigurationError, 'No supported database adapter found' unless defined?(ActiveRecord)
+#
+#             Adapters::ActiveRecord.new(@config)
+#         end
+#
+#         def create_record(model, data, metadata)
+#             @adapter.create(model, data, metadata)
+#         end
+#
+#         def update_record(model, data, metadata)
+#             @adapter.update(model, data, metadata)
+#         end
+#
+#         def delete_record(model, data, metadata)
+#             @adapter.delete(model, data, metadata)
+#         end
+#     end
+# end
+
 # frozen_string_literal: true
 
 module NatsWave

data/lib/nats_wave/publisher.rb

@@ -1,47 +1,150 @@
-# # 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
+# # # frozen_string_literal: true
 # #
-# #             def publish(subject, message)
-# #                 puts "NATS: Publishing to #{subject}: #{message}"
-# #             end
+# # require 'securerandom'
+# # require 'json'
 # #
-# #             def subscribe(subject, options = {})
-# #                 puts "NATS: Subscribing to #{subject}"
-# #                 yield('{"mock": "message"}') if block_given?
-# #                 Subscription.new
-# #             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
 # #
-# #             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, :client
+#
+#         def initialize(config, client, middleware_stack = [])
+#             @config = config
+#             @client = client
+#             @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)
+#             full_subject = build_full_subject(subject)
+#
+#             if @config.async_publishing && defined?(Concurrent)
+#                 publish_async(full_subject, message)
+#             else
+#                 publish_sync(full_subject, message)
+#             end
+#
+#             # 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)
+#             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
+#             }
+#
+#             subject = "#{@config.default_subject_prefix}.batch"
+#
+#             @client.publish(subject, batch_message.to_json)
+#
+#             # Metrics.increment_published_messages(subject)
+#             NatsWave.logger.info("Published batch with #{events.size} events")
+#         end
+#
+#         def connected?
+#             @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 publish_sync(subject, message)
+#             @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
+#                     @client.publish(subject, message.to_json)
+#                     NatsWave.logger.debug("Published async message to #{subject}")
+#                 end
+#             else
+#                 publish_sync(subject, message)
+#             end
+#         end
+#     end
+# end
 
-# frozen_string_literal: true
 
 module NatsWave
     class Publisher

data/lib/nats_wave/railtie.rb

@@ -1,3 +1,123 @@
+# # 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
+#                     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
+#                         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
+#         #         # Load the ActiveRecord extension (this replaces the old publishable)
+#         #         require 'nats_wave/adapters/active_record'
+#         #         include NatsWave::ActiveRecord
+#         #     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 2 # Give Rails time to fully boot
+#                         begin
+#                             NatsWave.client
+#                             NatsWave.logger.info "NatsWave client initialized"
+#
+#                             # Start subscriber if enabled
+#                             if NatsWave.configuration&.subscription_enabled
+#                                 NatsWave.client.start_subscriber
+#                                 NatsWave.logger.info "NatsWave subscriber started"
+#                             end
+#                         rescue => e
+#                             NatsWave.logger.error "Failed to initialize NatsWave client: #{e.message}"
+#                         end
+#                     end
+#                 end
+#             end
+#         end
+#     end
+# end
+
 # frozen_string_literal: true
 
 require 'rails/railtie'
@@ -77,9 +197,16 @@ module NatsWave
             end
         end
         
+        # Load extensions before ActiveRecord loads models
+        initializer "nats_wave.load_extensions", before: :load_config_initializers do
+            # Load the extensions early so they're available when models are loaded
+            require 'nats_wave/active_record_extension'
+            require 'nats_wave/concerns/mappable'
+        end
+        
         initializer "nats_wave.active_record" do
             ActiveSupport.on_load(:active_record) do
-                require 'nats_wave/concerns/publishable'
+                # The modules are already loaded, just include them
                 include NatsWave::ActiveRecordExtension
             end
         end
@@ -101,6 +228,12 @@ module NatsWave
                         begin
                             NatsWave.client
                             NatsWave.logger.info "NatsWave client initialized"
+                            
+                            # Start subscriber if enabled
+                            if NatsWave.configuration&.subscription_enabled
+                                NatsWave.client.start_subscriber
+                                NatsWave.logger.info "NatsWave subscriber started"
+                            end
                         rescue => e
                             NatsWave.logger.error "Failed to initialize NatsWave client: #{e.message}"
                         end