ruby_event_store 1.3.1 → 2.0.3

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

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

@@ -7,26 +7,28 @@ module RubyEventStore
     module Transformation
       class Serialization
         def initialize(serializer: YAML)
-          @serializer = serializer
+          warn <<~EOW
+            #{self.class} has been deprecated and is effectively no-op. You should remove this transformation from your pipeline.
+
+            Instead, pass the serializer 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(
+                RubyEventStore::ImmediateAsyncDispatcher.new(scheduler: ActiveJobScheduler.new(serializer: #{serializer}),
+                RubyEventStore::Dispatcher.new
+              )
+            )
+          EOW
         end
-        attr_reader :serializer
 
         def dump(item)
-          Item.new(
-            event_id:   item.event_id,
-            metadata:   serializer.dump(item.metadata),
-            data:       serializer.dump(item.data),
-            event_type: item.event_type
-          )
+          item
         end
 
         def load(item)
-          Item.new(
-            event_id:   item.event_id,
-            metadata:   serializer.load(item.metadata),
-            data:       serializer.load(item.data),
-            event_type: item.event_type
-          )
+          item
         end
       end
     end

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/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,19 +4,8 @@ module RubyEventStore
   class Projection
     private_class_method :new
 
-    def self.from_stream(*streams)
-      first_of_streams = streams.first
-      if first_of_streams.respond_to?(:flatten)
-        warn <<~EOW
-          Passing array to .from_stream is not supported. This method expects undefined number 
-          of positional arguments (splat) rather than an array.
-  
-          Expected: .from_stream(#{first_of_streams.map(&:inspect).join(", ")})
-          Received: .from_stream(#{first_of_streams})
-        EOW
-        streams = first_of_streams
-      end
-
+    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

data/lib/ruby_event_store/serialized_record.rb

@@ -3,18 +3,20 @@
 module RubyEventStore
   class SerializedRecord
     StringsRequired = Class.new(StandardError)
-    def initialize(event_id:, data:, metadata:, event_type:)
+    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
       freeze
     end
 
-    attr_reader :event_id, :data, :metadata, :event_type
+    attr_reader :event_id, :data, :metadata, :event_type, :timestamp, :valid_at
 
-    BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110011
+    BIG_VALUE = 0b110011100100000010010010110011101011110101010101001100111110111
     def hash
       [
         self.class,
@@ -22,6 +24,8 @@ module RubyEventStore
         data,
         metadata,
         event_type,
+        timestamp,
+        valid_at,
       ].hash ^ BIG_VALUE
     end
 
@@ -30,7 +34,9 @@ module RubyEventStore
         other.event_id.eql?(event_id) &&
         other.data.eql?(data) &&
         other.metadata.eql?(metadata) &&
-        other.event_type.eql?(event_type)
+        other.event_type.eql?(event_type) &&
+        other.timestamp.eql?(timestamp) &&
+        other.valid_at.eql?(valid_at)
     end
 
     def to_h
@@ -39,9 +45,22 @@ module RubyEventStore
         data: data,
         metadata: metadata,
         event_type: event_type,
+        timestamp: timestamp,
+        valid_at: valid_at,
       }
     end
 
+    def deserialize(serializer)
+      Record.new(
+        event_id:   event_id,
+        event_type: event_type,
+        data:       serializer.load(data),
+        metadata:   serializer.load(metadata),
+        timestamp:  Time.iso8601(timestamp),
+        valid_at:   Time.iso8601(valid_at),
+      )
+    end
+
     alias_method :eql?, :==
   end
 end

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -1,6 +1,6 @@
 RSpec.shared_examples :broker do |broker_klass|
   let(:event) { instance_double(::RubyEventStore::Event, event_type: 'EventType') }
-  let(:serialized_event) { instance_double(::RubyEventStore::SerializedRecord)  }
+  let(:record) { instance_double(::RubyEventStore::Record)  }
   let(:handler) { HandlerClass.new }
   let(:subscriptions) { ::RubyEventStore::Subscriptions.new }
   let(:dispatcher) { ::RubyEventStore::Dispatcher.new }
@@ -9,26 +9,26 @@ RSpec.shared_examples :broker do |broker_klass|
   specify "no dispatch when no subscriptions" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([])
     expect(dispatcher).not_to receive(:call)
-    broker.call(event, serialized_event)
+    broker.call(event, record)
   end
 
   specify "calls subscription" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler])
-    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
-    broker.call(event, serialized_event)
+    expect(dispatcher).to receive(:call).with(handler, event, record)
+    broker.call(event, record)
   end
 
   specify "calls subscribed class" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([HandlerClass])
-    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
-    broker.call(event, serialized_event)
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
+    broker.call(event, record)
   end
 
   specify "calls all subscriptions" do
     expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler, HandlerClass])
-    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
-    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
-    broker.call(event, serialized_event)
+    expect(dispatcher).to receive(:call).with(handler, event, record)
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
+    broker.call(event, record)
   end
 
   specify 'raise error when no subscriber' do