ruby_event_store 0.30.0 → 1.3.1

data/lib/ruby_event_store/mappers/in_memory_encryption_key_repository.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class InMemoryEncryptionKeyRepository
+      DEFAULT_CIPHER = 'aes-256-gcm'.freeze
+
+      def initialize
+        @keys = {}
+      end
+
+      def key_of(identifier, cipher: DEFAULT_CIPHER)
+        @keys[[identifier, cipher]]
+      end
+
+      def create(identifier, cipher: DEFAULT_CIPHER)
+        crypto = prepare_encrypt(cipher)
+        @keys[[identifier, cipher]] = EncryptionKey.new(cipher: cipher, key: crypto.random_key)
+      end
+
+      def forget(identifier)
+        @keys = @keys.reject { |(id, _)| id.eql?(identifier) }
+      end
+
+      private
+
+      def prepare_encrypt(cipher)
+        crypto = OpenSSL::Cipher.new(cipher)
+        crypto.encrypt
+        crypto
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class InstrumentedMapper
+      def initialize(mapper, instrumentation)
+        @mapper = mapper
+        @instrumentation = instrumentation
+      end
+
+      def event_to_serialized_record(domain_event)
+        instrumentation.instrument("serialize.mapper.rails_event_store", domain_event: domain_event) do
+          mapper.event_to_serialized_record(domain_event)
+        end
+      end
+
+      def serialized_record_to_event(record)
+        instrumentation.instrument("deserialize.mapper.rails_event_store", record: record) do
+          mapper.serialized_record_to_event(record)
+        end
+      end
+
+      private
+
+      attr_reader :instrumentation, :mapper
+    end
+  end
+end

data/lib/ruby_event_store/mappers/json_mapper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class JSONMapper < PipelineMapper
+      def initialize(events_class_remapping: {})
+        super(Pipeline.new(
+          transformations: [
+            Transformation::EventClassRemapper.new(events_class_remapping),
+            Transformation::SymbolizeMetadataKeys.new,
+          ],
+        ))
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -1,15 +1,12 @@
+# frozen_string_literal: true
+
 module RubyEventStore
   module Mappers
-    class NullMapper
-
-      def event_to_serialized_record(domain_event)
-        domain_event
-      end
+    class NullMapper < PipelineMapper
 
-      def serialized_record_to_event(record)
-        record
+      def initialize
+        super(Pipeline.new)
       end
-
     end
   end
 end

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class Pipeline
+      def initialize(to_domain_event: Transformation::DomainEvent.new,
+                     to_serialized_record: Transformation::SerializedRecord.new,
+                     transformations: nil)
+        @transformations = [
+          to_domain_event,
+          Array(transformations),
+          to_serialized_record
+        ].flatten.freeze
+      end
+
+      def dump(domain_event)
+        transformations.reduce(domain_event) do |item, transform|
+          transform.dump(item)
+        end
+      end
+
+      def load(record)
+        transformations.reverse.reduce(record) do |item, transform|
+          transform.load(item)
+        end
+      end
+
+      attr_reader :transformations
+    end
+  end
+end

data/lib/ruby_event_store/mappers/pipeline_mapper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class PipelineMapper
+      def initialize(pipeline)
+        @pipeline = pipeline
+      end
+
+      def event_to_serialized_record(domain_event)
+        pipeline.dump(domain_event)
+      end
+
+      def serialized_record_to_event(record)
+        pipeline.load(record)
+      end
+
+      private
+      attr_reader :pipeline
+    end
+  end
+end

data/lib/ruby_event_store/mappers/protobuf.rb

@@ -1,78 +1,24 @@
+# frozen_string_literal: true
+
 module RubyEventStore
   class Proto < RubyEventStore::Event
-    def initialize(event_id: SecureRandom.uuid, metadata: nil, data:)
-      @event_id = event_id
-      @metadata = Metadata.new(metadata.to_h)
-      @data     = data
-    end
-
-    def type
+    def event_type
       data.class.descriptor.name
     end
-
-    def encode_with(coder)
-      coder['event_id']   = event_id
-      coder['metadata']   = ProtobufNestedStruct::HashMapStringValue.dump(metadata.each_with_object({}){|(k,v),h| h[k.to_s] =v })
-      coder['data.proto'] = data.class.encode(data)
-      coder['data.type']  = type
-    end
-
-    def init_with(coder)
-      @event_id = coder['event_id']
-      @metadata = Metadata.new
-      ProtobufNestedStruct::HashMapStringValue.load(coder['metadata']).each_with_object(metadata){|(k,v),meta| meta[k.to_sym] = v }
-      @data = pool.lookup(coder['data.type']).msgclass.decode(coder['data.proto'])
-    end
-
-    def ==(other_event)
-      other_event.instance_of?(self.class) &&
-        other_event.event_id.eql?(event_id) &&
-        other_event.data == data # https://github.com/google/protobuf/issues/4455
-    end
-
-    private
-
-    def pool
-      Google::Protobuf::DescriptorPool.generated_pool
-    end
   end
 
   module Mappers
-    class Protobuf
+    class Protobuf < PipelineMapper
       def initialize(events_class_remapping: {})
-        require_optional_dependency
-        @events_class_remapping = events_class_remapping
-      end
-
-      def event_to_serialized_record(domain_event)
-        SerializedRecord.new(
-          event_id:   domain_event.event_id,
-          metadata:   ProtobufNestedStruct::HashMapStringValue.dump(domain_event.metadata.each_with_object({}){|(k,v),h| h[k.to_s] =v }),
-          data:       domain_event.data.class.encode(domain_event.data),
-          event_type: domain_event.type
-        )
-      end
-
-      def serialized_record_to_event(record)
-        event_type = events_class_remapping.fetch(record.event_type) { record.event_type }
-        data = Google::Protobuf::DescriptorPool.generated_pool.lookup(event_type).msgclass.decode(record.data)
-        Proto.new(
-          event_id: record.event_id,
-          data: data,
-        ).tap do |p|
-          ProtobufNestedStruct::HashMapStringValue.load(record.metadata).each_with_object(p.metadata) {|(k, v), meta| meta[k.to_sym] = v}
-        end
-      end
-
-      private
-
-      attr_reader :event_id_getter, :events_class_remapping
-
-      def require_optional_dependency
-        require 'protobuf_nested_struct'
-      rescue LoadError
-        raise LoadError, "cannot load such file -- protobuf_nested_struct. Add protobuf_nested_struct gem to Gemfile"
+        super(Pipeline.new(
+          to_domain_event: Transformation::ProtoEvent.new,
+          transformations: [
+            Transformation::ProtobufEncoder.new,
+            Transformation::EventClassRemapper.new(events_class_remapping),
+            Transformation::ProtobufNestedStructMetadata.new,
+          ]
+        ))
       end
     end
   end
-end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class DomainEvent
+        def dump(domain_event)
+          Item.new(
+            event_id:   domain_event.event_id,
+            metadata:   domain_event.metadata.to_h,
+            data:       domain_event.data,
+            event_type: domain_event.event_type
+          )
+        end
+
+        def load(item)
+          Object.const_get(item.event_type).new(
+            event_id: item.event_id,
+            metadata: item.metadata,
+            data:     item.data
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class Encryption
+        class Leaf
+          def self.===(hash)
+            hash.keys.sort.eql? %i(cipher identifier iv)
+          end
+        end
+        private_constant :Leaf
+
+        class MissingEncryptionKey < StandardError
+          def initialize(key_identifier)
+            super %Q|Could not find encryption key for '#{key_identifier}'|
+          end
+        end
+
+        def initialize(key_repository, serializer: YAML, forgotten_data: ForgottenData.new)
+          @key_repository = key_repository
+          @serializer = serializer
+          @forgotten_data = forgotten_data
+        end
+
+        def dump(item)
+          data        = item.data
+          metadata    = item.metadata.dup
+          event_class = Object.const_get(item.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
+          )
+        end
+
+        def load(item)
+          metadata = item.metadata.dup
+          crypto_description = Hash(metadata.delete(:encryption))
+
+          item.merge(
+            data: decrypt_data(item.data, crypto_description),
+            metadata: metadata
+          )
+        end
+
+        private
+        attr_reader :key_repository, :serializer, :forgotten_data
+
+        def encryption_schema(event_class)
+          event_class.respond_to?(:encryption_schema) ? event_class.encryption_schema : {}
+        end
+
+        def deep_dup(hash)
+          duplicate = hash.dup
+          duplicate.each do |k, v|
+            duplicate[k] = v.instance_of?(Hash) ? deep_dup(v) : v
+          end
+          duplicate
+        end
+
+        def encryption_metadata(data, schema)
+          schema.inject({}) do |acc, (key, value)|
+            case value
+            when Hash
+              acc[key] = encryption_metadata(data, value)
+            when Proc
+              key_identifier = value.call(data)
+              encryption_key = key_repository.key_of(key_identifier)
+              raise MissingEncryptionKey.new(key_identifier) unless encryption_key
+              acc[key] = {
+                cipher: encryption_key.cipher,
+                iv: encryption_key.random_iv,
+                identifier: key_identifier,
+              }
+            end
+            acc
+          end
+        end
+
+        def encrypt_data(data, meta)
+          meta.reduce(data) do |acc, (key, value)|
+            acc[key] = encrypt_attribute(acc, key, value) if data.has_key?(key)
+            acc
+          end
+        end
+
+        def decrypt_data(data, meta)
+          meta.reduce(data) do |acc, (key, value)|
+            acc[key] = decrypt_attribute(data, key, value) if data.has_key?(key)
+            acc
+          end
+        end
+
+        def encrypt_attribute(data, attribute, meta)
+          case meta
+          when Leaf
+            value = data.fetch(attribute)
+            return if value.nil?
+
+            encryption_key = key_repository.key_of(meta.fetch(:identifier))
+            encryption_key.encrypt(serializer.dump(value), meta.fetch(:iv))
+          when Hash
+            encrypt_data(data.fetch(attribute), meta)
+          end
+        end
+
+        def decrypt_attribute(data, attribute, meta)
+          case meta
+          when Leaf
+            cryptogram = data.fetch(attribute)
+            return unless cryptogram
+
+            encryption_key = key_repository.key_of(meta.fetch(:identifier), cipher: meta.fetch(:cipher)) or return forgotten_data
+            serializer.load(encryption_key.decrypt(cryptogram, meta.fetch(:iv)))
+          when Hash
+            decrypt_data(data.fetch(attribute), meta)
+          end
+        rescue OpenSSL::Cipher::CipherError
+          forgotten_data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class EventClassRemapper
+        def initialize(class_map)
+          @class_map = class_map
+        end
+
+        def dump(item)
+          item
+        end
+
+        def load(item)
+          item.merge(event_type: class_map[item.fetch(:event_type)] || item.fetch(:event_type))
+        end
+
+        private
+        attr_reader :class_map
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class Item
+        include Enumerable
+        extend  Forwardable
+
+        def initialize(h)
+          @h = {}
+          h.each do |k, v|
+            @h[k] = (v)
+          end
+        end
+
+        def event_id
+          fetch(:event_id)
+        end
+
+        def metadata
+          fetch(:metadata)
+        end
+
+        def data
+          fetch(:data)
+        end
+
+        def event_type
+          fetch(:event_type)
+        end
+
+        def ==(other_event)
+          other_event.instance_of?(self.class) &&
+            other_event.to_h.eql?(to_h)
+        end
+        alias_method :eql?, :==
+
+        def merge(args)
+          Item.new(@h.merge(args))
+        end
+
+        def to_h
+          @h.dup
+        end
+
+        SAFE_HASH_METHODS = [:[], :fetch]
+        delegate SAFE_HASH_METHODS => :@h
+
+        private_constant :SAFE_HASH_METHODS
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class ProtoEvent < DomainEvent
+        def load(item)
+          Proto.new(
+            event_id: item.event_id,
+            data:     item.data,
+            metadata: item.metadata
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class ProtobufEncoder
+        def dump(item)
+          item.merge(data: encode_data(item.data))
+        end
+
+        def load(item)
+          item.merge(data: load_data(item.event_type, item.data))
+        end
+
+        private
+        def encode_data(data)
+          begin
+            data.class.encode(data)
+          rescue NoMethodError
+            raise ProtobufEncodingFailed
+          end
+        end
+
+        def load_data(event_type, protobuf_data)
+          Google::Protobuf::DescriptorPool.generated_pool.lookup(event_type).msgclass.decode(protobuf_data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class ProtobufNestedStructMetadata
+        def initialize
+          require_optional_dependency
+        end
+
+        def dump(item)
+          metadata = ProtobufNestedStruct::HashMapStringValue.dump(item.metadata)
+          item.merge(metadata: metadata)
+        end
+
+        def load(item)
+          metadata = ProtobufNestedStruct::HashMapStringValue.load(item.metadata)
+          symbolize = SymbolizeMetadataKeys.new
+          symbolize.load(item.merge(metadata: metadata))
+        end
+
+        def require_optional_dependency
+          require 'protobuf_nested_struct'
+        rescue LoadError
+          raise LoadError, "cannot load such file -- protobuf_nested_struct. Add protobuf_nested_struct gem to Gemfile"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class Serialization
+        def initialize(serializer: YAML)
+          @serializer = serializer
+        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
+          )
+        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
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class SerializedRecord
+        def dump(item)
+          RubyEventStore::SerializedRecord.new(
+            event_id:   item.event_id,
+            metadata:   item.metadata,
+            data:       item.data,
+            event_type: item.event_type
+          )
+        end
+
+        def load(serialized_record)
+          Item.new(
+            event_id:   serialized_record.event_id,
+            metadata:   serialized_record.metadata,
+            data:       serialized_record.data,
+            event_type: serialized_record.event_type
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class StringifyMetadataKeys
+        def dump(item)
+          stringify(item)
+        end
+
+        def load(item)
+          stringify(item)
+        end
+
+        private
+        def stringify(item)
+          item.merge(
+            metadata: TransformKeys.stringify(item.metadata),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    module Transformation
+      class SymbolizeMetadataKeys
+        def dump(item)
+          symbolize(item)
+        end
+
+        def load(item)
+          symbolize(item)
+        end
+
+        private
+        def symbolize(item)
+          item.merge(
+            metadata: TransformKeys.symbolize(item.metadata),
+          )
+        end
+      end
+    end
+  end
+end