active_delivery 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34afeceddc78be6864aed136f68bc0a0f0eb43c203ef1520260fe94a8c934b39
-  data.tar.gz: dab4270f8b7a4c5e14b18c3fd36ceb081587425f26a50060191778bab768d688
+  metadata.gz: dfc96638e6c019dd1b13f57eef8ab3b9bf2a34df2b58ca7f7ea8ea167886c59e
+  data.tar.gz: b50d556edef4a01fc7d1a8af1659a05f99a821584c2d4818418401f3a03350dd
 SHA512:
-  metadata.gz: 67992b515155ae977dd2f839448b3fe89d8c1391906e3c20bd425782241378f70d0b933834433a5e30904a7f3a1176c1313cd690267f001258f9584b078f0367
-  data.tar.gz: c811abf777c5c0c7552749fcedd228e7914bc80ded1a14129f4194097d74049f72e80c229c59549ac09141fed3145ab4c4199706ca29055ce6a405c3c16e13a2
+  metadata.gz: 518d226591f5114383c2d138c163b4bac13e62666cce4f7edde7d2df5bca7e770c17576f00fee378b9a8733cc72372960efa2692839a6dc4d274d130787fcb41
+  data.tar.gz: 2bd5eed0775fd32d83ca45364d8ecdc4f28c275eb2ffbbcad768ef98d8581b1cd0e66eb72f7e012c9d4dbd0a18e8a72cb40a858f0459614e18a5ee3e24fb0420

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 1.1.0 (2023-12-01) ❄️
+
+- Support delayed delivery options (e.g, `wait_until`). ([@palkan][])
+
 ## 📬 1.0.0 (2023-08-29)
 
 - Add `resolver_pattern` option to specify naming pattern for notifiers without using Procs. ([@palkan][])
@@ -43,6 +47,20 @@
 
 - Add `#deliver_via(*lines)` RSpec matcher. ([@palkan][])
 
+- **BREAKING** The `#resolve_class` method in Line classes now receive a delivery class instead of a name:
+
+  ```ruby
+  # before
+  def resolve_class(name)
+    name.gsub(/Delivery$/, "Channel").safe_constantize
+  end
+
+  # after
+  def resolve_class(name)
+    name.to_s.gsub(/Delivery$/, "Channel").safe_constantize
+  end
+  ```
+
 - Provide ActionMailer-like interface to trigger notifications. ([@palkan][])
 
   Now you can send notifications as follows:

data/README.md

@@ -113,6 +113,9 @@ PostsDelivery.published(user, post).deliver_later
 PostsMailer.published(user, post).deliver_later
 PostsSMSNotifier.published(user, post).notify_later
 
+# You can also pass options supported by your async executor (such as ActiveJob)
+PostsDelivery.published(user, post).deliver_later(wait_until: 1.day.from_now)
+
 # and whaterver your ActionCableDeliveryLine does
 # under the hood.
 ```
@@ -706,7 +709,7 @@ end
 
 ### Background jobs / async notifications
 
-To use `#notify_later` you **must** configure an async adapter for Abstract Notifier.
+To use `#notify_later(**delivery_options)` you **must** configure an async adapter for Abstract Notifier.
 
 We provide an Active Job adapter out of the box and enable it if Active Job is found.
 
@@ -718,13 +721,13 @@ class MyAsyncAdapter
   def initialize(options = {})
   end
 
-  # `enqueue` method accepts notifier class, action name and notification parameters
-  def enqueue(notifier_class, action_name, params:, args:, kwargs:)
+  # `enqueue_delivery` method accepts notifier class, action name and notification parameters
+  def enqueue_delivery(delivery, **options)
     # <Your implementation here>
     # To trigger the notification delivery, you can use the following snippet:
     #
     #   AbstractNotifier::NotificationDelivery.new(
-    #     notifier_class.constantize, action_name, params:, args:, kwargs:
+    #     delivery.notifier_class, delivery.action_name, **delivery.delivery_params
     #   ).notify_now
   end
 end

data/lib/.rbnext/3.0/abstract_notifier/async_adapters/active_job.rb

@@ -11,15 +11,24 @@ module AbstractNotifier
 
       DEFAULT_QUEUE = "notifiers"
 
-      attr_reader :job
+      attr_reader :job, :queue
 
       def initialize(queue: DEFAULT_QUEUE, job: DeliveryJob)
-        @job = job.set(queue: queue)
+        @job = job
+        @queue = queue
       end
 
       def enqueue(...)
-        job.perform_later(...)
+        job.set(queue: queue).perform_later(...)
       end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :enqueue)
+
+      def enqueue_delivery(delivery, **opts)
+        job.set(queue: queue, **opts).perform_later(
+          delivery.notifier_class.name,
+          delivery.action_name,
+          **delivery.delivery_params
+        )
+      end
     end
   end
 end

data/lib/.rbnext/3.0/abstract_notifier/base.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module AbstractNotifier
+  # NotificationDelivery payload wrapper which contains
+  # information about the current notifier class
+  # and knows how to trigger the delivery
+  class NotificationDelivery
+    attr_reader :action_name, :notifier_class
+
+    def initialize(notifier_class, action_name, params: {}, args: [], kwargs: {})
+      @notifier_class = notifier_class
+      @action_name = action_name
+      @params = params
+      @args = args
+      @kwargs = kwargs
+    end
+
+    def processed
+      return @processed if instance_variable_defined?(:@processed)
+
+      @processed = notifier.process_action(action_name, *args, **kwargs) || Notification.new(nil)
+    end
+
+    alias_method :notification, :processed
+
+    def notify_later(**opts)
+      if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
+        notifier_class.async_adapter.enqueue_delivery(self, **opts)
+      else
+        notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params: params, args: args, kwargs: kwargs)
+      end
+    end
+
+    def notify_now
+      return unless notification.payload
+
+      notifier.deliver!(notification)
+    end
+
+    def delivery_params ;  {params: params, args: args, kwargs: kwargs}; end
+
+    private
+
+    attr_reader :params, :args, :kwargs
+
+    def notifier
+      @notifier ||= notifier_class.new(action_name, **params)
+    end
+  end
+
+  # Notification object contains the compiled payload to be delivered
+  class Notification
+    attr_reader :payload
+
+    def initialize(payload)
+      @payload = payload
+    end
+  end
+
+  # Base class for notifiers
+  class Base
+    class ParamsProxy
+      attr_reader :notifier_class, :params
+
+      def initialize(notifier_class, params)
+        @notifier_class = notifier_class
+        @params = params
+      end
+
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method_name, *args, **kwargs)
+        NotificationDelivery.new(notifier_class, method_name, params: params, args: args, kwargs: kwargs)
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      def respond_to_missing?(*args)
+        notifier_class.respond_to_missing?(*args)
+      end
+    end
+
+    class << self
+      attr_writer :driver
+
+      def driver
+        return @driver if instance_variable_defined?(:@driver)
+
+        @driver =
+          if superclass.respond_to?(:driver)
+            superclass.driver
+          else
+            raise "Driver not found for #{name}. " \
+                  "Please, specify driver via `self.driver = MyDriver`"
+          end
+      end
+
+      def async_adapter=(args)
+        adapter, options = Array(args)
+        @async_adapter = AsyncAdapters.lookup(adapter, options)
+      end
+
+      def async_adapter
+        return @async_adapter if instance_variable_defined?(:@async_adapter)
+
+        @async_adapter =
+          if superclass.respond_to?(:async_adapter)
+            superclass.async_adapter
+          else
+            AbstractNotifier.async_adapter
+          end
+      end
+
+      def default(method_name = nil, **hargs, &block)
+        return @defaults_generator = block if block
+
+        return @defaults_generator = proc { send(method_name) } unless method_name.nil?
+
+        @default_params =
+          if superclass.respond_to?(:default_params)
+            superclass.default_params.merge(hargs).freeze
+          else
+            hargs.freeze
+          end
+      end
+
+      def defaults_generator
+        return @defaults_generator if instance_variable_defined?(:@defaults_generator)
+
+        @defaults_generator =
+          if superclass.respond_to?(:defaults_generator)
+            superclass.defaults_generator
+          end
+      end
+
+      def default_params
+        return @default_params if instance_variable_defined?(:@default_params)
+
+        @default_params =
+          if superclass.respond_to?(:default_params)
+            superclass.default_params.dup
+          else
+            {}
+          end
+      end
+
+      def method_missing(method_name, *args, **kwargs)
+        if action_methods.include?(method_name.to_s)
+          NotificationDelivery.new(self, method_name, args: args, kwargs: kwargs)
+        else
+          super
+        end
+      end
+
+      def with(params)
+        ParamsProxy.new(self, params)
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        action_methods.include?(method_name.to_s) || super
+      end
+
+      # See https://github.com/rails/rails/blob/b13a5cb83ea00d6a3d71320fd276ca21049c2544/actionpack/lib/abstract_controller/base.rb#L74
+      def action_methods
+        @action_methods ||= begin
+          # All public instance methods of this class, including ancestors
+          methods = (public_instance_methods(true) -
+            # Except for public instance methods of Base and its ancestors
+            Base.public_instance_methods(true) +
+            # Be sure to include shadowed public instance methods of this class
+            public_instance_methods(false))
+
+          methods.map!(&:to_s)
+
+          methods.to_set
+        end
+      end
+    end
+
+    attr_reader :params, :notification_name
+
+    def initialize(notification_name, **params)
+      @notification_name = notification_name
+      @params = params.freeze
+    end
+
+    def process_action(...)
+      public_send(...)
+    end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :process_action)
+
+    def deliver!(notification)
+      self.class.driver.call(notification.payload)
+    end
+
+    def notification(**payload)
+      merge_defaults!(payload)
+
+      payload[:body] = implicit_payload_body unless payload.key?(:body)
+
+      raise ArgumentError, "Notification body must be present" if
+        payload[:body].nil? || payload[:body].empty?
+
+      @notification = Notification.new(payload)
+    end
+
+    private
+
+    def implicit_payload_body
+      # no-op — override to provide custom logic
+    end
+
+    def merge_defaults!(payload)
+      defaults =
+        if self.class.defaults_generator
+          instance_exec(&self.class.defaults_generator)
+        else
+          self.class.default_params
+        end
+
+      defaults.each do |k, v|
+        payload[k] = v unless payload.key?(k)
+      end
+    end
+  end
+end

data/lib/.rbnext/3.0/active_delivery/base.rb

@@ -12,9 +12,9 @@ module ActiveDelivery
       @metadata = metadata.freeze
     end
 
-    def deliver_later ;  owner.perform_notify(self); end
+    def deliver_later(**opts) ;  owner.perform_notify(self, enqueue_options: opts); end
 
-    def deliver_now ;  owner.perform_notify(self, sync: true); end
+    def deliver_now(**opts) ;  owner.perform_notify(self, sync: true); end
 
     def delivery_class ;  owner.class; end
   end
@@ -216,22 +216,23 @@ module ActiveDelivery
 
     protected
 
-    def perform_notify(delivery, sync: false)
+    def perform_notify(delivery, sync: false, enqueue_options: {})
       delivery_lines.each do |type, line|
         next unless line.notify?(delivery.notification)
 
-        notify_line(type, line, delivery, sync: sync)
+        notify_line(type, line, delivery, sync: sync, enqueue_options: enqueue_options)
       end
     end
 
     private
 
-    def notify_line(type, line, delivery, sync:)
+    def notify_line(type, line, delivery, sync:, enqueue_options:)
       line.notify(
         delivery.notification,
         *delivery.params,
         params: params,
         sync: sync,
+        enqueue_options: enqueue_options,
         **delivery.options
       )
       true

data/lib/.rbnext/3.0/active_delivery/lines/base.rb

@@ -37,9 +37,21 @@ module ActiveDelivery
       def notify_later(handler, mid, *__rest__, &__block__)
       end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later)
 
-      def notify(mid, *args, params:, sync:, **kwargs)
+      def notify_later_with_options(handler, enqueue_options, mid, *__rest__, &__block__)
+        notify_later(handler, mid, *__rest__, &__block__)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later_with_options)
+
+      def notify(mid, *args, params:, sync:, enqueue_options:, **kwargs)
         clazz = params.empty? ? handler_class : handler_class.with(**params)
-        sync ? notify_now(clazz, mid, *args, **kwargs) : notify_later(clazz, mid, *args, **kwargs)
+        if sync
+          return notify_now(clazz, mid, *args, **kwargs)
+        end
+
+        if enqueue_options.empty?
+          notify_later(clazz, mid, *args, **kwargs)
+        else
+          notify_later_with_options(clazz, enqueue_options, mid, *args, **kwargs)
+        end
       end
 
       def handler_class

data/lib/.rbnext/3.0/active_delivery/lines/mailer.rb

@@ -19,6 +19,10 @@ module ActiveDelivery
       def notify_later(mailer, mid, *__rest__, &__block__)
         mailer.public_send(mid, *__rest__, &__block__).deliver_later
       end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later)
+
+      def notify_later_with_options(mailer, enqueue_options, mid, *__rest__, &__block__)
+        mailer.public_send(mid, *__rest__, &__block__).deliver_later(**enqueue_options)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later_with_options)
     end
 
     ActiveDelivery::Base.register_line :mailer, Mailer, resolver: Mailer::DEFAULT_RESOLVER

data/lib/.rbnext/3.1/abstract_notifier/async_adapters/active_job.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AbstractNotifier
+  module AsyncAdapters
+    class ActiveJob
+      class DeliveryJob < ::ActiveJob::Base
+        def perform(notifier_class, ...)
+          AbstractNotifier::NotificationDelivery.new(notifier_class.constantize, ...).notify_now
+        end
+      end
+
+      DEFAULT_QUEUE = "notifiers"
+
+      attr_reader :job, :queue
+
+      def initialize(queue: DEFAULT_QUEUE, job: DeliveryJob)
+        @job = job
+        @queue = queue
+      end
+
+      def enqueue(...)
+        job.set(queue: queue).perform_later(...)
+      end
+
+      def enqueue_delivery(delivery, **opts)
+        job.set(queue: queue, **opts).perform_later(
+          delivery.notifier_class.name,
+          delivery.action_name,
+          **delivery.delivery_params
+        )
+      end
+    end
+  end
+end
+
+AbstractNotifier.async_adapter ||= :active_job

data/lib/.rbnext/3.1/abstract_notifier/base.rb

@@ -5,10 +5,10 @@ module AbstractNotifier
   # information about the current notifier class
   # and knows how to trigger the delivery
   class NotificationDelivery
-    attr_reader :action_name
+    attr_reader :action_name, :notifier_class
 
-    def initialize(owner_class, action_name, params: {}, args: [], kwargs: {})
-      @owner_class = owner_class
+    def initialize(notifier_class, action_name, params: {}, args: [], kwargs: {})
+      @notifier_class = notifier_class
       @action_name = action_name
       @params = params
       @args = args
@@ -23,8 +23,12 @@ module AbstractNotifier
 
     alias_method :notification, :processed
 
-    def notify_later
-      owner_class.async_adapter.enqueue(owner_class.name, action_name, params: params, args: args, kwargs: kwargs)
+    def notify_later(**opts)
+      if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
+        notifier_class.async_adapter.enqueue_delivery(self, **opts)
+      else
+        notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params: params, args: args, kwargs: kwargs)
+      end
     end
 
     def notify_now
@@ -33,12 +37,14 @@ module AbstractNotifier
       notifier.deliver!(notification)
     end
 
+    def delivery_params ;  {params: params, args: args, kwargs: kwargs}; end
+
     private
 
-    attr_reader :owner_class, :params, :args, :kwargs
+    attr_reader :params, :args, :kwargs
 
     def notifier
-      @notifier ||= owner_class.new(action_name, **params)
+      @notifier ||= notifier_class.new(action_name, **params)
     end
   end
 
@@ -178,7 +184,7 @@ module AbstractNotifier
 
     def process_action(...)
       public_send(...)
-    end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :process_action)
+    end
 
     def deliver!(notification)
       self.class.driver.call(notification.payload)

data/lib/.rbnext/3.1/active_delivery/base.rb

@@ -12,9 +12,9 @@ module ActiveDelivery
       @metadata = metadata.freeze
     end
 
-    def deliver_later = owner.perform_notify(self)
+    def deliver_later(**opts) = owner.perform_notify(self, enqueue_options: opts)
 
-    def deliver_now = owner.perform_notify(self, sync: true)
+    def deliver_now(**opts) = owner.perform_notify(self, sync: true)
 
     def delivery_class = owner.class
   end
@@ -216,22 +216,23 @@ module ActiveDelivery
 
     protected
 
-    def perform_notify(delivery, sync: false)
+    def perform_notify(delivery, sync: false, enqueue_options: {})
       delivery_lines.each do |type, line|
         next unless line.notify?(delivery.notification)
 
-        notify_line(type, line, delivery, sync: sync)
+        notify_line(type, line, delivery, sync: sync, enqueue_options: enqueue_options)
       end
     end
 
     private
 
-    def notify_line(type, line, delivery, sync:)
+    def notify_line(type, line, delivery, sync:, enqueue_options:)
       line.notify(
         delivery.notification,
         *delivery.params,
         params: params,
         sync: sync,
+        enqueue_options: enqueue_options,
         **delivery.options
       )
       true

data/lib/.rbnext/3.1/active_delivery/lines/base.rb

@@ -37,9 +37,21 @@ module ActiveDelivery
       def notify_later(handler, mid, ...)
       end
 
-      def notify(mid, *args, params:, sync:, **kwargs)
+      def notify_later_with_options(handler, enqueue_options, mid, ...)
+        notify_later(handler, mid, ...)
+      end
+
+      def notify(mid, *args, params:, sync:, enqueue_options:, **kwargs)
         clazz = params.empty? ? handler_class : handler_class.with(**params)
-        sync ? notify_now(clazz, mid, *args, **kwargs) : notify_later(clazz, mid, *args, **kwargs)
+        if sync
+          return notify_now(clazz, mid, *args, **kwargs)
+        end
+
+        if enqueue_options.empty?
+          notify_later(clazz, mid, *args, **kwargs)
+        else
+          notify_later_with_options(clazz, enqueue_options, mid, *args, **kwargs)
+        end
       end
 
       def handler_class

data/lib/abstract_notifier/async_adapters/active_job.rb

@@ -11,14 +11,23 @@ module AbstractNotifier
 
       DEFAULT_QUEUE = "notifiers"
 
-      attr_reader :job
+      attr_reader :job, :queue
 
       def initialize(queue: DEFAULT_QUEUE, job: DeliveryJob)
-        @job = job.set(queue: queue)
+        @job = job
+        @queue = queue
       end
 
       def enqueue(...)
-        job.perform_later(...)
+        job.set(queue:).perform_later(...)
+      end
+
+      def enqueue_delivery(delivery, **opts)
+        job.set(queue:, **opts).perform_later(
+          delivery.notifier_class.name,
+          delivery.action_name,
+          **delivery.delivery_params
+        )
       end
     end
   end

data/lib/abstract_notifier/base.rb

@@ -5,10 +5,10 @@ module AbstractNotifier
   # information about the current notifier class
   # and knows how to trigger the delivery
   class NotificationDelivery
-    attr_reader :action_name
+    attr_reader :action_name, :notifier_class
 
-    def initialize(owner_class, action_name, params: {}, args: [], kwargs: {})
-      @owner_class = owner_class
+    def initialize(notifier_class, action_name, params: {}, args: [], kwargs: {})
+      @notifier_class = notifier_class
       @action_name = action_name
       @params = params
       @args = args
@@ -23,8 +23,12 @@ module AbstractNotifier
 
     alias_method :notification, :processed
 
-    def notify_later
-      owner_class.async_adapter.enqueue(owner_class.name, action_name, params:, args:, kwargs:)
+    def notify_later(**opts)
+      if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
+        notifier_class.async_adapter.enqueue_delivery(self, **opts)
+      else
+        notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params:, args:, kwargs:)
+      end
     end
 
     def notify_now
@@ -33,12 +37,14 @@ module AbstractNotifier
       notifier.deliver!(notification)
     end
 
+    def delivery_params = {params:, args:, kwargs:}
+
     private
 
-    attr_reader :owner_class, :params, :args, :kwargs
+    attr_reader :params, :args, :kwargs
 
     def notifier
-      @notifier ||= owner_class.new(action_name, **params)
+      @notifier ||= notifier_class.new(action_name, **params)
     end
   end
 

data/lib/abstract_notifier/testing.rb

@@ -36,12 +36,12 @@ module AbstractNotifier
         Driver.send_notification payload.merge(via: notifier.class)
       end
 
-      def notify_later
+      def notify_later(**opts)
         return super unless AbstractNotifier.test?
 
         payload = notification.payload
 
-        Driver.enqueue_notification payload.merge(via: notifier.class)
+        Driver.enqueue_notification payload.merge(via: notifier.class, **opts)
       end
     end
   end

data/lib/active_delivery/base.rb

@@ -12,9 +12,9 @@ module ActiveDelivery
       @metadata = metadata.freeze
     end
 
-    def deliver_later = owner.perform_notify(self)
+    def deliver_later(**opts) = owner.perform_notify(self, enqueue_options: opts)
 
-    def deliver_now = owner.perform_notify(self, sync: true)
+    def deliver_now(**opts) = owner.perform_notify(self, sync: true)
 
     def delivery_class = owner.class
   end
@@ -216,22 +216,23 @@ module ActiveDelivery
 
     protected
 
-    def perform_notify(delivery, sync: false)
+    def perform_notify(delivery, sync: false, enqueue_options: {})
       delivery_lines.each do |type, line|
         next unless line.notify?(delivery.notification)
 
-        notify_line(type, line, delivery, sync:)
+        notify_line(type, line, delivery, sync:, enqueue_options:)
       end
     end
 
     private
 
-    def notify_line(type, line, delivery, sync:)
+    def notify_line(type, line, delivery, sync:, enqueue_options:)
       line.notify(
         delivery.notification,
         *delivery.params,
         params:,
         sync:,
+        enqueue_options:,
         **delivery.options
       )
       true

data/lib/active_delivery/lines/base.rb

@@ -37,9 +37,21 @@ module ActiveDelivery
       def notify_later(handler, mid, ...)
       end
 
-      def notify(mid, *args, params:, sync:, **kwargs)
+      def notify_later_with_options(handler, enqueue_options, mid, ...)
+        notify_later(handler, mid, ...)
+      end
+
+      def notify(mid, *args, params:, sync:, enqueue_options:, **kwargs)
         clazz = params.empty? ? handler_class : handler_class.with(**params)
-        sync ? notify_now(clazz, mid, *args, **kwargs) : notify_later(clazz, mid, *args, **kwargs)
+        if sync
+          return notify_now(clazz, mid, *args, **kwargs)
+        end
+
+        if enqueue_options.empty?
+          notify_later(clazz, mid, *args, **kwargs)
+        else
+          notify_later_with_options(clazz, enqueue_options, mid, *args, **kwargs)
+        end
       end
 
       def handler_class

data/lib/active_delivery/lines/mailer.rb

@@ -19,6 +19,10 @@ module ActiveDelivery
       def notify_later(mailer, mid, ...)
         mailer.public_send(mid, ...).deliver_later
       end
+
+      def notify_later_with_options(mailer, enqueue_options, mid, ...)
+        mailer.public_send(mid, ...).deliver_later(**enqueue_options)
+      end
     end
 
     ActiveDelivery::Base.register_line :mailer, Mailer, resolver: Mailer::DEFAULT_RESOLVER

data/lib/active_delivery/lines/notifier.rb

@@ -38,6 +38,10 @@ module ActiveDelivery
         handler.public_send(mid, *args).notify_later
       end
 
+      def notify_later_with_options(handler, enqueue_options, mid, *args)
+        handler.public_send(mid, *args).notify_later(**enqueue_options)
+      end
+
       private
 
       attr_reader :resolver

data/lib/active_delivery/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveDelivery
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_delivery
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-29 00:00:00.000000000 Z
+date: 2023-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,11 +94,13 @@ files:
 - bin/console
 - bin/setup
 - lib/.rbnext/3.0/abstract_notifier/async_adapters/active_job.rb
+- lib/.rbnext/3.0/abstract_notifier/base.rb
 - lib/.rbnext/3.0/active_delivery/base.rb
 - lib/.rbnext/3.0/active_delivery/callbacks.rb
 - lib/.rbnext/3.0/active_delivery/lines/base.rb
 - lib/.rbnext/3.0/active_delivery/lines/mailer.rb
 - lib/.rbnext/3.0/active_delivery/testing.rb
+- lib/.rbnext/3.1/abstract_notifier/async_adapters/active_job.rb
 - lib/.rbnext/3.1/abstract_notifier/base.rb
 - lib/.rbnext/3.1/active_delivery/base.rb
 - lib/.rbnext/3.1/active_delivery/lines/base.rb
@@ -146,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Ruby and Rails framework for managing all types of notifications in one place