nats_wave 1.1.8 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26e26c369d6d7d10d4f5c7bcd2f3cc9ba5560b759ff1c4478105c9e6e66853c7
-  data.tar.gz: 9786a3a34f636185b056ca4aed597efc69cd1e07897d57a10636fc51b754b3f3
+  metadata.gz: 76f94cf28e8dfa1742a78ef25bdd1531c4424fdde3b61dfbc61daca7b361bd79
+  data.tar.gz: 0015c75cb71bcae3e0e5ea48c12b7953b838b3d2eb47303a5a5ecc885de5e313
 SHA512:
-  metadata.gz: 10861846ae79ef25b5986752d5caa09a126c1b8d803f1a60df7cf95e2b2b4a288db150216cb827b2018ec7a2ea902188617dbd4beb1da7942ef0c6f052537e1c
-  data.tar.gz: 4e4bdf076e56692299090ad6f9f5dd22387a821f7795f4c5ebc4dc320dc864b5d9159b3a92747ca4b9bf6f2fbab981707d48056af9741a3c1c36ad9df7373032
+  metadata.gz: c015a2d561b28c7526a55cc8e1af696f4df70281e9d82377d878e11fa11b28181323296843484f47bdea3527ebb55881f9a96c62195323d0ebbf79d94903b4d9
+  data.tar.gz: 8dbcbfde92b22e044e187a10ec94d29ff8d3db227015a61bbd0b56f2622de7dba6a01db81a3fa83d45bd4b5b0b737e566434395340333b460ce6d3799cdc49da

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nats_wave (1.1.8)
+    nats_wave (1.1.9)
       activerecord (>= 6.1, < 8.0)
       activesupport (>= 6.1, < 8.0)
       concurrent-ruby (~> 1.1)

data/lib/nats_wave/active_record_extension.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module NatsWave
+    module ActiveRecordExtension
+        extend ActiveSupport::Concern
+        
+        module ClassMethods
+            def nats_publishable(options = {})
+                include NatsWave::NatsPublishable
+                class_attribute :nats_publishing_options
+                self.nats_publishing_options = {
+                        enabled: true,
+                        actions: %i[create update destroy],
+                        skip_attributes: [],
+                        include_associations: [],
+                        async: true
+                }.merge(options)
+                
+                # Register this model for publishing
+                NatsWave.configuration&.add_publication(name, nats_publishing_options[:actions])
+            end
+        end
+    end
+    
+    module NatsPublishable
+        extend ActiveSupport::Concern
+        
+        included do
+            after_commit :trigger_nats_wave_publish_on_create, on: :create, if: :should_publish_create?
+            after_commit :trigger_nats_wave_publish_on_update, on: :update, if: :should_publish_update?
+            after_commit :trigger_nats_wave_publish_on_destroy, on: :destroy, if: :should_publish_destroy?
+        end
+        
+        class_methods do
+            def nats_wave_enabled?
+                nats_publishing_options[:enabled]
+            end
+            
+            def nats_wave_actions
+                nats_publishing_options[:actions]
+            end
+            
+            def nats_wave_skip_attributes
+                nats_publishing_options[:skip_attributes]
+            end
+        end
+        
+        private
+        
+        def should_publish_create?
+            should_publish_action?(:create)
+        end
+        
+        def should_publish_update?
+            should_publish_action?(:update) && has_significant_changes?
+        end
+        
+        def should_publish_destroy?
+            should_publish_action?(:destroy)
+        end
+        
+        def should_publish_action?(action)
+            return false unless self.class.nats_wave_enabled?
+            return false unless self.class.nats_wave_actions.include?(action)
+            return false if Thread.current[:skip_nats_wave_publishing]
+            return false if @skip_nats_wave_publishing
+            
+            # Check conditional options
+            return false if nats_publishing_options[:if] && !instance_eval(&nats_publishing_options[:if])
+            return false if nats_publishing_options[:unless] && instance_eval(&nats_publishing_options[:unless])
+            
+            true
+        end
+        
+        def has_significant_changes?
+            skip_attrs = self.class.nats_wave_skip_attributes.map(&:to_s)
+            significant_changes = previous_changes.except(*skip_attrs, 'updated_at')
+            significant_changes.any?
+        end
+        
+        def trigger_nats_wave_publish_on_create
+            nats_wave_publish('create')
+        end
+        
+        def trigger_nats_wave_publish_on_update
+            nats_wave_publish('update')
+        end
+        
+        def trigger_nats_wave_publish_on_destroy
+            nats_wave_publish('destroy')
+        end
+    end
+end

data/lib/nats_wave/adapters/active_record.rb

@@ -1,3 +1,210 @@
+# # frozen_string_literal: true
+#
+# module NatsWave
+#     module Adapters
+#         class ActiveRecord
+#             def initialize(config)
+#                 @config = config
+#             end
+#
+#             def create_from_external(external_model, data, metadata = {})
+#                 mapping = ModelRegistry.local_models_for(external_model)
+#
+#                 mapping.each do |local_model_name, config|
+#                     create_or_update_local_record(local_model_name, external_model, data, config, 'create')
+#                 end
+#             end
+#
+#             def update_from_external(external_model, data, metadata = {})
+#                 mapping = ModelRegistry.local_models_for(external_model)
+#
+#                 mapping.each do |local_model_name, config|
+#                     create_or_update_local_record(local_model_name, external_model, data, config, 'update')
+#                 end
+#             end
+#
+#             def destroy_from_external(external_model, data, metadata = {})
+#                 mapping = ModelRegistry.local_models_for(external_model)
+#
+#                 mapping.each do |local_model_name, config|
+#                     destroy_local_record(local_model_name, external_model, data, config)
+#                 end
+#             end
+#
+#             # Legacy methods for backward compatibility
+#             def create(model_name, data, metadata = {})
+#                 model_class = get_model_class(model_name)
+#                 clean_data = data.except('created_at', 'updated_at', :created_at, :updated_at)
+#
+#                 with_nats_publishing_disabled do
+#                     record = model_class.create!(clean_data)
+#                     NatsWave.logger.debug("Created #{model_name} with ID: #{record.id}")
+#                     record
+#                 end
+#             rescue => e
+#                 raise DatabaseError, "Failed to create #{model_name}: #{e.message}"
+#             end
+#
+#             def connected?
+#                 return false unless defined?(::ActiveRecord)
+#                 ::ActiveRecord::Base.connected?
+#             rescue
+#                 false
+#             end
+#
+#             private
+#
+#             def create_or_update_local_record(local_model_name, external_model, external_data, config, action)
+#                 model_class = get_model_class(local_model_name)
+#
+#                 # Transform the data using field mappings and transformations
+#                 transformed_data = transform_external_data(external_data, config)
+#
+#                 # Find existing record based on unique fields
+#                 existing_record = find_existing_record(model_class, transformed_data, config[:unique_fields])
+#
+#                 with_nats_publishing_disabled do
+#                     case config[:sync_strategy]
+#                         when :create_only
+#                             create_record_if_not_exists(model_class, existing_record, transformed_data)
+#                         when :update_only
+#                             update_record_if_exists(existing_record, transformed_data) if existing_record
+#                         when :upsert, nil
+#                             upsert_record(model_class, existing_record, transformed_data, config)
+#                     end
+#                 end
+#
+#                 # Track the sync operation
+#                 NatsWave::Metrics.track_sync_operation(
+#                         local_model_name,
+#                         action,
+#                         0, # duration - you could track this
+#                         success: true
+#                 )
+#
+#             rescue => e
+#                 NatsWave.logger.error("Failed to sync #{external_model} to #{local_model_name}: #{e.message}")
+#
+#                 NatsWave::Metrics.track_sync_operation(
+#                         local_model_name,
+#                         action,
+#                         0,
+#                         success: false
+#                 )
+#
+#                 raise DatabaseError, "Sync failed for #{local_model_name}: #{e.message}"
+#             end
+#
+#             def transform_external_data(external_data, config)
+#                 field_mappings = config[:field_mappings] || {}
+#                 transformations = config[:transformations] || {}
+#                 skip_fields = config[:skip_fields] || []
+#
+#                 transformed = {}
+#
+#                 external_data.each do |key, value|
+#                     next if skip_fields.include?(key.to_s) || skip_fields.include?(key.to_sym)
+#
+#                     # Map field name
+#                     local_field = field_mappings[key] || field_mappings[key.to_sym] || key
+#
+#                     # Apply transformation
+#                     if transformations[local_field]
+#                         transformation = transformations[local_field]
+#                         value = case transformation
+#                                     when Proc
+#                                         transformation.arity == 1 ? transformation.call(value) : transformation.call(value, external_data)
+#                                     when Symbol
+#                                         # Would need to be called on the model instance
+#                                         value
+#                                     else
+#                                         value
+#                                 end
+#                     end
+#
+#                     transformed[local_field] = value
+#                 end
+#
+#                 # Remove Rails timestamp fields that might conflict
+#                 transformed.except('created_at', 'updated_at', :created_at, :updated_at)
+#             end
+#
+#             def find_existing_record(model_class, data, unique_fields)
+#                 unique_fields ||= [:id]
+#
+#                 unique_fields.each do |field|
+#                     value = data[field] || data[field.to_sym]
+#                     next unless value
+#
+#                     record = model_class.find_by(field => value)
+#                     return record if record
+#                 end
+#
+#                 nil
+#             end
+#
+#             def create_record_if_not_exists(model_class, existing_record, data)
+#                 return existing_record if existing_record
+#
+#                 record = model_class.create!(data)
+#                 NatsWave.logger.info("Created #{model_class.name} with ID: #{record.id}")
+#                 record
+#             end
+#
+#             def update_record_if_exists(existing_record, data)
+#                 return unless existing_record
+#
+#                 existing_record.update!(data)
+#                 NatsWave.logger.info("Updated #{existing_record.class.name} ID: #{existing_record.id}")
+#                 existing_record
+#             end
+#
+#             def upsert_record(model_class, existing_record, data, config)
+#                 if existing_record
+#                     existing_record.update!(data)
+#                     NatsWave.logger.info("Updated #{model_class.name} ID: #{existing_record.id}")
+#                     existing_record
+#                 else
+#                     record = model_class.create!(data)
+#                     NatsWave.logger.info("Created #{model_class.name} with ID: #{record.id}")
+#                     record
+#                 end
+#             end
+#
+#             def destroy_local_record(local_model_name, external_model, external_data, config)
+#                 model_class = get_model_class(local_model_name)
+#                 transformed_data = transform_external_data(external_data, config)
+#
+#                 existing_record = find_existing_record(model_class, transformed_data, config[:unique_fields])
+#                 return unless existing_record
+#
+#                 with_nats_publishing_disabled do
+#                     if existing_record.respond_to?(:soft_delete)
+#                         existing_record.soft_delete
+#                     else
+#                         existing_record.destroy!
+#                     end
+#
+#                     NatsWave.logger.info("Destroyed #{local_model_name} ID: #{existing_record.id}")
+#                 end
+#             end
+#
+#             def get_model_class(model_name)
+#                 model_name.constantize
+#             rescue NameError
+#                 raise DatabaseError, "Model class '#{model_name}' not found"
+#             end
+#
+#             def with_nats_publishing_disabled(&block)
+#                 Thread.current[:skip_nats_wave_publishing] = true
+#                 yield
+#             ensure
+#                 Thread.current[:skip_nats_wave_publishing] = false
+#             end
+#         end
+#     end
+# end
+
 # frozen_string_literal: true
 
 module NatsWave

data/lib/nats_wave/adapters/datadog_metrics.rb

@@ -77,7 +77,7 @@ module NatsWave
                 {
                         service: @service_name,
                         environment: ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'unknown',
-                        version: ENV['APP_VERSION'] || '1.1.8'
+                        version: ENV['APP_VERSION'] || '1.1.9'
                 }
             end