ruby_event_store 1.2.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eae1c274df87ef18c1b104d552c32e3354a90ee7bd08c536b14ef730da4e121
-  data.tar.gz: 5a102bbd8e4004244bd585a4f5a54d678ec140a1c9fd5ba976673a0c852c1c65
+  metadata.gz: 88203a9b943002241df25fa83c6f067e7944810e66d713eeb11e8cebf13271e2
+  data.tar.gz: 1b032e898517d787a2e6d0cb6b15775792591abc094e68d2483590f916e69c9e
 SHA512:
-  metadata.gz: f29812644675d45f21308cca20153cc9f31c2b371f8016037f057cde0ca575e006b2cb664b217c99435a7bef4c4b397f0c3c36c265649db28902fbbb0c75243c
-  data.tar.gz: e57b1936392592ea8eb8c10fda83459edfaece59af3d7ac6f538cbffb2f846fe807c7f17308808dbc04fd7eedeb258e3b8cfab589b317073b9e9c8a414369d29
+  metadata.gz: 780c9e0f6064311d45be29c0553c47e65e679a3967b91e6caca48a55ef9c34a06070e421b1413c1a35634c6e45c1452204ac29fae2aa706fe7a0e46d1dd99f40
+  data.tar.gz: 66b7a11ce2d3b58a5f9c2690a7f7f998fc9130c302343923cdd5a57a63d6a398ea258cced2d1b3161e07d9fb081d04bd7c4f305d6576cae59bd6e50f50ba6a92

data/README.md

@@ -1,3 +1,5 @@
 # RubyEventStore
 
-A Ruby implementation of an EventStore. It is an integral part of `rails_event_store` gem.
+Ruby implementation of an event store. Ships with in-memory event repository, generic instrumentation and dispatches events synchronously.
+
+Find out more at [https://railseventstore.org](https://railseventstore.org/)

data/lib/ruby_event_store.rb

@@ -15,19 +15,16 @@ require 'ruby_event_store/specification_reader'
 require 'ruby_event_store/event'
 require 'ruby_event_store/stream'
 require 'ruby_event_store/expected_version'
+require 'ruby_event_store/record'
 require 'ruby_event_store/serialized_record'
+require 'ruby_event_store/null'
 require 'ruby_event_store/transform_keys'
 require 'ruby_event_store/mappers/encryption_key'
 require 'ruby_event_store/mappers/in_memory_encryption_key_repository'
 require 'ruby_event_store/mappers/transformation/domain_event'
 require 'ruby_event_store/mappers/transformation/encryption'
 require 'ruby_event_store/mappers/transformation/event_class_remapper'
-require 'ruby_event_store/mappers/transformation/item'
-require 'ruby_event_store/mappers/transformation/proto_event'
-require 'ruby_event_store/mappers/transformation/protobuf_encoder'
-require 'ruby_event_store/mappers/transformation/protobuf_nested_struct_metadata'
-require 'ruby_event_store/mappers/transformation/serialization'
-require 'ruby_event_store/mappers/transformation/serialized_record'
+require 'ruby_event_store/mappers/transformation/upcast'
 require 'ruby_event_store/mappers/transformation/stringify_metadata_keys'
 require 'ruby_event_store/mappers/transformation/symbolize_metadata_keys'
 require 'ruby_event_store/mappers/pipeline'
@@ -38,7 +35,6 @@ require 'ruby_event_store/mappers/encryption_mapper'
 require 'ruby_event_store/mappers/instrumented_mapper'
 require 'ruby_event_store/mappers/json_mapper'
 require 'ruby_event_store/mappers/null_mapper'
-require 'ruby_event_store/mappers/protobuf'
 require 'ruby_event_store/batch_enumerator'
 require 'ruby_event_store/correlated_commands'
 require 'ruby_event_store/link_by_metadata'

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
+      @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
 
@@ -58,7 +64,7 @@ module RubyEventStore
     # @param expected_version (see #publish)
     # @return [self]
     def link(event_ids, stream_name:, expected_version: :any)
-      repository.link_to_stream(event_ids, Stream.new(stream_name), ExpectedVersion.new(expected_version))
+      repository.link_to_stream(Array(event_ids), Stream.new(stream_name), ExpectedVersion.new(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)
+    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 = 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 = 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