ruby_event_store 1.3.1 → 2.0.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/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