nats_wave 1.1.8 → 1.1.10

data/lib/nats_wave/concerns/publishable.rb

@@ -1,216 +0,0 @@
-# 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 :publish_to_nats_on_create, on: :create, if: :should_publish_create?
-            after_commit :publish_to_nats_on_update, on: :update,
-                         if: :should_publish_update?
-            after_commit :publish_to_nats_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
-            
-            def nats_wave_unique_attributes
-                # Override this method in your models to define unique attributes for syncing
-                %i[email slug code external_icn].select do |attr|
-                    column_names.include?(attr.to_s)
-                end
-            end
-            
-            def nats_wave_skip_sync_attributes
-                # Override this method to define attributes that shouldn't be synced from other instances
-                %w[created_at updated_at]
-            end
-            
-            def nats_wave_attribute_transformations
-                # Override this method to define custom transformations
-                {}
-            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 publish_to_nats_on_create
-            publish_to_nats('create', attributes, build_metadata)
-        end
-        
-        def publish_to_nats_on_update
-            publish_to_nats('update', previous_changes, build_metadata)
-        end
-        
-        def publish_to_nats_on_destroy
-            publish_to_nats('destroy', attributes, build_metadata)
-        end
-        
-        def publish_to_nats(action, _data, metadata)
-            subject = build_nats_subject(action)
-            
-            NatsWave.client.publish(
-                    subject: subject,
-                    model: self.class.name,
-                    action: action,
-                    data: publishable_attributes,
-                    metadata: metadata
-            )
-        rescue StandardError => e
-            NatsWave.logger.error("Failed to publish NATS event: #{e.message}")
-            # Don't raise to avoid breaking the main transaction
-        end
-        
-        def build_nats_subject(action)
-            prefix = nats_publishing_options&.dig(:subject_prefix)
-            model_name = self.class.name.underscore
-            
-            if prefix
-                "#{prefix}.#{model_name}.#{action}"
-            else
-                "#{model_name}.#{action}"
-            end
-        end
-        
-        def publishable_attributes
-            attrs = if nats_publishing_options&.dig(:only)
-                        attributes.slice(*nats_publishing_options[:only].map(&:to_s))
-                    elsif nats_publishing_options&.dig(:except)
-                        attributes.except(*nats_publishing_options[:except].map(&:to_s))
-                    else
-                        attributes
-                    end
-            
-            # Add associations if configured
-            attrs.merge!(serialize_associations) if nats_publishing_options[:include_associations].present?
-            
-            attrs
-        end
-        
-        def serialize_associations
-            associations = {}
-            
-            self.class.reflect_on_all_associations.each do |association|
-                unless nats_publishing_options[:include_associations].include?(association.name)
-                    next
-                end
-                
-                case association.macro
-                    when :belongs_to
-                        if (related = send(association.name))
-                            associations["#{association.name}_id"] =
-                                    related.id
-                            if association.polymorphic?
-                                associations["#{association.name}_type"] =
-                                        related.class.name
-                            end
-                        end
-                    when :has_many, :has_and_belongs_to_many
-                        if respond_to?("#{association.name}_ids")
-                            associations["#{association.name.to_s.singularize}_ids"] =
-                                    send("#{association.name}_ids")
-                        end
-                    when :has_one
-                        if (related = send(association.name))
-                            associations["#{association.name}_id"] =
-                                    related.id
-                        end
-                end
-            end
-            
-            associations
-        end
-        
-        def build_metadata
-            metadata = {
-                    model_id: id,
-                    model_type: self.class.name,
-                    table_name: self.class.table_name,
-                    primary_key: self.class.primary_key
-            }
-            
-            # Add custom metadata if method exists
-            metadata.merge!(nats_wave_metadata) if respond_to?(:nats_wave_metadata,
-                                                               true)
-            
-            # Add configured metadata
-            metadata.merge!(nats_publishing_options[:metadata]) if nats_publishing_options[:metadata]
-            
-            metadata
-        end
-        
-        def skip_nats_wave_publishing!
-            @skip_nats_wave_publishing = true
-        end
-        
-        def enable_nats_wave_publishing!
-            @skip_nats_wave_publishing = false
-        end
-    end
-end