pubsub_on_rails 0.0.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e3e25ad0c40aca45ee464ada4fd7f99c58b9d85c
-  data.tar.gz: f120f19a9df7626cfe7fe8322bca917644c0763c
+SHA256:
+  metadata.gz: 610b5e8d1415af6aa00766ef49444e4a3889aa6e1d79c0da2a74a58a09726d0c
+  data.tar.gz: 57ac3717989db60def406d8f6a85aa4139bdffef3ee3d05b5d7dcae70823f6dc
 SHA512:
-  metadata.gz: 41513d591f90f71e6ffdcbc21483236619d1912b5857d78a754bec3fa6d9180b40f9919fec7e2a17f43d3d3d4b618845e686510f8f423f2f4a801f73abec9167
-  data.tar.gz: f79dc8a3a235c565c51d1ccaaf0b06aba964bba67b322476d097776095083f989d0b9bd5fbdb482d6e128a16bf6e523f954fa4e4b0e4847e3604e8c0d8fef174
+  metadata.gz: 43d05d52a2f8dfbc52c9cca47a731acb8c98d2b36d2d490aef3f08cf9a902bf29e9dd394f441fcd914d74fcf53230ccaaf011c0ef64e5c1be546947e6a5ca7d1
+  data.tar.gz: 8c4fc34fc4404ff3476bef408760b10af12113720aadad1428566ab34e8350d902375022621148bf7e3016ae1cdc8ee682cdeacece0f95438d4a177a400bceec

data/README.md

@@ -16,12 +16,21 @@ This is especially true for applications covering many side effects, integration
 ```ruby
 # Gemfile
 
-gem 'pubsub_on_rails', '~> 0.0.3'
+gem 'pubsub_on_rails', '~> 1.0.0'
 
 # config/initializers/pub_sub.rb
 
-PubSub::Subscriptions.subscriptions_path = Rails.root.join('config/subscriptions.yml')
-PubSub::Subscriptions.load!
+require 'pub_sub/subscriptions_list'
+
+Rails.configuration.to_prepare do
+  Rails.configuration.event_store = event_store = RailsEventStore::Client.new(
+    repository: RailsEventStoreActiveRecord::EventRepository.new(serializer: RubyEventStore::NULL)
+  )
+
+  PubSub::SubscriptionsList.config_path =
+    Rails.root.join('config/subscriptions.yml')
+  PubSub::SubscriptionsList.load!(event_store)
+end
 ```
 
 ## Entities
@@ -40,7 +49,6 @@ Domain example:
 # app/domains/messaging.rb
 
 module Messaging
-  extend PubSub::Domain
 end
 ```
 
@@ -72,6 +80,26 @@ module Ordering
 end
 ```
 
+Since we are using Rails Event Store to handle events, it gives us a possibility to create **stream** of events. We can treat them as sub-list of events. To be able to use that functionality we need to declare which streams given event should be part of. By default we add event to stream based on its name. In case of our example it is `ordering__order_created`. We can provide also custom streams even based on some additional data from the event attributes (for example to group all events related to given order).
+
+Event example:
+
+```ruby
+# app/events/rails_event_store/ordering/order_created_event.rb
+
+module PubSub
+  module Ordering
+    class OrderCreatedEvent < PubSub::EventWithType
+      def stream_names
+        [
+          "order__#{data[:order_id]}"
+        ]
+      end
+    end
+  end
+end
+```
+
 ### Event publisher
 
 Event publisher is any class capable of emitting an event.
@@ -171,42 +199,41 @@ The recommended RSpec configuration is as follows:
 
 ```ruby
 # spec/support/pub_sub.rb
- 
+
 require 'pub_sub/testing'
 
 RSpec.configure do |config|
-  config.include Wisper::RSpec::BroadcastMatcher
-  config.include PubSub::Testing::SubscriptionsHelper
+  config.include PubSub::Testing::RailsEventStore
   config.include PubSub::Testing::EventDataHelper
 
-  config.before(:suite) do
-    PubSub::Testing::SubscriptionsHelper.clear_wisper_subscriptions!
-  end
-
-  config.around(:each, subscribers: true) do |example|
-    domain_name = example.metadata[:described_class].to_s.underscore
-    PubSub.subscriptions.register(domain_name)
+  config.around(:each, in_memory_res_client: true) do |example|
+    current_event_store = Rails.configuration.event_store
+    Rails.configuration.event_store = RubyEventStore::Client.new(
+      repository: RubyEventStore::InMemoryRepository.new
+    )
     example.run
-    clear_wisper_subscriptions!
+    Rails.configuration.event_store = current_event_store
   end
 end
 ```
 
+This will allow you to use `in_memory_res_client` which will not create object (event) in the database and do not call all dependent logic (handlers).
+
 ### Testing subscription
 
 Testing subscription is as easy as telling what domains should subscribe to what event in what way.
-Example of `subscribe_to` matcher can be found [here](https://gist.github.com/stevo/bd11c8dae812c919de6a61d1292dbfe1).
+
 Example:
 
 ```ruby
-RSpec.describe Messaging, subscribers: true do
+RSpec.describe Messaging do
   it { is_expected.to subscribe_to(:ordering__order_created).asynchronously }
 end
 ```
 
 ### Testing publishers
 
-To test publisher it is crucial to test if event was emitted (broadcasted) under certain conditions (if any).
+To test publisher it is crucial to test if event was emitted under certain conditions (if any).
 
 Example:
 
@@ -217,20 +244,21 @@ RSpec.describe Order do
       customer = create(:customer)
       line_items = create_list(:line_item, 2)
 
-      expect {
-        Order.create(
-          customer: customer,
-          total_amount: 100.99,
-          comment: 'Small order',
-          line_items: line_items
+      Order.create(
+        customer: customer,
+        total_amount: 100.99,
+        comment: 'Small order',
+        line_items: line_items
+      )
+
+      expect(event_store).to have_published(
+        an_event(PubSub::Ordering::OrderCreatedEvent).with_data(
+          order_id: fetch_next_id_for(Order),
+            total_amount: 100.99,
+            comment: 'Small order',
+            line_items: line_items
         )
-      }.to broadcast(
-             :ordering__order_created,
-             order_id: fetch_next_id_for(Order),
-             total_amount: 100.99,
-             comment: 'Small order',
-             line_items: line_items
-           )
+      ).in_stream('ordering__order_created')
     end
   end
 end
@@ -269,19 +297,6 @@ module Messaging
   end
 end
 ```
-### Integration testing
-
-By default all subscriptions are cleared in testing environment to enforce testing in isolation.
-To enable integration testing, a test can be wrapped in block provided by `with_subscription_to` helper.
-This way events emitted by code executed within this block will be handled by handlers from domains provided as arguments to `with_subscription_to` helper.
-
-```ruby
-it 'does something' do
-    with_subscription_to('messaging', 'logging') do
-      # setup, subject, assertions etc.
-    end
-end
-```
 
 ### Subscriptions linting
 
@@ -334,33 +349,6 @@ logging:
   all_events: sync
 ```
 
-# `emit` vs `broadcast`
-
-PubSub on Rails leverages `wisper` and `wisper-sidekiq` under the hood.
-This is why instead of using `emit`, you can broadcast events by using wisper's `broadcast` method.
-
-```ruby
-# app/models/order.rb
-
-class Order < ApplicationRecord
-  include Wisper::Publisher
-
-  #...
-
-  after_create do
-    broadcast(
-      :ordering__guest_checked_in,
-      order_id: id,
-      line_items: line_items,
-      total_amount: total_amount,
-      comment: comment
-    )
-  end
-end
-```
-
-Why `emit` then? `emit` provides a couple of simplifications that make emitting events easier and more reliable.
-
 ## Payload verification
 
 Every time event is emitted, its payload is supplied to corresponding event class and is verified.
@@ -370,7 +358,7 @@ Example:
 
 ```ruby
 module Accounts
-  class PersonCreatedEvent < DomainEvent
+  class PersonCreatedEvent < PubSub::DomainEvent
     attribute :person_id, Types::Strict::Integer
   end
 end
@@ -401,7 +389,7 @@ end
 
 ## Automatic event payload population
 
-Whenever you emit an event, it will try to populate its payload with data using public interface of object it is emitted from within. 
+Whenever you emit an event, it will try to populate its payload with data using public interface of object it is emitted from within.
 
 ```ruby
 # app/models/oriering/order.rb
@@ -423,16 +411,6 @@ module Ordering
 end
 ```
 
-## Manually broadcasting events
-
-If for some reason you need to safely broadcast some event, the best way is to instantiate its class and call `#broadcast!` on it.
-
-Example:
-
-```ruby
-Ordering::OrderCreatedEvent.new(order_id: 1, total_amount: 25, line_items: []).broadcast!
-```
-
 # TODO
 
 - Dynamic event classes

data/lib/pub_sub/domain_event.rb

@@ -1,28 +1,4 @@
-require 'pub_sub/pure_event'
-
 module PubSub
-  class DomainEvent < PureEvent
-    attribute :event_trace_id, Types::Strict::String.default {
-      EventTrace.trace_id ||= SecureRandom.hex(8)
-    }
-    attribute :event_id, Types::Strict::String.default {
-      SecureRandom.hex(8)
-    }
-    attribute :trigger_id, Types::Strict::String.default {
-      EventTrace.last_event_id || 'ORIGIN'
-    }
-
-    def initialize(*args)
-      super(*args)
-      EventTrace.last_event_id = event_id
-    end
-
-    private
-
-    def attributes_to_broadcast
-      super.
-        except(:event_trace_id, :event_id, :trigger_id).
-        merge(event_uid: "#{event_trace_id}-#{trigger_id}-#{event_id}")
-    end
+  class DomainEvent < Dry::Struct
   end
 end

data/lib/pub_sub/domain_event_handler.rb

@@ -1,7 +1,7 @@
 module PubSub
   class DomainEventHandler
-    def initialize(*args)
-      @event_data_hash = args.extract_options!
+    def initialize(event)
+      @event = event
     end
 
     def call
@@ -14,7 +14,7 @@ module PubSub
 
     private
 
-    attr_reader :event_data_hash
+    attr_reader :event
 
     def process_event?
       true
@@ -23,5 +23,9 @@ module PubSub
     def event_data
       @event_data ||= OpenStruct.new(event_data_hash)
     end
+
+    def event_data_hash
+      event.data
+    end
   end
 end

data/lib/pub_sub/emit.rb

@@ -4,13 +4,14 @@ require 'pub_sub/event_emission'
 module PubSub
   module Emit
     def emit(event_name, explicit_payload = {})
+      abstract_event_class = explicit_payload.delete(:abstract_event_class)
       event_class = EventClassFactory.build(
         event_name,
         domain_name: self.class.name.deconstantize.demodulize,
-        abstract_event_class: explicit_payload.delete(:abstract_event_class)
+        abstract_event_class:
       )
 
-      EventEmission.new(event_class, explicit_payload, self).call
+      EventEmission.new(abstract_event_class, event_class, event_name, explicit_payload, self).call
     end
   end
 end

data/lib/pub_sub/event_class_factory.rb

@@ -5,8 +5,8 @@ module PubSub
     def self.build(event_name, domain_name: nil, abstract_event_class: nil)
       new(
         event_name,
-        domain_name: domain_name,
-        abstract_event_class: abstract_event_class
+        domain_name:,
+        abstract_event_class:
       ).build_event_class
     end
 
@@ -17,9 +17,13 @@ module PubSub
     end
 
     def build_event_class
+      event_class = res_event_class_name.safe_constantize
+
+      return event_class if event_class.present?
+
       event_class = event_class_name.safe_constantize
 
-      return event_class unless event_class.nil?
+      return event_class if event_class.present?
 
       if abstract_event_class.nil?
         raise(EventClassDoesNotExist, event_class_name)
@@ -46,12 +50,16 @@ module PubSub
 
     def event_name_with_domain
       if event_name_includes_domain?
-        event_name.to_s.sub('__', '/')
+        event_name.to_s.downcase.sub('__', '/')
       else
-        "#{domain_name}/#{event_name}"
+        [domain_name&.underscore, event_name].compact.join('/')
       end
     end
 
+    def res_event_class_name
+      @res_event_class_name ||= "pub_sub/#{event_name_with_domain}_event".classify
+    end
+
     def event_class_name
       @event_class_name ||= "#{event_name_with_domain}_event".classify
     end

data/lib/pub_sub/event_emission.rb

@@ -1,44 +1,78 @@
 require 'pub_sub/payload_attribute'
 
 module PubSub
-  class EventEmission
-    EventPayloadArgumentMissing = Class.new(StandardError)
+  Error = Class.new(StandardError)
+  EventMissing = Class.new(Error)
+  EventPayloadArgumentMissing = Class.new(Error)
 
-    def initialize(event_class, explicit_payload, context)
+  class EventEmission
+    def initialize(abstract_event_class, event_class, event_name, explicit_payload, context)
+      @abstract_event_class = abstract_event_class
       @event_class = event_class
+      @event_name = event_name
       @explicit_payload = explicit_payload
       @context = context
     end
 
     def call
-      event_class.new(full_payload).broadcast!
+      if event_class.ancestors.include?(PubSub::EventWithType)
+        event_store.publish(event, stream_name:)
+      else
+        raise(EventMissing, event_name)
+      end
     end
 
     private
 
-    attr_reader :event_class, :explicit_payload, :context
+    attr_reader :abstract_event_class, :event_class, :event_name, :explicit_payload, :context
+
+    def event
+      event_class.new(data: full_payload)
+    end
+
+    def event_name_includes_domain?
+      event_name.to_s.include?('__')
+    end
+
+    def stream_name
+      return event_name.to_s.downcase if event_name_includes_domain?
 
-    def event_payload_attribute_names
-      event_class.attribute_names
+      "#{domain}__#{event_name}"
+    end
+
+    def domain
+      if abstract_event_class
+        abstract_event_class.name.deconstantize.underscore
+      else
+        context.class.name.deconstantize.demodulize.underscore
+      end
+    end
+
+    def dry_struct_event_class
+      @dry_struct_event_class ||= event_class.name.remove('PubSub').constantize
     end
 
     # rubocop:disable Metrics/MethodLength
     def full_payload
-      event_payload_attribute_names.each_with_object({}) do |attribute_name, result|
-        result[attribute_name] = PayloadAttribute.new(attribute_name, explicit_payload, context).get
-      rescue PayloadAttribute::CannotEvaluate => cannot_evaluate_error
-        if event_class.schema.key(attribute_name).default?
-          next
-        else
-          raise(
-            EventPayloadArgumentMissing,
-            "Event [#{event_class.name}] expects [#{attribute_name}] payload attribute to be" \
-              " either exposed as [#{cannot_evaluate_error.message}] method in emitting object" \
-              ' or provided as argument'
-          )
-        end
+      dry_struct_event_class.attribute_names.each_with_object({}) do |attribute_name, result|
+        result[attribute_name] = PayloadAttribute.new(
+          attribute_name, explicit_payload, context
+        ).get
+      rescue PayloadAttribute::CannotEvaluate => e
+        next if dry_struct_event_class.schema.key(attribute_name).default?
+
+        raise(
+          EventPayloadArgumentMissing,
+          "Event [#{dry_struct_event_class.name}] expects [#{attribute_name}] " \
+          "payload attribute to be either exposed as [#{e.message}] method in emitting object " \
+          'or provided as argument'
+        )
       end
     end
     # rubocop:enable Metrics/MethodLength
+
+    def event_store
+      Rails.configuration.event_store
+    end
   end
 end

data/lib/pub_sub/event_handler_builder.rb

@@ -0,0 +1,30 @@
+module PubSub
+  class EventHandlerBuilder
+    def initialize(class_name, subscription_type)
+      @class_name = class_name
+      @subscription_type = subscription_type.to_sym
+    end
+
+    def call(event)
+      if async?
+        EventWorker.perform_async(class_name.to_s, event.event_id)
+      else
+        class_name.new(event).call!
+      end
+    end
+
+    protected
+
+    attr_reader :class_name, :subscription_type
+
+    def ==(other)
+      class_name == other.class_name && subscription_type == other.subscription_type
+    end
+
+    private
+
+    def async?
+      subscription_type == :async
+    end
+  end
+end

data/lib/pub_sub/event_with_type.rb

@@ -0,0 +1,17 @@
+module PubSub
+  class EventWithType < RailsEventStore::Event
+    def initialize(event_id: SecureRandom.uuid, metadata: nil, data: {})
+      super(
+        event_id:,
+        metadata:,
+        data: self.class.name.remove('PubSub').constantize.new(
+          data.deep_symbolize_keys
+        ).attributes
+      )
+    end
+
+    def stream_names
+      []
+    end
+  end
+end

data/lib/pub_sub/event_worker.rb

@@ -0,0 +1,17 @@
+module PubSub
+  class EventWorker
+    include Sidekiq::Job
+
+    def perform(class_name, event_id)
+      class_name.constantize.new(
+        event_store.read.event(event_id)
+      ).call!
+    end
+
+    private
+
+    def event_store
+      Rails.configuration.event_store
+    end
+  end
+end

data/lib/pub_sub/subscriptions_linter.rb

@@ -0,0 +1,42 @@
+module PubSub
+  class SubscriptionsLinter
+    MissingSubscriptions = Class.new(StandardError)
+
+    def initialize(subscriptions)
+      @subscriptions = subscriptions
+    end
+
+    def lint!
+      raise MissingSubscriptions, error_message if missing_subscriptions.present?
+    end
+
+    private
+
+    attr_reader :subscriptions
+
+    def error_message
+      "The following subscriptions are missing: \n#{missing_subscriptions.join("\n")}"
+    end
+
+    def missing_subscriptions
+      (handled_subscription_names - all_subscription_names)
+    end
+
+    # :reek:UtilityFunction, :reek:DuplicateMethodCall
+    def handled_subscription_names
+      Dir[Rails.root.join('app/event_handlers/*/*.rb')].map do |file_path|
+        file_path.
+          sub(Rails.root.join('app/event_handlers/').to_s, '').
+          sub('_handler.rb', '')
+      end
+    end
+
+    def all_subscription_names
+      subscriptions.flat_map do |domain_name, subscriptions|
+        subscriptions.keys.map do |event_name|
+          "#{domain_name}/#{event_name.sub('__', '_')}"
+        end
+      end
+    end
+  end
+end

data/lib/pub_sub/subscriptions_list.rb

@@ -0,0 +1,62 @@
+require 'pub_sub/subscriptions_linter'
+require 'pub_sub/event_handler_builder'
+
+module PubSub
+  class SubscriptionsList
+    include Singleton
+
+    cattr_accessor :config_path
+    self.config_path = 'config/subscriptions.yml'
+
+    def self.load!(event_store)
+      instance.event_store = event_store
+      instance.load!
+    end
+
+    def self.lint!
+      instance.lint!
+    end
+
+    attr_accessor :event_store
+
+    def load!
+      domain_subscriptions.each do |domain_name, subscriptions|
+        subscriptions.each do |event_name, subscription_type|
+          if event_name == 'all_events'
+            subscribe_to_all_events(domain_name, subscription_type)
+          else
+            subscribe_to_event(domain_name, event_name, subscription_type)
+          end
+        end
+      end
+    end
+
+    def lint!
+      SubscriptionsLinter.new(domain_subscriptions).lint!
+    end
+
+    def initialize
+      @domain_subscriptions = YAML.load_file(self.class.config_path)
+    end
+
+    private
+
+    attr_reader :domain_subscriptions
+
+    def subscribe_to_all_events(domain_name, subscription_type)
+      handler_class = "#{domain_name.camelize}Handler".constantize
+      event_store.subscribe_to_all_events(
+        EventHandlerBuilder.new(handler_class, subscription_type)
+      )
+    end
+
+    def subscribe_to_event(domain_name, event_name, subscription_type)
+      event_domain, name = event_name.split('__').map(&:camelize)
+      event_class = "PubSub::#{event_domain}::#{name}Event".constantize
+      handler_class = "#{domain_name.camelize}::#{event_domain}#{name}Handler".constantize
+      event_store.subscribe(
+        EventHandlerBuilder.new(handler_class, subscription_type), to: [event_class]
+      )
+    end
+  end
+end

data/lib/pub_sub/testing/event_data_helper.rb

@@ -2,10 +2,15 @@ module PubSub
   module Testing
     module EventDataHelper
       def event_data_for(event_name, **payload)
-        EventClassFactory.
-          build(event_name, abstract_event_class: payload.delete(:abstract_event_class)).
-          new(payload).
-          attributes
+        event_class = PubSub::EventClassFactory.build(
+          event_name, abstract_event_class: payload.delete(:abstract_event_class)
+        )
+
+        if event_class.ancestors.include?(PubSub::EventWithType)
+          event_class.new(data: payload)
+        else
+          event_class.new(payload).attributes
+        end
       end
     end
   end

data/lib/pub_sub/testing/rails_event_store.rb

@@ -0,0 +1,9 @@
+module PubSub
+  module Testing
+    module RailsEventStore
+      def event_store
+        Rails.configuration.event_store
+      end
+    end
+  end
+end

data/lib/pub_sub/testing/subscribe_to.rb

@@ -0,0 +1,32 @@
+RSpec::Matchers.define :subscribe_to do |event_name|
+  match do |domain|
+    handler_class = build_handler_class(event_name, domain)
+    event_class = build_event_class(event_name)
+    subscription_type = async? ? :async : :sync
+
+    expect(
+      PubSub::EventHandlerBuilder.new(handler_class, subscription_type)
+    ).to have_subscribed_to_events(event_class).in(event_store)
+  end
+
+  chain :asynchronously do
+    @asynchronously = true
+  end
+
+  private
+
+  def build_handler_class(event_name, domain)
+    handler_name = event_name.to_s.sub('__', '/').camelize
+    handler_name.remove!('::')
+    "#{domain.name}::#{handler_name}Handler".constantize
+  end
+
+  def build_event_class(event_name)
+    event_class_name = event_name.to_s.sub('__', '/').camelize
+    "PubSub::#{event_class_name}Event".constantize
+  end
+
+  def async?
+    @asynchronously
+  end
+end

data/lib/pub_sub/testing.rb

@@ -1,3 +1,3 @@
-require 'wisper/rspec/matchers'
+require 'pub_sub/testing/rails_event_store'
 require 'pub_sub/testing/event_data_helper'
-require 'pub_sub/testing/subscription_helpers'
+require 'pub_sub/testing/subscribe_to'

data/lib/pub_sub/version.rb

@@ -1,3 +1,3 @@
 module PubSub
-  VERSION = '0.0.7'
+  VERSION = '1.0.0'
 end

data/lib/pubsub_on_rails.rb

@@ -1,11 +1,9 @@
-require 'wisper'
-require 'wisper/sidekiq'
+require 'rails_event_store'
 
 require 'pub_sub/dry'
 require 'pub_sub'
 require 'pub_sub/emit'
-require 'pub_sub/subscriptions'
-require 'pub_sub/event_trace'
-require 'pub_sub/domain'
+require 'pub_sub/event_with_type'
+require 'pub_sub/subscriptions_list'
 require 'pub_sub/domain_event'
 require 'pub_sub/domain_event_handler'

data/pubsub_on_rails.gemspec

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'pub_sub/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'pubsub_on_rails'
+  s.version       = PubSub::VERSION
+  s.authors       = ['Stevo']
+  s.email         = ['b.kosmowski@selleo.com']
+  s.homepage      = 'https://github.com/Selleo/pubsub_on_rails'
+  s.licenses      = ['MIT']
+  s.summary       = 'Opinionated publish-subscribe pattern for ruby and rails'
+  s.description   = 'Opinionated publish-subscribe pattern for ruby and rails'
+
+  s.files         = Dir.glob('{bin/*,lib/**/*,[A-Z]*}')
+  s.platform      = Gem::Platform::RUBY
+  s.require_paths = ['lib']
+  s.add_dependency 'dry-struct'
+  s.add_dependency 'sidekiq'
+  s.add_dependency 'rails_event_store'
+  s.add_dependency 'ruby_event_store-rspec'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubsub_on_rails
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 1.0.0
 platform: ruby
 authors:
 - Stevo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-10 00:00:00.000000000 Z
+date: 2023-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -25,21 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: wisper
+  name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: wisper-sidekiq
+  name: rails_event_store
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: wisper-rspec
+  name: ruby_event_store-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -74,32 +74,34 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- Gemfile.lock
 - LICENSE.md
 - README.md
 - lib/pub_sub.rb
-- lib/pub_sub/domain.rb
 - lib/pub_sub/domain_event.rb
 - lib/pub_sub/domain_event_handler.rb
 - lib/pub_sub/dry.rb
 - lib/pub_sub/emit.rb
 - lib/pub_sub/event_class_factory.rb
 - lib/pub_sub/event_emission.rb
-- lib/pub_sub/event_trace.rb
-- lib/pub_sub/linter.rb
+- lib/pub_sub/event_handler_builder.rb
+- lib/pub_sub/event_with_type.rb
+- lib/pub_sub/event_worker.rb
 - lib/pub_sub/payload_attribute.rb
-- lib/pub_sub/pure_event.rb
-- lib/pub_sub/subscriptions.rb
+- lib/pub_sub/subscriptions_linter.rb
+- lib/pub_sub/subscriptions_list.rb
 - lib/pub_sub/testing.rb
 - lib/pub_sub/testing/event_data_helper.rb
-- lib/pub_sub/testing/subscription_helpers.rb
+- lib/pub_sub/testing/rails_event_store.rb
+- lib/pub_sub/testing/subscribe_to.rb
 - lib/pub_sub/version.rb
 - lib/pubsub_on_rails.rb
+- pubsub_on_rails-0.0.7.gem
+- pubsub_on_rails.gemspec
 homepage: https://github.com/Selleo/pubsub_on_rails
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -114,9 +116,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.4.12
+signing_key:
 specification_version: 4
 summary: Opinionated publish-subscribe pattern for ruby and rails
 test_files: []

data/Gemfile.lock

@@ -1,64 +0,0 @@
-PATH
-  remote: .
-  specs:
-    pubsub_on_rails (0.0.1)
-      dry-struct
-      wisper (~> 2.0.0)
-      wisper-rspec
-      wisper-sidekiq
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    concurrent-ruby (1.1.5)
-    connection_pool (2.2.2)
-    dry-configurable (0.8.2)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.4, >= 0.4.7)
-    dry-container (0.7.0)
-      concurrent-ruby (~> 1.0)
-      dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.4.7)
-      concurrent-ruby (~> 1.0)
-    dry-equalizer (0.2.2)
-    dry-inflector (0.1.2)
-    dry-logic (1.0.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.2)
-      dry-equalizer (~> 0.2)
-    dry-struct (1.0.0)
-      dry-core (~> 0.4, >= 0.4.3)
-      dry-equalizer (~> 0.2)
-      dry-types (~> 1.0)
-      ice_nine (~> 0.11)
-    dry-types (1.0.0)
-      concurrent-ruby (~> 1.0)
-      dry-container (~> 0.3)
-      dry-core (~> 0.4, >= 0.4.4)
-      dry-equalizer (~> 0.2, >= 0.2.2)
-      dry-inflector (~> 0.1, >= 0.1.2)
-      dry-logic (~> 1.0)
-    ice_nine (0.11.2)
-    rack (2.0.7)
-    rack-protection (2.0.5)
-      rack
-    redis (4.1.1)
-    sidekiq (5.2.7)
-      connection_pool (~> 2.2, >= 2.2.2)
-      rack (>= 1.5.0)
-      rack-protection (>= 1.5.0)
-      redis (>= 3.3.5, < 5)
-    wisper (2.0.0)
-    wisper-rspec (1.1.0)
-    wisper-sidekiq (1.2.0)
-      sidekiq (>= 4.1)
-      wisper
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  pubsub_on_rails!
-
-BUNDLED WITH
-   1.17.2

data/lib/pub_sub/domain.rb

@@ -1,25 +0,0 @@
-module PubSub
-  module Domain
-    def method_missing(event_or_method_name, *event_data)
-      if handler_name(event_or_method_name)
-        event_payload = event_data.extract_options!
-        EventTrace.load_from(event_payload.delete(:event_uid))
-        const_get(handler_name(event_or_method_name)).new(event_payload).call!
-      else
-        super
-      end
-    end
-
-    def handler_name(event_name)
-      return nil unless event_name.to_s.start_with?(/[a-z_]+__/)
-      "#{event_name.to_s.camelize}Handler"
-    end
-
-    def respond_to_missing?(event_or_method_name, include_private = false)
-      return super unless handler_name(event_or_method_name)
-      const_get(handler_name(event_or_method_name))
-    rescue NameError
-      super
-    end
-  end
-end

data/lib/pub_sub/event_trace.rb

@@ -1,18 +0,0 @@
-module PubSub
-  class EventTrace < ActiveSupport::CurrentAttributes
-    EVENT_TRACE_UID_REGEX = /^(?<trace_id>\w+)-(?<trigger_id>\w+)-(?<event_id>\w+)$/
-    private_constant :EVENT_TRACE_UID_REGEX
-
-    attribute :trace_id
-    attribute :last_event_id
-
-    def self.load_from(event_trace_uid)
-      match_data = event_trace_uid&.match(EVENT_TRACE_UID_REGEX)
-
-      if match_data
-        self.trace_id = match_data['trace_id']
-        self.last_event_id = match_data['event_id']
-      end
-    end
-  end
-end

data/lib/pub_sub/linter.rb

@@ -1,39 +0,0 @@
-class Linter
-  MissingSubscriptions = Class.new(StandardError)
-
-  def initialize(config)
-    @config = config
-  end
-
-  def lint!
-    raise MissingSubscriptions, error_message if missing_subscriptions.present?
-  end
-
-  private
-
-  def error_message
-    "The following subscriptions are missing: \n#{missing_subscriptions.join("\n")}"
-  end
-
-  def missing_subscriptions
-    (handlers_list - subscriptions_list)
-  end
-
-  attr_reader :config
-
-  def subscriptions_list
-    config.flat_map do |domain_name, subscriptions|
-      subscriptions.keys.map do |event_name|
-        "#{domain_name}/#{event_name.sub('__', '_')}"
-      end
-    end
-  end
-
-  def handlers_list
-    Dir[Rails.root.join('app/event_handlers/*/*.rb')].map do |file_path|
-      file_path.
-        sub("#{Rails.root}/app/event_handlers/", '').
-        sub('_handler.rb', '')
-    end
-  end
-end

data/lib/pub_sub/pure_event.rb

@@ -1,19 +0,0 @@
-module PubSub
-  class PureEvent < Dry::Struct
-    include Wisper::Publisher
-
-    def broadcast!
-      broadcast(event_name, attributes_to_broadcast)
-    end
-
-    private
-
-    def attributes_to_broadcast
-      attributes
-    end
-
-    def event_name
-      self.class.name.underscore.sub('/', '__').chomp('_event')
-    end
-  end
-end

data/lib/pub_sub/subscriptions.rb

@@ -1,49 +0,0 @@
-require 'pub_sub/linter'
-
-module PubSub
-  mattr_accessor :subscriptions
-
-  class Subscriptions
-    include Singleton
-
-    cattr_accessor :subscriptions_path
-    self.subscriptions_path = 'config/subscriptions.yml'
-
-    def self.load!
-      PubSub.subscriptions = Subscriptions.instance
-      PubSub.subscriptions.register(:all)
-    end
-
-    def self.lint!
-      instance.lint!
-    end
-
-    def lint!
-      Linter.new(config).lint!
-    end
-
-    def initialize
-      @config = YAML.load_file(self.class.subscriptions_path)
-    end
-
-    def register(scope = :all)
-      (scope == :all ? config : config.slice(scope.to_s)).each do |domain_name, subscriptions|
-        subscriptions.each do |event_name, subscription_type|
-          options = {}
-          options[:on] = event_name unless event_name == 'all_events'
-          options[:broadcaster] = subscription_type == 'sync' ? :default : subscription_type.to_sym
-
-          Wisper.subscribe("::#{domain_name.camelize}".constantize, options)
-        end
-      end
-    end
-
-    def clear!
-      Wisper.clear
-    end
-
-    private
-
-    attr_reader :config
-  end
-end

data/lib/pub_sub/testing/subscription_helpers.rb

@@ -1,24 +0,0 @@
-module PubSub
-  module Testing
-    module SubscriptionsHelper
-      def with_subscription_to(*domains)
-        domains.each do |domain|
-          PubSub.subscriptions.register(domain)
-        end
-        yield
-        clear_wisper_subscriptions!
-      end
-
-      def subscribe_logger!
-        PubSub.subscriptions.register(:logging)
-      end
-      module_function :subscribe_logger!
-
-      def clear_wisper_subscriptions!
-        PubSub.subscriptions.clear!
-        subscribe_logger!
-      end
-      module_function :clear_wisper_subscriptions!
-    end
-  end
-end