active_event_store 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86a1b7e969cbfcc31c139a556751f16a99b113e94e1ec16ebd6b91d0b348b75f
-  data.tar.gz: b9f620f2513466b0deb45a6f9a957199c2b6c0e7f9efedfbeaec29fc98809f48
+  metadata.gz: a05deabdbcd4baa4ec3a0e6e0ef4696b7913af826913ab0b8ce1ef45e97886dd
+  data.tar.gz: 12c2eafe4f93d63188344e341c01060bbcdbbb1e83328df7689b35c99346502d
 SHA512:
-  metadata.gz: a4aace26f3a7a2a51be9b100cfa037cfa325abdfc4ad5f0ed77d798d0b950ada5e8692ad8da951362b9401e4700e903b4495e85db08670746f4cfacc215a3eea
-  data.tar.gz: f88ad5fce885311214e8cd29094dfec64e3f033696d38115d4375f899656db6450d8e24ad3daed6af0f2cd6b60526a7169cf560835c443a36ea3bead628eab37
+  metadata.gz: 7eb6392317c966efae31a8eea8ad935e178af3ea0a61c036fded170d32b39c2d1758b0853ba6df75f6c4b898ee24866400a385c5d04aae3ff99268d8f7c8dbf4
+  data.tar.gz: 48bda0e29b746d8dfe3b265df265eb398e55a61b6a414ed4980a5887822fa5fd3c7b332cf2b0c55fc666d28824bbf1b58e717959b4c0c65f00dc516838cd36d4

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 1.4.0 (2026-07-17)
+
+- Support `wait:` / `wait_until:` on asynchronous `subscribe`, scheduling the subscriber job to run after a delay. ([@rickychilcott][])
+
+- Support rails_event_store 3.0 by using the renamed `RailsEventStore::AfterCommitDispatcher`, `RubyEventStore::SyncScheduler` and `RubyEventStore::ActiveRecord::EventRepository`, falling back to the pre-2.19 names when running on older versions. ([#24](https://github.com/palkan/active_event_store/issues/24))
+
 ## 1.3.0 (2025-12-04)
 
 - Update Rails Event Store configuration to avoid deprecation warning ([@christophermlne][], [@phil-monroe][])
@@ -51,3 +57,4 @@ Now `ActiveSupport.on_load(:active_event_store) { ... }` works.
 [@chriscz]: https://github.com/chriscz
 [@caws]: https://github.com/caws
 [@Samsinite]: https://github.com/Samsinite
+[@rickychilcott]: https://github.com/rickychilcott

data/README.md

@@ -128,6 +128,16 @@ ActiveSupport.on_load :active_event_store do |store|
   # sync subscriber – invoked right "within" `publish` method
   store.subscribe MyEventHandler, to: ProfileCreated, sync: true
 
+  # delayed async subscriber – the background job is enqueued with a delay.
+  # `wait:` and `wait_until:` are passed through to Active Job's `.set`.
+  # `wait:` (a duration or number of seconds) is applied relative to when the
+  # event is published, so this reads "10 minutes after the event".
+  store.subscribe MyEventHandler, to: ProfileCreated, wait: 10.minutes
+
+  # NOTE: `wait_until:` is an absolute time, captured when `subscribe` runs
+  # (i.e. at boot). Prefer `wait:` unless you truly mean a fixed moment.
+  store.subscribe MyEventHandler, to: ProfileCreated, wait_until: Date.parse("2030-01-01").midnight
+
   # anonymous handler (could only be synchronous)
   store.subscribe(to: ProfileCreated, sync: true) do |event|
     # do something

data/lib/active_event_store/config.rb

@@ -7,7 +7,7 @@ module ActiveEventStore
     attr_writer :repository, :serializer, :job_queue_name, :store_options
 
     def repository
-      @repository ||= RailsEventStoreActiveRecord::EventRepository.new(serializer: serializer)
+      @repository ||= RubyEventStore::ActiveRecord::EventRepository.new(serializer: serializer)
     end
 
     def serializer

data/lib/active_event_store/engine.rb

@@ -15,16 +15,35 @@ module ActiveEventStore
     end
 
     config.to_prepare do
+      # `AfterCommitAsyncDispatcher` was renamed to `AfterCommitDispatcher` in
+      # rails_event_store 2.19.0 and removed in 3.0.0. Both share the same
+      # `scheduler:` interface, so pick whichever is available.
+      after_commit_dispatcher_class =
+        if defined?(RailsEventStore::AfterCommitDispatcher)
+          RailsEventStore::AfterCommitDispatcher
+        else
+          RailsEventStore::AfterCommitAsyncDispatcher
+        end
+
+      # `RubyEventStore::Dispatcher` was renamed to `SyncScheduler` in the same
+      # release (2.19.0) and removed in 3.0.0.
+      sync_dispatcher =
+        if defined?(RubyEventStore::SyncScheduler)
+          RubyEventStore::SyncScheduler.new
+        else
+          RubyEventStore::Dispatcher.new
+        end
+
       # See https://railseventstore.org/docs/subscribe/#scheduling-async-handlers-after-commit
       ActiveEventStore.event_store = RailsEventStore::Client.new(
         message_broker: RubyEventStore::Broker.new(
           dispatcher: RubyEventStore::ComposedDispatcher.new(
-            RailsEventStore::AfterCommitAsyncDispatcher.new(
+            after_commit_dispatcher_class.new(
               scheduler: RailsEventStore::ActiveJobScheduler.new(
                 serializer: ActiveEventStore.config.serializer
               )
             ),
-            RubyEventStore::Dispatcher.new
+            sync_dispatcher
           )
         ),
         repository: ActiveEventStore.config.repository,

data/lib/active_event_store/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveEventStore # :nodoc:
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/lib/active_event_store.rb

@@ -25,7 +25,7 @@ module ActiveEventStore
       @config ||= Config.new
     end
 
-    def subscribe(subscriber = nil, to: nil, sync: false, &block)
+    def subscribe(subscriber = nil, to: nil, sync: false, wait: nil, wait_until: nil, &block)
       subscriber ||= block
 
       to ||= infer_event_from_subscriber(subscriber) if subscriber.is_a?(Module)
@@ -35,6 +35,8 @@ module ActiveEventStore
                               "Please, specify event using `to:` option"
       end
 
+      assert_valid_enqueue_options!(sync: sync, wait: wait, wait_until: wait_until)
+
       identifier =
         if to.is_a?(Class) && to <= ActiveEventStore::Event
           # register event
@@ -45,7 +47,15 @@ module ActiveEventStore
           to
         end
 
-      subscriber = SubscriberJob.from(subscriber) unless sync
+      unless sync
+        subscriber = SubscriberJob.from(subscriber)
+
+        # Defer the subscriber job by passing Active Job's own scheduling options
+        # through `.set`. The resulting ConfiguredJob is dispatched via
+        # `perform_later`, so the delay is applied when the event is published.
+        enqueue_options = {wait: wait, wait_until: wait_until}.compact
+        subscriber = subscriber.set(**enqueue_options) unless enqueue_options.empty?
+      end
 
       event_store.subscribe subscriber, to: [identifier]
     end
@@ -56,6 +66,25 @@ module ActiveEventStore
 
     private
 
+    # `wait:`/`wait_until:` are forwarded to Active Job's `.set` verbatim, and it
+    # does not evaluate callables — validate here so a bad value fails at the
+    # subscription site instead of deep inside job dispatch, long after this ran.
+    def assert_valid_enqueue_options!(sync:, wait:, wait_until:)
+      return unless wait || wait_until
+
+      if sync
+        raise ArgumentError, "`wait:`/`wait_until:` are only supported for async subscribers"
+      end
+
+      if wait && !(wait.is_a?(Numeric) || wait.is_a?(ActiveSupport::Duration))
+        raise ArgumentError, "`wait:` must be a number of seconds or an ActiveSupport::Duration (e.g. `10.minutes`), got #{wait.class}"
+      end
+
+      if wait_until && !wait_until.acts_like?(:time)
+        raise ArgumentError, "`wait_until:` must be a time (e.g. `1.hour.from_now`), got #{wait_until.class}"
+      end
+    end
+
     def infer_event_from_subscriber(subscriber)
       event_class_name = subscriber.name.split("::").yield_self do |parts|
         # handle explicti top-level name, e.g. ::Some::Event

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_event_store
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-04 00:00:00.000000000 Z
+date: 2026-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails_event_store