activity_notification 2.5.1 → 2.6.0

data/lib/activity_notification/mailers/helpers.rb

@@ -94,6 +94,11 @@ module ActivityNotification
             headers[header_name] = header_value if header_value
           end
           @email = headers[:to]
+
+          # Resolve attachments
+          attachment_specs = resolve_attachments(key)
+          headers[:attachment_specs] = attachment_specs if attachment_specs.present?
+
           headers
         end
 
@@ -125,6 +130,58 @@ module ActivityNotification
           end
         end
 
+        # Returns attachment specification(s) for notification email.
+        # Checks target method first, then falls back to global configuration.
+        #
+        # @param [Object] target Target instance to notify
+        # @return [Hash, Array<Hash>, nil] Attachment specification(s) or nil
+        def mailer_attachments(target)
+          if target.respond_to?(:mailer_attachments)
+            target.mailer_attachments
+          elsif ActivityNotification.config.mailer_attachments.present?
+            if ActivityNotification.config.mailer_attachments.is_a?(Proc)
+              key = @notification ? @notification.key : nil
+              ActivityNotification.config.mailer_attachments.call(key)
+            else
+              ActivityNotification.config.mailer_attachments
+            end
+          else
+            nil
+          end
+        end
+
+        # Resolves attachment specifications with priority:
+        # notifiable override > target method > global configuration.
+        #
+        # @param [String] key Key of the notification
+        # @return [Hash, Array<Hash>, nil] Resolved attachment specification(s) or nil
+        def resolve_attachments(key)
+          if @notification&.notifiable&.respond_to?(:overriding_notification_email_attachments) &&
+             @notification.notifiable.overriding_notification_email_attachments(@target, key).present?
+            @notification.notifiable.overriding_notification_email_attachments(@target, key)
+          else
+            mailer_attachments(@target)
+          end
+        end
+
+        # Processes attachment specifications and adds them to the mail object.
+        #
+        # @param [Mail::Message] mail_obj The mail object to add attachments to
+        # @param [Hash, Array<Hash>, nil] specs Attachment specification(s)
+        # @return [void]
+        def process_attachments(mail_obj, specs)
+          return if specs.blank?
+          specs_array = specs.is_a?(Array) ? specs : [specs]
+          specs_array.each do |spec|
+            next if spec.blank?
+            validate_attachment_spec!(spec)
+            content = spec[:content] || File.read(spec[:path])
+            options = { content: content }
+            options[:mime_type] = spec[:mime_type] if spec[:mime_type]
+            mail_obj.attachments[spec[:filename]] = options
+          end
+        end
+
         # Returns sender email address as 'reply_to'.
         #
         # @param [String] key Key of the notification or batch notification email
@@ -204,17 +261,46 @@ module ActivityNotification
         # @param [Hash]           headers  Prepared email header
         # @param [String, Symbol] fallback Fallback option
         def send_mail(headers, fallback = nil)
+          attachment_specs = headers.delete(:attachment_specs)
           begin
-            mail headers
+            mail_obj = mail headers
+            process_attachments(mail_obj, attachment_specs)
+            mail_obj
           rescue ActionView::MissingTemplate => e
             if fallback.present?
-              mail headers.merge(template_name: fallback)
+              mail_obj = mail headers.merge(template_name: fallback)
+              process_attachments(mail_obj, attachment_specs)
+              mail_obj
             else
               raise e
             end
           end
         end
 
+        # Validates an attachment specification hash.
+        #
+        # @param [Hash] spec Attachment specification
+        # @raise [ArgumentError] If specification is invalid
+        # @return [void]
+        def validate_attachment_spec!(spec)
+          unless spec.is_a?(Hash)
+            raise ArgumentError, "Attachment specification must be a Hash, got #{spec.class}"
+          end
+          unless spec[:filename].present?
+            raise ArgumentError, "Attachment specification must include :filename"
+          end
+          content_sources = [spec[:content], spec[:path]].compact
+          if content_sources.empty?
+            raise ArgumentError, "Attachment specification must include :content or :path"
+          end
+          if content_sources.size > 1
+            raise ArgumentError, "Attachment specification must include only one of :content or :path"
+          end
+          if spec[:path].present? && !File.exist?(spec[:path])
+            raise ArgumentError, "Attachment file not found: #{spec[:path]}"
+          end
+        end
+
     end
   end
 end

data/lib/activity_notification/models/concerns/notifiable.rb

@@ -14,7 +14,7 @@ module ActivityNotification
       # Has many notification instances for this notifiable.
       # Dependency for these notifications can be overridden from acts_as_notifiable.
       # @scope instance
-      # @return [Array<Notificaion>, Mongoid::Criteria<Notificaion>] Array or database query of notifications for this notifiable
+      # @return [Array<Notification>, Mongoid::Criteria<Notification>] Array or database query of notifications for this notifiable
       has_many_records :generated_notifications_as_notifiable,
         class_name: "::ActivityNotification::Notification",
         as: :notifiable
@@ -65,13 +65,13 @@ module ActivityNotification
     end
 
     # Returns notification targets from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [Hash] options Options for notifications
     # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
     # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
-    # @return [Array<Notificaion> | ActiveRecord_AssociationRelation<Notificaion>] Array or database query of the notification targets
+    # @return [Array<Notification> | ActiveRecord_AssociationRelation<Notification>] Array or database query of the notification targets
     def notification_targets(target_type, options = {})
       target_typed_method_name = "notification_#{cast_to_resources_name(target_type)}"
       resolved_parameter = resolve_parameter(
@@ -86,8 +86,40 @@ module ActivityNotification
       resolved_parameter
     end
 
+    # Returns targets that have instance-level subscriptions for this notifiable.
+    # This method finds all active instance-level subscriptions for this specific notifiable
+    # instance and returns their target objects.
+    #
+    # @param [String] target_type Target type to notify
+    # @param [String] key Key of the notification (defaults to default_notification_key)
+    # @return [Array<Object>] Array of target instances with active instance-level subscriptions
+    def instance_subscription_targets(target_type, key = nil)
+      key ||= default_notification_key
+      target_class_name = target_type.to_s.to_model_name
+      if ActivityNotification.config.orm == :dynamoid
+        # :nocov:
+        delimiter = ActivityNotification.config.composite_key_delimiter
+        Subscription.where(
+          notifiable_key: "#{self.class.name}#{delimiter}#{self.id}",
+          key:            key,
+          subscribing:    true
+        ).select { |s| s.target_type == target_class_name }.map(&:target).compact
+        # :nocov:
+      else
+        # :nocov:
+        Subscription.where(
+          notifiable_type: self.class.name,
+          notifiable_id:   self.id,
+          key:             key,
+          subscribing:     true,
+          target_type:     target_class_name
+        ).map(&:target).compact
+        # :nocov:
+      end
+    end
+
     # Returns group unit of the notifications from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
@@ -101,7 +133,7 @@ module ActivityNotification
     end
 
     # Returns group expiry period of the notifications from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
@@ -115,7 +147,7 @@ module ActivityNotification
     end
 
     # Returns additional notification parameters from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
@@ -129,7 +161,7 @@ module ActivityNotification
     end
 
     # Returns notifier of the notification from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
@@ -143,7 +175,7 @@ module ActivityNotification
     end
 
     # Returns if sending notification email is allowed for the notifiable from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [Object] target Target instance to notify
     # @param [String] key Key of the notification
@@ -157,7 +189,7 @@ module ActivityNotification
     end
 
     # Returns if publishing WebSocket using ActionCable is allowed for the notifiable from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [Object] target Target instance to notify
     # @param [String] key Key of the notification
@@ -171,7 +203,7 @@ module ActivityNotification
     end
 
     # Returns if publishing WebSocket API using ActionCable is allowed for the notifiable from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [Object] target Target instance to notify
     # @param [String] key Key of the notification
@@ -185,7 +217,7 @@ module ActivityNotification
     end
 
     # Returns notifiable_path to move after opening notification from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
@@ -219,7 +251,7 @@ module ActivityNotification
     end
 
     # Returns optional_targets of the notification from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
@@ -233,7 +265,7 @@ module ActivityNotification
     end
 
     # Returns optional_target names of the notification from configured field or overridden method.
-    # This method is able to be overridden.
+    # This method can be overridden.
     #
     # @param [String] target_type Target type to notify
     # @param [String] key Key of the notification
@@ -275,8 +307,8 @@ module ActivityNotification
     # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
     # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
     # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-    # @return [Array<Notificaion>] Array of generated notifications
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+    # @return [Array<Notification>] Array of generated notifications
     def notify(target_type, options = {})
       Notification.notify(target_type, self, options)
     end
@@ -295,8 +327,8 @@ module ActivityNotification
     # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
     # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
     # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-    # @return [Array<Notificaion>] Array of generated notifications
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+    # @return [Array<Notification>] Array of generated notifications
     def notify_later(target_type, options = {})
       Notification.notify_later(target_type, self, options)
     end
@@ -316,8 +348,8 @@ module ActivityNotification
     # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
     # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
     # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-    # @return [Array<Notificaion>] Array of generated notifications
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+    # @return [Array<Notification>] Array of generated notifications
     def notify_all(targets, options = {})
       Notification.notify_all(targets, self, options)
     end
@@ -337,8 +369,8 @@ module ActivityNotification
     # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
     # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
     # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-    # @return [Array<Notificaion>] Array of generated notifications
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+    # @return [Array<Notification>] Array of generated notifications
     def notify_all_later(targets, options = {})
       Notification.notify_all_later(targets, self, options)
     end
@@ -357,7 +389,7 @@ module ActivityNotification
     # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
     # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
     # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
     # @return [Notification] Generated notification instance
     def notify_to(target, options = {})
       Notification.notify_to(target, self, options)
@@ -378,14 +410,14 @@ module ActivityNotification
     # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
     # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
     # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+    # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
     # @return [Notification] Generated notification instance
     def notify_later_to(target, options = {})
       Notification.notify_later_to(target, self, options)
     end
 
     # Returns default key of the notification.
-    # This method is able to be overridden.
+    # This method can be overridden.
     # "#{to_resource_name}.default" is defined as default key.
     #
     # @return [String] Default key of the notification
@@ -394,7 +426,7 @@ module ActivityNotification
     end
 
     # Returns key of the notification for tracked notifiable creation.
-    # This method is able to be overridden.
+    # This method can be overridden.
     # "#{to_resource_name}.create" is defined as default creation key.
     #
     # @return [String] Key of the notification for tracked notifiable creation
@@ -403,7 +435,7 @@ module ActivityNotification
     end
 
     # Returns key of the notification for tracked notifiable update.
-    # This method is able to be overridden.
+    # This method can be overridden.
     # "#{to_resource_name}.update" is defined as default update key.
     #
     # @return [String] Key of the notification for tracked notifiable update
@@ -435,12 +467,10 @@ module ActivityNotification
       # @api private
       # @param [String] target_type Target type of generated notifications
       def generated_notifications_as_notifiable_for(target_type = nil)
-        target_type.nil? ?
-          generated_notifications_as_notifiable.all :
-          generated_notifications_as_notifiable.filtered_by_target_type(target_type.to_s.to_model_name)
+        target_type.nil? ? generated_notifications_as_notifiable.all : generated_notifications_as_notifiable.filtered_by_target_type(target_type.to_s.to_model_name)
       end
 
-      # Destroies generated notifications for specified target type with dependency.
+      # Destroys generated notifications for specified target type with dependency.
       # This method is intended to be called before destroy this notifiable as dependent configuration.
       # @api private
       # @param [Symbol]  dependent         Has_many dependency, [:delete_all, :destroy, :restrict_with_error, :restrict_with_exception] are available

data/lib/activity_notification/models/concerns/notifier.rb

@@ -9,7 +9,7 @@ module ActivityNotification
 
       # Has many sent notification instances from this notifier.
       # @scope instance
-      # @return [Array<Notificaion>, Mongoid::Criteria<Notificaion>] Array or database query of sent notifications from this notifier
+      # @return [Array<Notification>, Mongoid::Criteria<Notification>] Array or database query of sent notifications from this notifier
       has_many_records :sent_notifications,
         class_name: "::ActivityNotification::Notification",
         as: :notifier

data/lib/activity_notification/models/concerns/subscriber.rb

@@ -27,20 +27,48 @@ module ActivityNotification
 
     # Gets subscription of the target and notification key.
     #
-    # @param [Hash] key Key of the notification for subscription
+    # @param [String] key Key of the notification for subscription
+    # @param [Object] notifiable Optional notifiable instance for instance-level subscription lookup
     # @return [Subscription] Configured subscription instance
-    def find_subscription(key)
-      subscriptions.where(key: key).first
+    def find_subscription(key, notifiable: nil)
+      if notifiable
+        if ActivityNotification.config.orm == :dynamoid
+          # :nocov:
+          delimiter = ActivityNotification.config.composite_key_delimiter
+          subscriptions.where(key: key, notifiable_key: "#{notifiable.class.name}#{delimiter}#{notifiable.id}").first
+          # :nocov:
+        else
+          # :nocov:
+          subscriptions.where(key: key, notifiable_type: notifiable.class.name, notifiable_id: notifiable.id).first
+          # :nocov:
+        end
+      else
+        if ActivityNotification.config.orm == :dynamoid
+          # :nocov:
+          subscriptions.where(key: key).select { |s| s.notifiable_type.nil? }.first
+          # :nocov:
+        else
+          # :nocov:
+          subscriptions.where(key: key, notifiable_type: nil).first
+          # :nocov:
+        end
+      end
     end
 
     # Gets subscription of the target and notification key.
     #
-    # @param [Hash] key                 Key of the notification for subscription
+    # @param [String] key                 Key of the notification for subscription
     # @param [Hash] subscription_params Parameters to create subscription record
     # @return [Subscription] Found or created subscription instance
     def find_or_create_subscription(key, subscription_params = {})
-      subscription = find_subscription(key)
-      subscription || create_subscription(subscription_params.merge(key: key))
+      notifiable = subscription_params.delete(:notifiable)
+      subscription = find_subscription(key, notifiable: notifiable)
+      merge_params = { key: key }
+      if notifiable
+        merge_params[:notifiable_type] = notifiable.class.name
+        merge_params[:notifiable_id]   = notifiable.id
+      end
+      subscription || create_subscription(subscription_params.merge(merge_params))
     end
 
     # Creates new subscription of the target.
@@ -65,6 +93,13 @@ module ActivityNotification
       elsif subscription_params[:subscribing_to_email].nil?
         subscription_params[:subscribing_to_email] = ActivityNotification.config.subscribe_to_email_as_default
       end
+      # :nocov:
+      # Convert notifiable_type/notifiable_id to notifiable_key for Dynamoid
+      if ActivityNotification.config.orm == :dynamoid && subscription_params[:notifiable_type].present? && subscription_params[:notifiable_id].present?
+        delimiter = ActivityNotification.config.composite_key_delimiter
+        subscription_params[:notifiable_key] = "#{subscription_params.delete(:notifiable_type)}#{delimiter}#{subscription_params.delete(:notifiable_id)}"
+      end
+      # :nocov:
       subscription = Subscription.new(subscription_params)
       subscription.assign_attributes(target: self)
       subscription.subscribing? ?
@@ -101,7 +136,7 @@ module ActivityNotification
     # @option options [String]     :filtered_by_key        (nil)   Key of the notification for filter
     # @option options [Array|Hash] :custom_filter          (nil)   Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago])
     # @option options [Boolean]    :with_target            (false) If it includes target with subscriptions
-    # @return [Array<Notificaion>] Configured subscription index of the target
+    # @return [Array<Notification>] Configured subscription index of the target
     def subscription_index(options = {})
       target_index = subscriptions.filtered_by_options(options)
       target_index = options[:reverse] ? target_index.earliest_order : target_index.latest_order
@@ -120,7 +155,7 @@ module ActivityNotification
     # @option options [Symbol|String] :filter                 (nil)   Filter option to load notification keys (Nothing as all, 'configured' with configured subscriptions or 'unconfigured' without subscriptions)
     # @option options [String]        :filtered_by_key        (nil)   Key of the notification for filter
     # @option options [Array|Hash]    :custom_filter          (nil)   Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago])
-    # @return [Array<Notificaion>] Unconfigured notification keys of the target
+    # @return [Array<Notification>] Unconfigured notification keys of the target
     def notification_keys(options = {})
       subscription_keys    = subscriptions.uniq_keys
       target_notifications = notifications.filtered_by_options(options.select { |k, _| [:filtered_by_key, :custom_filter].include?(k) })
@@ -146,10 +181,22 @@ module ActivityNotification
       # @api protected
       #
       # @param [String]  key                  Key of the notification
-      # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
+      # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record is not configured
       # @return [Boolean] If the target subscribes to the notification
       def _subscribes_to_notification?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
-        evaluate_subscription(subscriptions.where(key: key).first, :subscribing?, subscribe_as_default)
+        subscription = _find_key_level_subscription(key)
+        evaluate_subscription(subscription, :subscribing?, subscribe_as_default)
+      end
+
+      # Returns if the target subscribes to the notification for a specific notifiable instance.
+      # @api protected
+      #
+      # @param [String]  key        Key of the notification
+      # @param [Object]  notifiable Notifiable instance to check subscription for
+      # @return [Boolean] If the target has an active instance-level subscription for this notifiable
+      def _subscribes_to_notification_for_instance?(key, notifiable)
+        instance_sub = find_subscription(key, notifiable: notifiable)
+        instance_sub.present? && instance_sub.subscribing?
       end
 
       # Returns if the target subscribes to the notification email.
@@ -157,10 +204,11 @@ module ActivityNotification
       # @api protected
       #
       # @param [String]  key                  Key of the notification
-      # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
+      # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record is not configured
       # @return [Boolean] If the target subscribes to the notification
       def _subscribes_to_notification_email?(key, subscribe_as_default = ActivityNotification.config.subscribe_to_email_as_default)
-        evaluate_subscription(subscriptions.where(key: key).first, :subscribing_to_email?, subscribe_as_default)
+        subscription = _find_key_level_subscription(key)
+        evaluate_subscription(subscription, :subscribing_to_email?, subscribe_as_default)
       end
       alias_method :_subscribes_to_email?, :_subscribes_to_notification_email?
 
@@ -170,20 +218,29 @@ module ActivityNotification
       #
       # @param [String]         key                  Key of the notification
       # @param [String, Symbol] optional_target_name Class name of the optional target implementation (e.g. :amazon_sns, :slack)
-      # @param [Boolean]        subscribe_as_default Default subscription value to use when the subscription record does not configured
+      # @param [Boolean]        subscribe_as_default Default subscription value to use when the subscription record is not configured
       # @return [Boolean] If the target subscribes to the specified optional target
       def _subscribes_to_optional_target?(key, optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_to_optional_targets_as_default)
+        subscription = _find_key_level_subscription(key)
         _subscribes_to_notification?(key, subscribe_as_default) &&
-          evaluate_subscription(subscriptions.where(key: key).first, :subscribing_to_optional_target?, subscribe_as_default, optional_target_name, subscribe_as_default)
+          evaluate_subscription(subscription, :subscribing_to_optional_target?, subscribe_as_default, optional_target_name, subscribe_as_default)
       end
 
     private
 
+      # Finds a key-level subscription (where notifiable is nil) for the given key.
+      # @api private
+      # @param [String] key Key of the notification
+      # @return [Subscription, nil] Key-level subscription record or nil
+      def _find_key_level_subscription(key)
+        find_subscription(key, notifiable: nil)
+      end
+
       # Returns if the target subscribes.
       # @api private
       # @param [Boolean] record  Subscription record
       # @param [Symbol]  field   Evaluating subscription field or method of the record
-      # @param [Boolean] default Default subscription value to use when the subscription record does not configured
+      # @param [Boolean] default Default subscription value to use when the subscription record is not configured
       # @param [Array]   args    Arguments of evaluating subscription method
       # @return [Boolean] If the target subscribes
       def evaluate_subscription(record, field, default, *args)