nats_wave 1.1.8 → 1.1.10

data/lib/nats_wave/concerns/mappable.rb

@@ -1,3 +1,182 @@
+# # frozen_string_literal: true
+#
+# module NatsWave
+#     module Concerns
+#         module Mappable
+#             extend ActiveSupport::Concern
+#
+#             included do
+#                 class_attribute :nats_wave_mapping_config, :nats_wave_subscription_config
+#                 self.nats_wave_mapping_config = {}
+#                 self.nats_wave_subscription_config = {}
+#             end
+#
+#             class_methods do
+#                 # Configure how this model maps to external models
+#                 def nats_wave_maps_to(external_models)
+#                     self.nats_wave_mapping_config = external_models
+#
+#                     # Register this mapping globally
+#                     NatsWave::ModelRegistry.register_mapping(self.name, external_models)
+#                 end
+#
+#                 # Configure how external models map to this model AND what subjects to subscribe to
+#                 def nats_wave_maps_from(external_model, options = {})
+#                     Rails.logger.debug "🔄 #{self.name}: Setting up mapping from #{external_model} with options: #{options.inspect}" if defined?(Rails)
+#
+#                     mapping = {
+#                             field_mappings: options[:field_mappings] || {},
+#                             transformations: options[:transformations] || {},
+#                             conditions: options[:conditions] || {},
+#                             sync_strategy: options[:sync_strategy] || :upsert,
+#                             unique_fields: options[:unique_fields] || [:id],
+#                             skip_fields: options[:skip_fields] || [],
+#                             subjects: options[:subjects] || [],
+#                             handler: options[:handler],
+#                             queue_group: options[:queue_group]
+#                     }
+#
+#                     self.nats_wave_mapping_config[external_model] = mapping
+#
+#                     Rails.logger.debug "🔄 #{self.name}: Registering reverse mapping for #{external_model}" if defined?(Rails)
+#                     NatsWave::ModelRegistry.register_reverse_mapping(external_model, self.name, mapping)
+#
+#                     # Register subscription if subjects are provided
+#                     if mapping[:subjects].any?
+#                         Rails.logger.debug "🔄 #{self.name}: Registering subscription for subjects: #{mapping[:subjects]}" if defined?(Rails)
+#                         NatsWave::ModelRegistry.register_subscription(
+#                                 subjects: mapping[:subjects],
+#                                 model: self.name,
+#                                 external_model: external_model,
+#                                 handler: mapping[:handler],
+#                                 queue_group: mapping[:queue_group]
+#                         )
+#                     else
+#                         Rails.logger.debug "🔄 #{self.name}: No subjects provided, skipping subscription registration" if defined?(Rails)
+#                     end
+#                 end
+#
+#                 # Configure subscriptions without model mapping (for custom handlers)
+#                 def nats_wave_subscribes_to(*subjects, handler: nil, queue_group: nil, &block)
+#                     handler ||= block
+#
+#                     Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
+#
+#                     subscription_config = {
+#                             subjects: subjects.flatten,
+#                             handler: handler,
+#                             queue_group: queue_group,
+#                             model: self.name
+#                     }
+#
+#                     self.nats_wave_subscription_config[:custom] = subscription_config
+#
+#                     Rails.logger.debug "📡 #{self.name}: Registering subscription in ModelRegistry" if defined?(Rails)
+#                     NatsWave::ModelRegistry.register_subscription(
+#                             subjects: subjects.flatten,
+#                             model: self.name,
+#                             handler: handler,
+#                             queue_group: queue_group
+#                     )
+#                 end
+#
+#                 # Auto-generate subjects based on external model pattern
+#                 def nats_wave_auto_subjects_for(external_model, service_prefix: nil, actions: [:create, :update, :destroy])
+#                     model_name = external_model.underscore
+#
+#                     if service_prefix
+#                         subjects = actions.map { |action| "#{service_prefix}.#{model_name}.#{action}" }
+#                         subjects << "#{service_prefix}.#{model_name}.*" # Wildcard for all actions
+#                     else
+#                         # Try to infer from common patterns
+#                         subjects = [
+#                                 "#{model_name}.*", # Simple pattern
+#                                 "events.#{model_name}.*", # Events pattern
+#                                 "*.#{model_name}.*", # Service.model pattern
+#                                 "*.events.#{model_name}.*" # Service.events.model pattern
+#                         ]
+#                     end
+#
+#                     subjects
+#                 end
+#
+#                 # Get mapping configuration for an external model
+#                 def nats_wave_mapping_for(external_model)
+#                     nats_wave_mapping_config[external_model]
+#                 end
+#
+#                 # Check if this model can sync from an external model
+#                 def nats_wave_can_sync_from?(external_model)
+#                     nats_wave_mapping_config.key?(external_model)
+#                 end
+#
+#                 # Get all external models this model can sync from
+#                 def nats_wave_external_models
+#                     nats_wave_mapping_config.keys
+#                 end
+#
+#                 # Get all subjects this model subscribes to
+#                 def nats_wave_subscribed_subjects
+#                     subjects = []
+#
+#                     # From model mappings
+#                     nats_wave_mapping_config.each do |_, config|
+#                         subjects.concat(config[:subjects] || [])
+#                     end
+#
+#                     # From custom subscriptions
+#                     if nats_wave_subscription_config[:custom]
+#                         subjects.concat(nats_wave_subscription_config[:custom][:subjects] || [])
+#                     end
+#
+#                     subjects.uniq
+#                 end
+#             end
+#
+#             # Instance methods remain the same...
+#             def nats_wave_mapped_attributes_for(target_model)
+#                 mapping = self.class.nats_wave_mapping_config[target_model]
+#                 return attributes unless mapping
+#
+#                 mapped_attrs = {}
+#                 field_mappings = mapping[:field_mappings] || {}
+#                 skip_fields = mapping[:skip_fields] || []
+#
+#                 attributes.each do |key, value|
+#                     next if skip_fields.include?(key.to_s) || skip_fields.include?(key.to_sym)
+#
+#                     mapped_key = field_mappings[key] || field_mappings[key.to_sym] || key
+#                     mapped_attrs[mapped_key] = transform_value(value, mapped_key, mapping[:transformations] || {})
+#                 end
+#
+#                 mapped_attrs
+#             end
+#
+#             def nats_wave_unique_identifier_for(external_model)
+#                 mapping = self.class.nats_wave_mapping_config[external_model]
+#                 unique_fields = mapping&.dig(:unique_fields) || [:id]
+#
+#                 unique_fields.map { |field| [field, send(field)] }.to_h
+#             end
+#
+#             private
+#
+#             def transform_value(value, field, transformations)
+#                 transformation = transformations[field] || transformations[field.to_sym]
+#
+#                 case transformation
+#                     when Proc
+#                         transformation.call(value)
+#                     when Symbol
+#                         send(transformation, value) if respond_to?(transformation, true)
+#                     else
+#                         value
+#                 end
+#             end
+#         end
+#     end
+# end
+
 # frozen_string_literal: true
 
 module NatsWave
@@ -6,172 +185,357 @@ module NatsWave
             extend ActiveSupport::Concern
             
             included do
-                class_attribute :nats_wave_mapping_config, :nats_wave_subscription_config
-                self.nats_wave_mapping_config = {}
+                class_attribute :nats_wave_subscription_config, :nats_wave_publishing_config
                 self.nats_wave_subscription_config = {}
+                self.nats_wave_publishing_config = {}
             end
             
             class_methods do
-                # Configure how this model maps to external models
-                def nats_wave_maps_to(external_models)
-                    self.nats_wave_mapping_config = external_models
+                # Configure subscriptions with optional custom handler
+                def nats_wave_subscribes_to(*subjects, **options, &block)
+                    Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
                     
-                    # Register this mapping globally
-                    NatsWave::ModelRegistry.register_mapping(self.name, external_models)
-                end
-                
-                # Configure how external models map to this model AND what subjects to subscribe to
-                def nats_wave_maps_from(external_model, options = {})
-                    Rails.logger.debug "🔄 #{self.name}: Setting up mapping from #{external_model} with options: #{options.inspect}" if defined?(Rails)
+                    handler = options[:handler] || block
                     
-                    mapping = {
+                    subscription_config = {
+                            subjects: subjects.flatten,
                             field_mappings: options[:field_mappings] || {},
                             transformations: options[:transformations] || {},
-                            conditions: options[:conditions] || {},
-                            sync_strategy: options[:sync_strategy] || :upsert,
-                            unique_fields: options[:unique_fields] || [:id],
                             skip_fields: options[:skip_fields] || [],
-                            subjects: options[:subjects] || [],
-                            handler: options[:handler],
-                            queue_group: options[:queue_group]
+                            unique_fields: options[:unique_fields] || [:id],
+                            sync_strategy: options[:sync_strategy] || :upsert,
+                            handler: handler,
+                            queue_group: options[:queue_group],
+                            auto_sync: options[:auto_sync] != false # Default to true, can be disabled
                     }
                     
-                    self.nats_wave_mapping_config[external_model] = mapping
-                    
-                    Rails.logger.debug "🔄 #{self.name}: Registering reverse mapping for #{external_model}" if defined?(Rails)
-                    NatsWave::ModelRegistry.register_reverse_mapping(external_model, self.name, mapping)
-                    
-                    # Register subscription if subjects are provided
-                    if mapping[:subjects].any?
-                        Rails.logger.debug "🔄 #{self.name}: Registering subscription for subjects: #{mapping[:subjects]}" if defined?(Rails)
-                        NatsWave::ModelRegistry.register_subscription(
-                                subjects: mapping[:subjects],
-                                model: self.name,
-                                external_model: external_model,
-                                handler: mapping[:handler],
-                                queue_group: mapping[:queue_group]
-                        )
-                    else
-                        Rails.logger.debug "🔄 #{self.name}: No subjects provided, skipping subscription registration" if defined?(Rails)
-                    end
+                    # Store the config
+                    config_key = subjects.join(',')
+                    self.nats_wave_subscription_config[config_key] = subscription_config
+                    
+                    # Create the subscription handler
+                    processed_handler = create_subscription_handler(subscription_config)
+                    
+                    # Register the subscription
+                    NatsWave::ModelRegistry.register_subscription(
+                            subjects: subjects.flatten,
+                            model: self.name,
+                            handler: processed_handler,
+                            queue_group: subscription_config[:queue_group]
+                    )
+                    
+                    Rails.logger.debug "📡 #{self.name}: Registered subscription for subjects: #{subjects}" if defined?(Rails)
                 end
                 
-                # Configure subscriptions without model mapping (for custom handlers)
-                def nats_wave_subscribes_to(*subjects, handler: nil, queue_group: nil, &block)
-                    handler ||= block
+                # Configure publishing with optional custom handler
+                def nats_wave_publishes_to(*subjects, **options, &block)
+                    Rails.logger.debug "📤 #{self.name}: Setting up publishing to subjects: #{subjects.inspect}" if defined?(Rails)
                     
-                    Rails.logger.debug "📡 #{self.name}: Setting up subscription to subjects: #{subjects.inspect}" if defined?(Rails)
+                    handler = options[:handler] || block
                     
-                    subscription_config = {
+                    publishing_config = {
                             subjects: subjects.flatten,
+                            field_mappings: options[:field_mappings] || {},
+                            transformations: options[:transformations] || {},
+                            skip_fields: options[:skip_fields] || [],
+                            conditions: options[:conditions] || {},
+                            actions: options[:actions] || [:create, :update, :destroy],
                             handler: handler,
-                            queue_group: queue_group,
-                            model: self.name
+                            async: options[:async] != false, # Default to true
+                            enabled: options[:enabled] != false # Default to true
                     }
                     
-                    self.nats_wave_subscription_config[:custom] = subscription_config
+                    # Store the config
+                    config_key = subjects.join(',')
+                    self.nats_wave_publishing_config[config_key] = publishing_config
                     
-                    Rails.logger.debug "📡 #{self.name}: Registering subscription in ModelRegistry" if defined?(Rails)
-                    NatsWave::ModelRegistry.register_subscription(
-                            subjects: subjects.flatten,
-                            model: self.name,
-                            handler: handler,
-                            queue_group: queue_group
-                    )
+                    Rails.logger.debug "📤 #{self.name}: Registered publishing config for subjects: #{subjects}" if defined?(Rails)
                 end
                 
-                # Auto-generate subjects based on external model pattern
-                def nats_wave_auto_subjects_for(external_model, service_prefix: nil, actions: [:create, :update, :destroy])
-                    model_name = external_model.underscore
-                    
-                    if service_prefix
-                        subjects = actions.map { |action| "#{service_prefix}.#{model_name}.#{action}" }
-                        subjects << "#{service_prefix}.#{model_name}.*" # Wildcard for all actions
-                    else
-                        # Try to infer from common patterns
-                        subjects = [
-                                "#{model_name}.*", # Simple pattern
-                                "events.#{model_name}.*", # Events pattern
-                                "*.#{model_name}.*", # Service.model pattern
-                                "*.events.#{model_name}.*" # Service.events.model pattern
-                        ]
-                    end
-                    
-                    subjects
+                # Get all subscription configurations
+                def nats_wave_subscription_configs
+                    nats_wave_subscription_config
                 end
                 
-                # Get mapping configuration for an external model
-                def nats_wave_mapping_for(external_model)
-                    nats_wave_mapping_config[external_model]
+                # Get all publishing configurations
+                def nats_wave_publishing_configs
+                    nats_wave_publishing_config
                 end
                 
-                # Check if this model can sync from an external model
-                def nats_wave_can_sync_from?(external_model)
-                    nats_wave_mapping_config.key?(external_model)
+                # Get all subjects this model subscribes to
+                def nats_wave_subscribed_subjects
+                    nats_wave_subscription_config.values.flat_map { |config| config[:subjects] }.uniq
                 end
                 
-                # Get all external models this model can sync from
-                def nats_wave_external_models
-                    nats_wave_mapping_config.keys
+                # Get all subjects this model publishes to
+                def nats_wave_published_subjects
+                    nats_wave_publishing_config.values.flat_map { |config| config[:subjects] }.uniq
                 end
                 
-                # Get all subjects this model subscribes to
-                def nats_wave_subscribed_subjects
-                    subjects = []
+                private
+                
+                # Create a subscription handler that processes data and calls custom handler or auto-sync
+                def create_subscription_handler(config)
+                    model_class = self
                     
-                    # From model mappings
-                    nats_wave_mapping_config.each do |_, config|
-                        subjects.concat(config[:subjects] || [])
+                    lambda do |message|
+                        begin
+                            Rails.logger.debug "📨 Processing subscription message for #{model_class.name}" if defined?(Rails)
+                            
+                            # Extract the raw data
+                            raw_data = message['data'] || {}
+                            model_name = message['model']
+                            action = message['action']
+                            
+                            # Process the data through mappings and transformations
+                            processed_data = model_class.process_data(raw_data, config)
+                            
+                            # If custom handler is provided, call it with model_name, action, processed_data
+                            if config[:handler]
+                                Rails.logger.debug "📨 Calling custom subscription handler" if defined?(Rails)
+                                config[:handler].call(model_name, action, processed_data, message)
+                            elsif config[:auto_sync]
+                                Rails.logger.debug "📨 Performing auto-sync" if defined?(Rails)
+                                # Default auto-sync behavior
+                                model_class.perform_auto_sync(model_name, action, processed_data, config)
+                            else
+                                Rails.logger.debug "📨 No handler provided and auto_sync disabled" if defined?(Rails)
+                            end
+                        
+                        rescue => e
+                            Rails.logger.error "Error in subscription handler for #{model_class.name}: #{e.message}" if defined?(Rails)
+                            Rails.logger.error e.backtrace.join("\n") if defined?(Rails)
+                            raise
+                        end
                     end
+                end
+                
+                # Process data through field mappings and transformations (used by both subscription and publishing)
+                def process_data(raw_data, config)
+                    processed_data = {}
+                    field_mappings = config[:field_mappings]
+                    transformations = config[:transformations]
+                    skip_fields = config[:skip_fields]
                     
-                    # From custom subscriptions
-                    if nats_wave_subscription_config[:custom]
-                        subjects.concat(nats_wave_subscription_config[:custom][:subjects] || [])
+                    raw_data.each do |field, value|
+                        field_str = field.to_s
+                        field_sym = field.to_sym
+                        
+                        # Skip if in skip_fields
+                        next if skip_fields.include?(field_str) || skip_fields.include?(field_sym)
+                        
+                        # Apply field mapping
+                        mapped_field = field_mappings[field_str] ||
+                                field_mappings[field_sym] ||
+                                field
+                        
+                        # Apply transformation if any
+                        transformed_value = apply_transformation(value, mapped_field, transformations, raw_data)
+                        
+                        processed_data[mapped_field.to_s] = transformed_value
                     end
                     
-                    subjects.uniq
+                    processed_data
                 end
-            end
-            
-            # Instance methods remain the same...
-            def nats_wave_mapped_attributes_for(target_model)
-                mapping = self.class.nats_wave_mapping_config[target_model]
-                return attributes unless mapping
                 
-                mapped_attrs = {}
-                field_mappings = mapping[:field_mappings] || {}
-                skip_fields = mapping[:skip_fields] || []
+                # Apply transformations to field values
+                def apply_transformation(value, field, transformations, full_record)
+                    transformation = transformations[field] || transformations[field.to_sym]
+                    
+                    case transformation
+                        when Proc
+                            if transformation.arity == 2 || transformation.arity < 0
+                                transformation.call(value, full_record)
+                            else
+                                transformation.call(value)
+                            end
+                        when Symbol
+                            if self.respond_to?(transformation, true)
+                                self.send(transformation, value)
+                            elsif value.respond_to?(transformation)
+                                value.send(transformation)
+                            else
+                                Rails.logger.warn "Transformation method #{transformation} not found" if defined?(Rails)
+                                value
+                            end
+                        else
+                            value
+                    end
+                end
                 
-                attributes.each do |key, value|
-                    next if skip_fields.include?(key.to_s) || skip_fields.include?(key.to_sym)
+                # Default auto-sync behavior
+                def perform_auto_sync(model_name, action, processed_data, config)
+                    unique_fields = config[:unique_fields]
+                    sync_strategy = config[:sync_strategy]
                     
-                    mapped_key = field_mappings[key] || field_mappings[key.to_sym] || key
-                    mapped_attrs[mapped_key] = transform_value(value, mapped_key, mapping[:transformations] || {})
+                    case action.to_s.downcase
+                        when 'create', 'created'
+                            handle_auto_create(processed_data, unique_fields, sync_strategy)
+                        when 'update', 'updated'
+                            handle_auto_update(processed_data, unique_fields, sync_strategy)
+                        when 'delete', 'deleted', 'destroy', 'destroyed'
+                            handle_auto_delete(processed_data, unique_fields)
+                        else
+                            Rails.logger.warn "Unknown action for auto-sync: #{action}" if defined?(Rails)
+                    end
+                end
+                
+                def handle_auto_create(data, unique_fields, sync_strategy)
+                    case sync_strategy
+                        when :upsert
+                            existing = find_by_unique_fields(data, unique_fields)
+                            if existing
+                                existing.update!(data)
+                                Rails.logger.info "✅ Updated existing #{self.name}: #{existing.id}" if defined?(Rails)
+                            else
+                                record = self.create!(data)
+                                Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+                            end
+                        when :create_only
+                            record = self.create!(data)
+                            Rails.logger.info "✅ Created new #{self.name}: #{record.id}" if defined?(Rails)
+                    end
+                rescue => e
+                    Rails.logger.error "❌ Failed to create #{self.name}: #{e.message}" if defined?(Rails)
+                    raise
                 end
                 
-                mapped_attrs
+                def handle_auto_update(data, unique_fields, sync_strategy)
+                    existing = find_by_unique_fields(data, unique_fields)
+                    if existing
+                        existing.update!(data)
+                        Rails.logger.info "✅ Updated #{self.name}: #{existing.id}" if defined?(Rails)
+                    elsif sync_strategy == :upsert
+                        record = self.create!(data)
+                        Rails.logger.info "✅ Created new #{self.name} during update: #{record.id}" if defined?(Rails)
+                    else
+                        Rails.logger.warn "⚠️  Record not found for update: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+                    end
+                rescue => e
+                    Rails.logger.error "❌ Failed to update #{self.name}: #{e.message}" if defined?(Rails)
+                    raise
+                end
+                
+                def handle_auto_delete(data, unique_fields)
+                    existing = find_by_unique_fields(data, unique_fields)
+                    if existing
+                        existing.destroy!
+                        Rails.logger.info "✅ Deleted #{self.name}: #{existing.id}" if defined?(Rails)
+                    else
+                        Rails.logger.warn "⚠️  Record not found for deletion: #{data.slice(*unique_fields.map(&:to_s))}" if defined?(Rails)
+                    end
+                rescue => e
+                    Rails.logger.error "❌ Failed to delete #{self.name}: #{e.message}" if defined?(Rails)
+                    raise
+                end
+                
+                def find_by_unique_fields(data, unique_fields)
+                    conditions = {}
+                    unique_fields.each do |field|
+                        field_str = field.to_s
+                        if data.key?(field_str)
+                            conditions[field] = data[field_str]
+                        elsif data.key?(field.to_sym)
+                            conditions[field] = data[field.to_sym]
+                        end
+                    end
+                    
+                    return nil if conditions.empty?
+                    self.find_by(conditions)
+                end
             end
             
-            def nats_wave_unique_identifier_for(external_model)
-                mapping = self.class.nats_wave_mapping_config[external_model]
-                unique_fields = mapping&.dig(:unique_fields) || [:id]
+            # Instance methods for publishing
+            def nats_wave_publish(action = nil)
+                action ||= determine_action_from_context
                 
-                unique_fields.map { |field| [field, send(field)] }.to_h
+                self.class.nats_wave_publishing_configs.each do |subjects_key, config|
+                    next unless config[:enabled]
+                    next unless config[:actions].include?(action.to_sym)
+                    
+                    # Check conditions (only for publishing)
+                    if config[:conditions].any? && !evaluate_conditions(config[:conditions])
+                        Rails.logger.debug "📤 Skipping publish - conditions not met" if defined?(Rails)
+                        next
+                    end
+                    
+                    # Get the raw data (current model attributes)
+                    raw_data = get_raw_attributes
+                    
+                    # Process the data through mappings and transformations (same as subscription)
+                    processed_data = self.class.process_data(raw_data, config)
+                    
+                    # If custom handler is provided, call it
+                    if config[:handler]
+                        Rails.logger.debug "📤 Calling custom publishing handler" if defined?(Rails)
+                        config[:handler].call(self.class.name, action, processed_data, self)
+                    else
+                        # Default publishing behavior - publish the processed data
+                        config[:subjects].each do |subject|
+                            NatsWave.client.publish(
+                                    subject: subject,
+                                    model: self.class.name,
+                                    action: action,
+                                    data: processed_data, # This is the processed data, not raw attributes
+                                    metadata: build_publishing_metadata
+                            )
+                            
+                            Rails.logger.info "📤 Published #{self.class.name}##{id} to #{subject} (#{action})" if defined?(Rails)
+                        end
+                    end
+                end
+            rescue StandardError => e
+                Rails.logger.error("Failed to publish: #{e.message}") if defined?(Rails)
+                # Don't re-raise to avoid breaking transactions
             end
             
             private
             
-            def transform_value(value, field, transformations)
-                transformation = transformations[field] || transformations[field.to_sym]
-                
-                case transformation
-                    when Proc
-                        transformation.call(value)
-                    when Symbol
-                        send(transformation, value) if respond_to?(transformation, true)
-                    else
-                        value
+            def determine_action_from_context
+                # Try to determine action from ActiveRecord context
+                if defined?(ActiveRecord) && is_a?(ActiveRecord::Base)
+                    return 'create' if previously_new_record?
+                    return 'update' if saved_changes.any?
+                    return 'destroy' if destroyed?
                 end
+                
+                'update' # Default fallback
+            end
+            
+            def get_raw_attributes
+                # Get attributes (works for both ActiveRecord and other objects)
+                if respond_to?(:attributes)
+                    attributes
+                else
+                    # For non-ActiveRecord objects, get instance variables
+                    instance_variables.map { |v| [v.to_s.delete('@'), instance_variable_get(v)] }.to_h
+                end
+            end
+            
+            def evaluate_conditions(conditions)
+                conditions.all? do |condition, expected_value|
+                    case condition
+                        when Proc
+                            condition.call(self)
+                        when Symbol, String
+                            if respond_to?(condition, true)
+                                result = send(condition)
+                                expected_value.nil? ? result : result == expected_value
+                            else
+                                false
+                            end
+                        else
+                            false
+                    end
+                end
+            end
+            
+            def build_publishing_metadata
+                {
+                        source_model: self.class.name,
+                        source_id: respond_to?(:id) ? id : object_id,
+                        published_at: Time.current.iso8601
+                }
             end
         end
     end