ruby_event_store 1.2.0 → 2.0.1

data/lib/ruby_event_store/in_memory_repository.rb

@@ -4,19 +4,40 @@ require 'ostruct'
 module RubyEventStore
   class InMemoryRepository
 
-    def initialize
-      @streams = Hash.new
-      @mutex = Mutex.new
-      @global = Array.new
+    def initialize(serializer: NULL)
+      @serializer = serializer
+      @streams = Hash.new { |h, k| h[k] = Array.new }
+      @mutex   = Mutex.new
+      @storage = Hash.new
     end
 
-    def append_to_stream(events, stream, expected_version)
-      add_to_stream(events, expected_version, stream, true)
+    def append_to_stream(records, stream, expected_version)
+      serialized_records = Array(records).map{ |record| record.serialize(serializer) }
+
+      with_synchronize(expected_version, stream) do |resolved_version|
+        raise WrongExpectedEventVersion unless last_stream_version(stream).equal?(resolved_version)
+
+        serialized_records.each do |serialized_record|
+          raise EventDuplicatedInStream if has_event?(serialized_record.event_id)
+          storage[serialized_record.event_id] = serialized_record
+          streams[stream.name] << serialized_record.event_id
+        end
+      end
+      self
     end
 
     def link_to_stream(event_ids, stream, expected_version)
-      events = Array(event_ids).map {|eid| read_event(eid)}
-      add_to_stream(events, expected_version, stream, nil)
+      serialized_records = Array(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)
+
+        serialized_records.each do |serialized_record|
+          raise EventDuplicatedInStream if has_event_in_stream?(serialized_record.event_id, stream.name)
+          streams[stream.name] << serialized_record.event_id
+        end
+      end
+      self
     end
 
     def delete_stream(stream)
@@ -24,24 +45,34 @@ module RubyEventStore
     end
 
     def has_event?(event_id)
-       global.any?{ |item| item.event_id.eql?(event_id) }
+      storage.has_key?(event_id)
     end
 
     def last_stream_event(stream)
-      stream_of(stream.name).last
+      last_id = event_ids_of_stream(stream).last
+      storage.fetch(last_id).deserialize(serializer) if last_id
     end
 
     def read(spec)
-      events = read_scope(spec)
+      serialized_records = 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
+        batch_reader = ->(offset, limit) do
+          serialized_records
+            .drop(offset)
+            .take(limit)
+            .map{|serialized_record| serialized_record.deserialize(serializer) }
+        end
+        BatchEnumerator.new(spec.batch_size, serialized_records.size, batch_reader).each
       elsif spec.first?
-        events.first
+        serialized_records.first&.deserialize(serializer)
       elsif spec.last?
-        events.last
+        serialized_records.last&.deserialize(serializer)
       else
-        events.each
+        Enumerator.new do |y|
+          serialized_records.each do |serialized_record|
+            y << serialized_record.deserialize(serializer)
+          end
+        end
       end
     end
 
@@ -49,52 +80,73 @@ module RubyEventStore
       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)} or raise EventNotFound.new(new_msg.event_id)
-        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
+    def update_messages(records)
+      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)
+        storage[record.event_id] = serialized_record
       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) }
+      streams
+        .select { |name,| has_event_in_stream?(event_id, name) }
+        .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
+      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.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
     end
 
     def read_event(event_id)
-      global.find {|e| event_id.eql?(e.event_id)} or raise EventNotFound.new(event_id)
+      storage.fetch(event_id) { raise EventNotFound.new(event_id) }
     end
 
-    def stream_of(name)
-      streams.fetch(name, Array.new)
+    def event_ids_of_stream(stream)
+      streams.fetch(stream.name, Array.new)
     end
 
-    def add_to_stream(events, expected_version, stream, include_global)
-      append_with_synchronize(Array(events), expected_version, stream, include_global)
+    def serialized_records_of_stream(stream)
+      stream.global? ? storage.values : storage.fetch_values(*event_ids_of_stream(stream))
+    end
+
+    def ordered(serialized_records, spec)
+      case spec.time_sort_by
+      when :as_at
+        serialized_records.sort_by(&:timestamp)
+      when :as_of
+        serialized_records.sort_by(&:valid_at)
+      else
+        serialized_records
+      end
     end
 
     def last_stream_version(stream)
-      stream_of(stream.name).size - 1
+      event_ids_of_stream(stream).size - 1
     end
 
-    def append_with_synchronize(events, expected_version, stream, include_global)
+    def with_synchronize(expected_version, stream, &block)
       resolved_version = expected_version.resolve_for(stream, method(:last_stream_version))
 
       # expected_version :auto assumes external lock is used
@@ -107,30 +159,18 @@ module RubyEventStore
       Thread.pass
       mutex.synchronize do
         resolved_version = last_stream_version(stream) if expected_version.any?
-        append(events, resolved_version, stream, include_global)
+        block.call(resolved_version)
       end
     end
 
-    def append(events, resolved_version, stream, include_global)
-      stream_events = stream_of(stream.name)
-      raise WrongExpectedEventVersion unless last_stream_version(stream).equal?(resolved_version)
-
-      events.each do |event|
-        raise EventDuplicatedInStream if stream_events.any? {|ev| ev.event_id.eql?(event.event_id)}
-        if include_global
-          raise EventDuplicatedInStream if has_event?(event.event_id)
-          global.push(event)
-        end
-        stream_events.push(event)
-      end
-      streams[stream.name] = stream_events
-      self
+    def has_event_in_stream?(event_id, stream_name)
+      streams.fetch(stream_name, Array.new).any? { |id| id.eql?(event_id) }
     end
 
     def index_of(source, event_id)
       source.index {|item| item.event_id.eql?(event_id)}
     end
 
-    attr_reader :streams, :mutex, :global
+    attr_reader :streams, :mutex, :storage, :serializer
   end
 end

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -7,9 +7,9 @@ module RubyEventStore
       @instrumentation = instrumentation
     end
 
-    def call(subscriber, event, serialized_event)
+    def call(subscriber, event, record)
       instrumentation.instrument("call.dispatcher.rails_event_store", event: event, subscriber: subscriber) do
-        dispatcher.call(subscriber, event, serialized_event)
+        dispatcher.call(subscriber, event, record)
       end
     end
 

data/lib/ruby_event_store/mappers/default.rb

@@ -5,13 +5,35 @@ require 'yaml'
 module RubyEventStore
   module Mappers
     class Default < PipelineMapper
-      def initialize(serializer: YAML, events_class_remapping: {})
+      UNSET = Object.new.freeze
+
+      attr_reader :serializer
+
+      def initialize(serializer: UNSET, events_class_remapping: {})
+        case serializer
+        when UNSET
+          @serializer = YAML
+        else
+          warn <<~EOW
+            Passing serializer: to #{self.class} has been deprecated.
+
+            Pass it directly to the repository and the scheduler. For example:
+
+            Rails.configuration.event_store = RailsEventStore::Client.new(
+              mapper:     RubyEventStore::Mappers::Default.new,
+              repository: RailsEventStoreActiveRecord::EventRepository.new(serializer: #{serializer}),
+              dispatcher: RubyEventStore::ComposedDispatcher.new(
+                RailsEventStore::AfterCommitAsyncDispatcher.new(scheduler: RailsEventStore::ActiveJobScheduler.new(serializer: #{serializer}),
+                RubyEventStore::Dispatcher.new
+              )
+            )
+          EOW
+          @serializer = serializer
+        end
+
         super(Pipeline.new(
-          transformations: [
-            Transformation::EventClassRemapper.new(events_class_remapping),
-            Transformation::SymbolizeMetadataKeys.new,
-            Transformation::Serialization.new(serializer: serializer),
-          ]
+          Transformation::EventClassRemapper.new(events_class_remapping),
+          Transformation::SymbolizeMetadataKeys.new,
         ))
       end
     end

data/lib/ruby_event_store/mappers/deprecated_wrapper.rb

@@ -0,0 +1,33 @@
+module RubyEventStore
+  module Mappers
+    class DeprecatedWrapper
+      def initialize(mapper)
+        @mapper = mapper
+      end
+
+      def serializer
+        @mapper.serializer
+      end
+
+      def event_to_record(any)
+        @mapper.event_to_record(any)
+      rescue NoMethodError => e
+        raise unless e.message =~ /undefined method `event_to_record/
+        warn <<~EOW
+          Deprecation: Please rename #{@mapper.class}#event_to_serialized_record to #{@mapper.class}#event_to_record.
+        EOW
+        @mapper.event_to_serialized_record(any)
+      end
+
+      def record_to_event(any)
+        @mapper.record_to_event(any)
+      rescue NoMethodError => e
+        raise unless e.message =~ /undefined method `record_to_event/
+        warn <<~EOW
+          Deprecation: Please rename #{@mapper.class}#serialized_record_to_event to #{@mapper.class}#record_to_event.
+        EOW
+        @mapper.serialized_record_to_event(any)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/encryption_mapper.rb

@@ -5,10 +5,7 @@ module RubyEventStore
     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),
-          ]
+          Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data),
         ))
       end
     end

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -8,18 +8,22 @@ module RubyEventStore
         @instrumentation = instrumentation
       end
 
-      def event_to_serialized_record(domain_event)
+      def event_to_record(domain_event)
         instrumentation.instrument("serialize.mapper.rails_event_store", domain_event: domain_event) do
-          mapper.event_to_serialized_record(domain_event)
+          mapper.event_to_record(domain_event)
         end
       end
 
-      def serialized_record_to_event(record)
+      def record_to_event(record)
         instrumentation.instrument("deserialize.mapper.rails_event_store", record: record) do
-          mapper.serialized_record_to_event(record)
+          mapper.record_to_event(record)
         end
       end
 
+      def serializer
+        mapper.serializer
+      end
+
       private
 
       attr_reader :instrumentation, :mapper

data/lib/ruby_event_store/mappers/json_mapper.rb

@@ -5,10 +5,8 @@ module RubyEventStore
     class JSONMapper < PipelineMapper
       def initialize(events_class_remapping: {})
         super(Pipeline.new(
-          transformations: [
-            Transformation::EventClassRemapper.new(events_class_remapping),
-            Transformation::SymbolizeMetadataKeys.new,
-          ],
+          Transformation::EventClassRemapper.new(events_class_remapping),
+          Transformation::SymbolizeMetadataKeys.new,
         ))
       end
     end

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -3,13 +3,13 @@
 module RubyEventStore
   module Mappers
     class Pipeline
-      def initialize(to_domain_event: Transformation::DomainEvent.new,
-                     to_serialized_record: Transformation::SerializedRecord.new,
-                     transformations: nil)
+      UNSET = Object.new.freeze
+
+      def initialize(*transformations_, transformations: UNSET, to_domain_event: Transformation::DomainEvent.new)
         @transformations = [
           to_domain_event,
-          Array(transformations),
-          to_serialized_record
+          deprecated_transformations(transformations),
+          transformations_,
         ].flatten.freeze
       end
 
@@ -26,6 +26,27 @@ module RubyEventStore
       end
 
       attr_reader :transformations
+
+      private
+
+      def deprecated_transformations(transformations)
+        case transformations
+        when UNSET
+          []
+        else
+          warn <<~EOW
+            Passing transformations via keyword parameter is deprecated.
+            Please use positional arguments from now on.
+          
+            Was:
+              RubyEventStore::Mappers::Pipeline.new(transformations: transformations)
+          
+            Is now:
+              RubyEventStore::Mappers::Pipeline.new(*transformations)
+          EOW
+          transformations
+        end
+      end
     end
   end
 end

data/lib/ruby_event_store/mappers/pipeline_mapper.rb

@@ -7,14 +7,18 @@ module RubyEventStore
         @pipeline = pipeline
       end
 
-      def event_to_serialized_record(domain_event)
+      def event_to_record(domain_event)
         pipeline.dump(domain_event)
       end
 
-      def serialized_record_to_event(record)
+      def record_to_event(record)
         pipeline.load(record)
       end
 
+      def serializer
+        NULL
+      end
+
       private
       attr_reader :pipeline
     end

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

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