activity_notification 2.4.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d670191ff319b7ca33142f0f92cdd3d0332287082d4512515175492431a14b2d
-  data.tar.gz: da39c715f28ae37adc1da46ca3b148b7664627f9e0a9bd924200707340599b18
+  metadata.gz: 7ac9e17e63d801b74604936ea099825e1eedd68c5f743b35c01e7af9e73d90ab
+  data.tar.gz: 07db03884cf03f86db283a7b5cbd92f7629277ea5f4f5a910629924471ff62e3
 SHA512:
-  metadata.gz: 82104cb3b70c4530714d56a91bec204bc7ffc5c4a0f93c6646f483b7eff888b5906c20613410df2df423c155eb8a18771538e30b07c59e07d525dda35afbf9a7
-  data.tar.gz: c0c9027327dbd0667bced6899cb619a4463bef3ff131c8818d3388ea6e5abeeffa51ce63990f6770210d98d06c504972cc33996593f58f14dce4de4089d95632
+  metadata.gz: 91e6206957623ce19971e581afa07fe3b464b02273a968c17bbf145da5836aecbd9b0919b05fae844f912a003a9eeb0d2d4a1df011889ba6bcfb7d752c632346
+  data.tar.gz: 0efe5572854a47c271f6b79b1e0ad649b0d491c1ba4b5370a09a78a0876b4f684bf841069fbaba26fff24e3735ae6b11eeb9bf92ce75f359776d59fd526519ce

data/README.md

@@ -24,6 +24,7 @@
 * Grouping notifications (grouping like *"Kevin and 7 other users posted comments to this article"*)
 * Email notification
 * Batch email notification (event driven or periodical email notification, daily or weekly etc)
+* Cascading notifications (progressive notification escalation through multiple channels with time delays)
 * Push notification with [Action Cable](https://guides.rubyonrails.org/action_cable_overview.html)
 * Subscription management (subscribing and unsubscribing for each target and notification type)
 * REST API backend and [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification)
@@ -104,6 +105,7 @@ You can see sample single page application using [Vue.js](https://vuejs.org) as
     - [Batch email subject](/docs/Functions.md#batch-email-subject)
     - [i18n for batch email](/docs/Functions.md#i18n-for-batch-email)
   - [Grouping notifications](/docs/Functions.md#grouping-notifications)
+  - [Cascading notifications](/docs/Functions.md#cascading-notifications)
   - [Subscription management](/docs/Functions.md#subscription-management)
     - [Configuring subscriptions](/docs/Functions.md#configuring-subscriptions)
     - [Managing subscriptions](/docs/Functions.md#managing-subscriptions)
@@ -325,9 +327,9 @@ See [Testing](/docs/Testing.md#Testing).
 
 ## Documentation
 
-See [API Reference](http://www.rubydoc.info/github/simukappu/activity_notification/index) for more details.
+`docs/` contains documentation for users to read. These files are included in the distributed Gem. `ai-docs/` contains AI-generated and design documents. These files are not included in the distributed Gem.
 
-RubyDoc.info does not support parsing methods in *included* and *class_methods* of *ActiveSupport::Concern* currently.
+See [API Reference](http://www.rubydoc.info/github/simukappu/activity_notification/index) for more details. RubyDoc.info does not support parsing methods in *included* and *class_methods* of *ActiveSupport::Concern* currently.
 To read complete documents, please generate YARD documents on your local environment:
 ```console
 $ git pull https://github.com/simukappu/activity_notification.git

data/app/jobs/activity_notification/cascading_notification_job.rb

@@ -0,0 +1,123 @@
+if defined?(ActiveJob)
+  # Job to handle cascading notifications with time delays and read status checking.
+  # This job enables sequential delivery of notifications through different channels
+  # based on whether previous notifications were read.
+  #
+  # @example Basic usage
+  #   cascade_config = [
+  #     { delay: 10.minutes, target: :slack },
+  #     { delay: 10.minutes, target: :email }
+  #   ]
+  #   CascadingNotificationJob.perform_later(notification.id, cascade_config, 0)
+  class ActivityNotification::CascadingNotificationJob < ActivityNotification.config.parent_job.constantize
+    queue_as ActivityNotification.config.active_job_queue
+  
+    # Performs a single step in the cascading notification chain.
+    # Checks if the notification is still unread, and if so, triggers the next optional target
+    # and schedules the next step in the cascade.
+    #
+    # @param [Integer] notification_id ID of the notification to check
+    # @param [Array<Hash>] cascade_config Array of cascade step configurations
+    # @option cascade_config [ActiveSupport::Duration] :delay Time to wait before checking and sending
+    # @option cascade_config [Symbol, String] :target Name of the optional target to trigger (e.g., :slack, :email)
+    # @option cascade_config [Hash] :options Optional parameters to pass to the optional target
+    # @param [Integer] step_index Current step index in the cascade chain (0-based)
+    # @return [Hash, nil] Result of triggering the optional target, or nil if notification was read or not found
+    def perform(notification_id, cascade_config, step_index = 0)
+      # Find the notification using ORM-appropriate method
+      # :nocov:
+      notification = case ActivityNotification.config.orm
+                     when :dynamoid
+                       ActivityNotification::Notification.find(notification_id, raise_error: false)
+                     when :mongoid
+                       begin
+                         ActivityNotification::Notification.find(notification_id)
+                       rescue Mongoid::Errors::DocumentNotFound
+                         nil
+                       end
+                     else
+                       ActivityNotification::Notification.find_by(id: notification_id)
+                     end
+      # :nocov:
+      
+      # Return early if notification not found or has been opened (read)
+      return nil if notification.nil? || notification.opened?
+      
+      # Get current step configuration
+      current_step = cascade_config[step_index]
+      return nil if current_step.nil?
+      
+      # Extract step parameters
+      target_name = current_step[:target] || current_step['target']
+      target_options = current_step[:options] || current_step['options'] || {}
+      
+      # Trigger the optional target for this step
+      result = trigger_optional_target(notification, target_name, target_options)
+      
+      # Schedule next step if available and notification is still unread
+      next_step_index = step_index + 1
+      if next_step_index < cascade_config.length
+        next_step = cascade_config[next_step_index]
+        delay = next_step[:delay] || next_step['delay']
+        
+        if delay.present?
+          # Schedule the next step with the specified delay
+          self.class.set(wait: delay).perform_later(
+            notification_id,
+            cascade_config,
+            next_step_index
+          )
+        end
+      end
+      
+      result
+    end
+    
+    private
+    
+    # Triggers a specific optional target for the notification
+    # @param [Notification] notification The notification instance
+    # @param [Symbol, String] target_name Name of the optional target
+    # @param [Hash] options Options to pass to the optional target
+    # @return [Hash] Result of triggering the target
+    def trigger_optional_target(notification, target_name, options = {})
+      target_name_sym = target_name.to_sym
+      
+      # Get all configured optional targets for this notification
+      optional_targets = notification.notifiable.optional_targets(
+        notification.target.to_resources_name,
+        notification.key
+      )
+      
+      # Find the matching optional target
+      optional_target = optional_targets.find do |ot|
+        ot.to_optional_target_name == target_name_sym
+      end
+      
+      if optional_target.nil?
+        Rails.logger.warn("Optional target '#{target_name}' not found for notification #{notification.id}")
+        return { target_name_sym => :not_configured }
+      end
+      
+      # Check subscription status
+      unless notification.optional_target_subscribed?(target_name_sym)
+        Rails.logger.info("Target not subscribed to optional target '#{target_name}' for notification #{notification.id}")
+        return { target_name_sym => :not_subscribed }
+      end
+      
+      # Trigger the optional target
+      begin
+        optional_target.notify(notification, options)
+        Rails.logger.info("Successfully triggered optional target '#{target_name}' for notification #{notification.id}")
+        { target_name_sym => :success }
+      rescue => e
+        Rails.logger.error("Failed to trigger optional target '#{target_name}' for notification #{notification.id}: #{e.message}")
+        if ActivityNotification.config.rescue_optional_target_errors
+          { target_name_sym => e }
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/docs/Functions.md

@@ -99,7 +99,7 @@ If you use i18n for email, you can configure email subject in your locale files.
 
 #### Other header fields
 
-Similarly to the [Email subject](#email-subject), the `From`, `Reply-To` and `Message-ID` headers are configurable per notifiable model. From and reply to will override the `config.mailer_sender` config setting.
+Similarly to the [Email subject](#email-subject), the `From`, `Reply-To`, `CC` and `Message-ID` headers are configurable per notifiable model. From and reply to will override the `config.mailer_sender` config setting.
 
 ```ruby
 class Comment < ActiveRecord::Base
@@ -120,12 +120,88 @@ class Comment < ActiveRecord::Base
     "no-reply.article+comment-#{self.id}@example.com"
   end
 
+  def overriding_notification_email_cc(target, key)
+    # CC the article author on comment notifications
+    if key == "comment.create"
+      article.user.email
+    else
+      nil
+    end
+  end
+
   def overriding_notification_email_message_id(target, key)
     "https://www.example.com/article/#{article.id}@example.com/"
   end
 end
 ```
 
+#### CC (Carbon Copy) configuration
+
+*activity_notification* supports CC (Carbon Copy) email addresses at three levels with the following priority order:
+
+1. **Notifiable model override** (highest priority) - using `overriding_notification_email_cc` method
+2. **Target model method** - using `mailer_cc` method  
+3. **Global configuration** - using `config.mailer_cc` setting
+
+##### Global CC configuration
+
+You can configure global CC recipients in *activity_notification.rb* initializer as *String*, *Array*, or *Proc*:
+
+```ruby
+# Single CC recipient for all notifications
+config.mailer_cc = 'admin@example.com'
+
+# Multiple CC recipients for all notifications
+config.mailer_cc = ['admin@example.com', 'support@example.com']
+
+# Dynamic CC based on notification key
+config.mailer_cc = ->(key) {
+  if key.include?('urgent')
+    ['urgent@example.com', 'manager@example.com']
+  else
+    'admin@example.com'
+  end
+}
+```
+
+##### Target-level CC configuration
+
+You can define `mailer_cc` method in your target model to set CC recipients for that specific target:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_target
+  belongs_to :team_lead, class_name: 'User'
+
+  # Return single or multiple CC addresses
+  def mailer_cc
+    team_lead.present? ? team_lead.email : 'admin@example.com'
+  end
+end
+```
+
+##### Notifiable-level CC override
+
+For the most granular control, implement `overriding_notification_email_cc` in your notifiable model to set CC per notification type:
+
+```ruby
+class Article < ActiveRecord::Base
+  acts_as_notifiable :users,
+    targets: ->(article, key) { [article.user] }
+
+  def overriding_notification_email_cc(target, key)
+    case key
+    when 'article.published'
+      ['editor@example.com', 'marketing@example.com']
+    when 'article.flagged'
+      'moderation@example.com'
+    else
+      nil # Falls back to target's mailer_cc or global config
+    end
+  end
+end
+```
+
 #### i18n for email
 
 The subject of notification email can be put in your locale *.yml* files as **mail_subject** field:
@@ -263,6 +339,126 @@ notification:
 
 Then, you will see *"Kevin and 7 other users posted 10 comments to your article"*.
 
+### Cascading notifications
+
+*activity_notification* provides cascading notifications that enable progressive notification escalation through multiple channels with time delays. This ensures important notifications are not missed while avoiding unnecessary interruptions when users have already engaged with earlier notification channels.
+
+#### How cascading notifications work
+
+Cascading notifications automatically send notifications through different channels (Slack, Email, SMS, etc.) with configurable time delays, but only if the user hasn't already read the notification:
+
+1. User gets an in-app notification
+2. ⏱️ Wait 10 minutes → Still unread? Send Slack message  
+3. ⏱️ Wait 10 more minutes → Still unread? Send Email
+4. ⏱️ Wait 30 more minutes → Still unread? Send SMS
+
+If the user reads the notification at any point, the cascade stops automatically.
+
+#### Basic usage
+
+```ruby
+# Create a notification
+notification = Notification.create!(
+  target: user,
+  notifiable: comment,
+  key: 'comment.reply'
+)
+
+# Setup cascade: Slack after 10 min, Email after another 10 min
+cascade_config = [
+  { delay: 10.minutes, target: :slack },
+  { delay: 10.minutes, target: :email }
+]
+
+# Start the cascade
+notification.cascade_notify(cascade_config)
+```
+
+#### Configuration options
+
+Each step in the cascade requires:
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `delay` | Duration | Yes | How long to wait (e.g., `10.minutes`, `1.hour`) |
+| `target` | Symbol/String | Yes | Optional target name (`:slack`, `:email`, etc.) |
+| `options` | Hash | No | Custom options to pass to the target |
+
+#### Advanced usage
+
+**Immediate first notification:**
+```ruby
+# Send Slack immediately, then email if still unread
+cascade_config = [
+  { delay: 5.minutes, target: :slack },
+  { delay: 10.minutes, target: :email }
+]
+
+notification.cascade_notify(cascade_config, trigger_first_immediately: true)
+```
+
+**With custom options:**
+```ruby
+cascade_config = [
+  { 
+    delay: 5.minutes, 
+    target: :slack,
+    options: { channel: '#urgent' }
+  },
+  { 
+    delay: 10.minutes, 
+    target: :email
+  }
+]
+
+notification.cascade_notify(cascade_config)
+```
+
+**Integration with notification creation:**
+```ruby
+# In your controller
+comment = Comment.create!(comment_params)
+
+# Create notifications
+comment.notify(:users, key: 'comment.new')
+
+# Add cascade to all created notifications
+comment.notifications.each do |notification|
+  cascade_config = [
+    { delay: 10.minutes, target: :slack },
+    { delay: 30.minutes, target: :email }
+  ]
+  notification.cascade_notify(cascade_config)
+end
+```
+
+#### Prerequisites
+
+Before using cascading notifications, ensure:
+
+1. **Optional targets are configured** on your notifiable models
+2. **ActiveJob is configured** (default in Rails)
+3. **Job queue is running** (Sidekiq, Delayed Job, etc.)
+
+#### Common patterns
+
+**Urgent notifications (fast escalation):**
+```ruby
+URGENT_CASCADE = [
+  { delay: 2.minutes, target: :slack },
+  { delay: 5.minutes, target: :email },
+  { delay: 10.minutes, target: :sms }
+].freeze
+```
+
+**Normal notifications (gentle escalation):**
+```ruby
+NORMAL_CASCADE = [
+  { delay: 30.minutes, target: :slack },
+  { delay: 1.hour, target: :email }
+].freeze
+```
+
 
 ### Subscription management
 

data/lib/activity_notification/apis/cascading_notification_api.rb

@@ -0,0 +1,208 @@
+module ActivityNotification
+  # Defines API for cascading notifications included in Notification model.
+  # Cascading notifications enable sequential delivery through different channels
+  # based on read status, with configurable time delays between each step.
+  module CascadingNotificationApi
+    extend ActiveSupport::Concern
+    
+    # Starts a cascading notification chain with the specified configuration.
+    # The chain will automatically check the read status before each step and
+    # only proceed if the notification remains unread.
+    #
+    # @example Simple cascade with Slack then email
+    #   notification.cascade_notify([
+    #     { delay: 10.minutes, target: :slack },
+    #     { delay: 10.minutes, target: :email }
+    #   ])
+    #
+    # @example Cascade with custom options for each target
+    #   notification.cascade_notify([
+    #     { delay: 5.minutes, target: :slack, options: { channel: '#alerts' } },
+    #     { delay: 10.minutes, target: :amazon_sns, options: { subject: 'Urgent' } },
+    #     { delay: 15.minutes, target: :email }
+    #   ])
+    #
+    # @param [Array<Hash>] cascade_config Array of cascade step configurations
+    # @option cascade_config [ActiveSupport::Duration] :delay Required. Time to wait before this step
+    # @option cascade_config [Symbol, String] :target Required. Name of the optional target (e.g., :slack, :email)
+    # @option cascade_config [Hash] :options Optional. Parameters to pass to the optional target
+    # @param [Hash] options Additional options for cascade
+    # @option options [Boolean] :validate (true) Whether to validate the cascade configuration
+    # @option options [Boolean] :trigger_first_immediately (false) Whether to trigger the first target immediately without delay
+    # @return [Boolean] true if cascade was initiated successfully, false otherwise
+    # @raise [ArgumentError] if cascade_config is invalid and :validate is true
+    def cascade_notify(cascade_config, options = {})
+      validate = options.fetch(:validate, true)
+      trigger_first_immediately = options.fetch(:trigger_first_immediately, false)
+      
+      # Validate configuration if requested
+      if validate
+        validation_result = validate_cascade_config(cascade_config)
+        unless validation_result[:valid]
+          raise ArgumentError, "Invalid cascade configuration: #{validation_result[:errors].join(', ')}"
+        end
+      end
+      
+      # Return false if cascade config is empty
+      return false if cascade_config.blank?
+      
+      # Return false if notification is already opened
+      return false if opened?
+      
+      if defined?(ActiveJob) && defined?(ActivityNotification::CascadingNotificationJob) && 
+         ActivityNotification::CascadingNotificationJob.respond_to?(:perform_later)
+        if trigger_first_immediately && cascade_config.any?
+          # Trigger first target immediately
+          first_step = cascade_config.first
+          target_name = first_step[:target] || first_step['target']
+          target_options = first_step[:options] || first_step['options'] || {}
+          
+          # Perform the first step synchronously
+          perform_cascade_step(target_name, target_options)
+          
+          # Schedule remaining steps if any
+          if cascade_config.length > 1
+            remaining_config = cascade_config[1..-1]
+            first_delay = remaining_config.first[:delay] || remaining_config.first['delay']
+            
+            if first_delay.present?
+              ActivityNotification::CascadingNotificationJob
+                .set(wait: first_delay)
+                .perform_later(id, remaining_config, 0)
+            end
+          end
+        else
+          # Schedule first step with its configured delay
+          first_step = cascade_config.first
+          first_delay = first_step[:delay] || first_step['delay']
+          
+          if first_delay.present?
+            ActivityNotification::CascadingNotificationJob
+              .set(wait: first_delay)
+              .perform_later(id, cascade_config, 0)
+          else
+            # If no delay specified for first step, trigger immediately
+            ActivityNotification::CascadingNotificationJob
+              .perform_later(id, cascade_config, 0)
+          end
+        end
+        
+        true
+      else
+        Rails.logger.error("ActiveJob or CascadingNotificationJob not available for cascading notifications")
+        false
+      end
+    end
+    
+    # Validates a cascade configuration array
+    #
+    # @param [Array<Hash>] cascade_config The configuration to validate
+    # @return [Hash] Hash with :valid (Boolean) and :errors (Array<String>) keys
+    def validate_cascade_config(cascade_config)
+      errors = []
+      
+      if cascade_config.nil?
+        errors << "cascade_config cannot be nil"
+        return { valid: false, errors: errors }
+      end
+      
+      unless cascade_config.is_a?(Array)
+        errors << "cascade_config must be an Array"
+        return { valid: false, errors: errors }
+      end
+      
+      if cascade_config.empty?
+        errors << "cascade_config cannot be empty"
+      end
+      
+      cascade_config.each_with_index do |step, index|
+        unless step.is_a?(Hash)
+          errors << "Step #{index} must be a Hash"
+          next
+        end
+        
+        # Check for required target parameter
+        target = step[:target] || step['target']
+        if target.nil?
+          errors << "Step #{index} missing required :target parameter"
+        elsif !target.is_a?(Symbol) && !target.is_a?(String)
+          errors << "Step #{index} :target must be a Symbol or String"
+        end
+        
+        # Check for delay parameter (only required for steps after the first if not using trigger_first_immediately)
+        delay = step[:delay] || step['delay']
+        if delay.nil?
+          errors << "Step #{index} missing :delay parameter"
+        elsif !delay.respond_to?(:from_now) && !delay.is_a?(Numeric)
+          errors << "Step #{index} :delay must be an ActiveSupport::Duration or Numeric (seconds)"
+        end
+        
+        # Check options if present
+        options = step[:options] || step['options']
+        if options.present? && !options.is_a?(Hash)
+          errors << "Step #{index} :options must be a Hash"
+        end
+      end
+      
+      { valid: errors.empty?, errors: errors }
+    end
+    
+    # Checks if a cascading notification is currently in progress for this notification
+    # This is a helper method that checks if there are scheduled jobs for this notification
+    #
+    # @return [Boolean] true if cascade jobs are scheduled (this is a best-effort check)
+    def cascade_in_progress?
+      # This is a best-effort check that returns false by default
+      # In production, you might want to track this state differently
+      # (e.g., in Redis, database flag, or by querying the job queue)
+      false
+    end
+    
+    private
+    
+    # Performs a single cascade step immediately (synchronously)
+    # @api private
+    # @param [Symbol, String] target_name Name of the optional target
+    # @param [Hash] options Options to pass to the optional target
+    # @return [Hash] Result of the operation
+    def perform_cascade_step(target_name, options = {})
+      target_name_sym = target_name.to_sym
+      
+      # Get all configured optional targets for this notification
+      optional_targets = notifiable.optional_targets(
+        target.to_resources_name,
+        key
+      )
+      
+      # Find the matching optional target
+      optional_target = optional_targets.find do |ot|
+        ot.to_optional_target_name == target_name_sym
+      end
+      
+      if optional_target.nil?
+        Rails.logger.warn("Optional target '#{target_name}' not found for notification #{id}")
+        return { target_name_sym => :not_configured }
+      end
+      
+      # Check subscription status
+      unless optional_target_subscribed?(target_name_sym)
+        Rails.logger.info("Target not subscribed to optional target '#{target_name}' for notification #{id}")
+        return { target_name_sym => :not_subscribed }
+      end
+      
+      # Trigger the optional target
+      begin
+        optional_target.notify(self, options)
+        Rails.logger.info("Successfully triggered optional target '#{target_name}' for notification #{id}")
+        { target_name_sym => :success }
+      rescue => e
+        Rails.logger.error("Failed to trigger optional target '#{target_name}' for notification #{id}: #{e.message}")
+        if ActivityNotification.config.rescue_optional_target_errors
+          { target_name_sym => e }
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/activity_notification/apis/notification_api.rb

@@ -1,7 +1,10 @@
+require 'activity_notification/apis/cascading_notification_api'
+
 module ActivityNotification
   # Defines API for notification included in Notification model.
   module NotificationApi
     extend ActiveSupport::Concern
+    include CascadingNotificationApi
 
     included do
       # Defines store_notification as private clas method

data/lib/activity_notification/config.rb

@@ -82,6 +82,15 @@ module ActivityNotification
     #   @return [String] Email address as sender of notification email.
     attr_accessor :mailer_sender
 
+    # @overload mailer_cc
+    #   Returns carbon copy (CC) email address(es) for notification email
+    #   @return [String, Array<String>, Proc] CC email address(es) for notification email.
+    # @overload mailer_cc=(value)
+    #   Sets carbon copy (CC) email address(es) for notification email
+    #   @param [String, Array<String>, Proc] mailer_cc The new mailer_cc
+    #   @return [String, Array<String>, Proc] CC email address(es) for notification email.
+    attr_accessor :mailer_cc
+
     # @overload mailer
     #   Returns mailer class for email notification
     #   @return [String] Mailer class for email notification.
@@ -236,6 +245,7 @@ module ActivityNotification
       @subscribe_to_email_as_default            = nil
       @subscribe_to_optional_targets_as_default = nil
       @mailer_sender                            = nil
+      @mailer_cc                                = nil
       @mailer                                   = 'ActivityNotification::Mailer'
       @parent_mailer                            = 'ActionMailer::Base'
       @parent_job                               = 'ActiveJob::Base'

data/lib/activity_notification/mailers/helpers.rb

@@ -74,6 +74,7 @@ module ActivityNotification
             subject: :subject_for,
             from: :mailer_from,
             reply_to: :mailer_reply_to,
+            cc: :mailer_cc,
             message_id: nil
           }.each do |header_name, default_method|
             overridding_method_name = "overriding_notification_email_#{header_name.to_s}"
@@ -81,7 +82,12 @@ module ActivityNotification
                 @notification.notifiable.send(overridding_method_name, @target, key).present?
               @notification.notifiable.send(overridding_method_name, @target, key)
             elsif default_method
-              send(default_method, key)
+              # Special handling for methods that take target instead of key
+              if [:mailer_cc].include?(default_method)
+                send(default_method, @target)
+              else
+                send(default_method, key)
+              end
             else
               nil
             end
@@ -99,6 +105,26 @@ module ActivityNotification
           target.mailer_to
         end
 
+        # Returns carbon copy (CC) email address(es).
+        #
+        # @param [Object] target Target instance to notify
+        # @return [String, Array<String>, nil] CC email address(es) or nil
+        def mailer_cc(target)
+          if target.respond_to?(:mailer_cc)
+            target.mailer_cc
+          elsif ActivityNotification.config.mailer_cc.present?
+            if ActivityNotification.config.mailer_cc.is_a?(Proc)
+              # Get the notification key from current context
+              key = @notification ? @notification.key : nil
+              ActivityNotification.config.mailer_cc.call(key)
+            else
+              ActivityNotification.config.mailer_cc
+            end
+          else
+            nil
+          end
+        end
+
         # Returns sender email address as 'reply_to'.
         #
         # @param [String] key Key of the notification or batch notification email

data/lib/activity_notification/version.rb

@@ -1,3 +1,3 @@
 module ActivityNotification
-  VERSION = "2.4.1"
+  VERSION = "2.5.0"
 end