ruby_event_store 0.30.0 → 1.3.1

data/lib/ruby_event_store/correlated_commands.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+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)
+      correlation_id = event_store.metadata[:correlation_id]
+      causation_id   = event_store.metadata[:causation_id]
+
+      if correlation_id && 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/dispatcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class Dispatcher
+    def call(subscriber, event, _)
+      subscriber = subscriber.new if Class === subscriber
+      subscriber.call(event)
+    end
+
+    def verify(subscriber)
+      begin
+        subscriber_instance = Class === subscriber ? subscriber.new : subscriber
+      rescue ArgumentError
+        false
+      else
+        subscriber_instance.respond_to?(:call)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/errors.rb

@@ -1,25 +1,25 @@
+# frozen_string_literal: true
+
 module RubyEventStore
-  WrongExpectedEventVersion  = Class.new(StandardError)
-  InvalidExpectedVersion     = Class.new(StandardError)
-  IncorrectStreamData        = Class.new(StandardError)
-  SubscriberNotExist         = Class.new(StandardError)
-  InvalidPageStart           = Class.new(ArgumentError)
-  InvalidPageSize            = Class.new(ArgumentError)
-  EventDuplicatedInStream    = Class.new(StandardError)
-  NotSupported               = Class.new(StandardError)
-  ReservedInternalName       = Class.new(StandardError)
+  Error                     = Class.new(StandardError)
+  WrongExpectedEventVersion = Class.new(Error)
+  InvalidExpectedVersion    = Class.new(Error)
+  IncorrectStreamData       = Class.new(Error)
+  SubscriberNotExist        = Class.new(Error)
+  InvalidPageStart          = Class.new(Error)
+  InvalidPageStop           = Class.new(Error)
+  InvalidPageSize           = Class.new(Error)
+  EventDuplicatedInStream   = Class.new(Error)
+  ReservedInternalName      = Class.new(Error)
+  InvalidHandler            = Class.new(Error)
+  ProtobufEncodingFailed    = Class.new(Error)
 
-  class EventNotFound < StandardError
+  class EventNotFound < Error
     attr_reader :event_id
+
     def initialize(event_id)
       super("Event not found: #{event_id}")
       @event_id = event_id
     end
   end
-
-  class InvalidHandler < StandardError
-    def initialize(object)
-      super("#call method not found in #{object.inspect} subscriber. Are you sure it is a valid subscriber?")
-    end
-  end
 end

data/lib/ruby_event_store/event.rb

@@ -1,45 +1,76 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 
 module RubyEventStore
+
+  # Data structure representing an event
   class Event
-    def initialize(event_id: SecureRandom.uuid, metadata: nil, data: nil)
+    # 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: {})
       @event_id = event_id.to_s
       @metadata = Metadata.new(metadata.to_h)
-      @data     = data.to_h
+      @data     = data
     end
+
     attr_reader :event_id, :metadata, :data
 
+    # Event id
+    # @return [String]
     def message_id
       event_id
     end
 
-    def type
+    # Type of event. Used when matching with subscribed handlers.
+    # @return [String]
+    def event_type
       self.class.name
     end
 
-    def to_h
-      {
-          event_id:   event_id,
-          metadata:   metadata.to_h,
-          data:       data,
-          type:       type,
-      }
-    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,27 +78,52 @@ 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
+      self
     end
 
     alias_method :eql?, :==
   end
-end
+end

data/lib/ruby_event_store/expected_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RubyEventStore
   class ExpectedVersion
     POSITION_DEFAULT = -1.freeze

data/lib/ruby_event_store/immediate_async_dispatcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class ImmediateAsyncDispatcher
+    def initialize(scheduler:)
+      @scheduler = scheduler
+    end
+
+    def call(subscriber, _, serialized_event)
+      @scheduler.call(subscriber, serialized_event)
+    end
+
+    def verify(subscriber)
+      @scheduler.verify(subscriber)
+    end
+  end
+end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -1,6 +1,6 @@
-require 'ostruct'
-require 'thread'
+# frozen_string_literal: true
 
+require 'ostruct'
 module RubyEventStore
   class InMemoryRepository
 
@@ -15,7 +15,7 @@ module RubyEventStore
     end
 
     def link_to_stream(event_ids, stream, expected_version)
-      events = normalize_to_array(event_ids).map {|eid| read_event(eid)}
+      events = Array(event_ids).map {|eid| read_event(eid)}
       add_to_stream(events, expected_version, stream, nil)
     end
 
@@ -31,36 +31,64 @@ module RubyEventStore
       stream_of(stream.name).last
     end
 
-    def read_event(event_id)
-      global.find {|e| event_id.eql?(e.event_id)} or raise EventNotFound.new(event_id)
-    end
-
     def read(spec)
-      events = spec.global_stream? ? global : stream_of(spec.stream_name)
-      events = events.reverse if spec.backward?
-      events = events.drop(index_of(events, spec.start) + 1) unless spec.head?
-      events = events[0...spec.count] if spec.limit?
+      events = read_scope(spec)
       if spec.batched?
         batch_reader = ->(offset, limit) { events.drop(offset).take(limit) }
         BatchEnumerator.new(spec.batch_size, events.size, batch_reader).each
+      elsif spec.first?
+        events.first
+      elsif spec.last?
+        events.last
       else
         events.each
       end
     end
 
+    def count(spec)
+      read_scope(spec).count
+    end
+
+    def update_messages(messages)
+      messages.each do |new_msg|
+        location = global.index{|m| new_msg.event_id.eql?(m.event_id)}
+        raise EventNotFound.new(new_msg.event_id) unless location
+        global[location] = new_msg
+        streams.values.each do |str|
+          location = str.index{|m| new_msg.event_id.eql?(m.event_id)}
+          str[location] = new_msg if location
+        end
+      end
+    end
+
+    def streams_of(event_id)
+      streams.select do |_, stream_events|
+        stream_events.any? { |event| event.event_id.eql?(event_id) }
+      end.map { |name, | Stream.new(name) }
+    end
+
     private
+    def read_scope(spec)
+      events = spec.stream.global? ? global : stream_of(spec.stream.name)
+      events = events.select{|e| spec.with_ids.any?{|x| x.eql?(e.event_id)}} if spec.with_ids?
+      events = events.select{|e| spec.with_types.any?{|x| x.eql?(e.event_type)}} if spec.with_types?
+      events = events.reverse if spec.backward?
+      events = events.drop(index_of(events, spec.start) + 1) if spec.start
+      events = events.take(index_of(events, spec.stop)) if spec.stop
+      events = events[0...spec.limit] if spec.limit?
+      events
+    end
 
-    def stream_of(name)
-      streams.fetch(name, Array.new)
+    def read_event(event_id)
+      global.find {|e| event_id.eql?(e.event_id)} or raise EventNotFound.new(event_id)
     end
 
-    def normalize_to_array(events)
-      return *events
+    def stream_of(name)
+      streams.fetch(name, Array.new)
     end
 
     def add_to_stream(events, expected_version, stream, include_global)
-      events = normalize_to_array(events)
-      append_with_synchronize(events, expected_version, stream, include_global)
+      append_with_synchronize(Array(events), expected_version, stream, include_global)
     end
 
     def last_stream_version(stream)

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class InstrumentedDispatcher
+    def initialize(dispatcher, instrumentation)
+      @dispatcher = dispatcher
+      @instrumentation = instrumentation
+    end
+
+    def call(subscriber, event, serialized_event)
+      instrumentation.instrument("call.dispatcher.rails_event_store", event: event, subscriber: subscriber) do
+        dispatcher.call(subscriber, event, serialized_event)
+      end
+    end
+
+    def verify(subscriber)
+      dispatcher.verify(subscriber)
+    end
+
+    private
+    attr_reader :instrumentation, :dispatcher
+  end
+end

data/lib/ruby_event_store/instrumented_repository.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class InstrumentedRepository
+    def initialize(repository, instrumentation)
+      @repository = repository
+      @instrumentation = instrumentation
+    end
+
+    def append_to_stream(events, stream, expected_version)
+      instrumentation.instrument("append_to_stream.repository.rails_event_store", events: events, stream: stream) do
+        repository.append_to_stream(events, stream, expected_version)
+      end
+    end
+
+    def link_to_stream(event_ids, stream, expected_version)
+      instrumentation.instrument("link_to_stream.repository.rails_event_store", event_ids: event_ids, stream: stream) do
+        repository.link_to_stream(event_ids, stream, expected_version)
+      end
+    end
+
+    def delete_stream(stream)
+      instrumentation.instrument("delete_stream.repository.rails_event_store", stream: stream) do
+        repository.delete_stream(stream)
+      end
+    end
+
+    def has_event?(event_id)
+      repository.has_event?(event_id)
+    end
+
+    def last_stream_event(stream)
+      repository.last_stream_event(stream)
+    end
+
+    def read(specification)
+      instrumentation.instrument("read.repository.rails_event_store", specification: specification) do
+        repository.read(specification)
+      end
+    end
+
+    def count(specification)
+      instrumentation.instrument("count.repository.rails_event_store", specification: specification) do
+        repository.count(specification)
+      end
+    end
+
+    def update_messages(messages)
+      instrumentation.instrument("update_messages.repository.rails_event_store", messages: messages) do
+        repository.update_messages(messages)
+      end
+    end
+
+    def streams_of(event_id)
+      instrumentation.instrument("streams_of.repository.rails_event_store", event_id: event_id) do
+        repository.streams_of(event_id)
+      end
+    end
+
+    private
+    attr_reader :repository, :instrumentation
+  end
+end

data/lib/ruby_event_store/link_by_metadata.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+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(
+        [event.event_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(
+        [event.event_id],
+        stream_name: "#{@prefix}#{event.event_type}"
+      )
+    end
+  end
+
+end

data/lib/ruby_event_store/mappers/default.rb

@@ -1,35 +1,19 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module RubyEventStore
   module Mappers
-    class Default
+    class Default < PipelineMapper
       def initialize(serializer: YAML, events_class_remapping: {})
-        @serializer = serializer
-        @events_class_remapping = events_class_remapping
-      end
-
-      def event_to_serialized_record(domain_event)
-        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.class.name
-        )
-      end
-
-      def serialized_record_to_event(record)
-        event_type = events_class_remapping.fetch(record.event_type) { record.event_type }
-        Object.const_get(event_type).new(
-          event_id: record.event_id,
-          metadata: serializer.load(record.metadata),
-          data:     serializer.load(record.data)
-        )
+        super(Pipeline.new(
+          transformations: [
+            Transformation::EventClassRemapper.new(events_class_remapping),
+            Transformation::SymbolizeMetadataKeys.new,
+            Transformation::Serialization.new(serializer: serializer),
+          ]
+        ))
       end
-
-      private
-
-      attr_reader :serializer, :events_class_remapping
-
     end
   end
 end

data/lib/ruby_event_store/mappers/encryption_key.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class EncryptionKey
+      def initialize(cipher:, key:)
+        @cipher = cipher
+        @key    = key
+      end
+
+      def encrypt(message, iv)
+        crypto     = prepare_encrypt(cipher)
+        crypto.iv  = iv
+        crypto.key = key
+
+        if crypto.authenticated?
+          encrypt_authenticated(crypto, message)
+        else
+          crypto.update(message) + crypto.final
+        end
+      end
+
+      def decrypt(message, iv)
+        crypto     = prepare_decrypt(cipher)
+        crypto.iv  = iv
+        crypto.key = key
+        ciphertext =
+          if crypto.authenticated?
+            ciphertext_from_authenticated(crypto, message)
+          else
+            message
+          end
+        (crypto.update(ciphertext) + crypto.final).force_encoding("UTF-8")
+      end
+
+      def random_iv
+        crypto = prepare_encrypt(cipher)
+        crypto.random_iv
+      end
+
+      attr_reader :cipher, :key
+
+      private
+
+      def ciphertext_from_authenticated(crypto, message)
+        prepare_auth_data(crypto)
+        crypto.auth_tag = message[-16...message.length]
+        message[0...-16]
+      end
+
+      def encrypt_authenticated(crypto, message)
+        prepare_auth_data(crypto)
+        crypto.update(message) + crypto.final + crypto.auth_tag
+      end
+
+      def prepare_auth_data(crypto)
+        crypto.auth_data = ""
+        crypto
+      end
+
+      def prepare_encrypt(cipher)
+        crypto = OpenSSL::Cipher.new(cipher)
+        crypto.encrypt
+        crypto
+      end
+
+      def prepare_decrypt(cipher)
+        crypto = OpenSSL::Cipher.new(cipher)
+        crypto.decrypt
+        crypto
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/encryption_mapper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class EncryptionMapper < PipelineMapper
+      def initialize(key_repository, serializer: YAML, forgotten_data: ForgottenData.new)
+        super(Pipeline.new(
+          transformations: [
+            Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data),
+            Transformation::Serialization.new(serializer: serializer),
+          ]
+        ))
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/forgotten_data.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class ForgottenData
+      FORGOTTEN_DATA = 'FORGOTTEN_DATA'.freeze
+
+      def initialize(string = FORGOTTEN_DATA)
+        @string = string
+      end
+
+      def to_s
+        @string
+      end
+
+      def ==(other)
+        @string == other
+      end
+      alias_method :eql?, :==
+
+      def method_missing(*)
+        self
+      end
+
+      def respond_to_missing?(*)
+        true
+      end
+    end
+  end
+end