ruby_event_store 0.39.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93c4fb13b69f6c54171be328e0bb2f10ad9172afbad3b367762a831754523700
-  data.tar.gz: e3ee2f58ed04b5df00c2e44685b9f6d1172fce73f8df639d35bae021930af3ae
+  metadata.gz: 257a578c0c9d6dac951fd1a21fc739227b3169cb14af5535b3c782501280461c
+  data.tar.gz: 55b40e9ab1dd90afb841ed1b92a8e950ea6aa3285ce0f187443f92341dbcfb31
 SHA512:
-  metadata.gz: 3fd6b0a07e06ec3faf668a57e7564c8d151b567d0b24e07097042a29032ec9e598d430a9107c64d581dcb83f89a4ea52420798ee6039e7b08da5d417db337ef7
-  data.tar.gz: e7426bddb8d654198b340c7aba9d882cb2296bf379dab83dd6182cb824ff3fd3f2839cdc17f2ddd8d3bd4a5f0846cf38c82fa29d9925bc7cc0dac4852fcf9677
+  metadata.gz: 90fa7cccf1b1832c441b2f63701e2a931afc778f819f9df6152463b90a9533adb087254adb879de64e6a94a4c9f35463da2cc14d481012ff5a0a3e1f6f8240c5
+  data.tar.gz: 70a286e9f88972228b392a4a56ef37035a0d571c9f75b19376313dc8147e518a270f70a2f1097983d6d547e1590c9c51f2005095d4d8229ad3919d3cffd4dac7

data/lib/ruby_event_store.rb

@@ -1,6 +1,7 @@
-require 'ruby_event_store/pub_sub/dispatcher'
-require 'ruby_event_store/pub_sub/subscriptions'
-require 'ruby_event_store/pub_sub/broker'
+require 'ruby_event_store/dispatcher'
+require 'ruby_event_store/subscriptions'
+require 'ruby_event_store/broker'
+require 'ruby_event_store/pub_sub'
 require 'ruby_event_store/in_memory_repository'
 require 'ruby_event_store/projection'
 require 'ruby_event_store/errors'
@@ -15,11 +16,28 @@ require 'ruby_event_store/stream'
 require 'ruby_event_store/expected_version'
 require 'ruby_event_store/serialized_record'
 require 'ruby_event_store/transform_keys'
+require 'ruby_event_store/mappers'
+require 'ruby_event_store/mappers/encryption_key'
+require 'ruby_event_store/mappers/in_memory_encryption_key_repository'
+require 'ruby_event_store/mappers/transformation/domain_event'
+require 'ruby_event_store/mappers/transformation/encryption'
+require 'ruby_event_store/mappers/transformation/event_class_remapper'
+require 'ruby_event_store/mappers/transformation/item'
+require 'ruby_event_store/mappers/transformation/proto_event'
+require 'ruby_event_store/mappers/transformation/protobuf_encoder'
+require 'ruby_event_store/mappers/transformation/protobuf_nested_struct_metadata'
+require 'ruby_event_store/mappers/transformation/serialization'
+require 'ruby_event_store/mappers/transformation/serialized_record'
+require 'ruby_event_store/mappers/transformation/stringify_metadata_keys'
+require 'ruby_event_store/mappers/transformation/symbolize_metadata_keys'
+require 'ruby_event_store/mappers/pipeline'
+require 'ruby_event_store/mappers/pipeline_mapper'
 require 'ruby_event_store/mappers/default'
-require 'ruby_event_store/mappers/protobuf'
-require 'ruby_event_store/mappers/null_mapper'
-require 'ruby_event_store/mappers/instrumented_mapper'
+require 'ruby_event_store/mappers/forgotten_data'
 require 'ruby_event_store/mappers/encryption_mapper'
+require 'ruby_event_store/mappers/instrumented_mapper'
+require 'ruby_event_store/mappers/null_mapper'
+require 'ruby_event_store/mappers/protobuf'
 require 'ruby_event_store/batch_enumerator'
 require 'ruby_event_store/correlated_commands'
 require 'ruby_event_store/link_by_metadata'

data/lib/ruby_event_store/broker.rb

@@ -0,0 +1,43 @@
+module RubyEventStore
+  class Broker
+    def initialize(subscriptions:, dispatcher:)
+      @subscriptions = subscriptions
+      @dispatcher = dispatcher
+    end
+
+    def call(event, serialized_event)
+      subscribers = subscriptions.all_for(event.type)
+      subscribers.each do |subscriber|
+        dispatcher.call(subscriber, event, serialized_event)
+      end
+    end
+
+    def add_subscription(subscriber, event_types)
+      verify_subscription(subscriber)
+      subscriptions.add_subscription(subscriber, event_types)
+    end
+
+    def add_global_subscription(subscriber)
+      verify_subscription(subscriber)
+      subscriptions.add_global_subscription(subscriber)
+    end
+
+    def add_thread_subscription(subscriber, event_types)
+      verify_subscription(subscriber)
+      subscriptions.add_thread_subscription(subscriber, event_types)
+    end
+
+    def add_thread_global_subscription(subscriber)
+      verify_subscription(subscriber)
+      subscriptions.add_thread_global_subscription(subscriber)
+    end
+
+    private
+    attr_reader :subscriptions, :dispatcher
+
+    def verify_subscription(subscriber)
+      raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber
+      raise InvalidHandler.new("Handler #{subscriber} is invalid for dispatcher #{dispatcher}") unless dispatcher.verify(subscriber)
+    end
+  end
+end

data/lib/ruby_event_store/client.rb

@@ -5,12 +5,12 @@ module RubyEventStore
 
     def initialize(repository:,
                    mapper: Mappers::Default.new,
-                   subscriptions: PubSub::Subscriptions.new,
-                   dispatcher: PubSub::Dispatcher.new,
+                   subscriptions: Subscriptions.new,
+                   dispatcher: Dispatcher.new,
                    clock: ->{ Time.now.utc })
       @repository     = repository
       @mapper         = mapper
-      @broker         = PubSub::Broker.new(subscriptions: subscriptions, dispatcher: dispatcher)
+      @broker         = Broker.new(subscriptions: subscriptions, dispatcher: dispatcher)
       @clock          = clock
       @metadata       = Concurrent::ThreadLocalVar.new
     end

data/lib/ruby_event_store/dispatcher.rb

@@ -0,0 +1,18 @@
+module RubyEventStore
+  class Dispatcher
+    def call(subscriber, event, _)
+      subscriber = subscriber.new if Class === subscriber
+      subscriber.call(event)
+    end
+
+    def verify(subscriber)
+      begin
+        subscriber_instance = Class === subscriber ? subscriber.new : subscriber
+      rescue ArgumentError
+        false
+      else
+        subscriber_instance.respond_to?(:call)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/errors.rb

@@ -1,17 +1,18 @@
 module RubyEventStore
-  WrongExpectedEventVersion = Class.new(StandardError)
-  InvalidExpectedVersion    = Class.new(StandardError)
-  IncorrectStreamData       = Class.new(StandardError)
-  SubscriberNotExist        = Class.new(StandardError)
-  InvalidPageStart          = Class.new(ArgumentError)
-  InvalidPageStop           = Class.new(ArgumentError)
-  InvalidPageSize           = Class.new(ArgumentError)
-  EventDuplicatedInStream   = Class.new(StandardError)
-  ReservedInternalName      = Class.new(StandardError)
-  InvalidHandler            = Class.new(StandardError)
-  ProtobufEncodingFailed    = Class.new(StandardError)
+  Error                     = Class.new(StandardError)
+  WrongExpectedEventVersion = Class.new(Error)
+  InvalidExpectedVersion    = Class.new(Error)
+  IncorrectStreamData       = Class.new(Error)
+  SubscriberNotExist        = Class.new(Error)
+  InvalidPageStart          = Class.new(Error)
+  InvalidPageStop           = Class.new(Error)
+  InvalidPageSize           = Class.new(Error)
+  EventDuplicatedInStream   = Class.new(Error)
+  ReservedInternalName      = Class.new(Error)
+  InvalidHandler            = Class.new(Error)
+  ProtobufEncodingFailed    = Class.new(Error)
 
-  class EventNotFound < StandardError
+  class EventNotFound < Error
     attr_reader :event_id
 
     def initialize(event_id)

data/lib/ruby_event_store/event.rb

@@ -133,6 +133,7 @@ module RubyEventStore
     def correlate_with(other_message)
       self.correlation_id = other_message.correlation_id || other_message.message_id
       self.causation_id   = other_message.message_id
+      self
     end
 
     alias_method :eql?, :==

data/lib/ruby_event_store/mappers.rb

@@ -0,0 +1,10 @@
+module RubyEventStore
+  module Mappers
+    def self.const_missing(const_name)
+      super unless const_name.equal?(:MissingEncryptionKey)
+      warn "`RubyEventStore::Mappers::MissingEncryptionKey` has been deprecated. Use `RubyEventStore::Mappers::Transformation::Encryption::MissingEncryptionKey` instead."
+
+      Transformation::Encryption::MissingEncryptionKey
+    end
+  end
+end

data/lib/ruby_event_store/mappers/default.rb

@@ -2,32 +2,16 @@ require 'yaml'
 
 module RubyEventStore
   module Mappers
-    class Default
+    class Default < PipelineMapper
       def initialize(serializer: YAML, events_class_remapping: {})
-        @serializer = serializer
-        @events_class_remapping = events_class_remapping
+        super(Pipeline.new(
+          transformations: [
+            Transformation::EventClassRemapper.new(events_class_remapping),
+            Transformation::SymbolizeMetadataKeys.new,
+            Transformation::Serialization.new(serializer: serializer),
+          ]
+        ))
       end
-
-      def event_to_serialized_record(domain_event)
-        SerializedRecord.new(
-          event_id:         domain_event.event_id,
-          metadata:   serializer.dump(domain_event.metadata.to_h),
-          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 }
-        Object.const_get(event_type).new(
-          event_id: record.event_id,
-          metadata: TransformKeys.symbolize(serializer.load(record.metadata)),
-          data:     serializer.load(record.data)
-        )
-      end
-
-      private
-      attr_reader :serializer, :events_class_remapping
     end
   end
 end

data/lib/ruby_event_store/mappers/encryption_key.rb

@@ -0,0 +1,72 @@
+module RubyEventStore
+  module Mappers
+    class EncryptionKey
+      def initialize(cipher:, key:)
+        @cipher = cipher
+        @key    = key
+      end
+
+      def encrypt(message, iv)
+        crypto     = prepare_encrypt(cipher)
+        crypto.iv  = iv
+        crypto.key = key
+
+        if crypto.authenticated?
+          encrypt_authenticated(crypto, message)
+        else
+          crypto.update(message) + crypto.final
+        end
+      end
+
+      def decrypt(message, iv)
+        crypto     = prepare_decrypt(cipher)
+        crypto.iv  = iv
+        crypto.key = key
+        ciphertext =
+          if crypto.authenticated?
+            ciphertext_from_authenticated(crypto, message)
+          else
+            message
+          end
+        (crypto.update(ciphertext) + crypto.final).force_encoding("UTF-8")
+      end
+
+      def random_iv
+        crypto = prepare_encrypt(cipher)
+        crypto.random_iv
+      end
+
+      attr_reader :cipher, :key
+
+      private
+
+      def ciphertext_from_authenticated(crypto, message)
+        prepare_auth_data(crypto)
+        crypto.auth_tag = message[-16...message.length]
+        message[0...-16]
+      end
+
+      def encrypt_authenticated(crypto, message)
+        prepare_auth_data(crypto)
+        crypto.update(message) + crypto.final + crypto.auth_tag
+      end
+
+      def prepare_auth_data(crypto)
+        crypto.auth_data = ""
+        crypto
+      end
+
+      def prepare_encrypt(cipher)
+        crypto = OpenSSL::Cipher.new(cipher)
+        crypto.encrypt
+        crypto
+      end
+
+      def prepare_decrypt(cipher)
+        crypto = OpenSSL::Cipher.new(cipher)
+        crypto.decrypt
+        crypto
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/encryption_mapper.rb

@@ -1,245 +1,14 @@
 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
-
-      def method_missing(*)
-        self
-      end
-
-      def respond_to_missing?(*)
-        true
-      end
-    end
-
-    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
-
-    class EncryptionKey
-      def initialize(cipher:, key:)
-        @cipher = cipher
-        @key    = key
-      end
-
-      def encrypt(message, iv)
-        crypto     = prepare_encrypt(cipher)
-        crypto.iv  = iv
-        crypto.key = key
-
-        if crypto.authenticated?
-          encrypt_authenticated(crypto, message)
-        else
-          crypto.update(message) + crypto.final
-        end
-      end
-
-      def decrypt(message, iv)
-        crypto     = prepare_decrypt(cipher)
-        crypto.iv  = iv
-        crypto.key = key
-        ciphertext =
-          if crypto.authenticated?
-            ciphertext_from_authenticated(crypto, message)
-          else
-            message
-          end
-        (crypto.update(ciphertext) + crypto.final).force_encoding("UTF-8")
-      end
-
-      def random_iv
-        crypto = prepare_encrypt(cipher)
-        crypto.random_iv
-      end
-
-      attr_reader :cipher, :key
-
-      private
-
-      def ciphertext_from_authenticated(crypto, message)
-        prepare_auth_data(crypto)
-        crypto.auth_tag = message[-16...message.length]
-        message[0...-16]
-      end
-
-      def encrypt_authenticated(crypto, message)
-        prepare_auth_data(crypto)
-        crypto.update(message) + crypto.final + crypto.auth_tag
-      end
-
-      def prepare_auth_data(crypto)
-        crypto.auth_data = ""
-        crypto
-      end
-
-      def prepare_encrypt(cipher)
-        crypto = OpenSSL::Cipher.new(cipher)
-        crypto.encrypt
-        crypto
-      end
-
-      def prepare_decrypt(cipher)
-        crypto = OpenSSL::Cipher.new(cipher)
-        crypto.decrypt
-        crypto
-      end
-    end
-
-    class MissingEncryptionKey < StandardError
-      def initialize(key_identifier)
-        super %Q|Could not find encryption key for '#{key_identifier}'|
-      end
-    end
-
-    class EncryptionMapper
-      class Leaf
-        def self.===(hash)
-          hash.keys.sort.eql? %i(cipher identifier iv)
-        end
-      end
-      private_constant :Leaf
-
+    class EncryptionMapper < PipelineMapper
       def initialize(key_repository, serializer: YAML, forgotten_data: ForgottenData.new)
-        @key_repository = key_repository
-        @serializer     = serializer
-        @forgotten_data = forgotten_data
-      end
-
-      def event_to_serialized_record(domain_event)
-        metadata              = domain_event.metadata.to_h
-        crypto_description    = encryption_metadata(domain_event.data, encryption_schema(domain_event))
-        metadata[:encryption] = crypto_description unless crypto_description.empty?
-
-        SerializedRecord.new(
-          event_id: domain_event.event_id,
-          metadata: serializer.dump(metadata),
-          data: serializer.dump(encrypt_data(deep_dup(domain_event.data), crypto_description)),
-          event_type: domain_event.class.to_s
-        )
-      end
-
-      def serialized_record_to_event(record)
-        metadata           = serializer.load(record.metadata)
-        crypto_description = Hash(metadata.delete(:encryption))
-
-        Object.const_get(record.event_type).new(
-          event_id: record.event_id,
-          data: decrypt_data(serializer.load(record.data), crypto_description),
-          metadata: metadata,
-        )
-      end
-
-      private
-      attr_reader :key_repository, :serializer, :forgotten_data
-
-      def encryption_schema(event)
-        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
+        super(Pipeline.new(
+          transformations: [
+            Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data),
+            Transformation::Serialization.new(serializer: serializer),
+          ]
+        ))
       end
     end
   end
-end
+end