noticed 2.0.0 → 3.0.0

data/app/jobs/noticed/event_job.rb

@@ -1,17 +1,15 @@
 module Noticed
-  class EventJob < ApplicationJob
-    queue_as :default
-
+  class EventJob < Noticed.parent_class.constantize
     def perform(event)
       # Enqueue bulk deliveries
-      event.bulk_delivery_methods.each do |_, deliver_by|
-        deliver_by.perform_later(event)
+      event.bulk_delivery_methods.each_value do |deliver_by|
+        deliver_by.perform_later(event) if deliver_by.perform?(event)
       end
 
       # Enqueue individual deliveries
       event.notifications.each do |notification|
-        event.delivery_methods.each do |_, deliver_by|
-          deliver_by.perform_later(notification)
+        event.delivery_methods.each_value do |deliver_by|
+          deliver_by.perform_later(notification) if deliver_by.perform?(notification)
         end
       end
     end

data/app/models/concerns/noticed/deliverable.rb

@@ -6,14 +6,7 @@ module Noticed
       class_attribute :bulk_delivery_methods, instance_writer: false, default: {}
       class_attribute :delivery_methods, instance_writer: false, default: {}
       class_attribute :required_param_names, instance_writer: false, default: []
-
-      attribute :params, default: {}
-
-      if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
-        serialize :params, coder: Coder
-      else
-        serialize :params, Coder
-      end
+      class_attribute :_recipients, instance_writer: false
     end
 
     class_methods do
@@ -35,24 +28,54 @@ module Noticed
       def deliver_by(name, options = {})
         raise NameError, "#{name} has already been used for this Notifier." if delivery_methods.has_key?(name)
 
+        if name == :database
+          Noticed.deprecator.warn <<-WARNING.squish
+            The :database delivery method has been deprecated and does nothing. Notifiers automatically save to the database now.
+          WARNING
+          return
+        end
+
         config = ActiveSupport::OrderedOptions.new.merge(options)
         yield config if block_given?
         delivery_methods[name] = DeliverBy.new(name, config)
       end
 
+      def recipients(option = nil, &block)
+        self._recipients = block || option
+      end
+
       def required_params(*names)
         required_param_names.concat names
       end
       alias_method :required_param, :required_params
 
+      def params(*names)
+        Noticed.deprecator.warn <<-WARNING.squish
+          `params` is deprecated and has been renamed to `required_params`
+        WARNING
+        required_params(*names)
+      end
+
+      def param(*names)
+        Noticed.deprecator.warn <<-WARNING.squish
+          `param :name` is deprecated and has been renamed to `required_param :name`
+        WARNING
+        required_params(*names)
+      end
+
       def with(params)
-        record = params.delete(:record)
-        new(params: params, record: record)
+        if self < Ephemeral
+          new(params: params)
+        else
+          record = params.delete(:record)
+          new(params: params, record: record)
+        end
       end
 
-      def deliver(recipients = nil, options = {})
-        new.deliver(recipients, options)
+      def deliver(recipients = nil, **options)
+        new.deliver(recipients, **options)
       end
+      alias_method :deliver_later, :deliver
     end
 
     # CommentNotifier.deliver(User.all)
@@ -60,16 +83,19 @@ module Noticed
     # CommentNotifier.deliver(User.all, queue: :low_priority)
     # CommentNotifier.deliver(User.all, wait: 5.minutes)
     # CommentNotifier.deliver(User.all, wait_until: 1.hour.from_now)
-    def deliver(recipients = nil, options = {})
+    def deliver(recipients = nil, enqueue_job: true, **options)
+      recipients ||= evaluate_recipients
+
       validate!
 
       transaction do
-        save!
-
         recipients_attributes = Array.wrap(recipients).map do |recipient|
           recipient_attributes_for(recipient)
         end
 
+        self.notifications_count = recipients_attributes.size
+        save!
+
         if Rails.gem_version >= Gem::Version.new("7.0.0.alpha1")
           notifications.insert_all!(recipients_attributes, record_timestamps: true) if recipients_attributes.any?
         else
@@ -83,15 +109,26 @@ module Noticed
       end
 
       # Enqueue delivery job
-      EventJob.set(options).perform_later(self)
+      EventJob.set(options).perform_later(self) if enqueue_job
 
       self
     end
+    alias_method :deliver_later, :deliver
+
+    def evaluate_recipients
+      return unless _recipients
+
+      if _recipients.respond_to?(:call, true)
+        instance_exec(&_recipients)
+      elsif _recipients.is_a?(Symbol) && respond_to?(_recipients, true)
+        send(_recipients)
+      end
+    end
 
     def recipient_attributes_for(recipient)
       {
         type: "#{self.class.name}::Notification",
-        recipient_type: recipient.class.name,
+        recipient_type: recipient.class.base_class.name,
         recipient_id: recipient.id
       }
     end
@@ -103,7 +140,7 @@ module Noticed
 
     def validate_params!
       required_param_names.each do |param_name|
-        raise ValidationError, "Param `#{param_name}` is required for #{self.class.name}." unless params[param_name].present?
+        raise ValidationError, "Param `#{param_name}` is required for #{self.class.name}." unless params.has_key?(param_name)
       end
     end
 
@@ -111,5 +148,10 @@ module Noticed
       bulk_delivery_methods.values.each(&:validate!)
       delivery_methods.values.each(&:validate!)
     end
+
+    # If a GlobalID record in params is no longer found, the params will default with a noticed_error key
+    def deserialize_error?
+      !!params[:noticed_error]
+    end
   end
 end

data/app/models/concerns/noticed/notification_methods.rb

@@ -6,7 +6,7 @@ module Noticed
       # Generate a Notification class each time a Notifier is defined
       def inherited(notifier)
         super
-        notifier.const_set :Notification, Class.new(Noticed::Notification)
+        notifier.const_set :Notification, Class.new(const_defined?(:Notification) ? const_get(:Notification) : Noticed::Notification)
       end
 
       def notification_methods(&block)

data/app/models/concerns/noticed/readable.rb

@@ -10,20 +10,28 @@ module Noticed
     end
 
     class_methods do
-      def mark_as_read
-        update_all(read_at: Time.current)
+      def mark_as_read_and_seen(**kwargs)
+        update_all(**kwargs.with_defaults(read_at: Time.current, seen_at: Time.current, updated_at: Time.current))
       end
 
-      def mark_as_unread
-        update_all(read_at: nil)
+      def mark_as_unread_and_unseen(**kwargs)
+        update_all(**kwargs.with_defaults(read_at: nil, seen_at: nil, updated_at: Time.current))
       end
 
-      def mark_as_seen
-        update_all(seen_at: Time.current)
+      def mark_as_read(**kwargs)
+        update_all(**kwargs.with_defaults(read_at: Time.current, updated_at: Time.current))
       end
 
-      def mark_as_unseen
-        update_all(seen_at: nil)
+      def mark_as_unread(**kwargs)
+        update_all(**kwargs.with_defaults(read_at: nil, updated_at: Time.current))
+      end
+
+      def mark_as_seen(**kwargs)
+        update_all(**kwargs.with_defaults(seen_at: Time.current, updated_at: Time.current))
+      end
+
+      def mark_as_unseen(**kwargs)
+        update_all(**kwargs.with_defaults(seen_at: nil, updated_at: Time.current))
       end
     end
 
@@ -31,18 +39,34 @@ module Noticed
       update(read_at: Time.current)
     end
 
+    def mark_as_read!
+      update!(read_at: Time.current)
+    end
+
     def mark_as_unread
       update(read_at: nil)
     end
 
+    def mark_as_unread!
+      update!(read_at: nil)
+    end
+
     def mark_as_seen
       update(seen_at: Time.current)
     end
 
+    def mark_as_seen!
+      update!(seen_at: Time.current)
+    end
+
     def mark_as_unseen
       update(seen_at: nil)
     end
 
+    def mark_as_unseen!
+      update!(seen_at: nil)
+    end
+
     def read?
       read_at?
     end

data/app/models/noticed/deliverable/deliver_by.rb

@@ -19,25 +19,46 @@ module Noticed
       end
 
       def perform_later(event_or_notification, options = {})
-        options[:wait] = evaluate_option(:wait, event_or_notification) if config.has_key?(:wait)
-        options[:wait_until] = evaluate_option(:wait_until, event_or_notification) if config.has_key?(:wait_until)
-        options[:queue] = evaluate_option(:queue, event_or_notification) if config.has_key?(:queue)
-        options[:priority] = evaluate_option(:priority, event_or_notification) if config.has_key?(:priority)
+        constant.set(computed_options(options, event_or_notification)).perform_later(name, event_or_notification)
+      end
 
-        constant.set(options).perform_later(name, event_or_notification)
+      def ephemeral_perform_later(notifier, recipient, params, options = {})
+        constant.set(computed_options(options, recipient))
+          .perform_later(name, "#{notifier}::Notification", recipient: recipient, params: params)
       end
 
       def evaluate_option(name, context)
         option = config[name]
 
-        if option&.respond_to?(:call)
+        if option.respond_to?(:call)
           context.instance_exec(&option)
-        elsif option.is_a?(Symbol) && context.respond_to?(option)
+        elsif option.is_a?(Symbol) && context.respond_to?(option, true)
           context.send(option)
         else
           option
         end
       end
+
+      def perform?(notification)
+        return true unless config.key?(:before_enqueue)
+
+        perform = false
+        catch(:abort) {
+          evaluate_option(:before_enqueue, notification)
+          perform = true
+        }
+        perform
+      end
+
+      private
+
+      def computed_options(options, recipient)
+        options[:wait] ||= evaluate_option(:wait, recipient) if config.has_key?(:wait)
+        options[:wait_until] ||= evaluate_option(:wait_until, recipient) if config.has_key?(:wait_until)
+        options[:queue] ||= evaluate_option(:queue, recipient) if config.has_key?(:queue)
+        options[:priority] ||= evaluate_option(:priority, recipient) if config.has_key?(:priority)
+        options
+      end
     end
   end
 end

data/app/models/noticed/ephemeral.rb

@@ -0,0 +1,63 @@
+module Noticed
+  class Ephemeral
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Noticed::Deliverable
+    include Noticed::Translation
+    include Rails.application.routes.url_helpers
+
+    attribute :record
+    attribute :params, default: {}
+
+    class Notification
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+      include Noticed::Translation
+      include Rails.application.routes.url_helpers
+
+      attribute :recipient
+      attribute :event
+
+      delegate :params, :record, to: :event
+
+      def self.new_with_params(recipient, params)
+        instance = new(recipient: recipient)
+        instance.event = module_parent.new(params: params)
+        instance
+      end
+    end
+
+    # Dynamically define Notification on each Ephemeral Notifier
+    def self.inherited(notifier)
+      super
+      notifier.const_set :Notification, Class.new(Noticed::Ephemeral::Notification)
+    end
+
+    def self.notification_methods(&block)
+      const_get(:Notification).class_eval(&block)
+    end
+
+    def deliver(recipients = nil)
+      recipients ||= evaluate_recipients
+      recipients = Array.wrap(recipients)
+
+      bulk_delivery_methods.each do |_, deliver_by|
+        deliver_by.ephemeral_perform_later(self.class.name, recipients, params)
+      end
+
+      recipients.each do |recipient|
+        delivery_methods.each do |_, deliver_by|
+          deliver_by.ephemeral_perform_later(self.class.name, recipient, params)
+        end
+      end
+
+      self
+    end
+
+    def record
+      params[:record]
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :noticed_ephemeral, Noticed::Ephemeral

data/app/models/noticed/event.rb

@@ -11,5 +11,18 @@ module Noticed
     accepts_nested_attributes_for :notifications
 
     scope :newest_first, -> { order(created_at: :desc) }
+
+    attribute :params, :json, default: {}
+
+    # Ephemeral notifiers cannot serialize params since they aren't ActiveRecord backed
+    if respond_to? :serialize
+      if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
+        serialize :params, coder: Coder
+      else
+        serialize :params, Coder
+      end
+    end
   end
 end
+
+ActiveSupport.run_load_hooks :noticed_event, Noticed::Event

data/app/models/noticed/notification.rb

@@ -4,13 +4,13 @@ module Noticed
     include Readable
     include Translation
 
-    belongs_to :event
+    belongs_to :event, counter_cache: true
     belongs_to :recipient, polymorphic: true
 
     scope :newest_first, -> { order(created_at: :desc) }
 
     delegate :params, :record, to: :event
-
-    attribute :params, default: {}
   end
 end
+
+ActiveSupport.run_load_hooks :noticed_notification, Noticed::Notification

data/db/migrate/20231215190233_create_noticed_tables.rb

@@ -1,8 +1,9 @@
 class CreateNoticedTables < ActiveRecord::Migration[6.1]
   def change
-    create_table :noticed_events do |t|
+    primary_key_type, foreign_key_type = primary_and_foreign_key_types
+    create_table :noticed_events, id: primary_key_type do |t|
       t.string :type
-      t.belongs_to :record, polymorphic: true
+      t.belongs_to :record, polymorphic: true, type: foreign_key_type
       if t.respond_to?(:jsonb)
         t.jsonb :params
       else
@@ -12,14 +13,24 @@ class CreateNoticedTables < ActiveRecord::Migration[6.1]
       t.timestamps
     end
 
-    create_table :noticed_notifications do |t|
+    create_table :noticed_notifications, id: primary_key_type do |t|
       t.string :type
-      t.belongs_to :event, null: false
-      t.belongs_to :recipient, polymorphic: true, null: false
+      t.belongs_to :event, null: false, type: foreign_key_type
+      t.belongs_to :recipient, polymorphic: true, null: false, type: foreign_key_type
       t.datetime :read_at
       t.datetime :seen_at
 
       t.timestamps
     end
   end
+
+  private
+
+  def primary_and_foreign_key_types
+    config = Rails.configuration.generators
+    setting = config.options[config.orm][:primary_key_type]
+    primary_key_type = setting || :primary_key
+    foreign_key_type = setting || :bigint
+    [primary_key_type, foreign_key_type]
+  end
 end

data/db/migrate/20240129184740_add_notifications_count_to_noticed_event.rb

@@ -0,0 +1,5 @@
+class AddNotificationsCountToNoticedEvent < ActiveRecord::Migration[6.1]
+  def change
+    add_column :noticed_events, :notifications_count, :integer
+  end
+end

data/lib/generators/noticed/delivery_method_generator.rb

@@ -11,8 +11,16 @@ module Noticed
 
       desc "Generates a class for a custom delivery method with the given NAME."
 
+      class_option :bulk, desc: "Generate as a bulk delivery method", type: :boolean, default: false
+
       def generate_notification
-        template "delivery_method.rb", "app/notifiers/delivery_methods/#{singular_name}.rb"
+        if options[:bulk]
+          template "application_bulk_delivery_method.rb", "app/notifiers/application_bulk_delivery_method.rb"
+          template "bulk_delivery_method.rb", "app/notifiers/bulk_delivery_methods/#{singular_name}.rb"
+        else
+          template "application_delivery_method.rb", "app/notifiers/application_delivery_method.rb"
+          template "delivery_method.rb", "app/notifiers/delivery_methods/#{singular_name}.rb"
+        end
       end
     end
   end

data/lib/generators/noticed/notifier_generator.rb

@@ -7,12 +7,25 @@ module Noticed
     class NotifierGenerator < Rails::Generators::NamedBase
       include Rails::Generators::ResourceHelpers
 
+      check_class_collision suffix: "Notifier"
+
       source_root File.expand_path("../templates", __FILE__)
 
       desc "Generates a notification with the given NAME."
 
+      def generate_abstract_class
+        return if File.exist?("app/notifiers/application_notifier.rb")
+        template "application_notifier.rb", "app/notifiers/application_notifier.rb"
+      end
+
       def generate_notification
-        template "notifier.rb", "app/notifiers/#{file_path}.rb"
+        template "notifier.rb", "app/notifiers/#{file_path}_notifier.rb"
+      end
+
+      private
+
+      def file_name # :doc:
+        @_file_name ||= super.sub(/_notifier\z/i, "")
       end
     end
   end

data/lib/generators/noticed/templates/application_bulk_delivery_method.rb.tt

@@ -0,0 +1,2 @@
+class ApplicationBulkDeliveryMethod < Noticed::BulkDeliveryMethod
+end

data/lib/generators/noticed/templates/application_delivery_method.rb.tt

@@ -0,0 +1,2 @@
+class ApplicationDeliveryMethod < Noticed::DeliveryMethod
+end

data/lib/generators/noticed/templates/application_notifier.rb.tt

@@ -0,0 +1,2 @@
+class ApplicationNotifier < Noticed::Event
+end

data/lib/generators/noticed/templates/bulk_delivery_method.rb.tt

@@ -0,0 +1,14 @@
+class BulkDeliveryMethods::<%= class_name %> < ApplicationBulkDeliveryMethod
+  # To use this delivery method, specify the class option in your notifier.
+  #
+  #   class MyNotifer < ApplicationNotifier
+  #     bulk_deliver_by :<%= file_path %>, class: "<%= class_name %>"
+  #   end
+
+  # Specify required options for the deliver_by config block
+  # required_options :foo, :bar
+
+  def deliver
+    # Logic for sending the notification
+  end
+end

data/lib/generators/noticed/templates/delivery_method.rb.tt

@@ -1,12 +1,14 @@
-class DeliveryMethods::<%= class_name %> < Noticed::DeliveryMethods::Base
+class DeliveryMethods::<%= class_name %> < ApplicationDeliveryMethod
+  # To use this delivery method, specify the class option in your notifier.
+  #
+  #   class MyNotifer < ApplicationNotifier
+  #     deliver_by :<%= file_path %>, class: "<%= class_name %>"
+  #   end
+
+  # Specify required options for the deliver_by config block
+  # required_options :foo, :bar
+
   def deliver
     # Logic for sending the notification
   end
-
-  # You may override this method to validate options for the delivery method
-  # Invalid options should raise a ValidationError
-  #
-  # def self.validate!(options)
-  #   raise ValidationError, "required_option missing" unless options[:required_option]
-  # end
 end

data/lib/generators/noticed/templates/notifier.rb.tt

@@ -1,8 +1,8 @@
 # To deliver this notification:
 #
-# <%= class_name %>.with(record: @post, message: "New post").deliver(User.all)
+# <%= class_name %>Notifier.with(record: @post, message: "New post").deliver(User.all)
 
-class <%= class_name %> < Noticed::Event
+class <%= class_name %>Notifier < ApplicationNotifier
   # Add your delivery methods
   #
   # deliver_by :email do |config|
@@ -21,4 +21,10 @@ class <%= class_name %> < Noticed::Event
   # Add required params
   #
   # required_param :message
+
+  # Compute recipients without having to pass them in
+  #
+  # recipients do
+  #   params[:record].thread.all_authors
+  # end
 end

data/lib/noticed/api_client.rb

@@ -28,7 +28,9 @@ module Noticed
       if (json = args.delete(:json))
         request.body = json.to_json
       elsif (form = args.delete(:form))
-        request.set_form(form, "multipart/form-data")
+        request.form_data = form
+      elsif (body = args.delete(:body))
+        request.body = body
       end
 
       logger.debug("POST #{url}")

data/lib/noticed/bulk_delivery_method.rb

@@ -1,20 +1,32 @@
 module Noticed
-  class BulkDeliveryMethod < ApplicationJob
+  class BulkDeliveryMethod < Noticed.parent_class.constantize
     include ApiClient
     include RequiredOptions
 
+    extend ActiveModel::Callbacks
+
+    define_model_callbacks :deliver
+
     class_attribute :logger, default: Rails.logger
 
     attr_reader :config, :event
 
-    def perform(delivery_method_name, event)
-      @event = event
-      @config = event.bulk_delivery_methods.fetch(delivery_method_name).config
+    def perform(delivery_method_name, event, recipient: nil, params: {}, overrides: {})
+      # Ephemeral notifications
+      if event.is_a? String
+        @event = event.constantize.new_with_params(recipient, params)
+        @config = overrides
+      else
+        @event = event
+        @config = event.bulk_delivery_methods.fetch(delivery_method_name).config.merge(overrides)
+      end
 
       return false if config.has_key?(:if) && !evaluate_option(:if)
       return false if config.has_key?(:unless) && evaluate_option(:unless)
 
-      deliver
+      run_callbacks :deliver do
+        deliver
+      end
     end
 
     def deliver
@@ -23,7 +35,7 @@ module Noticed
 
     def fetch_constant(name)
       option = config[name]
-      option.is_a?(String) ? option.constantize : option
+      option.is_a?(String) ? option.constantize : evaluate_option(option)
     end
 
     def evaluate_option(name)
@@ -34,7 +46,7 @@ module Noticed
         event.instance_exec(&option)
 
       # Call method if symbol and matching method
-      elsif option.is_a?(Symbol) && event.respond_to?(option)
+      elsif option.is_a?(Symbol) && event.respond_to?(option, true)
         event.send(option)
 
       # Return the value