activity_notification 2.3.3 → 2.4.1

data/docs/Functions.md

@@ -381,8 +381,6 @@ end
 
 Then, you can access *users/1/subscriptions* and use *[ActivityNotification::SubscriptionsController](/app/controllers/activity_notification/subscriptions_controller.rb)* or *[ActivityNotification::SubscriptionsWithDeviseController](/app/controllers/activity_notification/subscriptions_with_devise_controller.rb)* to manage the subscriptions.
 
-You can see sample subscription management view in demo application here: *https://activity-notification-example.herokuapp.com/users/1/subscriptions*
-
 If you would like to customize subscription controllers or views, you can use generators like notifications:
 
 * Customize subscription controllers
@@ -436,8 +434,6 @@ You can see [sample single page application](/spec/rails_app/app/javascript/) us
 
 *activity_notification* provides API reference as [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification).
 
-OpenAPI Specification in [online demo](https://activity-notification-example.herokuapp.com/) is published here: **https://activity-notification-example.herokuapp.com/api/v2/apidocs**
-
 Public API reference is also hosted in [SwaggerHub](https://swagger.io/tools/swaggerhub/) here: **https://app.swaggerhub.com/apis-docs/simukappu/activity-notification/**
 
 You can also publish OpenAPI Specification in your own application using *[ActivityNotification::ApidocsController](/app/controllers/activity_notification/apidocs_controller.rb)* like this:
@@ -588,7 +584,7 @@ end
 To sign in and get *access-token* from Devise Token Auth, call *sign_in* API which you configured by *mount_devise_token_auth_for* method:
 
 ```console
-$ curl -X POST -H "Content-Type: application/json" -D - -d '{"email": "ichiro@example.com","password": "changeit"}' https://activity-notification-example.herokuapp.com/api/v2/auth/sign_in
+$ curl -X POST -H "Content-Type: application/json" -D - -d '{"email": "ichiro@example.com","password": "changeit"}' https://localhost:3000/api/v2/auth/sign_in
 
 
 HTTP/1.1 200 OK
@@ -615,7 +611,7 @@ uid: ichiro@example.com
 Then, call *activity_notification* API with returned *access-token*, *client* and *uid* as HTTP headers:
 
 ```console
-$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://activity-notification-example.herokuapp.com/api/v2/notifications
+$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://localhost:3000/api/v2/notifications
 
 HTTP/1.1 200 OK
 ...
@@ -631,7 +627,7 @@ HTTP/1.1 200 OK
 Without valid *access-token*, API returns *401 Unauthorized*:
 
 ```console
-$ curl -X GET -H "Content-Type: application/json" -D - https://activity-notification-example.herokuapp.com/api/v2/notifications
+$ curl -X GET -H "Content-Type: application/json" -D - https://localhost:3000/api/v2/notifications
 
 HTTP/1.1 401 Unauthorized
 ...
@@ -646,7 +642,7 @@ HTTP/1.1 401 Unauthorized
 When you request restricted resources of unauthorized targets, *activity_notification* API returns *403 Forbidden*:
 
 ```console
-$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://activity-notification-example.herokuapp.com/api/v2/notifications/1
+$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://localhost:3000/api/v2/notifications/1
 
 HTTP/1.1 403 Forbidden
 ...
@@ -1141,6 +1137,4 @@ user.find_or_create_subscription('comment.reply').subscribe_to_optional_target(:
 user.find_or_create_subscription('comment.reply').unsubscribe_to_optional_target(:slack)
 ```
 
-You can also manage subscriptions of optional targets by subscriptions REST API. See [REST API backend](#rest-api-backend) for more details.
-
-You can see sample subscription management view in demo application here: *https://activity-notification-example.herokuapp.com/users/1/subscriptions*
+You can also manage subscriptions of optional targets by subscriptions REST API. See [REST API backend](#rest-api-backend) for more details.

data/docs/Setup.md

@@ -22,6 +22,24 @@ $ bin/rails generate activity_notification:install
 The generator will install an initializer which describes all configuration options of *activity_notification*.
 It also generates a i18n based translation file which we can configure the presentation of notifications.
 
+#### ORM Dependencies
+
+By default, *activity_notification* uses **ActiveRecord** as the ORM and no additional ORM gems are required.
+
+If you intend to use **Mongoid** support, you need to add the `mongoid` gem separately to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'mongoid', '>= 4.0.0', '< 10.0'
+```
+
+If you intend to use **Dynamoid** support for Amazon DynamoDB, you need to add the `dynamoid` gem separately to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'dynamoid', '>= 3.11.0', '< 4.0'
+```
+
 ### Database setup
 
 #### Using ActiveRecord ORM
@@ -64,7 +82,14 @@ config.yaml_column_permitted_classes << Time
 
 #### Using Mongoid ORM
 
-When you use *activity_notification* with [Mongoid](http://mongoid.org) ORM, set **AN_ORM** environment variable to **mongoid**:
+When you use *activity_notification* with [Mongoid](http://mongoid.org) ORM, you first need to add the `mongoid` gem to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'mongoid', '>= 4.0.0', '< 10.0'
+```
+
+Then set **AN_ORM** environment variable to **mongoid**:
 
 ```console
 $ export AN_ORM=mongoid
@@ -80,13 +105,14 @@ You need to configure Mongoid in your Rails application for your MongoDB environ
 
 #### Using Dynamoid ORM
 
-Currently, *activity_notification* only works with Dynamoid 3.1.0.
+When you use *activity_notification* with [Dynamoid](https://github.com/Dynamoid/dynamoid) ORM, you first need to add the `dynamoid` gem to your Gemfile:
 
 ```ruby
-gem 'dynamoid', '3.1.0'
+gem 'activity_notification'
+gem 'dynamoid', '>= 3.11.0', '< 4.0'
 ```
 
-When you use *activity_notification* with [Dynamoid](https://github.com/Dynamoid/dynamoid) ORM, set **AN_ORM** environment variable to **dynamoid**:
+Then set **AN_ORM** environment variable to **dynamoid**:
 
 ```console
 $ export AN_ORM=dynamoid
@@ -762,6 +788,49 @@ notification:
 
 This structure is valid for notifications with keys *"notification.comment.reply"* or *"comment.reply"*. As mentioned before, *"notification."* part of the key is optional. In addition for above example, `%{notifier_name}` and `%{article_title}` are used from parameter field in the notification record. Pluralization is supported (but optional) for grouped notifications using the `%{group_notification_count}` value.
 
+### Managing notifications
+
+*activity_notification* provides several methods to manage notifications programmatically. The most common operation is opening notifications to mark them as read.
+
+#### Opening notifications
+
+You can mark individual notifications as opened (read) using the **open!** method:
+
+```ruby
+# Open a single notification
+notification = current_user.notifications.first
+notification.open!
+
+# Open notification with specific timestamp
+notification.open!(opened_at: 1.hour.ago)
+
+# Open notification with opening group members
+notification.open!(with_members: true)
+
+# Open notification skipping validations when the associated notifiable record may have been deleted
+notification.open!(skip_validation: true)
+```
+
+The **open!** method accepts the following options:
+
+* **:opened_at** (Time) - Time to set as the opened timestamp (defaults to `Time.current`)
+* **:with_members** (Boolean) - Whether to open group member notifications as well (defaults to `false`)
+* **:skip_validation** (Boolean) - Whether to skip ActiveRecord validations when updating (defaults to `false`). Useful when the associated notifiable record may have been deleted but the notification still exists.
+
+You can also open all notifications for a target:
+
+```ruby
+# Open all unopened notifications for a user
+ActivityNotification::Notification.open_all_of(current_user)
+
+# Open notifications with filters
+ActivityNotification::Notification.open_all_of(
+  current_user,
+  filtered_by_type: 'Comment',
+  opened_at: 1.hour.ago
+)
+```
+
 ### Customizing controllers (optional)
 
 If the customization at the views level is not enough, you can customize each controller by following these steps:

data/docs/Testing.md

@@ -104,6 +104,17 @@ $ bin/rails server
 ```
 Then, you can access <http://localhost:3000> for the example application.
 
+##### Default test users
+
+Login as the following test users to experience user activity notifications:
+
+| Email | Password | Admin? |
+|:---:|:---:|:---:|
+| ichiro@example.com  | changeit | Yes |
+| stephen@example.com | changeit |     |
+| klay@example.com    | changeit |     |
+| kevin@example.com   | changeit |     |
+
 ##### Run with your local database
 As default, example Rails application runs with local SQLite database in *spec/rails_app/db/development.sqlite3*.
 This application supports to run with your local MySQL, PostgreSQL, MongoDB.
@@ -144,5 +155,5 @@ $ cd spec/rails_app
 $ # You don't need migration when you use MongoDB only (AN_ORM=mongoid and AN_TEST_DB=mongodb)
 $ bin/rake db:migrate
 $ bin/rake db:seed
-$ bin/rails server Puma
+$ bin/rails server
 ```

data/gemfiles/Gemfile.rails-7.0

@@ -4,6 +4,8 @@ gemspec path: '../'
 
 gem 'rails', '~> 7.0.0'
 gem 'sprockets-rails'
+gem 'concurrent-ruby', '<= 1.3.4'
+gem 'sqlite3', '~> 1.4'
 
 group :development do
   gem 'bullet'

data/gemfiles/Gemfile.rails-8.0

@@ -4,8 +4,6 @@ gemspec path: '../'
 
 gem 'rails', '~> 8.0.0'
 gem 'sprockets-rails'
-# https://github.com/lynndylanhurley/devise_token_auth/pull/1639
-gem 'devise_token_auth', git: 'https://github.com/lynndylanhurley/devise_token_auth.git'
 
 group :development do
   gem 'bullet'

data/lib/activity_notification/apis/notification_api.rb

@@ -411,15 +411,63 @@ module ActivityNotification
       # @option options [String]   :filtered_by_key        (nil)          Key of the notification for filter
       # @option options [String]   :later_than             (nil)          ISO 8601 format time to filter notification index later than specified time
       # @option options [String]   :earlier_than           (nil)          ISO 8601 format time to filter notification index earlier than specified time
+      # @option options [Array]    :ids                    (nil)          Array of specific notification IDs to open
       # @return [Array<Notification>] Opened notification records
       def open_all_of(target, options = {})
         opened_at = options[:opened_at] || Time.current
         target_unopened_notifications = target.notifications.unopened_only.filtered_by_options(options)
+        # If specific IDs are provided, filter by them
+        if options[:ids].present?
+          # :nocov:
+          case ActivityNotification.config.orm
+          when :mongoid
+            target_unopened_notifications = target_unopened_notifications.where(id: { '$in' => options[:ids] })
+          when :dynamoid
+            target_unopened_notifications = target_unopened_notifications.where('id.in': options[:ids])
+          else # :active_record
+            target_unopened_notifications = target_unopened_notifications.where(id: options[:ids])
+          end
+          # :nocov:
+        end
         opened_notifications = target_unopened_notifications.to_a.map { |n| n.opened_at = opened_at; n }
         target_unopened_notifications.update_all(opened_at: opened_at)
         opened_notifications
       end
 
+      # Destroys all notifications of the target matching the filter criteria.
+      #
+      # @param [Object] target Target of the notifications to destroy
+      # @param [Hash] options Options for filtering notifications to destroy
+      # @option options [String]   :filtered_by_type       (nil) Notifiable type for filter
+      # @option options [Object]   :filtered_by_group      (nil) Group instance for filter  
+      # @option options [String]   :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
+      # @option options [String]   :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
+      # @option options [String]   :filtered_by_key        (nil) Key of the notification for filter
+      # @option options [String]   :later_than             (nil) ISO 8601 format time to filter notifications later than specified time
+      # @option options [String]   :earlier_than           (nil) ISO 8601 format time to filter notifications earlier than specified time
+      # @option options [Array]    :ids                    (nil) Array of specific notification IDs to destroy
+      # @return [Array<Notification>] Destroyed notification records
+      def destroy_all_of(target, options = {})
+        target_notifications = target.notifications.filtered_by_options(options)
+        # If specific IDs are provided, filter by them
+        if options[:ids].present?
+          # :nocov:
+          case ActivityNotification.config.orm
+          when :mongoid
+            target_notifications = target_notifications.where(id: { '$in' => options[:ids] })
+          when :dynamoid
+            target_notifications = target_notifications.where('id.in': options[:ids])
+          else # :active_record
+            target_notifications = target_notifications.where(id: options[:ids])
+          end
+          # :nocov:
+        end
+        # Get the notifications before destroying them for return value
+        destroyed_notifications = target_notifications.to_a
+        target_notifications.destroy_all
+        destroyed_notifications
+      end
+
       # Returns if group member of the notifications exists.
       # This method is designed to be called from controllers or views to avoid N+1.
       #
@@ -517,7 +565,7 @@ module ActivityNotification
     # @param [Hash] options Options for notification email
     # @option options [Boolean]        :send_later            If it sends notification email asynchronously
     # @option options [String, Symbol] :fallback   (:default) Fallback template to use when MissingTemplate is raised
-    # @return [Mail::Message, ActionMailer::DeliveryJob] Email message or its delivery job
+    # @return [Mail::Message, ActionMailer::DeliveryJob, NilClass] Email message, its delivery job, or nil if notification not found
     def send_notification_email(options = {})
       if target.notification_email_allowed?(notifiable, key) &&
          notifiable.notification_email_allowed?(target, key) &&
@@ -559,6 +607,7 @@ module ActivityNotification
     # @param [Hash] options Options for opening notifications
     # @option options [DateTime] :opened_at   (Time.current) Time to set to opened_at of the notification record
     # @option options [Boolean] :with_members (true)         If it opens notifications including group members
+    # @option options [Boolean] :skip_validation (true)      If it skips validation of the notification record
     # @return [Integer] Number of opened notification records
     def open!(options = {})
       opened? and return 0
@@ -566,7 +615,7 @@ module ActivityNotification
       with_members = options.has_key?(:with_members) ? options[:with_members] : true
       unopened_member_count = with_members ? group_members.unopened_only.count : 0
       group_members.update_all(opened_at: opened_at) if with_members
-      update(opened_at: opened_at)
+      options[:skip_validation] ? update_attribute(:opened_at, opened_at) : update(opened_at: opened_at)
       unopened_member_count + 1
     end
 

data/lib/activity_notification/controllers/concerns/swagger/notifications_api.rb

@@ -92,6 +92,18 @@ module ActivityNotification
           extend Swagger::NotificationsParameters::TargetParameters
           extend Swagger::NotificationsParameters::FilterByParameters
 
+          parameter do
+            key :name, :ids
+            key :in, :query
+            key :description, "Array of specific notification IDs to open"
+            key :required, false
+            key :type, :array
+            items do
+              key :type, :string
+            end
+            key :example, ["1", "2", "3"]
+          end
+
           response 200 do
             key :description, "Opened notifications"
             content 'application/json' do
@@ -117,6 +129,53 @@ module ActivityNotification
         end
       end
 
+      swagger_path '/{target_type}/{target_id}/notifications/destroy_all' do
+        operation :post do
+          key :summary, 'Destroy all notifications'
+          key :description, 'Destroys all notifications of the target matching filter criteria.'
+          key :operationId, 'destroyAllNotifications'
+          key :tags, ['notifications']
+
+          extend Swagger::NotificationsParameters::TargetParameters
+          extend Swagger::NotificationsParameters::FilterByParameters
+
+          parameter do
+            key :name, :ids
+            key :in, :query
+            key :description, "Array of specific notification IDs to destroy"
+            key :required, false
+            key :type, :array
+            items do
+              key :type, :string
+            end
+            key :example, ["1", "2", "3"]
+          end
+
+          response 200 do
+            key :description, "Destroyed notifications"
+            content 'application/json' do
+              schema do
+                key :type, :object
+                property :count do
+                  key :type, :integer
+                  key :description, "Number of destroyed notification records"
+                  key :example, 3
+                end
+                property :notifications do
+                  key :type, :array
+                  items do
+                    key :'$ref', :Notification
+                  end
+                  key :description, "Destroyed notifications"
+                end
+              end
+            end
+          end
+          extend Swagger::ErrorResponses::InvalidParameterError
+          extend Swagger::ErrorResponses::ResourceNotFoundError
+        end
+      end
+
       swagger_path '/{target_type}/{target_id}/notifications/{id}' do
         operation :get do
           key :summary, 'Get notification'

data/lib/activity_notification/helpers/view_helpers.rb

@@ -145,6 +145,20 @@ module ActivityNotification
         send("open_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_path", target, options)
     end
 
+    # Returns destroy_all_notifications_path for the target
+    #
+    # @param [Object] target Target instance
+    # @param [Hash] params Request parameters
+    # @return [String] destroy_all_notifications_path for the target
+    # @todo Needs any other better implementation
+    # @todo Must handle devise namespace
+    def destroy_all_notifications_path_for(target, params = {})
+      options = params.dup
+      options.delete(:devise_default_routes) ?
+        send("destroy_all_#{routing_scope(options)}notifications_path", options) :
+        send("destroy_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_path", target, options)
+    end
+
     # Returns notifications_url for the target
     #
     # @param [Object] target Target instance
@@ -215,6 +229,20 @@ module ActivityNotification
         send("open_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_url", target, options)
     end
 
+    # Returns destroy_all_notifications_url for the target
+    #
+    # @param [Object] target Target instance
+    # @param [Hash] params Request parameters
+    # @return [String] destroy_all_notifications_url for the target
+    # @todo Needs any other better implementation
+    # @todo Must handle devise namespace
+    def destroy_all_notifications_url_for(target, params = {})
+      options = params.dup
+      options.delete(:devise_default_routes) ?
+        send("destroy_all_#{routing_scope(options)}notifications_url", options) :
+        send("destroy_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_url", target, options)
+    end
+
     # Returns subscriptions_path for the target
     #
     # @param [Object] target Target instance

data/lib/activity_notification/mailers/helpers.rb

@@ -5,6 +5,7 @@ module ActivityNotification
     # Use to resolve parameters from email configuration and send notification email.
     module Helpers
       extend ActiveSupport::Concern
+      include ActivityNotification::NotificationResilience
 
       protected
 
@@ -13,10 +14,13 @@ module ActivityNotification
         # @param [Notification] notification Notification instance to send email
         # @param [Hash]         options      Options for notification email
         # @option options [String, Symbol] :fallback (:default) Fallback template to use when MissingTemplate is raised
+        # @return [Mail::Message, nil] Email message or nil if notification was not found
         def notification_mail(notification, options = {})
-          initialize_from_notification(notification)
-          headers = headers_for(notification.key, options)
-          send_mail(headers, options[:fallback])
+          with_notification_resilience(notification&.id, { target: 'unknown' }) do
+            initialize_from_notification(notification)
+            headers = headers_for(notification.key, options)
+            send_mail(headers, options[:fallback])
+          end
         end
 
         # Send batch notification email with configured options.
@@ -26,11 +30,14 @@ module ActivityNotification
         # @param [String]              batch_key     Key of the batch notification email
         # @param [Hash]                options       Options for notification email
         # @option options [String, Symbol] :fallback (:batch_default) Fallback template to use when MissingTemplate is raised
+        # @return [Mail::Message, nil] Email message or nil if notifications were not found
         def batch_notification_mail(target, notifications, batch_key, options = {})
-          initialize_from_notifications(target, notifications)
-          headers = headers_for(batch_key, options)
-          @notification = nil
-          send_mail(headers, options[:fallback])
+          with_notification_resilience(notifications&.first&.id, { target: target&.class&.name, batch: true }) do
+            initialize_from_notifications(target, notifications)
+            headers = headers_for(batch_key, options)
+            @notification = nil
+            send_mail(headers, options[:fallback])
+          end
         end
 
         # Initialize instance variables from notification.

data/lib/activity_notification/models/concerns/swagger/subscription_schema.rb

@@ -85,7 +85,7 @@ module ActivityNotification
                     },
                     subscribed_at: {
                       type: "string",
-                      format: "date-time"
+                      nullable: true
                     }
                   }
                 }

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

@@ -419,6 +419,22 @@ module ActivityNotification
       Notification.open_all_of(self, options)
     end
 
+    # Destroys all notifications of the target matching the filter criteria.
+    #
+    # @param [Hash] options Options for filtering notifications to destroy
+    # @option options [String]   :filtered_by_type       (nil) Notifiable type for filter
+    # @option options [Object]   :filtered_by_group      (nil) Group instance for filter
+    # @option options [String]   :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
+    # @option options [String]   :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
+    # @option options [String]   :filtered_by_key        (nil) Key of the notification for filter
+    # @option options [String]   :later_than             (nil) ISO 8601 format time to filter notifications later than specified time
+    # @option options [String]   :earlier_than           (nil) ISO 8601 format time to filter notifications earlier than specified time
+    # @option options [Array]    :ids                    (nil) Array of specific notification IDs to destroy
+    # @return [Array<Notification>] Destroyed notification records
+    def destroy_all_notifications(options = {})
+      Notification.destroy_all_of(self, options)
+    end
+
 
     # Gets automatically arranged notification index of the target with included attributes like target, notifiable, group and notifier.
     # This method is the typical way to get notifications index from controller of view.

data/lib/activity_notification/models.rb

@@ -18,11 +18,11 @@ module ActivityNotification
 end
 
 if defined?(ActiveRecord::Base)
+  # :nocov:
   ActiveRecord::Base.class_eval { include ActivityNotification::Models }
 
   # https://github.com/simukappu/activity_notification/issues/166
   # https://discuss.rubyonrails.org/t/cve-2022-32224-possible-rce-escalation-bug-with-serialized-columns-in-active-record/81017
-  # :nocov:
   if (Gem::Version.new("5.2.8.1") <= Rails.gem_version && Rails.gem_version < Gem::Version.new("6.0")) ||
     (Gem::Version.new("6.0.5.1") <= Rails.gem_version && Rails.gem_version < Gem::Version.new("6.1")) ||
     (Gem::Version.new("6.1.6.1") <= Rails.gem_version && Rails.gem_version < Gem::Version.new("7.0"))

data/lib/activity_notification/notification_resilience.rb

@@ -0,0 +1,115 @@
+module ActivityNotification
+  # Provides resilient notification handling across different ORMs
+  # Handles missing notification scenarios gracefully without raising exceptions
+  module NotificationResilience
+    extend ActiveSupport::Concern
+
+    # Exception classes for different ORMs
+    ORM_EXCEPTIONS = {
+      active_record: 'ActiveRecord::RecordNotFound',
+      mongoid: 'Mongoid::Errors::DocumentNotFound', 
+      dynamoid: 'Dynamoid::Errors::RecordNotFound'
+    }.freeze
+
+    class_methods do
+      # Returns the current ORM being used
+      # @return [Symbol] The ORM symbol (:active_record, :mongoid, :dynamoid)
+      def current_orm
+        ActivityNotification.config.orm
+      end
+
+      # Returns the exception class for the current ORM
+      # @return [Class] The exception class for missing records in current ORM
+      def record_not_found_exception_class
+        exception_name = ORM_EXCEPTIONS[current_orm]
+        return nil unless exception_name
+        
+        begin
+          exception_name.constantize
+        rescue NameError
+          nil
+        end
+      end
+
+      # Checks if an exception is a "record not found" exception for any supported ORM
+      # @param [Exception] exception The exception to check
+      # @return [Boolean] True if the exception indicates a missing record
+      def record_not_found_exception?(exception)
+        ORM_EXCEPTIONS.values.any? do |exception_name|
+          begin
+            exception.is_a?(exception_name.constantize)
+          rescue NameError
+            false
+          end
+        end
+      end
+    end
+
+    # Module-level methods that delegate to class methods
+    def self.current_orm
+      ActivityNotification.config.orm
+    end
+
+    def self.record_not_found_exception_class
+      exception_name = ORM_EXCEPTIONS[current_orm]
+      return nil unless exception_name
+      
+      begin
+        exception_name.constantize
+      rescue NameError
+        nil
+      end
+    end
+
+    def self.record_not_found_exception?(exception)
+      ORM_EXCEPTIONS.values.any? do |exception_name|
+        begin
+          exception.is_a?(exception_name.constantize)
+        rescue NameError
+          false
+        end
+      end
+    end
+
+    # Executes a block with resilient notification handling
+    # Catches ORM-specific "record not found" exceptions and logs them appropriately
+    # @param [String, Integer] notification_id The ID of the notification being processed
+    # @param [Hash] context Additional context for logging
+    # @yield Block to execute with resilient handling
+    # @return [Object, nil] Result of the block, or nil if notification was not found
+    def with_notification_resilience(notification_id = nil, context = {})
+      yield
+    rescue => exception
+      if self.class.record_not_found_exception?(exception)
+        log_missing_notification(notification_id, exception, context)
+        nil
+      else
+        raise exception
+      end
+    end
+
+    private
+
+    # Logs a warning when a notification is not found
+    # @param [String, Integer] notification_id The ID of the missing notification
+    # @param [Exception] exception The exception that was caught
+    # @param [Hash] context Additional context for logging
+    def log_missing_notification(notification_id, exception, context = {})
+      orm_name = self.class.current_orm
+      exception_class = exception.class.name
+      
+      message = "ActivityNotification: Notification"
+      message += " with id #{notification_id}" if notification_id
+      message += " not found for email delivery"
+      message += " (#{orm_name}/#{exception_class})"
+      message += ", likely destroyed before job execution"
+      
+      if context.any?
+        context_info = context.map { |k, v| "#{k}: #{v}" }.join(', ')
+        message += " [#{context_info}]"
+      end
+
+      Rails.logger.warn(message)
+    end
+  end
+end