ruby_event_store 2.1.0 → 2.4.0

data/lib/ruby_event_store/in_memory_repository.rb

@@ -1,26 +1,49 @@
 # frozen_string_literal: true
 
-require 'ostruct'
+require "ostruct"
 module RubyEventStore
   class InMemoryRepository
+    class UnsupportedVersionAnyUsage < StandardError
+      def initialize
+        super <<~EOS
+        Mixing expected version :any and specific position (or :auto) is unsupported.
+
+        Read more about expected versions here:
+        https://railseventstore.org/docs/v2/expected_version/
+        EOS
+      end
+    end
+
+    class EventInStream
+      def initialize(event_id, position)
+        @event_id = event_id
+        @position = position
+      end
+
+      attr_reader :event_id, :position
+    end
 
-    def initialize(serializer: NULL)
+    def initialize(serializer: NULL, ensure_supported_any_usage: false)
       @serializer = serializer
       @streams = Hash.new { |h, k| h[k] = Array.new }
-      @mutex   = Mutex.new
+      @mutex = Mutex.new
       @storage = Hash.new
+      @ensure_supported_any_usage = ensure_supported_any_usage
     end
 
     def append_to_stream(records, stream, expected_version)
       serialized_records = records.map { |record| record.serialize(serializer) }
 
       with_synchronize(expected_version, stream) do |resolved_version|
-        raise WrongExpectedEventVersion unless last_stream_version(stream).equal?(resolved_version)
+        ensure_supported_any_usage(resolved_version, stream)
+        unless resolved_version.nil? || last_stream_version(stream).equal?(resolved_version)
+          raise WrongExpectedEventVersion
+        end
 
-        serialized_records.each do |serialized_record|
+        serialized_records.each_with_index do |serialized_record, index|
           raise EventDuplicatedInStream if has_event?(serialized_record.event_id)
           storage[serialized_record.event_id] = serialized_record
-          streams[stream.name] << serialized_record.event_id
+          add_to_stream(stream, serialized_record, resolved_version, index)
         end
       end
       self
@@ -30,11 +53,14 @@ module RubyEventStore
       serialized_records = event_ids.map { |id| read_event(id) }
 
       with_synchronize(expected_version, stream) do |resolved_version|
-        raise WrongExpectedEventVersion unless last_stream_version(stream).equal?(resolved_version)
+        ensure_supported_any_usage(resolved_version, stream)
+        unless resolved_version.nil? || last_stream_version(stream).equal?(resolved_version)
+          raise WrongExpectedEventVersion
+        end
 
-        serialized_records.each do |serialized_record|
+        serialized_records.each_with_index do |serialized_record, index|
           raise EventDuplicatedInStream if has_event_in_stream?(serialized_record.event_id, stream.name)
-          streams[stream.name] << serialized_record.event_id
+          add_to_stream(stream, serialized_record, resolved_version, index)
         end
       end
       self
@@ -69,9 +95,7 @@ module RubyEventStore
         serialized_records.last&.deserialize(serializer)
       else
         Enumerator.new do |y|
-          serialized_records.each do |serialized_record|
-            y << serialized_record.deserialize(serializer)
-          end
+          serialized_records.each { |serialized_record| y << serialized_record.deserialize(serializer) }
         end
       end
     end
@@ -84,38 +108,61 @@ module RubyEventStore
       records.each do |record|
         read_event(record.event_id)
         serialized_record =
-          Record.new(
-            event_id:   record.event_id,
-            event_type: record.event_type,
-            data:       record.data,
-            metadata:   record.metadata,
-            timestamp:  Time.iso8601(storage.fetch(record.event_id).timestamp),
-            valid_at:   record.valid_at,
-          ).serialize(serializer)
+          Record
+            .new(
+              event_id: record.event_id,
+              event_type: record.event_type,
+              data: record.data,
+              metadata: record.metadata,
+              timestamp: Time.iso8601(storage.fetch(record.event_id).timestamp),
+              valid_at: record.valid_at
+            )
+            .serialize(serializer)
         storage[record.event_id] = serialized_record
       end
     end
 
     def streams_of(event_id)
-      streams
-        .select { |name,| has_event_in_stream?(event_id, name) }
-        .map    { |name,| Stream.new(name) }
+      streams.select { |name,| has_event_in_stream?(event_id, name) }.map { |name,| Stream.new(name) }
+    end
+
+    def position_in_stream(event_id, stream)
+      event_in_stream = streams[stream.name].find { |event_in_stream| event_in_stream.event_id.eql?(event_id) }
+      raise EventNotFoundInStream if event_in_stream.nil?
+      event_in_stream.position
+    end
+
+    def global_position(event_id)
+      storage.keys.index(event_id) or raise EventNotFound.new(event_id)
+    end
+
+    def event_in_stream?(event_id, stream)
+      !streams[stream.name].find { |event_in_stream| event_in_stream.event_id.eql?(event_id) }.nil?
     end
 
     private
+
     def read_scope(spec)
       serialized_records = serialized_records_of_stream(spec.stream)
       serialized_records = ordered(serialized_records, spec)
-      serialized_records = serialized_records.select{|e| spec.with_ids.any?{|x| x.eql?(e.event_id)}} if spec.with_ids?
-      serialized_records = serialized_records.select{|e| spec.with_types.any?{|x| x.eql?(e.event_type)}} if spec.with_types?
+      serialized_records = serialized_records.select { |e| spec.with_ids.any? { |x| x.eql?(e.event_id) } } if spec
+        .with_ids?
+      serialized_records = serialized_records.select { |e| spec.with_types.any? { |x| x.eql?(e.event_type) } } if spec
+        .with_types?
       serialized_records = serialized_records.reverse if spec.backward?
       serialized_records = serialized_records.drop(index_of(serialized_records, spec.start) + 1) if spec.start
       serialized_records = serialized_records.take(index_of(serialized_records, spec.stop)) if spec.stop
       serialized_records = serialized_records.take(spec.limit) if spec.limit?
-      serialized_records = serialized_records.select { |sr| Time.iso8601(sr.timestamp) < spec.older_than } if spec.older_than
-      serialized_records = serialized_records.select { |sr| Time.iso8601(sr.timestamp) <= spec.older_than_or_equal } if spec.older_than_or_equal
-      serialized_records = serialized_records.select { |sr| Time.iso8601(sr.timestamp) > spec.newer_than } if spec.newer_than
-      serialized_records = serialized_records.select { |sr| Time.iso8601(sr.timestamp) >= spec.newer_than_or_equal } if spec.newer_than_or_equal
+      serialized_records = serialized_records.select { |sr| Time.iso8601(sr.timestamp) < spec.older_than } if spec
+        .older_than
+      serialized_records =
+        serialized_records.select { |sr| Time.iso8601(sr.timestamp) <= spec.older_than_or_equal } if spec
+        .older_than_or_equal
+      serialized_records = serialized_records.select { |sr| Time.iso8601(sr.timestamp) > spec.newer_than } if spec
+        .newer_than
+      serialized_records =
+        serialized_records.select { |sr| Time.iso8601(sr.timestamp) >= spec.newer_than_or_equal } if spec
+        .newer_than_or_equal
       serialized_records
     end
 
@@ -124,7 +171,7 @@ module RubyEventStore
     end
 
     def event_ids_of_stream(stream)
-      streams.fetch(stream.name, Array.new)
+      streams.fetch(stream.name, Array.new).map(&:event_id)
     end
 
     def serialized_records_of_stream(stream)
@@ -143,7 +190,7 @@ module RubyEventStore
     end
 
     def last_stream_version(stream)
-      event_ids_of_stream(stream).size - 1
+      streams.fetch(stream.name, Array.new).size - 1
     end
 
     def with_synchronize(expected_version, stream, &block)
@@ -157,18 +204,34 @@ module RubyEventStore
       # conditions more likely. And we only use mutex.synchronize for writing
       # not for the whole read+write algorithm.
       Thread.pass
-      mutex.synchronize do
-        resolved_version = last_stream_version(stream) if expected_version.any?
-        block.call(resolved_version)
-      end
+      mutex.synchronize { block.call(resolved_version) }
     end
 
     def has_event_in_stream?(event_id, stream_name)
-      streams.fetch(stream_name, Array.new).any? { |id| id.eql?(event_id) }
+      streams.fetch(stream_name, Array.new).any? { |event_in_stream| event_in_stream.event_id.eql?(event_id) }
     end
 
     def index_of(source, event_id)
-      source.index {|item| item.event_id.eql?(event_id)}
+      source.index { |item| item.event_id.eql?(event_id) }
+    end
+
+    def compute_position(resolved_version, index)
+      resolved_version + index + 1 unless resolved_version.nil?
+    end
+
+    def add_to_stream(stream, serialized_record, resolved_version, index)
+      streams[stream.name] << EventInStream.new(serialized_record.event_id, compute_position(resolved_version, index))
+    end
+
+    def ensure_supported_any_usage(resolved_version, stream)
+      if @ensure_supported_any_usage
+        stream_positions = streams.fetch(stream.name, Array.new).map(&:position)
+        if resolved_version.nil?
+          raise UnsupportedVersionAnyUsage if !stream_positions.compact.empty?
+        else
+          raise UnsupportedVersionAnyUsage if stream_positions.include?(nil)
+        end
+      end
     end
 
     attr_reader :streams, :mutex, :storage, :serializer

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -13,11 +13,20 @@ module RubyEventStore
       end
     end
 
-    def verify(subscriber)
-      dispatcher.verify(subscriber)
+    def method_missing(method_name, *arguments, **keyword_arguments, &block)
+      if respond_to?(method_name)
+        dispatcher.public_send(method_name, *arguments, **keyword_arguments, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private)
+      dispatcher.respond_to?(method_name)
     end
 
     private
+
     attr_reader :instrumentation, :dispatcher
   end
 end

data/lib/ruby_event_store/instrumented_repository.rb

@@ -25,14 +25,6 @@ module RubyEventStore
       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)
@@ -57,7 +49,20 @@ module RubyEventStore
       end
     end
 
+    def method_missing(method_name, *arguments, **keyword_arguments, &block)
+      if respond_to?(method_name)
+        repository.public_send(method_name, *arguments, **keyword_arguments, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private)
+      repository.respond_to?(method_name)
+    end
+
     private
+
     attr_reader :repository, :instrumentation
   end
 end

data/lib/ruby_event_store/link_by_metadata.rb

@@ -2,7 +2,6 @@
 
 module RubyEventStore
   class LinkByMetadata
-
     def initialize(event_store:, key:, prefix: nil)
       @event_store = event_store
       @key = key
@@ -12,31 +11,19 @@ module RubyEventStore
     def call(event)
       return unless event.metadata.has_key?(@key)
 
-      @event_store.link(
-        [event.event_id],
-        stream_name: "#{@prefix}#{event.metadata.fetch(@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,
-      )
+      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,
-      )
+      super(event_store: event_store, prefix: prefix, key: :causation_id)
     end
   end
 
@@ -47,11 +34,7 @@ module RubyEventStore
     end
 
     def call(event)
-      @event_store.link(
-        [event.event_id],
-        stream_name: "#{@prefix}#{event.event_type}"
-      )
+      @event_store.link([event.event_id], stream_name: "#{@prefix}#{event.event_type}")
     end
   end
-
 end

data/lib/ruby_event_store/mappers/default.rb

@@ -4,10 +4,12 @@ module RubyEventStore
   module Mappers
     class Default < PipelineMapper
       def initialize(events_class_remapping: {})
-        super(Pipeline.new(
-          Transformation::EventClassRemapper.new(events_class_remapping),
-          Transformation::SymbolizeMetadataKeys.new,
-        ))
+        super(
+          Pipeline.new(
+            Transformation::EventClassRemapper.new(events_class_remapping),
+            Transformation::SymbolizeMetadataKeys.new
+          )
+        )
       end
     end
   end

data/lib/ruby_event_store/mappers/encryption_key.rb

@@ -5,31 +5,22 @@ module RubyEventStore
     class EncryptionKey
       def initialize(cipher:, key:)
         @cipher = cipher
-        @key    = key
+        @key = key
       end
 
       def encrypt(message, iv)
-        crypto     = prepare_encrypt(cipher)
-        crypto.iv  = 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
+        crypto.authenticated? ? encrypt_authenticated(crypto, message) : crypto.update(message) + crypto.final
       end
 
       def decrypt(message, iv)
-        crypto     = prepare_decrypt(cipher)
-        crypto.iv  = iv
+        crypto = prepare_decrypt(cipher)
+        crypto.iv = iv
         crypto.key = key
-        ciphertext =
-          if crypto.authenticated?
-            ciphertext_from_authenticated(crypto, message)
-          else
-            message
-          end
+        ciphertext = crypto.authenticated? ? ciphertext_from_authenticated(crypto, message) : message
         (crypto.update(ciphertext) + crypto.final).force_encoding("UTF-8")
       end
 

data/lib/ruby_event_store/mappers/encryption_mapper.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module RubyEventStore
   module Mappers
     class EncryptionMapper < PipelineMapper
-      def initialize(key_repository, serializer: YAML, forgotten_data: ForgottenData.new)
-        super(Pipeline.new(
-          Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data),
-        ))
+      def initialize(key_repository, serializer: Serializers::YAML, forgotten_data: ForgottenData.new)
+        super(
+          Pipeline.new(
+            Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data)
+          )
+        )
       end
     end
   end

data/lib/ruby_event_store/mappers/forgotten_data.rb

@@ -3,7 +3,7 @@
 module RubyEventStore
   module Mappers
     class ForgottenData
-      FORGOTTEN_DATA = 'FORGOTTEN_DATA'.freeze
+      FORGOTTEN_DATA = "FORGOTTEN_DATA".freeze
 
       def initialize(string = FORGOTTEN_DATA)
         @string = string

data/lib/ruby_event_store/mappers/in_memory_encryption_key_repository.rb

@@ -3,7 +3,7 @@
 module RubyEventStore
   module Mappers
     class InMemoryEncryptionKeyRepository
-      DEFAULT_CIPHER = 'aes-256-gcm'.freeze
+      DEFAULT_CIPHER = "aes-256-gcm".freeze
 
       def initialize
         @keys = {}

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -3,7 +3,6 @@
 module RubyEventStore
   module Mappers
     class NullMapper < PipelineMapper
-
       def initialize
         super(Pipeline.new)
       end

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -4,22 +4,15 @@ module RubyEventStore
   module Mappers
     class Pipeline
       def initialize(*transformations, to_domain_event: Transformation::DomainEvent.new)
-        @transformations = [
-          to_domain_event,
-          transformations,
-        ].flatten.freeze
+        @transformations = [to_domain_event, transformations].flatten.freeze
       end
 
       def dump(domain_event)
-        transformations.reduce(domain_event) do |item, transform|
-          transform.dump(item)
-        end
+        transformations.reduce(domain_event) { |item, transform| transform.dump(item) }
       end
 
       def load(record)
-        transformations.reverse.reduce(record) do |item, transform|
-          transform.load(item)
-        end
+        transformations.reverse.reduce(record) { |item, transform| transform.load(item) }
       end
 
       attr_reader :transformations

data/lib/ruby_event_store/mappers/pipeline_mapper.rb

@@ -16,6 +16,7 @@ module RubyEventStore
       end
 
       private
+
       attr_reader :pipeline
     end
   end

data/lib/ruby_event_store/mappers/transformation/domain_event.rb

@@ -5,27 +5,37 @@ module RubyEventStore
     module Transformation
       class DomainEvent
         def dump(domain_event)
-          metadata = domain_event.metadata.to_h
+          metadata = domain_event.metadata.dup.to_h
           timestamp = metadata.delete(:timestamp)
           valid_at = metadata.delete(:valid_at)
           Record.new(
-            event_id:   domain_event.event_id,
-            metadata:   metadata,
-            data:       domain_event.data,
+            event_id: domain_event.event_id,
+            metadata: metadata,
+            data: domain_event.data,
             event_type: domain_event.event_type,
-            timestamp:  timestamp,
-            valid_at:   valid_at,
+            timestamp: timestamp,
+            valid_at: valid_at
           )
         end
 
         def load(record)
-          Object.const_get(record.event_type).new(
+          Object
+            .const_get(record.event_type)
+            .new(
+              event_id: record.event_id,
+              data: record.data,
+              metadata: record.metadata.merge(timestamp: record.timestamp, valid_at: record.valid_at)
+            )
+        rescue NameError
+          Event.new(
             event_id: record.event_id,
-            metadata: record.metadata.merge(
-              timestamp: record.timestamp,
-              valid_at: record.valid_at,
-            ),
-            data:     record.data,
+            data: record.data,
+            metadata:
+              record.metadata.merge(
+                timestamp: record.timestamp,
+                valid_at: record.valid_at,
+                event_type: record.event_type
+              )
           )
         end
       end

data/lib/ruby_event_store/mappers/transformation/encryption.rb

@@ -6,38 +6,38 @@ module RubyEventStore
       class Encryption
         class Leaf
           def self.===(hash)
-            hash.keys.sort.eql? %i(cipher identifier iv)
+            hash.keys.sort.eql? %i[cipher identifier iv]
           end
         end
         private_constant :Leaf
 
         class MissingEncryptionKey < StandardError
           def initialize(key_identifier)
-            super %Q|Could not find encryption key for '#{key_identifier}'|
+            super "Could not find encryption key for '#{key_identifier}'"
           end
         end
 
-        def initialize(key_repository, serializer: YAML, forgotten_data: ForgottenData.new)
+        def initialize(key_repository, serializer: Serializers::YAML, forgotten_data: ForgottenData.new)
           @key_repository = key_repository
           @serializer = serializer
           @forgotten_data = forgotten_data
         end
 
         def dump(record)
-          data        = record.data
-          metadata    = record.metadata.dup
+          data = record.data
+          metadata = record.metadata.dup
           event_class = Object.const_get(record.event_type)
 
-          crypto_description    = encryption_metadata(data, encryption_schema(event_class))
+          crypto_description = encryption_metadata(data, encryption_schema(event_class))
           metadata[:encryption] = crypto_description unless crypto_description.empty?
 
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       encrypt_data(deep_dup(data), crypto_description),
-            metadata:   metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: encrypt_data(deep_dup(data), crypto_description),
+            metadata: metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
@@ -46,16 +46,17 @@ module RubyEventStore
           crypto_description = Hash(metadata.delete(:encryption))
 
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       decrypt_data(record.data, crypto_description),
-            metadata:   metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: decrypt_data(record.data, crypto_description),
+            metadata: metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
         private
+
         attr_reader :key_repository, :serializer, :forgotten_data
 
         def encryption_schema(event_class)
@@ -64,9 +65,7 @@ module RubyEventStore
 
         def deep_dup(hash)
           duplicate = hash.dup
-          duplicate.each do |k, v|
-            duplicate[k] = v.instance_of?(Hash) ? deep_dup(v) : v
-          end
+          duplicate.each { |k, v| duplicate[k] = v.instance_of?(Hash) ? deep_dup(v) : v }
           duplicate
         end
 
@@ -79,11 +78,7 @@ module RubyEventStore
               key_identifier = value.call(data)
               encryption_key = key_repository.key_of(key_identifier)
               raise MissingEncryptionKey.new(key_identifier) unless encryption_key
-              acc[key] = {
-                cipher: encryption_key.cipher,
-                iv: encryption_key.random_iv,
-                identifier: key_identifier,
-              }
+              acc[key] = { cipher: encryption_key.cipher, iv: encryption_key.random_iv, identifier: key_identifier }
             end
             acc
           end
@@ -122,7 +117,8 @@ module RubyEventStore
             cryptogram = data.fetch(attribute)
             return unless cryptogram
 
-            encryption_key = key_repository.key_of(meta.fetch(:identifier), cipher: meta.fetch(:cipher)) or return forgotten_data
+            encryption_key = key_repository.key_of(meta.fetch(:identifier), cipher: meta.fetch(:cipher)) or
+              return forgotten_data
             serializer.load(encryption_key.decrypt(cryptogram, meta.fetch(:iv)))
           when Hash
             decrypt_data(data.fetch(attribute), meta)

data/lib/ruby_event_store/mappers/transformation/event_class_remapper.rb

@@ -14,16 +14,17 @@ module RubyEventStore
 
         def load(record)
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: class_map[record.event_type] || record.event_type,
-            data:       record.data,
-            metadata:   record.metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: record.data,
+            metadata: record.metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
         private
+
         attr_reader :class_map
       end
     end