ruby_event_store 1.3.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88193e00bf9ebd58347de1cb3cf58848cc4b09abc603ffef5fb85b2565bf0b74
-  data.tar.gz: 744d44d76c00843f897c321919eed85b9597063d44a52328f7616c6682063d90
+  metadata.gz: 285893bc28288225780ac559aa8a3ef11e1b5a769870f5821161273b7087b3bb
+  data.tar.gz: 43112f7f7bc9e0e1cbc38f0a5d3e574575b91e94f208803e533ffe0f4b782b04
 SHA512:
-  metadata.gz: ffd5f11e365d901d7bdf7a6c5d78cad674166416dcd44cd8448982dbe23d8a243ea72b3f66e02c4cab134ef87e3f5d0e519e4de0a913bf26390f7867cc5318d8
-  data.tar.gz: 3044ebfc2ca93c1b5c5fa40afd250c8aac8edc1c5299444b6094df17d1b5214b19400070761a408f8816dbe507fb52c2063587fdd428f911470310ef26434778
+  metadata.gz: 376292ff1199abb79bc64adfea0335b8c9b898963313a9d136b943eea666319cefeeceb8891c305d7fe51e1985fe151a27713ae14dc33038858f6c4a34bb024d
+  data.tar.gz: 62f53d5723681398e5ad972b2807248912e7e0b610b3bc8790bba5c9a107a1f8da132e279b79ac246dff80efac8b3a7c895f2691496a4bf156d8720bc36727ef

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,121 @@
+GIT
+  remote: https://github.com/ruby-concurrency/concurrent-ruby.git
+  revision: c4cbc968c55e5b983dae953095761896220c46d1
+  ref: c4cbc968c55e5b983dae953095761896220c46d1
+  specs:
+    concurrent-ruby (1.1.7)
+
+PATH
+  remote: .
+  specs:
+    ruby_event_store (2.0.3)
+      concurrent-ruby (~> 1.0, >= 1.1.6)
+
+GEM
+  remote: https://oss:7AXfeZdAfCqL1PvHm2nvDJO6Zd9UW8IK@gem.mutant.dev/
+  specs:
+    abstract_type (0.0.7)
+    adamantium (0.2.0)
+      ice_nine (~> 0.11.0)
+      memoizable (~> 0.4.0)
+    anima (0.3.2)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2)
+      equalizer (~> 0.0.11)
+    ast (2.4.1)
+    concord (0.1.6)
+      adamantium (~> 0.2.0)
+      equalizer (~> 0.0.9)
+    diff-lcs (1.4.4)
+    equalizer (0.0.11)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    ice_nine (0.11.2)
+    memoizable (0.4.2)
+      thread_safe (~> 0.3, >= 0.3.1)
+    minitest (5.14.2)
+    mprelude (0.1.0)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      concord (~> 0.1.5)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.1)
+      procto (~> 0.0.2)
+    mutant-license (0.1.1.2.1627430819213747598431630701693729869473.0)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    procto (0.0.3)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.1)
+    thread_safe (0.3.6)
+    tzinfo (1.2.9)
+      thread_safe (~> 0.1)
+    unparser (0.5.6)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.1)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.3)
+      equalizer (~> 0.0.9)
+      mprelude (~> 0.1.0)
+      parser (>= 3.0.0)
+      procto (~> 0.0.2)
+    variable (0.0.1)
+      equalizer (~> 0.0.11)
+    zeitwerk (2.4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.0.3.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    mutant (0.10.22)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.1)
+      ast (~> 2.2)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.3)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.1)
+      memoizable (~> 0.4.2)
+      mprelude (~> 0.1.0)
+      parser (~> 3.0.0)
+      procto (~> 0.0.2)
+      unparser (~> 0.5.6)
+      variable (~> 0.0.1)
+    mutant-rspec (0.10.22)
+      mutant (= 0.10.22)
+      rspec-core (>= 3.8.0, < 4.0.0)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (= 6.0.3.4)
+  concurrent-ruby!
+  mutant (~> 0.10.21)
+  mutant-license!
+  mutant-rspec (~> 0.10.21)
+  rake (>= 10.0)
+  rspec (~> 3.6)
+  ruby_event_store!
+
+BUNDLED WITH
+   2.2.27

data/Makefile

@@ -1,17 +1,27 @@
 GEM_VERSION = $(shell cat ../RES_VERSION)
 GEM_NAME    = ruby_event_store
 REQUIRE     = $(GEM_NAME)
-IGNORE      = RubyEventStore::InMemoryRepository\#append_with_synchronize \
+IGNORE      = RubyEventStore::InMemoryRepository\#with_synchronize \
+              RubyEventStore::Client\#initialize \
+              RubyEventStore::Client\#default_clock \
+              RubyEventStore::Client\#default_correlation_id_generator \
               RubyEventStore::Client::Within\#add_thread_subscribers \
               RubyEventStore::Client::Within\#add_thread_global_subscribers \
               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
+              RubyEventStore::Mappers::EncryptionKey\#ciphertext_from_authenticated \
+              RubyEventStore::Mappers::Default\#serializer \
+              RubyEventStore::Mappers::JSONMapper\#serializer \
+              RubyEventStore::Mappers::NullMapper\#serializer \
+              RubyEventStore::Mappers::EncryptionMapper\#serializer \
+              RubyEventStore::Mappers::PipelineMapper\#serializer \
+              RubyEventStore::Mappers::DeprecatedWrapper\#serializer \
+              RubyEventStore::Mappers::InstrumentedMapper\#serializer \
+              RubyEventStore::Mappers::Transformation::Serialization*
 
 SUBJECT     ?= RubyEventStore*
 

data/lib/ruby_event_store/broker.rb

@@ -7,10 +7,10 @@ module RubyEventStore
       @dispatcher = dispatcher
     end
 
-    def call(event, serialized_event)
+    def call(event, record)
       subscribers = subscriptions.all_for(event.event_type)
       subscribers.each do |subscriber|
-        dispatcher.call(subscriber, event, serialized_event)
+        dispatcher.call(subscriber, event, record)
       end
     end
 
@@ -35,7 +35,7 @@ module RubyEventStore
     end
 
     private
-    attr_reader :subscriptions, :dispatcher
+    attr_reader :dispatcher, :subscriptions
 
     def verify_subscription(subscriber)
       raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber

data/lib/ruby_event_store/client.rb

@@ -10,8 +10,11 @@ module RubyEventStore
                    dispatcher: Dispatcher.new,
                    clock: default_clock,
                    correlation_id_generator: default_correlation_id_generator)
+
+
       @repository     = repository
-      @mapper         = mapper
+      @mapper         = Mappers::DeprecatedWrapper.new(mapper)
+      @subscriptions  = subscriptions
       @broker         = Broker.new(subscriptions: subscriptions, dispatcher: dispatcher)
       @clock          = clock
       @metadata       = Concurrent::ThreadLocalVar.new
@@ -21,20 +24,20 @@ module RubyEventStore
 
     # Persists events and notifies subscribed handlers about them
     #
-    # @param events [Array<Event, Proto>, Event, Proto] event(s)
+    # @param events [Array<Event>, Event] 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|
+      records         = transform(enriched_events)
+      append_records_to_stream(records, stream_name: stream_name, expected_version: expected_version)
+      enriched_events.zip(records) do |event, record|
         with_metadata(
           correlation_id: event.metadata.fetch(:correlation_id),
           causation_id:   event.event_id,
         ) do
-          broker.(event, serialized_event)
+          broker.(event, record)
         end
       end
       self
@@ -45,8 +48,11 @@ module RubyEventStore
     # @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)
+      append_records_to_stream(
+        transform(enrich_events_metadata(events)),
+        stream_name: stream_name,
+        expected_version: expected_version
+      )
       self
     end
 
@@ -121,6 +127,14 @@ module RubyEventStore
       broker.add_global_subscription(subscriber || proc)
     end
 
+    # Get list of handlers subscribed to an event
+    #
+    # @param to [Class, String] type of events to get list of sybscribed handlers
+    # @return [Array<Object, Class>]
+    def subscribers_for(event_type)
+      subscriptions.all_for(event_type.to_s)
+    end
+
     # Builder object for collecting temporary handlers (subscribers)
     # which are active only during the invocation of the provided
     # block of code.
@@ -222,9 +236,22 @@ module RubyEventStore
     # 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))
+    # @return [Event] deserialized event
+    def deserialize(serializer:, event_type:, event_id:, data:, metadata:, timestamp: nil, valid_at: nil)
+      extract_timestamp = lambda do |m|
+        (m[:timestamp] || Time.parse(m.fetch('timestamp'))).iso8601
+      end
+
+      mapper.record_to_event(
+        SerializedRecord.new(
+          event_type: event_type,
+          event_id:   event_id,
+          data:       data,
+          metadata:   metadata,
+          timestamp:  timestamp || timestamp_ = extract_timestamp[serializer.load(metadata)],
+          valid_at:   valid_at  || timestamp_,
+        ).deserialize(serializer)
+      )
     end
 
     # Read additional metadata which will be added for published events
@@ -262,12 +289,10 @@ module RubyEventStore
     #   end
     #   event_store.overwrite(events)
     #
-    # @param events [Array<Event, Proto>, Event, Proto] event(s) to serialize and overwrite again
+    # @param events [Array<Event>, Event] 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)
+      repository.update_messages(transform(Array(events_or_event)))
       self
     end
 
@@ -280,10 +305,8 @@ module RubyEventStore
 
     private
 
-    def serialize_events(events)
-      events.map do |ev|
-        mapper.event_to_serialized_record(ev)
-      end
+    def transform(events)
+      events.map { |ev| mapper.event_to_record(ev) }
     end
 
     def enrich_events_metadata(events)
@@ -295,11 +318,12 @@ module RubyEventStore
     def enrich_event_metadata(event)
       metadata.each { |key, value| event.metadata[key] ||= value }
       event.metadata[:timestamp]      ||= clock.call
+      event.metadata[:valid_at]       ||= event.metadata.fetch(:timestamp)
       event.metadata[:correlation_id] ||= correlation_id_generator.call
     end
 
-    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))
+    def append_records_to_stream(records, stream_name:, expected_version:)
+      repository.append_to_stream(records, Stream.new(stream_name), ExpectedVersion.new(expected_version))
     end
 
     protected
@@ -309,13 +333,13 @@ module RubyEventStore
     end
 
     def default_clock
-      ->{ Time.now.utc }
+      ->{ Time.now.utc.round(TIMESTAMP_PRECISION) }
     end
 
     def default_correlation_id_generator
       ->{ SecureRandom.uuid }
     end
 
-    attr_reader :repository, :mapper, :broker, :clock, :correlation_id_generator
+    attr_reader :repository, :mapper, :subscriptions, :broker, :clock, :correlation_id_generator
   end
 end

data/lib/ruby_event_store/composed_dispatcher.rb

@@ -6,10 +6,10 @@ module RubyEventStore
       @dispatchers = dispatchers
     end
 
-    def call(subscriber, event, serialized_event)
+    def call(subscriber, event, record)
       @dispatchers.each do |dispatcher|
         if dispatcher.verify(subscriber)
-          dispatcher.call(subscriber, event, serialized_event)
+          dispatcher.call(subscriber, event, record)
           break
         end
       end

data/lib/ruby_event_store/constants.rb

@@ -3,4 +3,5 @@
 module RubyEventStore
   GLOBAL_STREAM = Object.new
   PAGE_SIZE = 100.freeze
+  TIMESTAMP_PRECISION = 6
 end

data/lib/ruby_event_store/errors.rb

@@ -12,7 +12,6 @@ module RubyEventStore
   EventDuplicatedInStream   = Class.new(Error)
   ReservedInternalName      = Class.new(Error)
   InvalidHandler            = Class.new(Error)
-  ProtobufEncodingFailed    = Class.new(Error)
 
   class EventNotFound < Error
     attr_reader :event_id

data/lib/ruby_event_store/event.rb

@@ -41,6 +41,13 @@ module RubyEventStore
       metadata[:timestamp]
     end
 
+    # Validity time from metadata
+    #
+    # @return [Time, nil]
+    def valid_at
+      metadata[:valid_at]
+    end
+
     # Two events are equal if:
     # * they are of the same class
     # * have identical event id
@@ -116,7 +123,7 @@ module RubyEventStore
     # 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.
+    # @param other_message [Event, 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

data/lib/ruby_event_store/immediate_async_dispatcher.rb

@@ -6,8 +6,8 @@ module RubyEventStore
       @scheduler = scheduler
     end
 
-    def call(subscriber, _, serialized_event)
-      @scheduler.call(subscriber, serialized_event)
+    def call(subscriber, _, record)
+      @scheduler.call(subscriber, record)
     end
 
     def verify(subscriber)

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,53 +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)}
-        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
+    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
@@ -108,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