Events mappers / serialisers proposal (#168)

* wip: extracted creating and building of the event to mapper

* fix for accidential change.

* small refactor to avoid code duplicity

* moved back responsibility of Event record creation back to repository

* removed DI from YAML mapper, following the code review feedback

* moved nil check back to repository

* refactored hash to event factorization

* cleanup of code style

* rename methods to show intent

* moving condition to specific use case method

* cleanup

* SerializedRecord contract introduced

* fixed remapping mapper example

* added serialized record

* move of mapper to ruby event store

* added missing spec, enforced contract of configuration

* cleanup in contract validation

* added constantize via activesupport gem

* cleanup all constantizer

* improved specs regards to mutant feedback

* refactored based on code review feedback

* refactored based on code review feedback

* refactored based on code review feedback

* refactored based on code review feedback

* adjusted styling in rspec

* adjusted styling in rspec

* fixed spec following mutant feedback

* fix for specs following mutant feedback

Author: andrzejsliwa

rails_event_store_active_record/lib/rails_event_store_active_record/event.rb

@@ -4,8 +4,6 @@ module RailsEventStoreActiveRecord
   class Event < ::ActiveRecord::Base
     self.primary_key = :id
     self.table_name = 'event_store_events'
-    serialize :metadata
-    serialize :data
   end
 
   class EventInStream < ::ActiveRecord::Base

rails_event_store_active_record/lib/rails_event_store_active_record/event_repository.rb

@@ -6,8 +6,9 @@ class EventRepository
 
     POSITION_SHIFT = 1
 
-    def initialize
+    def initialize(mapper: RubyEventStore::Mappers::Default.new)
       verify_correct_schema_present
+      @mapper = mapper
     end
 
     def append_to_stream(events, stream_name, expected_version)
@@ -32,12 +33,7 @@ def append_to_stream(events, stream_name, expected_version)
           position = unless expected_version.equal?(:any)
             expected_version + index + POSITION_SHIFT
           end
-          Event.create!(
-            id: event.event_id,
-            data: event.data,
-            metadata: event.metadata,
-            event_type: event.class,
-          )
+          build_event_record(event).save!
           events = [{
             stream: RubyEventStore::GLOBAL_STREAM,
             position: nil,
@@ -69,9 +65,8 @@ def has_event?(event_id)
     end
 
     def last_stream_event(stream_name)
-      build_event_entity(
-        EventInStream.where(stream: stream_name).order('position DESC, id DESC').first
-      )
+      record = EventInStream.where(stream: stream_name).order('position DESC, id DESC').first
+      record && build_event_instance(record)
     end
 
     def read_events_forward(stream_name, after_event_id, count)
@@ -82,7 +77,7 @@ def read_events_forward(stream_name, after_event_id, count)
       end
 
       stream.preload(:event).order('position ASC, id ASC').limit(count)
-        .map(&method(:build_event_entity))
+        .map(&method(:build_event_instance))
     end
 
     def read_events_backward(stream_name, before_event_id, count)
@@ -93,17 +88,17 @@ def read_events_backward(stream_name, before_event_id, count)
       end
 
       stream.preload(:event).order('position DESC, id DESC').limit(count)
-        .map(&method(:build_event_entity))
+        .map(&method(:build_event_instance))
     end
 
     def read_stream_events_forward(stream_name)
       EventInStream.preload(:event).where(stream: stream_name).order('position ASC, id ASC')
-        .map(&method(:build_event_entity))
+        .map(&method(:build_event_instance))
     end
 
     def read_stream_events_backward(stream_name)
       EventInStream.preload(:event).where(stream: stream_name).order('position DESC, id DESC')
-        .map(&method(:build_event_entity))
+        .map(&method(:build_event_instance))
     end
 
     def read_all_streams_forward(after_event_id, count)
@@ -114,7 +109,7 @@ def read_all_streams_forward(after_event_id, count)
       end
 
       stream.preload(:event).order('id ASC').limit(count)
-        .map(&method(:build_event_entity))
+        .map(&method(:build_event_instance))
     end
 
     def read_all_streams_backward(before_event_id, count)
@@ -125,24 +120,37 @@ def read_all_streams_backward(before_event_id, count)
       end
 
       stream.preload(:event).order('id DESC').limit(count)
-        .map(&method(:build_event_entity))
+        .map(&method(:build_event_instance))
     end
 
     private
 
+    attr_reader :mapper
+
     def detect_pkey_index_violated(e)
       e.message.include?("for key 'PRIMARY'")       ||  # MySQL
       e.message.include?("event_store_events_pkey") ||  # Postgresql
       e.message.include?("event_store_events.id")       # Sqlite3
     end
 
-    def build_event_entity(record)
-      return nil unless record
-      record.event.event_type.constantize.new(
-        event_id: record.event.id,
-        metadata: record.event.metadata,
-        data: record.event.data
+    def build_event_record(event)
+      serialized_record = mapper.event_to_serialized_record(event)
+      Event.new(
+        id:         serialized_record.event_id,
+        data:       serialized_record.data,
+        metadata:   serialized_record.metadata,
+        event_type: serialized_record.event_type
+      )
+    end
+
+    def build_event_instance(record)
+      serialized_record = RubyEventStore::SerializedRecord.new(
+        event_id:         record.event.id,
+        metadata:   record.event.metadata,
+        data:       record.event.data,
+        event_type: record.event.event_type
       )
+      mapper.serialized_record_to_event(serialized_record)
     end
 
     def normalize_to_array(events)

ruby_event_store/Makefile

@@ -10,7 +10,7 @@ test: ## Run tests
 
 mutate: test  ## Run mutation tests
 	@echo "Running mutation tests - only 100% free mutation will be accepted"
-	@bundle exec mutant --include lib --require ruby_event_store --use rspec "RubyEventStore*" --ignore-subject "RubyEventStore.const_missing" --ignore-subject "RubyEventStore::InMemoryRepository#append_with_synchronize" --ignore-subject "RubyEventStore::InMemoryRepository#normalize_to_array" --ignore-subject "RubyEventStore::Client#normalize_to_array"
+	@bundle exec mutant --include lib --require ruby_event_store --use rspec "RubyEventStore*" --ignore-subject "RubyEventStore.const_missing" --ignore-subject "RubyEventStore::InMemoryRepository#append_with_synchronize" --ignore-subject "RubyEventStore::InMemoryRepository#normalize_to_array" --ignore-subject "RubyEventStore::Client#normalize_to_array" --ignore-subject "RubyEventStore::SerializedRecord"
 
 build:
 	@gem build -V ruby_event_store.gemspec

ruby_event_store/lib/ruby_event_store.rb

@@ -7,4 +7,6 @@
 require 'ruby_event_store/client'
 require 'ruby_event_store/event'
 require 'ruby_event_store/deprecations'
+require 'ruby_event_store/serialized_record'
+require 'ruby_event_store/mappers/default'
 require 'ruby_event_store/version'

ruby_event_store/lib/ruby_event_store/mappers/default.rb

@@ -0,0 +1,35 @@
+require 'yaml'
+require 'active_support'
+
+module RubyEventStore
+  module Mappers
+    class Default
+      def initialize(serializer: YAML, events_class_remapping: {})
+        @serializer = serializer
+        @events_class_remapping = events_class_remapping
+      end
+
+      def event_to_serialized_record(domain_event)
+        SerializedRecord.new(
+          event_id:         domain_event.event_id,
+          metadata:   serializer.dump(domain_event.metadata),
+          data:       serializer.dump(domain_event.data),
+          event_type: domain_event.class.name
+        )
+      end
+
+      def serialized_record_to_event(record)
+        event_type = events_class_remapping.fetch(record.event_type) { record.event_type }
+        ActiveSupport::Inflector.constantize(event_type).new(
+          event_id: record.event_id,
+          metadata: serializer.load(record.metadata),
+          data:     serializer.load(record.data)
+        )
+      end
+
+      private
+
+      attr_reader :serializer, :events_class_remapping
+    end
+  end
+end

ruby_event_store/lib/ruby_event_store/serialized_record.rb

@@ -0,0 +1,15 @@
+module RubyEventStore
+  class SerializedRecord
+    StringsRequired = Class.new(StandardError)
+    def initialize(event_id:, data:, metadata:, event_type:)
+      raise StringsRequired unless [event_id, data, metadata, event_type].all? { |v| v.instance_of?(String) }
+      @event_id   = event_id
+      @data       = data
+      @metadata   = metadata
+      @event_type = event_type
+      freeze
+    end
+
+    attr_reader :event_id, :data, :metadata, :event_type
+  end
+end

ruby_event_store/ruby_event_store.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+
+  spec.add_dependency 'activesupport'
   spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.6'

ruby_event_store/spec/mappers/default_spec.rb

@@ -0,0 +1,95 @@
+SomethingHappened = Class.new(RubyEventStore::Event)
+
+module RubyEventStore
+  module Mappers
+    RSpec.describe Default do
+      let(:data)         { {some_attribute: 5} }
+      let(:metadata)     { {some_meta: 1} }
+      let(:event_id)     { SecureRandom.uuid }
+      let(:domain_event) { SomethingHappened.new(data: data, metadata: metadata, event_id: event_id) }
+
+      specify '#event_to_serialized_record returns YAML serialized record' do
+        record = subject.event_to_serialized_record(domain_event)
+        expect(record).to            be_a SerializedRecord
+        expect(record.event_id).to   eq event_id
+        expect(record.data).to       eq "---\n:some_attribute: 5\n"
+        expect(record.metadata).to   eq "---\n:some_meta: 1\n"
+        expect(record.event_type).to eq "SomethingHappened"
+      end
+
+      specify '#serialized_record_to_event returns event instance' do
+        record = SerializedRecord.new(
+          event_id:   domain_event.event_id,
+          data:       "---\n:some_attribute: 5\n",
+          metadata:   "---\n:some_meta: 1\n",
+          event_type: SomethingHappened.name
+        )
+        event = subject.serialized_record_to_event(record)
+        expect(event).to              eq(domain_event)
+        expect(event.event_id).to     eq domain_event.event_id
+        expect(event.data).to         eq(data)
+        expect(event.metadata).to     eq(metadata)
+      end
+
+      specify '#serialized_record_to_event its using events class remapping' do
+        subject = described_class.new(events_class_remapping: {'EventNameBeforeRefactor' => 'SomethingHappened'})
+        record = SerializedRecord.new(
+          event_id:   domain_event.event_id,
+          data:       "---\n:some_attribute: 5\n",
+          metadata:   "---\n:some_meta: 1\n",
+          event_type: "EventNameBeforeRefactor"
+        )
+        event = subject.serialized_record_to_event(record)
+        expect(event).to eq(domain_event)
+      end
+
+      context 'when custom serializer is provided' do
+        class ExampleYamlSerializer
+          def self.load(value)
+            YAML.load(decrypt(value))
+          end
+
+          def self.dump(value)
+            encrypt(YAML.dump(value))
+          end
+
+          private
+
+          def self.encrypt(value)
+            value.reverse
+          end
+
+          def self.decrypt(value)
+            value.reverse
+          end
+        end
+
+        let(:custom_serializer) { ExampleYamlSerializer }
+        subject { described_class.new(serializer: custom_serializer) }
+
+        specify '#event_to_serialized_record returns serialized record' do
+          record = subject.event_to_serialized_record(domain_event)
+          expect(record).to            be_a SerializedRecord
+          expect(record.event_id).to   eq event_id
+          expect(record.data).to       eq "\n5 :etubirtta_emos:\n---"
+          expect(record.metadata).to   eq "\n1 :atem_emos:\n---"
+          expect(record.event_type).to eq "SomethingHappened"
+        end
+
+        specify '#serialized_record_to_event returns event instance' do
+          record = SerializedRecord.new(
+            event_id:   domain_event.event_id,
+            data:       "\n5 :etubirtta_emos:\n---",
+            metadata:   "\n1 :atem_emos:\n---",
+            event_type: SomethingHappened.name
+          )
+          event = subject.serialized_record_to_event(record)
+          expect(event).to              eq(domain_event)
+          expect(event.event_id).to     eq domain_event.event_id
+          expect(event.data).to         eq(data)
+          expect(event.metadata).to     eq(metadata)
+        end
+      end
+    end
+  end
+end

ruby_event_store/spec/serialized_record_spec.rb

@@ -0,0 +1,38 @@
+module RubyEventStore
+
+  RSpec.describe SerializedRecord do
+    let(:event_id)   { "event_id" }
+    let(:data)       { "data" }
+    let(:metadata)   { "metadata" }
+    let(:event_type) { "event_type" }
+
+    specify 'constructor accept all arguments and returns frozen instance' do
+      record = described_class.new(event_id: event_id, data: data, metadata: metadata, event_type: event_type)
+      expect(record.event_id).to   be event_id
+      expect(record.metadata).to   be metadata
+      expect(record.data).to       be data
+      expect(record.event_type).to be event_type
+      expect(record.frozen?).to    be true
+    end
+
+    specify 'constructor raised SerializedRecord::StringsRequired when argument is not a String' do
+      [[1, 1, 1, 1],
+       [1, "string", "string", "string"],
+       ["string", 1, "string", "string"],
+       ["string", "string", 1, "string"],
+       ["string", "string", "string", 1]].each do |sample|
+        event_id, data, metadata, event_type = sample
+        expect do
+          described_class.new(event_id: event_id, data: data, metadata: metadata, event_type: event_type)
+        end.to raise_error SerializedRecord::StringsRequired
+      end
+    end
+
+    specify 'constructor raised when required args are missing' do
+      expect do
+        described_class.new
+      end.to raise_error ArgumentError
+    end
+  end
+end
+