ruby_event_store 0.39.0 → 0.40.0

data/lib/ruby_event_store/mappers/forgotten_data.rb

@@ -0,0 +1,28 @@
+module RubyEventStore
+  module Mappers
+    class ForgottenData
+      FORGOTTEN_DATA = 'FORGOTTEN_DATA'.freeze
+
+      def initialize(string = FORGOTTEN_DATA)
+        @string = string
+      end
+
+      def to_s
+        @string
+      end
+
+      def ==(other)
+        @string == other
+      end
+      alias_method :eql?, :==
+
+      def method_missing(*)
+        self
+      end
+
+      def respond_to_missing?(*)
+        true
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/in_memory_encryption_key_repository.rb

@@ -0,0 +1,32 @@
+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/null_mapper.rb

@@ -1,26 +1,10 @@
-require 'forwardable'
-
 module RubyEventStore
   module Mappers
-    class NullMapper
-      extend Forwardable
-      class NULL
-        def self.dump(event)
-          event
-        end
-
-        def self.load(record)
-          record
-        end
-      end
-      private_constant :NULL
-
+    class NullMapper < PipelineMapper
 
       def initialize
-        @mapper = Default.new(serializer: NULL)
+        super(Pipeline.new)
       end
-
-      def_delegators :@mapper, :event_to_serialized_record, :serialized_record_to_event
     end
   end
 end

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -0,0 +1,29 @@
+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,20 @@
+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

@@ -12,54 +12,16 @@ module RubyEventStore
   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(TransformKeys.stringify(domain_event.metadata)),
-          data:       encode_data(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 }
-        Proto.new(
-          event_id: record.event_id,
-          data:     load_data(event_type, record.data),
-          metadata: load_metadata(record.metadata)
-        )
-      end
-
-      private
-
-      attr_reader :event_id_getter, :events_class_remapping
-
-      def load_metadata(protobuf_metadata)
-        TransformKeys.symbolize(ProtobufNestedStruct::HashMapStringValue.load(protobuf_metadata))
-      end
-
-      def load_data(event_type, protobuf_data)
-        Google::Protobuf::DescriptorPool.generated_pool.lookup(event_type).msgclass.decode(protobuf_data)
-      end
-
-      def encode_data(domain_event_data)
-        begin
-          domain_event_data.class.encode(domain_event_data)
-        rescue NoMethodError
-          raise ProtobufEncodingFailed
-        end
-      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"
+        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

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

@@ -0,0 +1,24 @@
+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.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,125 @@
+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) or raise MissingEncryptionKey.new(key_identifier)
+              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)
+            acc
+          end
+        end
+
+        def decrypt_data(data, meta)
+          meta.reduce(data) do |acc, (key, value)|
+            acc[key] = decrypt_attribute(data, key, value)
+            acc
+          end
+        end
+
+        def encrypt_attribute(data, attribute, meta)
+          case meta
+          when Leaf
+            value = data.fetch(attribute)
+            return unless value
+
+            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,22 @@
+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,55 @@
+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
+        private_constant :SAFE_HASH_METHODS
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+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