ruby_event_store 1.2.2 → 2.1.0

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/instrumented_repository.rb

@@ -7,9 +7,9 @@ module RubyEventStore
       @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)
+    def append_to_stream(records, stream, expected_version)
+      instrumentation.instrument("append_to_stream.repository.rails_event_store", events: records, stream: stream) do
+        repository.append_to_stream(records, stream, expected_version)
       end
     end
 

data/lib/ruby_event_store/mappers/default.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module RubyEventStore
   module Mappers
     class Default < PipelineMapper
-      def initialize(serializer: YAML, events_class_remapping: {})
+      def initialize(events_class_remapping: {})
         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/encryption_mapper.rb

@@ -1,14 +1,13 @@
 # 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(
-          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,15 +8,15 @@ 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
 

data/lib/ruby_event_store/mappers/json_mapper.rb

@@ -2,14 +2,14 @@
 
 module RubyEventStore
   module Mappers
-    class JSONMapper < PipelineMapper
+    class JSONMapper < Default
       def initialize(events_class_remapping: {})
-        super(Pipeline.new(
-          transformations: [
-            Transformation::EventClassRemapper.new(events_class_remapping),
-            Transformation::SymbolizeMetadataKeys.new,
-          ],
-        ))
+        warn <<~EOW
+          Please replace RubyEventStore::Mappers::JSONMapper with RubyEventStore::Mappers::Default
+
+          They're now identical and the former will be removed in next major release.
+        EOW
+        super
       end
     end
   end

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -3,13 +3,10 @@
 module RubyEventStore
   module Mappers
     class Pipeline
-      def initialize(to_domain_event: Transformation::DomainEvent.new,
-                     to_serialized_record: Transformation::SerializedRecord.new,
-                     transformations: nil)
+      def initialize(*transformations, to_domain_event: Transformation::DomainEvent.new)
         @transformations = [
           to_domain_event,
-          Array(transformations),
-          to_serialized_record
+          transformations,
         ].flatten.freeze
       end
 

data/lib/ruby_event_store/mappers/pipeline_mapper.rb

@@ -7,11 +7,11 @@ 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
 

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

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

@@ -23,27 +23,35 @@ module RubyEventStore
           @forgotten_data = forgotten_data
         end
 
-        def dump(item)
-          data        = item.data
-          metadata    = item.metadata.dup
-          event_class = Object.const_get(item.event_type)
+        def dump(record)
+          data        = record.data
+          metadata    = record.metadata.dup
+          event_class = Object.const_get(record.event_type)
 
           crypto_description    = encryption_metadata(data, encryption_schema(event_class))
           metadata[:encryption] = crypto_description unless crypto_description.empty?
 
-          item.merge(
-            data: encrypt_data(deep_dup(data), crypto_description),
-            metadata: metadata
+          Record.new(
+            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,
           )
         end
 
-        def load(item)
-          metadata = item.metadata.dup
+        def load(record)
+          metadata = record.metadata.dup
           crypto_description = Hash(metadata.delete(:encryption))
 
-          item.merge(
-            data: decrypt_data(item.data, crypto_description),
-            metadata: metadata
+          Record.new(
+            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,
           )
         end
 

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

@@ -8,12 +8,19 @@ module RubyEventStore
           @class_map = class_map
         end
 
-        def dump(item)
-          item
+        def dump(record)
+          record
         end
 
-        def load(item)
-          item.merge(event_type: class_map[item.fetch(:event_type)] || item.fetch(:event_type))
+        def load(record)
+          Record.new(
+            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,
+          )
         end
 
         private

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

@@ -4,18 +4,23 @@ module RubyEventStore
   module Mappers
     module Transformation
       class StringifyMetadataKeys
-        def dump(item)
-          stringify(item)
+        def dump(record)
+          stringify(record)
         end
 
-        def load(item)
-          stringify(item)
+        def load(record)
+          stringify(record)
         end
 
         private
-        def stringify(item)
-          item.merge(
-            metadata: TransformKeys.stringify(item.metadata),
+        def stringify(record)
+          Record.new(
+            event_id:   record.event_id,
+            event_type: record.event_type,
+            data:       record.data,
+            metadata:   TransformKeys.stringify(record.metadata),
+            timestamp:  record.timestamp,
+            valid_at:   record.valid_at,
           )
         end
       end

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

@@ -4,18 +4,23 @@ module RubyEventStore
   module Mappers
     module Transformation
       class SymbolizeMetadataKeys
-        def dump(item)
-          symbolize(item)
+        def dump(record)
+          symbolize(record)
         end
 
-        def load(item)
-          symbolize(item)
+        def load(record)
+          symbolize(record)
         end
 
         private
-        def symbolize(item)
-          item.merge(
-            metadata: TransformKeys.symbolize(item.metadata),
+        def symbolize(record)
+          Record.new(
+            event_id:   record.event_id,
+            event_type: record.event_type,
+            data:       record.data,
+            metadata:   TransformKeys.symbolize(record.metadata),
+            timestamp:  record.timestamp,
+            valid_at:   record.valid_at,
           )
         end
       end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class Upcast
+        class RecordUpcaster
+          def initialize(upcast_map)
+            @upcast_map = upcast_map
+          end
+
+          def call(record)
+            identity   = lambda { |r| r }
+            new_record = @upcast_map.fetch(record.event_type, identity)[record]
+            if new_record.equal?(record)
+              record
+            else
+              call(new_record)
+            end
+          end
+        end
+
+        def initialize(upcast_map)
+          @record_upcaster = RecordUpcaster.new(upcast_map)
+        end
+
+        def dump(record)
+          record
+        end
+
+        def load(record)
+          @record_upcaster.call(record)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/null.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module NULL
+    def self.dump(value)
+      value
+    end
+
+    def self.load(value)
+      value
+    end
+  end
+end

data/lib/ruby_event_store/projection.rb

@@ -4,7 +4,8 @@ module RubyEventStore
   class Projection
     private_class_method :new
 
-    def self.from_stream(*streams)
+    def self.from_stream(stream_or_streams)
+      streams = Array(stream_or_streams)
       raise(ArgumentError, "At least one stream must be given") if streams.empty?
       new(streams: streams)
     end

data/lib/ruby_event_store/record.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class Record
+    StringsRequired = Class.new(StandardError)
+    def initialize(event_id:, data:, metadata:, event_type:, timestamp:, valid_at:)
+      raise StringsRequired unless [event_id, event_type].all? { |v| v.instance_of?(String) }
+      @event_id   = event_id
+      @data       = data
+      @metadata   = metadata
+      @event_type = event_type
+      @timestamp  = timestamp
+      @valid_at   = valid_at
+      @serialized_records = {}
+      freeze
+    end
+
+    attr_reader :event_id, :data, :metadata, :event_type, :timestamp, :valid_at
+
+    BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110011
+    def hash
+      [
+        self.class,
+        event_id,
+        data,
+        metadata,
+        event_type,
+        timestamp,
+        valid_at,
+      ].hash ^ BIG_VALUE
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) &&
+        other.event_id.eql?(event_id) &&
+        other.data.eql?(data) &&
+        other.metadata.eql?(metadata) &&
+        other.event_type.eql?(event_type) &&
+        other.timestamp.eql?(timestamp) &&
+        other.valid_at.eql?(valid_at)
+    end
+
+    def to_h
+      {
+        event_id: event_id,
+        data: data,
+        metadata: metadata,
+        event_type: event_type,
+        timestamp: timestamp,
+        valid_at: valid_at,
+      }
+    end
+
+    def serialize(serializer)
+      @serialized_records[serializer] ||=
+        SerializedRecord.new(
+          event_id:   event_id,
+          event_type: event_type,
+          data:       serializer.dump(data),
+          metadata:   serializer.dump(metadata),
+          timestamp:  timestamp.iso8601(TIMESTAMP_PRECISION),
+          valid_at:   valid_at.iso8601(TIMESTAMP_PRECISION),
+        )
+    end
+
+    alias_method :eql?, :==
+  end
+end