ruby_event_store 0.30.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4df1be4d7e983bb77d1c069496cdca690f72d593a0c0d83f9d3d7519d63ed115
-  data.tar.gz: 0d156019cb436a9fb262b680e3e46d007d7c64ec46f1186bae82c5e4344b03c8
+  metadata.gz: 88193e00bf9ebd58347de1cb3cf58848cc4b09abc603ffef5fb85b2565bf0b74
+  data.tar.gz: 744d44d76c00843f897c321919eed85b9597063d44a52328f7616c6682063d90
 SHA512:
-  metadata.gz: 490e25c72237a78d241df447ad97d55f2d245d40ea4d3b7665b5c699e5273d3b8257f06d2a0a3a1d8d3bc0940158819f433d72b47460620a5c4ed756fad5d646
-  data.tar.gz: 4355818327a762070c48a8121728c9914b74881187f028c8dc8c440d46c9b51556621b5fb697cdbbd97fc93c3eaff03cafa69fefa6d84f6655023cb053336ae4
+  metadata.gz: ffd5f11e365d901d7bdf7a6c5d78cad674166416dcd44cd8448982dbe23d8a243ea72b3f66e02c4cab134ef87e3f5d0e519e4de0a913bf26390f7867cc5318d8
+  data.tar.gz: 3044ebfc2ca93c1b5c5fa40afd250c8aac8edc1c5299444b6094df17d1b5214b19400070761a408f8816dbe507fb52c2063587fdd428f911470310ef26434778

data/Gemfile

@@ -1,3 +1,11 @@
 source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
 gemspec
-gem 'protobuf_nested_struct'
+
+eval_gemfile File.expand_path('../support/bundler/Gemfile.shared', __dir__)
+
+gem 'protobuf_nested_struct'
+gem 'google-protobuf', '~> 3.12.2', '>= 3.12.2'
+gem 'activesupport', '~> 5.0'
+gem 'concurrent-ruby', github: 'ruby-concurrency/concurrent-ruby', ref: 'c4cbc968c55e5b983dae953095761896220c46d1'

data/Makefile

@@ -1,69 +1,22 @@
 GEM_VERSION = $(shell cat ../RES_VERSION)
 GEM_NAME    = ruby_event_store
 REQUIRE     = $(GEM_NAME)
-IGNORE      = RubyEventStore.const_missing \
-              RubyEventStore::InMemoryRepository\#append_with_synchronize \
-              RubyEventStore::InMemoryRepository\#normalize_to_array \
-              RubyEventStore::Client\#normalize_to_array \
-              RubyEventStore::Client::Within\#normalize_to_array \
+IGNORE      = RubyEventStore::InMemoryRepository\#append_with_synchronize \
               RubyEventStore::Client::Within\#add_thread_subscribers \
               RubyEventStore::Client::Within\#add_thread_global_subscribers \
-              RubyEventStore::Client\#read_all_streams_forward \
-              RubyEventStore::Client\#read_all_streams_backward \
-              RubyEventStore::Client\#read_stream_events_forward \
-              RubyEventStore::Client\#read_stream_events_backward \
-              RubyEventStore::Client\#read_events_forward \
-              RubyEventStore::Client\#read_events_backward \
-              RubyEventStore::DeprecatedReadAPIRunner* \
-              RubyEventStore::DeprecatedReadAPIRewriter*
-SUBJECT     ?= RubyEventStore*
-
-install: ## Install gem dependencies
-	@echo "Installing gem dependencies"
-	@bundle install
-
-remove-lock:
-	@echo "Removing resolved dependency versions"
-	-rm Gemfile.lock
-
-reinstall: remove-lock install ## Removing resolved dependency versions
-
-test: ## Run unit tests
-	@echo "Running unit tests"
-	@bundle exec rspec
-
-mutate: test ## Run mutation tests
-	@echo "Running mutation tests"
-	@MUTATING=true bundle exec mutant --include lib \
-		$(addprefix --require ,$(REQUIRE)) \
-		$(addprefix --ignore-subject ,$(IGNORE)) \
-		--use rspec "$(SUBJECT)"
+              RubyEventStore::Client::Within\#call \
+              RubyEventStore::Client\#default_correlation_id_generator \
+              RubyEventStore::Mappers::InMemoryEncryptionKeyRepository\#prepare_encrypt \
+              RubyEventStore::Mappers::EncryptionKey\#prepare_encrypt \
+              RubyEventStore::Mappers::EncryptionKey\#prepare_decrypt \
+              RubyEventStore::Mappers::EncryptionKey\#prepare_auth_data \
+              RubyEventStore::Mappers::EncryptionKey\#encrypt_authenticated \
+              RubyEventStore::Mappers::EncryptionKey\#ciphertext_from_authenticated
 
-mutate-fast: ## Run mutation tests with --fail-fast
-	@echo "Running mutation tests"
-	@MUTATING=true bundle exec mutant --include lib \
-		$(addprefix --require ,$(REQUIRE)) \
-		$(addprefix --ignore-subject ,$(IGNORE)) \
-		--fail-fast \
-		--use rspec "$(SUBJECT)"
-
-build:
-	@echo "Building gem package"
-	@gem build -V $(GEM_NAME).gemspec
-	@mkdir -p pkg/
-	@mv $(GEM_NAME)-$(GEM_VERSION).gem pkg/
-
-push:
-	@echo "Pushing package to RubyGems"
-	@gem push -k dev_arkency pkg/$(GEM_NAME)-$(GEM_VERSION).gem
-
-clean:
-	@echo "Removing previously built package"
-	-rm pkg/$(GEM_NAME)-$(GEM_VERSION).gem
-
-help:
-	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
-
-.PHONY: help
-.DEFAULT_GOAL := help
+SUBJECT     ?= RubyEventStore*
 
+include ../support/make/install.mk
+include ../support/make/test.mk
+include ../support/make/mutant.mk
+include ../support/make/gem.mk
+include ../support/make/help.mk

data/lib/ruby_event_store/batch_enumerator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RubyEventStore
   class BatchEnumerator
     def initialize(batch_size, total_limit, reader)
@@ -8,18 +10,26 @@ module RubyEventStore
 
     def each
       return to_enum unless block_given?
-      (0...total_limit).step(batch_size) do |batch_offset|
-        batch_offset = Integer(batch_offset)
-        batch_limit  = [batch_size, total_limit - batch_offset].min
-        result       = reader.call(batch_offset, batch_limit)
+
+      0.step(total_limit - 1, batch_size) do |batch_offset|
+        batch_limit = [batch_size, total_limit - batch_offset].min
+        result      = reader.call(batch_offset, batch_limit)
 
         break if result.empty?
         yield result
       end
     end
 
+    def first
+      each.first
+    end
+
+    def to_a
+      each.to_a
+    end
+
     private
 
-    attr_accessor :batch_size, :total_limit, :reader
+    attr_reader :batch_size, :total_limit, :reader
   end
 end

data/lib/ruby_event_store/broker.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class Broker
+    def initialize(subscriptions:, dispatcher:)
+      @subscriptions = subscriptions
+      @dispatcher = dispatcher
+    end
+
+    def call(event, serialized_event)
+      subscribers = subscriptions.all_for(event.event_type)
+      subscribers.each do |subscriber|
+        dispatcher.call(subscriber, event, serialized_event)
+      end
+    end
+
+    def add_subscription(subscriber, event_types)
+      verify_subscription(subscriber)
+      subscriptions.add_subscription(subscriber, event_types)
+    end
+
+    def add_global_subscription(subscriber)
+      verify_subscription(subscriber)
+      subscriptions.add_global_subscription(subscriber)
+    end
+
+    def add_thread_subscription(subscriber, event_types)
+      verify_subscription(subscriber)
+      subscriptions.add_thread_subscription(subscriber, event_types)
+    end
+
+    def add_thread_global_subscription(subscriber)
+      verify_subscription(subscriber)
+      subscriptions.add_thread_global_subscription(subscriber)
+    end
+
+    private
+    attr_reader :subscriptions, :dispatcher
+
+    def verify_subscription(subscriber)
+      raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber
+      raise InvalidHandler.new("Handler #{subscriber} is invalid for dispatcher #{dispatcher}") unless dispatcher.verify(subscriber)
+    end
+  end
+end

data/lib/ruby_event_store/client.rb

@@ -1,231 +1,321 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
 module RubyEventStore
   class Client
     def initialize(repository:,
                    mapper: Mappers::Default.new,
-                   event_broker:  PubSub::Broker.new,
-                   page_size: PAGE_SIZE,
-                   metadata_proc: nil,
-                   clock: ->{ Time.now.utc })
+                   subscriptions: Subscriptions.new,
+                   dispatcher: Dispatcher.new,
+                   clock: default_clock,
+                   correlation_id_generator: default_correlation_id_generator)
       @repository     = repository
       @mapper         = mapper
-      @event_broker   = event_broker
-      @page_size      = page_size
-      warn "`RubyEventStore::Client#metadata_proc` has been deprecated. Use `RubyEventStore::Client#with_metadata` instead." if metadata_proc
-      @metadata_proc  = metadata_proc
+      @broker         = Broker.new(subscriptions: subscriptions, dispatcher: dispatcher)
       @clock          = clock
+      @metadata       = Concurrent::ThreadLocalVar.new
+      @correlation_id_generator = correlation_id_generator
     end
 
-    def publish_events(events, stream_name: GLOBAL_STREAM, expected_version: :any)
-      append_to_stream(events, stream_name: stream_name, expected_version: expected_version)
-      events.each do |ev|
-        event_broker.notify_subscribers(ev)
-      end
-      :ok
-    end
 
-    def publish_event(event, stream_name: GLOBAL_STREAM, expected_version: :any)
-      publish_events([event], stream_name: stream_name, expected_version: expected_version)
+    # Persists events and notifies subscribed handlers about them
+    #
+    # @param events [Array<Event, Proto>, Event, Proto] event(s)
+    # @param stream_name [String] name of the stream for persisting events.
+    # @param expected_version [:any, :auto, :none, Integer] controls optimistic locking strategy. {http://railseventstore.org/docs/expected_version/ Read more}
+    # @return [self]
+    def publish(events, stream_name: GLOBAL_STREAM, expected_version: :any)
+      enriched_events = enrich_events_metadata(events)
+      serialized_events = serialize_events(enriched_events)
+      append_to_stream_serialized_events(serialized_events, stream_name: stream_name, expected_version: expected_version)
+      enriched_events.zip(serialized_events) do |event, serialized_event|
+        with_metadata(
+          correlation_id: event.metadata.fetch(:correlation_id),
+          causation_id:   event.event_id,
+        ) do
+          broker.(event, serialized_event)
+        end
+      end
+      self
     end
 
-    def append_to_stream(events, stream_name: GLOBAL_STREAM, expected_version: :any)
-      events = normalize_to_array(events)
-      events.each{|event| enrich_event_metadata(event) }
-      repository.append_to_stream(serialized_events(events), Stream.new(stream_name), ExpectedVersion.new(expected_version))
-      :ok
+    # Persists new event(s) without notifying any subscribed handlers
+    #
+    # @param (see #publish)
+    # @return [self]
+    def append(events, stream_name: GLOBAL_STREAM, expected_version: :any)
+      serialized_events = serialize_events(enrich_events_metadata(events))
+      append_to_stream_serialized_events(serialized_events, stream_name: stream_name, expected_version: expected_version)
+      self
     end
 
-    def link_to_stream(event_ids, stream_name:, expected_version: :any)
+    # Links already persisted event(s) to a different stream.
+    # Does not notify any subscribed handlers.
+    #
+    # @param event_ids [String, Array<String>] ids of events
+    # @param stream_name (see #publish)
+    # @param expected_version (see #publish)
+    # @return [self]
+    def link(event_ids, stream_name:, expected_version: :any)
       repository.link_to_stream(event_ids, Stream.new(stream_name), ExpectedVersion.new(expected_version))
       self
     end
 
+    # Deletes a stream.
+    # All events from the stream remain intact but they are no
+    # longer linked to the stream.
+    #
+    # @param stream_name [String] name of the stream to be cleared.
+    # @return [self]
     def delete_stream(stream_name)
       repository.delete_stream(Stream.new(stream_name))
-      :ok
-    end
-
-    def read_events_forward(stream_name, start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_events_forward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).limit(count).from(start).each.to_a
-      EOW
-      read.stream(stream_name).limit(count).from(start).each.to_a
-    end
-
-    def read_events_backward(stream_name, start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_events_backward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).limit(count).from(start).backward.each.to_a
-      EOW
-      read.stream(stream_name).limit(count).from(start).backward.each.to_a
-    end
-
-    def read_stream_events_forward(stream_name)
-      warn <<~EOW
-        RubyEventStore::Client#read_stream_events_forward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).each.to_a
-      EOW
-      read.stream(stream_name).each.to_a
-    end
-
-    def read_stream_events_backward(stream_name)
-      warn <<~EOW
-        RubyEventStore::Client#read_stream_events_backward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).backward.each.to_a
-      EOW
-      read.stream(stream_name).backward.each.to_a
-    end
-
-    def read_all_streams_forward(start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_all_streams_forward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.limit(count).from(start).each.to_a
-      EOW
-      read.limit(count).from(start).each.to_a
-    end
-
-    def read_all_streams_backward(start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_all_streams_backward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.limit(count).from(start).backward.each.to_a
-      EOW
-      read.limit(count).from(start).backward.each.to_a
+      self
     end
 
-    def read_event(event_id)
-      deserialize_event(repository.read_event(event_id))
+    # Starts building a query specification for reading events.
+    # {http://railseventstore.org/docs/read/ More info.}
+    #
+    # @return [Specification]
+    def read
+      Specification.new(SpecificationReader.new(repository, mapper))
     end
 
-    def read
-      Specification.new(repository, mapper)
+    # Gets list of streams where event is stored or linked
+    #
+    # @return [Array<Stream>] where event is stored or linked
+    def streams_of(event_id)
+      repository.streams_of(event_id)
     end
 
-    # subscribe(subscriber, to:)
-    # subscribe(to:, &subscriber)
+    # Subscribes a handler (subscriber) that will be invoked for published events of provided type.
+    #
+    # @overload subscribe(subscriber, to:)
+    #   @param to [Array<Class>] types of events to subscribe
+    #   @param subscriber [Object, Class] handler
+    #   @return [Proc] - unsubscribe proc. Call to unsubscribe.
+    #   @raise [ArgumentError, SubscriberNotExist]
+    # @overload subscribe(to:, &subscriber)
+    #   @param to [Array<Class>] types of events to subscribe
+    #   @param subscriber [Proc] handler
+    #   @return [Proc] - unsubscribe proc. Call to unsubscribe.
+    #   @raise [ArgumentError, SubscriberNotExist]
     def subscribe(subscriber = nil, to:, &proc)
       raise ArgumentError, "subscriber must be first argument or block, cannot be both" if subscriber && proc
-      raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber || proc
       subscriber ||= proc
-      event_broker.add_subscriber(subscriber, to)
+      broker.add_subscription(subscriber, to)
     end
 
-    # subscribe_to_all_events(subscriber)
-    # subscribe_to_all_events(&subscriber)
+    # Subscribes a handler (subscriber) that will be invoked for all published events
+    #
+    # @overload subscribe_to_all_events(subscriber)
+    #   @param subscriber [Object, Class] handler
+    #   @return [Proc] - unsubscribe proc. Call to unsubscribe.
+    #   @raise [ArgumentError, SubscriberNotExist]
+    # @overload subscribe_to_all_events(&subscriber)
+    #   @param subscriber [Proc] handler
+    #   @return [Proc] - unsubscribe proc. Call to unsubscribe.
+    #   @raise [ArgumentError, SubscriberNotExist]
     def subscribe_to_all_events(subscriber = nil, &proc)
       raise ArgumentError, "subscriber must be first argument or block, cannot be both" if subscriber && proc
-      raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber || proc
-      event_broker.add_global_subscriber(subscriber || proc)
+      broker.add_global_subscription(subscriber || proc)
     end
 
+    # Builder object for collecting temporary handlers (subscribers)
+    # which are active only during the invocation of the provided
+    # block of code.
     class Within
-      def initialize(block, event_broker)
+      def initialize(block, broker)
         @block = block
-        @event_broker = event_broker
+        @broker = broker
         @global_subscribers = []
         @subscribers = Hash.new {[]}
       end
 
+      # Subscribes temporary handlers that
+      # will be called for all published events.
+      # The subscription is active only during the invocation
+      # of the block of code provided to {Client#within}.
+      # {http://railseventstore.org/docs/subscribe/#temporary-subscriptions Read more.}
+      #
+      # @param handlers [Object, Class] handlers passed as objects or classes
+      # @param handler2 [Proc] handler passed as proc
+      # @return [self]
       def subscribe_to_all_events(*handlers, &handler2)
         handlers << handler2 if handler2
         @global_subscribers += handlers
         self
       end
 
+      # Subscribes temporary handlers that
+      # will be called for published events of provided type.
+      # The subscription is active only during the invocation
+      # of the block of code provided to {Client#within}.
+      # {http://railseventstore.org/docs/subscribe/#temporary-subscriptions Read more.}
+      #
+      # @overload subscribe(handler, to:)
+      #   @param handler [Object, Class] handler passed as objects or classes
+      #   @param to [Array<Class>] types of events to subscribe
+      #   @return [self]
+      # @overload subscribe(to:, &handler)
+      #   @param to [Array<Class>] types of events to subscribe
+      #   @param handler [Proc] handler passed as proc
+      #   @return [self]
       def subscribe(handler=nil, to:, &handler2)
         raise ArgumentError if handler && handler2
-        @subscribers[handler || handler2] += normalize_to_array(to)
+        @subscribers[handler || handler2] += Array(to)
         self
       end
 
+      # Invokes the block of code provided to {Client#within}
+      # and then unsubscribes temporary handlers.
+      # {http://railseventstore.org/docs/subscribe/#temporary-subscriptions Read more.}
+      #
+      # @return [Object] value returned by the invoked block of code
       def call
         unsubs  = add_thread_global_subscribers
         unsubs += add_thread_subscribers
         @block.call
       ensure
-        unsubs.each(&:call)
+        unsubs.each(&:call) if unsubs
       end
 
       private
 
       def add_thread_subscribers
-        @subscribers.map do |handler, types|
-          @event_broker.add_thread_subscriber(handler, types)
+        @subscribers.map do |subscriber, types|
+          @broker.add_thread_subscription(subscriber, types)
         end
       end
 
       def add_thread_global_subscribers
-        @global_subscribers.map do |s|
-          @event_broker.add_thread_global_subscriber(s)
+        @global_subscribers.map do |subscriber|
+          @broker.add_thread_global_subscription(subscriber)
         end
       end
-
-      def normalize_to_array(objs)
-        return *objs
-      end
     end
 
+    # Use for starting temporary subscriptions.
+    # {http://railseventstore.org/docs/subscribe/#temporary-subscriptions Read more}
+    #
+    # @param block [Proc] block of code during which the temporary subscriptions will be active
+    # @return [Within] builder object which collects temporary subscriptions
     def within(&block)
       raise ArgumentError if block.nil?
-      Within.new(block, event_broker)
+      Within.new(block, broker)
     end
 
+    # Set additional metadata for all events published within the provided block
+    # {http://railseventstore.org/docs/request_metadata#passing-your-own-metadata-using-with_metadata-method Read more}
+    #
+    # @param metadata [Hash] metadata to set for events
+    # @param block [Proc] block of code during which the metadata will be added
+    # @return [Object] last value returned by the provided block
     def with_metadata(metadata, &block)
       previous_metadata = metadata()
-      self.metadata = (previous_metadata || {}).merge(metadata)
+      self.metadata = previous_metadata.merge(metadata)
       block.call if block_given?
     ensure
       self.metadata = previous_metadata
     end
 
+    # Deserialize event which was serialized for async event handlers
+    # {http://railseventstore.org/docs/subscribe/#async-handlers Read more}
+    #
+    # @return [Event, Proto] deserialized event
+    def deserialize(event_type:, event_id:, data:, metadata:)
+      mapper.serialized_record_to_event(SerializedRecord.new(event_type: event_type, event_id: event_id, data: data, metadata: metadata))
+    end
+
+    # Read additional metadata which will be added for published events
+    # {http://railseventstore.org/docs/request_metadata#passing-your-own-metadata-using-with_metadata-method Read more}
+    #
+    # @return [Hash]
+    def metadata
+      @metadata.value || EMPTY_HASH
+    end
+
+    # Overwrite existing event(s) with the same ID.
+    #
+    # Does not notify any subscribed handlers.
+    # Does not enrich with additional current metadata.
+    # Does not allow changing which streams these events are in.
+    # {http://railseventstore.org/docs/migrating_messages Read more}
+    #
+    # @example Add data and metadata to existing events
+    #
+    #   events = event_store.read.limit(10).to_a
+    #   events.each do |ev|
+    #     ev.data[:tenant_id] = 1
+    #     ev.metadata[:server_id] = "eu-west-2"
+    #   end
+    #   event_store.overwrite(events)
+    #
+    # @example Change event type
+    #
+    #   events = event_store.read.limit(10).each.select{|ev| OldType === ev }.map do |ev|
+    #     NewType.new(
+    #       event_id: ev.event_id,
+    #       data: ev.data,
+    #       metadata: ev.metadata,
+    #     )
+    #   end
+    #   event_store.overwrite(events)
+    #
+    # @param events [Array<Event, Proto>, Event, Proto] event(s) to serialize and overwrite again
+    # @return [self]
+    def overwrite(events_or_event)
+      events = Array(events_or_event)
+      serialized_events = serialize_events(events)
+      repository.update_messages(serialized_events)
+      self
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{__id__.to_s(16)}>"
+    end
+
+    EMPTY_HASH = {}.freeze
+    private_constant :EMPTY_HASH
+
     private
 
-    def serialized_events(events)
+    def serialize_events(events)
       events.map do |ev|
         mapper.event_to_serialized_record(ev)
       end
     end
 
-    def deserialize_event(sev)
-      mapper.serialized_record_to_event(sev)
-    end
-
-    def normalize_to_array(events)
-      return *events
+    def enrich_events_metadata(events)
+      events = Array(events)
+      events.each{|event| enrich_event_metadata(event) }
+      events
     end
 
     def enrich_event_metadata(event)
-      if metadata_proc
-        md = metadata_proc.call || {}
-        md.each{|k,v| event.metadata[k]=(v) }
-      end
-      if metadata
-        metadata.each { |key, value| event.metadata[key] = value }
-      end
-      event.metadata[:timestamp] ||= clock.call
+      metadata.each { |key, value| event.metadata[key] ||= value }
+      event.metadata[:timestamp]      ||= clock.call
+      event.metadata[:correlation_id] ||= correlation_id_generator.call
     end
 
-    attr_reader :repository, :mapper, :event_broker, :clock, :metadata_proc, :page_size
+    def append_to_stream_serialized_events(serialized_events, stream_name:, expected_version:)
+      repository.append_to_stream(serialized_events, Stream.new(stream_name), ExpectedVersion.new(expected_version))
+    end
 
     protected
 
-    def metadata
-      Thread.current["ruby_event_store_#{hash}"]
+    def metadata=(value)
+      @metadata.value = value
     end
 
-    def metadata=(value)
-      Thread.current["ruby_event_store_#{hash}"] = value
+    def default_clock
+      ->{ Time.now.utc }
     end
+
+    def default_correlation_id_generator
+      ->{ SecureRandom.uuid }
+    end
+
+    attr_reader :repository, :mapper, :broker, :clock, :correlation_id_generator
   end
 end

data/lib/ruby_event_store/composed_dispatcher.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class ComposedDispatcher
+    def initialize(*dispatchers)
+      @dispatchers = dispatchers
+    end
+
+    def call(subscriber, event, serialized_event)
+      @dispatchers.each do |dispatcher|
+        if dispatcher.verify(subscriber)
+          dispatcher.call(subscriber, event, serialized_event)
+          break
+        end
+      end
+    end
+
+    def verify(subscriber)
+      @dispatchers.any? do |dispatcher|
+        dispatcher.verify(subscriber)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RubyEventStore
   GLOBAL_STREAM = Object.new
   PAGE_SIZE = 100.freeze