ruby_event_store 0.30.0 → 0.31.0

data/lib/ruby_event_store/correlated_commands.rb

@@ -0,0 +1,37 @@
+module RubyEventStore
+  class CorrelatedCommands
+
+    def initialize(event_store, command_bus)
+      @event_store = event_store
+      @command_bus = command_bus
+    end
+
+    class MiniEvent < Struct.new(:correlation_id, :message_id)
+    end
+
+    def call(command)
+      if (correlation_id = event_store.metadata[:correlation_id]) && (causation_id = event_store.metadata[:causation_id])
+        command.correlate_with(MiniEvent.new(
+          correlation_id,
+          causation_id,
+        )) if command.respond_to?(:correlate_with)
+        event_store.with_metadata(
+          causation_id: command.message_id,
+        ) do
+          command_bus.call(command)
+        end
+      else
+        event_store.with_metadata(
+          correlation_id: command.message_id,
+          causation_id: command.message_id,
+        ) do
+          command_bus.call(command)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :event_store, :command_bus
+  end
+end

data/lib/ruby_event_store/event.rb

@@ -1,22 +1,42 @@
 require 'securerandom'
 
 module RubyEventStore
+
+  # Data structure representing an event
   class Event
+    # Instantiates a new event
+    #
+    # @param event_id [String] event id
+    # @param data [Hash] event data which belong to your application domain
+    # @param metadata [Hash] event metadata which are technical and not
+    #   part of your domain such as remote_ip, request_id, correlation_id,
+    #   causation_id etc.
+    # @return [Event]
     def initialize(event_id: SecureRandom.uuid, metadata: nil, data: nil)
       @event_id = event_id.to_s
       @metadata = Metadata.new(metadata.to_h)
       @data     = data.to_h
     end
+
     attr_reader :event_id, :metadata, :data
 
+    # Event id
+    # @return [String]
     def message_id
       event_id
     end
 
+    # Type of event. Used when matching with subscribed handlers.
+    # @return [String]
     def type
       self.class.name
     end
 
+    # Returns a hash representation of the event.
+    #
+    # Metadata is converted to hash as well
+    #
+    # @return [Hash] with :event_id, :metadata, :data, :type keys
     def to_h
       {
           event_id:   event_id,
@@ -26,20 +46,43 @@ module RubyEventStore
       }
     end
 
+    # Timestamp from metadata
+    #
+    # @return [Time, nil]
     def timestamp
       metadata[:timestamp]
     end
 
+    # Two events are equal if:
+    # * they are of the same class
+    # * have identical event id
+    # * have identical data (verified with eql? method)
+    #
+    # @param other_event [Event, Object] object to compare
+    #
+    # Event equality ignores metadata!
+    # @return [TrueClass, FalseClass]
     def ==(other_event)
       other_event.instance_of?(self.class) &&
         other_event.event_id.eql?(event_id) &&
         other_event.data.eql?(data)
     end
 
+    # @private
     BIG_VALUE = 0b111111100100000010010010110011101011000101010101001100100110000
 
-    # We don't use metadata because == does not use metadata
+    # Generates a Fixnum hash value for this object. This function
+    # have the property that a.eql?(b) implies a.hash == b.hash.
+    #
+    # The hash value is used along with eql? by the Hash class to
+    # determine if two objects reference the same hash key.
+    #
+    # This hash is based on
+    # * class
+    # * event_id
+    # * data
     def hash
+      # We don't use metadata because == does not use metadata
       [
         self.class,
         event_id,
@@ -47,22 +90,46 @@ module RubyEventStore
       ].hash ^ BIG_VALUE
     end
 
+    # Reads correlation_id from metadata.
+    # {http://railseventstore.org/docs/correlation_causation/ Find out more}
+    #
+    # @return [String, nil]
     def correlation_id
       metadata[:correlation_id]
     end
 
+    # Sets correlation_id in metadata.
+    # {http://railseventstore.org/docs/correlation_causation/ Find out more}
+    #
+    # @param val [String]
+    # @return [String]
     def correlation_id=(val)
       metadata[:correlation_id] = val
     end
 
+    # Reads causation_id from metadata.
+    # {http://railseventstore.org/docs/correlation_causation/ Find out more}
+    #
+    # @return [String, nil]
     def causation_id
       metadata[:causation_id]
     end
 
+    # Sets causation_id= in metadata.
+    # {http://railseventstore.org/docs/correlation_causation/ Find out more}
+    #
+    # @param val [String]
+    # @return [String]
     def causation_id=(val)
       metadata[:causation_id]= val
     end
 
+    # Sets correlation_id and causation_id in metadata based
+    # on correlation_id and message_id of the provided message.
+    # {http://railseventstore.org/docs/correlation_causation/ Find out more}
+    #
+    # @param other_message [Event, Proto, command] message to correlate with. Most likely an event or a command. Must respond to correlation_id and message_id.
+    # @return [String] set causation_id
     def correlate_with(other_message)
       self.correlation_id = other_message.correlation_id || other_message.message_id
       self.causation_id   = other_message.message_id

data/lib/ruby_event_store/link_by_metadata.rb

@@ -0,0 +1,55 @@
+module RubyEventStore
+  class LinkByMetadata
+
+    def initialize(event_store:, key:, prefix: nil)
+      @event_store = event_store
+      @key = key
+      @prefix = prefix || ["$by", key, nil].join("_")
+    end
+
+    def call(event)
+      return unless event.metadata.has_key?(@key)
+
+      @event_store.link_to_stream(
+        [event.message_id],
+        stream_name: "#{@prefix}#{event.metadata.fetch(@key)}"
+      )
+    end
+
+  end
+
+  class LinkByCorrelationId < LinkByMetadata
+    def initialize(event_store:, prefix: nil)
+      super(
+        event_store: event_store,
+        prefix:      prefix,
+        key:         :correlation_id,
+      )
+    end
+  end
+
+  class LinkByCausationId < LinkByMetadata
+    def initialize(event_store:, prefix: nil)
+      super(
+        event_store: event_store,
+        prefix:      prefix,
+        key:         :causation_id,
+      )
+    end
+  end
+
+  class LinkByEventType
+    def initialize(event_store:, prefix: nil)
+      @event_store = event_store
+      @prefix = prefix || "$by_type_"
+    end
+
+    def call(event)
+      @event_store.link_to_stream(
+        [event.message_id],
+        stream_name: "#{@prefix}#{event.type}"
+      )
+    end
+  end
+
+end

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -9,7 +9,6 @@ module RubyEventStore
       def serialized_record_to_event(record)
         record
       end
-
     end
   end
 end

data/lib/ruby_event_store/mappers/protobuf.rb

@@ -55,19 +55,27 @@ module RubyEventStore
 
       def serialized_record_to_event(record)
         event_type = events_class_remapping.fetch(record.event_type) { record.event_type }
-        data = Google::Protobuf::DescriptorPool.generated_pool.lookup(event_type).msgclass.decode(record.data)
         Proto.new(
           event_id: record.event_id,
-          data: data,
-        ).tap do |p|
-          ProtobufNestedStruct::HashMapStringValue.load(record.metadata).each_with_object(p.metadata) {|(k, v), meta| meta[k.to_sym] = v}
-        end
+          data:     load_data(event_type, record.data),
+          metadata: load_metadata(record.metadata)
+        )
       end
 
       private
 
       attr_reader :event_id_getter, :events_class_remapping
 
+      def load_metadata(protobuf_metadata)
+        ProtobufNestedStruct::HashMapStringValue.load(protobuf_metadata).each_with_object({}) do |(k, v), meta|
+          meta[k.to_sym] = v
+        end
+      end
+
+      def load_data(event_type, protobuf_data)
+        Google::Protobuf::DescriptorPool.generated_pool.lookup(event_type).msgclass.decode(protobuf_data)
+      end
+
       def require_optional_dependency
         require 'protobuf_nested_struct'
       rescue LoadError

data/lib/ruby_event_store/pub_sub/broker.rb

@@ -1,73 +1,45 @@
-require 'concurrent'
-
 module RubyEventStore
   module PubSub
     class Broker
-      DEFAULT_DISPATCHER = Dispatcher.new
-
-      def initialize(dispatcher: DEFAULT_DISPATCHER)
-        @subscribers = Hash.new {|hsh, key| hsh[key] = [] }
-        @global_subscribers = []
-
-        @thread_global_subscribers = Concurrent::ThreadLocalVar.new([])
-        @thread_subscribers = Concurrent::ThreadLocalVar.new do
-          Hash.new {|hsh, key| hsh[key] = [] }
-        end
-
+      def initialize(subscriptions:, dispatcher:)
+        @subscriptions = subscriptions
         @dispatcher = dispatcher
       end
 
-      def add_subscriber(subscriber, event_types)
-        verify_subscriber(subscriber)
-        subscribe(subscriber, event_types)
+      def call(event, serialized_event)
+        subscribers = subscriptions.all_for(event.type)
+        subscribers.each do |subscriber|
+          dispatcher.call(subscriber, event, serialized_event)
+        end
       end
 
-      def add_global_subscriber(subscriber)
-        verify_subscriber(subscriber)
-        global_subscribers << subscriber
-
-        ->() { global_subscribers.delete(subscriber) }
+      def add_subscription(subscriber, event_types)
+        verify_subscription(subscriber)
+        subscriptions.add_subscription(subscriber, event_types)
       end
 
-      def add_thread_global_subscriber(subscriber)
-        verify_subscriber(subscriber)
-        thread_global_subscribers.value += [subscriber]
-
-        ->() { thread_global_subscribers.value -= [subscriber] }
+      def add_global_subscription(subscriber)
+        verify_subscription(subscriber)
+        subscriptions.add_global_subscription(subscriber)
       end
 
-      def add_thread_subscriber(subscriber, event_types)
-        verify_subscriber(subscriber)
-        event_types.each{ |type| thread_subscribers.value[type.to_s] << subscriber }
-        ->() {event_types.each{ |type| thread_subscribers.value.fetch(type.to_s).delete(subscriber) } }
+      def add_thread_subscription(subscriber, event_types)
+        verify_subscription(subscriber)
+        subscriptions.add_thread_subscription(subscriber, event_types)
       end
 
-      def notify_subscribers(event)
-        all_subscribers_for(event.type).each do |subscriber|
-          dispatcher.call(subscriber, event)
-        end
+      def add_thread_global_subscription(subscriber)
+        verify_subscription(subscriber)
+        subscriptions.add_thread_global_subscription(subscriber)
       end
 
       private
+      attr_reader :subscriptions, :dispatcher
 
-      def verify_subscriber(subscriber)
-        raise SubscriberNotExist if subscriber.nil?
+      def verify_subscription(subscriber)
+        raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber
         dispatcher.verify(subscriber)
       end
-
-      def subscribe(subscriber, event_types)
-        event_types.each{ |type| subscribers[type.to_s] << subscriber }
-        ->() {event_types.each{ |type| subscribers.fetch(type.to_s).delete(subscriber) } }
-      end
-
-      def all_subscribers_for(event_type)
-        subscribers[event_type] +
-        global_subscribers +
-        thread_global_subscribers.value +
-        thread_subscribers.value[event_type]
-      end
-
-      attr_reader :dispatcher, :subscribers, :global_subscribers, :thread_global_subscribers, :thread_subscribers
     end
   end
 end

data/lib/ruby_event_store/pub_sub/dispatcher.rb

@@ -2,7 +2,7 @@ module RubyEventStore
   module PubSub
 
     class Dispatcher
-      def call(subscriber, event)
+      def call(subscriber, event, _)
         subscriber = subscriber.new if Class === subscriber
         subscriber.call(event)
       end

data/lib/ruby_event_store/pub_sub/subscriptions.rb

@@ -0,0 +1,110 @@
+require 'concurrent'
+
+module RubyEventStore
+  module PubSub
+    class Subscriptions
+      def initialize
+        @local  = LocalSubscriptions.new
+        @global = GlobalSubscriptions.new
+        @thread  = ThreadSubscriptions.new
+      end
+
+      def add_subscription(subscriber, event_types)
+        local.add(subscriber, event_types)
+      end
+
+      def add_global_subscription(subscriber)
+        global.add(subscriber)
+      end
+
+      def add_thread_subscription(subscriber, event_types)
+        thread.local.add(subscriber, event_types)
+      end
+
+      def add_thread_global_subscription(subscriber)
+        thread.global.add(subscriber)
+      end
+
+      def all_for(event_type)
+        [local, global, thread].map{|r| r.all_for(event_type)}.reduce(&:+)
+      end
+
+      private
+      attr_reader :local, :global, :thread
+
+      class ThreadSubscriptions
+        def initialize
+          @local  = ThreadLocalSubscriptions.new
+          @global = ThreadGlobalSubscriptions.new
+        end
+        attr_reader :local, :global
+
+        def all_for(event_type)
+          [global, local].map{|r| r.all_for(event_type)}.reduce(&:+)
+        end
+      end
+
+      class LocalSubscriptions
+        def initialize
+          @subscriptions = Hash.new {|hsh, key| hsh[key] = [] }
+        end
+
+        def add(subscription, event_types)
+          event_types.each{ |type| @subscriptions[type.to_s] << subscription }
+          ->() {event_types.each{ |type| @subscriptions.fetch(type.to_s).delete(subscription) } }
+        end
+
+        def all_for(event_type)
+          @subscriptions[event_type]
+        end
+      end
+
+      class GlobalSubscriptions
+        def initialize
+          @subscriptions = []
+        end
+
+        def add(subscription)
+          @subscriptions << subscription
+          ->() { @subscriptions.delete(subscription) }
+        end
+
+        def all_for(_event_type)
+          @subscriptions
+        end
+      end
+
+      class ThreadLocalSubscriptions
+        def initialize
+          @subscriptions = Concurrent::ThreadLocalVar.new do
+            Hash.new {|hsh, key| hsh[key] = [] }
+          end
+        end
+
+        def add(subscription, event_types)
+          event_types.each{ |type| @subscriptions.value[type.to_s] << subscription }
+          ->() {event_types.each{ |type| @subscriptions.value.fetch(type.to_s).delete(subscription) } }
+        end
+
+        def all_for(event_type)
+          @subscriptions.value[event_type]
+        end
+      end
+
+      class ThreadGlobalSubscriptions
+        def initialize
+          @subscriptions = Concurrent::ThreadLocalVar.new([])
+        end
+
+        def add(subscription)
+          @subscriptions.value += [subscription]
+          ->() { @subscriptions.value -= [subscription] }
+        end
+
+        def all_for(_event_type)
+          @subscriptions.value
+        end
+      end
+    end
+  end
+end