active_event_store 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a94c6723818483ba570ca3b781125da2461c53d7869213e5e7545606496c912
-  data.tar.gz: a160dca5145e401308d15aede842cd4ad758400bb4f96cb07d11f199424c31ed
+  metadata.gz: 79a390bc7f50283a2ed74f34d62ae845dfa5208a19a2a174238a5ebf4a684203
+  data.tar.gz: cfd5584f0a8c56a645fdb58fb1dfe6b35252d1c23481898974a6c333233d59a1
 SHA512:
-  metadata.gz: e0cd0a84d08b51d8851e6cefe51bc95e39bc47a69d3a209f9c254793a9e70b0400ea788320e16208b7b0a9b1b1221923062c6cd1f02fae751ff810a3d387aee5
-  data.tar.gz: '08effd30fe98d80eba9d72c65a7d04154ce54e6dd13effe9e9598b8c22af09bf33028a67dd92abe714c78d01671018116717135e409da8beef0771799fdc48e6'
+  metadata.gz: 91d3ecb6b2635ff0e895176e687d3fa3820d519b3d50cbba6d3d4ec9a79c632c527fd17817317d9eddf15d3c6fdff6a581f729bdcc1df55231e9250bb7332c74
+  data.tar.gz: ce974d79cd1989cfdd86e1ecfdfbf408b1facae1b9ab0be50c72f644f9abb32a0ce0c8a024752b3f2450c921d1f3c0ec5b0a8bc31c311ff814aa0cbd8dba89df

data/CHANGELOG.md

@@ -2,4 +2,8 @@
 
 ## master
 
+## 0.1.0 (2020-04-22)
+
+- Open source Active Event Store. ([@palkan][])
+
 [@palkan]: https://github.com/palkan

data/README.md

@@ -1,38 +1,189 @@
 [![Gem Version](https://badge.fury.io/rb/active_event_store.svg)](https://rubygems.org/gems/active_event_store) [![Build](https://github.com/palkan/active_event_store/workflows/Build/badge.svg)](https://github.com/palkan/active_event_store/actions)
-[![JRuby Build](https://github.com/palkan/active_event_store/workflows/JRuby%20Build/badge.svg)](https://github.com/palkan/active_event_store/actions)
 
 # Active Event Store
 
-TBD
+Active Event Store is a wrapper over [Rails Event Store](https://railseventstore.org/) which adds conventions and transparent Rails integration.
 
-## Installation
+## Motivation
 
-Adding to a gem:
+Why creating a wrapper and not using Rails Event Store itself?
 
-```ruby
-# my-cool-gem.gemspec
-Gem::Specification.new do |spec|
-  # ...
-  spec.add_dependency "active_event_store"
-  # ...
-end
-```
+RES is an awesome project but, in our opinion, it lacks Rails simplicity and elegance (=conventions and less boilerplate). It's an advanced tool for advanced developers. We've been using it in multiple projects in a similar way, and decided to extract our approach into this gem (originally private).
+
+Secondly, we wanted to have a store implementation independent API that would allow us to adapterize the actual event store in the future (something like `ActiveEventStore.store_engine = :rails_event_store` or `ActiveEventStore.store_engine = :hanami_events`).
 
-Or adding to your project:
+<a href="https://evilmartians.com/?utm_source=active_event_store">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+## Installation
+
+Add gem to your project:
 
 ```ruby
 # Gemfile
 gem "active_event_store"
 ```
 
-### Supported Ruby versions
+Setup database according to the [Rails Event Store docs](https://railseventstore.org/docs/install/#setup-data-model):
+
+```sh
+rails generate rails_event_store_active_record:migration
+rails db:migrate
+```
+
+### Requirements
 
 - Ruby (MRI) >= 2.5.0
-- JRuby >= 9.2.9
+- Rails >= 5.0
 
 ## Usage
 
-TBD
+### Describe events
+
+Events are represented by _event classes_, which describe events payloads and identifiers:
+
+```ruby
+class ProfileCompleted < ActiveEventStore::Event
+  # (optional) event identifier is used for transmitting events
+  # to subscribers.
+  #
+  # By default, identifier is equal to `name.underscore.gsub('/', '.')`.
+  #
+  # You don't need to specify identifier manually, only for backward compatibility when
+  # class name is changed.
+  self.identifier = "profile_completed"
+
+  # Add attributes accessors
+  attributes :user_id
+
+  # Sync attributes only available for sync subscribers
+  # (so you can add some optional non-JSON serializable data here)
+  # For example, we can also add `user` record to the event to avoid
+  # reloading in sync subscribers
+  sync_attributes :user
+end
+```
+
+**NOTE:** we use JSON to [serialize events](https://railseventstore.org/docs/mapping_serialization/), thus only the simple field types (numbers, strings, booleans) are supported.
+
+Each event has predefined (_reserved_) fields:
+
+- `event_id` – unique event id
+- `type` – event type (=identifier)
+- `metadata`
+
+We suggest to use a naming convention for event classes, for example, using the past tense and describe what happened (e.g. "ProfileCreated", "EventPublished", etc.).
+
+We recommend to keep event definitions in the `app/events` folder.
+
+### Events registration
+
+Since we use _abstract_ identifiers instead of class names, we need a way to tell our _mapper_ how to infer an event class from its type.
+
+In most cases, we register events automatically when they're published or when a subscription is created.
+
+You can also register events manually:
+
+```ruby
+# by passing an event class
+ActiveEventStore.mapper.register_event MyEventClass
+
+# or more precisely (in that case `event.type` must be equal to "my_event")
+ActiveEventStore.mapper.register "my_event", MyEventClass
+```
+
+### Publish events
+
+To publish an event you must first create an instance of the event class and call `ActiveEventStore.publish` method:
+
+```ruby
+event = ProfileCompleted.new(user_id: user.id)
+
+# or with metadata
+event = ProfileCompleted.new(user_id: user.id, metadata: {ip: request.remote_ip})
+
+# then publish the event
+ActiveEventStore.publish(event)
+```
+
+That's it! Your event has been stored and propagated to the subscribers.
+
+### Subscribe to events
+
+To subscribe a handler to an event you must use `ActiveEventStore.subscribe` method.
+
+You can do this in your app or engine initializer:
+
+```ruby
+# some/engine.rb
+
+# To make sure event store has been initialized use the load hook
+# `store` == `ActiveEventStore`
+ActiveSupport.on_load :active_event_store do |store|
+  # async subscriber – invoked from background job, enqueued after the current transaction commits
+  # NOTE: all subscribers are asynchronous by default
+  store.subscribe MyEventHandler, to: ProfileCreated
+
+  # sync subscriber – invoked right "within" `publish` method
+  store.subscribe MyEventHandler, to: ProfileCreated, sync: true
+
+  # anonymous handler (could only be synchronous)
+  store.subscribe(to: ProfileCreated, sync: true) do |event|
+    # do something
+  end
+
+  # you can omit event if your subscriber follows the convention
+  # for example, the following subscriber would subscribe to
+  # ProfileCreated event
+  store.subscribe OnProfileCreated::DoThat
+end
+```
+
+Subscribers could be any callable Ruby objects that accept a single argument (event) as its input.
+
+We suggest putting subscribers to the `app/subscribers` folder using the following convention: `app/subscribers/on_<event_type>/<subscriber.rb>`, e.g. `app/subscribers/on_profile_created/create_chat_user.rb`.
+
+### Testing
+
+You can test subscribers as normal Ruby objects.
+
+**NOTE:** Currently, we provide additional matchers only for RSpec. PRs with Minitest support are welcomed!
+
+To test that a given subscriber exists, you can use the `have_enqueued_async_subscriber_for` matcher:
+
+```ruby
+# for asynchronous subscriptions
+it "is subscribed to some event" do
+  event = MyEvent.new(some: "data")
+  expect { ActiveEventStore.publish event }
+    .to have_enqueued_async_subscriber_for(MySubscriberService)
+    .with(event)
+end
+```
+
+For synchronous subscribers using `have_received` is enough:
+
+```ruby
+it "is subscribed to some event" do
+  allow(MySubscriberService).to receive(:call)
+
+  event = MyEvent.new(some: "data")
+
+  ActiveEventStore.publish event
+
+  expect(MySubscriberService).to have_received(:call).with(event)
+end
+```
+
+To test event publishing, use `have_published_event` matcher:
+
+```ruby
+expect { subject }.to have_published_event(ProfileCreated).with(user_id: user.id)
+```
+
+**NOTE:** `have_published_event` only supports block expectations.
+
+**NOTE 2** `with` modifier works like `have_attributes` matcher (not `contain_exactly`); you can only specify serializable attributes in `with` (i.e. sync attributes are not supported, 'cause they are not persistent).
 
 ## Contributing
 

data/lib/active_event_store.rb

@@ -1,4 +1,75 @@
 # frozen_string_literal: true
 
+require "rails_event_store"
+
 require "active_event_store/version"
-require "active_event_store/railtie" if defined?(Rails::Railtie)
+
+require "active_event_store/config"
+require "active_event_store/event"
+require "active_event_store/mapping"
+require "active_event_store/mapper"
+
+require "active_event_store/rspec" if defined?(RSpec::Core)
+
+module ActiveEventStore
+  class << self
+    # Underlying RailsEventStore
+    attr_accessor :event_store
+
+    def mapping
+      @mapping ||= Mapping.new
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def subscribe(subscriber = nil, to: nil, sync: false)
+      subscriber ||= Proc.new
+
+      to ||= infer_event_from_subscriber(subscriber) if subscriber.is_a?(Module)
+
+      if to.nil?
+        raise ArgumentError, "Couldn't infer event from subscriber. " \
+                              "Please, specify event using `to:` option"
+      end
+
+      identifier =
+        if to.is_a?(Class) && ActiveEventStore::Event >= to
+          # register event
+          mapping.register_event to
+
+          to.identifier
+        else
+          to
+        end
+
+      subscriber = SubscriberJob.from(subscriber) unless sync
+
+      event_store.subscribe subscriber, to: [identifier]
+    end
+
+    def publish(event, **options)
+      event_store.publish event, **options
+    end
+
+    private
+
+    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
+        parts.shift if parts.first.empty?
+        # drop last part – it's a unique subscriber name
+        parts.pop
+
+        parts.last.sub!(/^On/, "")
+
+        parts.join("::")
+      end
+
+      event_class_name.safe_constantize
+    end
+  end
+end
+
+require "active_event_store/engine"

data/lib/active_event_store/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveEventStore
+  class Config
+    attr_writer :repository, :job_queue_name, :store_options
+
+    def repository
+      @repository ||= RailsEventStoreActiveRecord::EventRepository.new
+    end
+
+    def job_queue_name
+      @job_queue_name ||= :events_subscribers
+    end
+
+    def store_options
+      @store_options ||= {}
+    end
+  end
+end

data/lib/active_event_store/engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module ActiveEventStore
+  class Engine < ::Rails::Engine
+    config.active_event_store = ActiveEventStore.config
+
+    # Use before configuration hook to check for ActiveJob presence
+    ActiveSupport.on_load(:before_configuration) do
+      next warn "Active Job is not loaded. Active Event Store asynchrounous subscriptions won't worke" unless defined?(::ActiveJob)
+
+      require "active_event_store/subscriber_job"
+      require "active_event_store/rspec/have_enqueued_async_subscriber_for" if defined?(::RSpec::Matchers)
+    end
+
+    config.to_prepare do
+      # See https://railseventstore.org/docs/subscribe/#scheduling-async-handlers-after-commit
+      ActiveEventStore.event_store = RailsEventStore::Client.new(
+        dispatcher: RubyEventStore::ComposedDispatcher.new(
+          RailsEventStore::AfterCommitAsyncDispatcher.new(scheduler: RailsEventStore::ActiveJobScheduler.new),
+          RubyEventStore::Dispatcher.new
+        ),
+        repository: ActiveEventStore.config.repository,
+        mapper: ActiveEventStore::Mapper.new(mapping: ActiveEventStore.mapping),
+        **ActiveEventStore.config.store_options
+      )
+
+      ActiveSupport.run_load_hooks("active_event_store", ActiveEventStore)
+    end
+  end
+end

data/lib/active_event_store/event.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ActiveEventStore
+  # RES event wrapper
+  class Event < RubyEventStore::Event
+    RESERVED_ATTRIBUTES = %i[event_id type metadata].freeze
+
+    class << self
+      attr_writer :identifier
+
+      def identifier
+        return @identifier if instance_variable_defined?(:@identifier)
+
+        @identifier = name.underscore.tr("/", ".")
+      end
+
+      # define store readers
+      def attributes(*fields)
+        fields.each do |field|
+          raise ArgumentError, "#{field} is reserved" if RESERVED_ATTRIBUTES.include?(field)
+
+          defined_attributes << field
+
+          class_eval <<~CODE, __FILE__, __LINE__ + 1
+            def #{field}
+              data[:#{field}]
+            end
+          CODE
+        end
+      end
+
+      def sync_attributes(*fields)
+        fields.each do |field|
+          raise ArgumentError, "#{field} is reserved" if RESERVED_ATTRIBUTES.include?(field)
+
+          defined_sync_attributes << field
+
+          attr_reader field
+        end
+      end
+
+      def defined_attributes
+        return @defined_attributes if instance_variable_defined?(:@defined_attributes)
+
+        @defined_attributes =
+          if superclass.respond_to?(:defined_attributes)
+            superclass.defined_attributes.dup
+          else
+            []
+          end
+      end
+
+      def defined_sync_attributes
+        return @defined_sync_attributes if instance_variable_defined?(:@defined_sync_attributes)
+
+        @defined_sync_attributes =
+          if superclass.respond_to?(:defined_sync_attributes)
+            superclass.defined_sync_attributes.dup
+          else
+            []
+          end
+      end
+    end
+
+    def initialize(metadata: {}, event_id: nil, **params)
+      validate_attributes!(params)
+      extract_sync_attributes!(params)
+      super(**{event_id: event_id, metadata: metadata, data: params}.compact)
+    end
+
+    def type
+      self.class.identifier
+    end
+
+    def inspect
+      "#{self.class.name}<#{type}##{message_id}>, data: #{data}, metadata: #{metadata}"
+    end
+
+    protected
+
+    attr_writer :event_id
+
+    def validate_attributes!(params)
+      unknown_fields = params.keys.map(&:to_sym) - self.class.defined_attributes - self.class.defined_sync_attributes
+      unless unknown_fields.empty?
+        raise ArgumentError, "Unknown event attributes: #{unknown_fields.join(", ")}"
+      end
+    end
+
+    def extract_sync_attributes!(params)
+      params.keys.each do |key|
+        next unless self.class.defined_sync_attributes.include?(key.to_sym)
+
+        instance_variable_set(:"@#{key}", params.delete(key))
+      end
+    end
+  end
+end

data/lib/active_event_store/mapper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ActiveEventStore
+  using(Module.new do
+    refine Hash do
+      def symbolize_keys
+        RubyEventStore::TransformKeys.symbolize(self)
+      end
+    end
+  end)
+
+  # Custom mapper for RES events.
+  #
+  # See https://github.com/RailsEventStore/rails_event_store/blob/v0.35.0/ruby_event_store/lib/ruby_event_store/mappers/default.rb
+  class Mapper
+    def initialize(mapping:, serializer: JSON)
+      @serializer = serializer
+      @mapping = mapping
+    end
+
+    def event_to_serialized_record(domain_event)
+      # lazily add type to mapping
+      # NOTE: use class name instead of a class to handle code reload
+      # in development (to avoid accessing orphaned classes)
+      mapping.register(domain_event.type, domain_event.class.name) unless mapping.exist?(domain_event.type)
+
+      RubyEventStore::SerializedRecord.new(
+        event_id: domain_event.event_id,
+        metadata: serializer.dump(domain_event.metadata.to_h),
+        data: serializer.dump(domain_event.data),
+        event_type: domain_event.type
+      )
+    end
+
+    def serialized_record_to_event(record)
+      event_class = mapping.fetch(record.event_type) do
+        raise "Don't know how to deserialize event: \"#{record.event_type}\". " \
+              "Add explicit mapping: ActiveEventStore.mapper.register \"#{record.event_type}\", \"<Class Name>\""
+      end
+
+      Object.const_get(event_class).new(
+        **serializer.load(record.data).symbolize_keys,
+        metadata: serializer.load(record.metadata).symbolize_keys,
+        event_id: record.event_id
+      )
+    end
+
+    private
+
+    attr_reader :serializer, :mapping
+  end
+end

data/lib/active_event_store/mapping.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveEventStore
+  class Mapping
+    delegate :fetch, to: :data
+
+    def initialize
+      @data = {}
+    end
+
+    def register(type, class_name)
+      data[type] = class_name
+    end
+
+    def register_event(event_class)
+      register event_class.identifier, event_class.name
+    end
+
+    def exist?(type)
+      data.key?(type)
+    end
+
+    private
+
+    attr_reader :data
+  end
+end

data/lib/active_event_store/rspec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_event_store/rspec/have_published_event"

data/lib/active_event_store/rspec/have_enqueued_async_subscriber_for.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Do not fail if rspec-rails is not available
+begin
+  require "rspec/rails"
+  require "rspec/rails/matchers/active_job"
+rescue LoadError
+  warn "You must add `rspec-rails` to your project to use `have_enqueued_async_subscriber_for` matcher"
+  return
+end
+
+module ActiveEventStore
+  class HaveEnqueuedAsyncSubscriberFor < RSpec::Rails::Matchers::ActiveJob::HaveEnqueuedJob
+    class EventMatcher
+      include ::RSpec::Matchers::Composable
+
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def matches?(actual_serialized)
+        actual = ActiveEventStore.event_store.deserialize(actual_serialized)
+
+        actual.type == event.type && data_matches?(actual.data)
+      end
+
+      def description
+        "be #{event.inspect}"
+      end
+
+      private
+
+      def data_matches?(actual)
+        ::RSpec::Matchers::BuiltIn::Match.new(event.data).matches?(actual)
+      end
+    end
+
+    def initialize(subscriber_class)
+      subscriber_job = ActiveEventStore::SubscriberJob.for(subscriber_class)
+      if subscriber_job.nil?
+        raise(
+          RSpec::Expectations::ExpectationNotMetError,
+          "No such async subscriber: #{subscriber_class.name}"
+        )
+      end
+      super(subscriber_job)
+      on_queue("events_subscribers")
+    end
+
+    def with(event)
+      super(EventMatcher.new(event))
+    end
+
+    def matches?(block)
+      raise ArgumentError, "have_enqueued_async_subscriber_for only supports block expectations" unless block.is_a?(Proc)
+      # Make sure that there is a transaction
+      super(proc { ActiveRecord::Base.transaction(&block) })
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def have_enqueued_async_subscriber_for(*args)
+      ActiveEventStore::HaveEnqueuedAsyncSubscriberFor.new(*args)
+    end
+  end)
+end

data/lib/active_event_store/rspec/have_published_event.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module ActiveEventStore
+  class HavePublishedEvent < RSpec::Matchers::BuiltIn::BaseMatcher
+    attr_reader :event_class, :event_store, :attributes
+
+    def initialize(event_class)
+      @event_class = event_class
+      @event_store = ActiveEventStore.event_store
+      set_expected_number(:exactly, 1)
+    end
+
+    def with_store(store)
+      @event_store = store
+      self
+    end
+
+    def with(attributes)
+      @attributes = attributes
+      self
+    end
+
+    def exactly(count)
+      set_expected_number(:exactly, count)
+      self
+    end
+
+    def at_least(count)
+      set_expected_number(:at_least, count)
+      self
+    end
+
+    def at_most(count)
+      set_expected_number(:at_most, count)
+      self
+    end
+
+    def times
+      self
+    end
+
+    def once
+      exactly(:once)
+    end
+
+    def twice
+      exactly(:twice)
+    end
+
+    def thrice
+      exactly(:thrice)
+    end
+
+    def supports_block_expectations?
+      true
+    end
+
+    def matches?(block)
+      raise ArgumentError, "have_published_event only supports block expectations" unless block.is_a?(Proc)
+
+      original_count = event_store.read.count
+      block.call
+      new_count = event_store.read.count - original_count
+      in_block_events = new_count.positive? ? event_store.read.backward.limit(new_count).to_a :
+                                              []
+
+      @matching_events, @unmatching_events =
+        in_block_events.partition do |actual_event|
+          (event_class.identifier == actual_event.type) &&
+            (attributes.nil? || attributes_match?(actual_event))
+        end
+
+      @matching_count = @matching_events.size
+
+      case @expectation_type
+      when :exactly then @expected_number == @matching_count
+      when :at_most then @expected_number >= @matching_count
+      when :at_least then @expected_number <= @matching_count
+      end
+    end
+
+    private
+
+    def attributes_match?(event)
+      RSpec::Matchers::BuiltIn::HaveAttributes.new(attributes).matches?(event)
+    end
+
+    def set_expected_number(relativity, count)
+      @expectation_type = relativity
+      @expected_number =
+        case count
+        when :once then 1
+        when :twice then 2
+        when :thrice then 3
+        else Integer(count)
+        end
+    end
+
+    def failure_message
+      (+"expected to publish #{event_class.identifier} event").tap do |msg|
+        msg << " #{message_expectation_modifier}, but"
+
+        if @unmatching_events.any?
+          msg << " published the following events:"
+          @unmatching_events.each do |unmatching_event|
+            msg << "\n  #{unmatching_event.inspect}"
+          end
+        else
+          msg << " haven't published anything"
+        end
+      end
+    end
+
+    def failure_message_when_negated
+      "expected not to publish #{event_class.identifier} event"
+    end
+
+    def message_expectation_modifier
+      number_modifier = @expected_number == 1 ? "once" : "#{@expected_number} times"
+      case @expectation_type
+      when :exactly then "exactly #{number_modifier}"
+      when :at_most then "at most #{number_modifier}"
+      when :at_least then "at least #{number_modifier}"
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def have_published_event(*args)
+      ActiveEventStore::HavePublishedEvent.new(*args)
+    end
+  end)
+end

data/lib/active_event_store/subscriber_job.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveEventStore
+  # Base job for async subscribers
+  class SubscriberJob < ActiveJob::Base
+    class << self
+      attr_accessor :subscriber
+
+      def from(callable)
+        if callable.is_a?(Proc) || callable.name.nil?
+          raise ArgumentError, "Anonymous subscribers (blocks/procs/lambdas or anonymous modules) " \
+                                "could not be asynchronous (use sync: true)"
+        end
+
+        raise ArgumentError, "Async subscriber must be a module/class, not instance" unless callable.is_a?(Module)
+
+        if callable.const_defined?("SubscriberJob", false)
+          callable.const_get("SubscriberJob", false)
+        else
+          callable.const_set(
+            "SubscriberJob",
+            Class.new(self).tap do |job|
+              queue_as ActiveEventStore.config.job_queue_name
+
+              job.subscriber = callable
+            end
+          )
+        end
+      end
+
+      def for(callable)
+        raise ArgumentError, "Async subscriber must be a module/class" unless callable.is_a?(Module)
+
+        callable.const_defined?("SubscriberJob", false) ?
+          callable.const_get("SubscriberJob", false) :
+          nil
+      end
+    end
+
+    def perform(payload)
+      event = event_store.deserialize(payload)
+
+      event_store.with_metadata(**event.metadata.to_h) do
+        subscriber.call(event)
+      end
+    end
+
+    private
+
+    def subscriber
+      self.class.subscriber
+    end
+
+    def event_store
+      ActiveEventStore.event_store
+    end
+  end
+end

data/lib/active_event_store/version.rb

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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: active_event_store
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-09 00:00:00.000000000 Z
+date: 2020-04-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails_event_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.42.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.42.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -53,17 +67,17 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.8'
 description: Wrapper over Rails Event Store with conventions and transparent Rails
@@ -78,7 +92,15 @@ files:
 - LICENSE.txt
 - README.md
 - lib/active_event_store.rb
-- lib/active_event_store/railtie.rb
+- lib/active_event_store/config.rb
+- lib/active_event_store/engine.rb
+- lib/active_event_store/event.rb
+- lib/active_event_store/mapper.rb
+- lib/active_event_store/mapping.rb
+- lib/active_event_store/rspec.rb
+- lib/active_event_store/rspec/have_enqueued_async_subscriber_for.rb
+- lib/active_event_store/rspec/have_published_event.rb
+- lib/active_event_store/subscriber_job.rb
 - lib/active_event_store/version.rb
 homepage: http://github.com/palkan/active_event_store
 licenses:

data/lib/active_event_store/railtie.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveEventStore # :nodoc:
-  class Railtie < ::Rails::Railtie # :nodoc:
-  end
-end