ruby_event_store 2.15.0 → 2.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62ed90d03bfe8826f822e6f384c9571e58cdd9cd98457d22e06c79d57fec5637
-  data.tar.gz: 131fbd2996e056d9010811acc065df372f520e6c588c304f860b3bc604b92856
+  metadata.gz: 27e060aa3ab06f96bd8ad44af2213213bd0b7bce53dfb8b40c1f3a3ab24d9c28
+  data.tar.gz: 4895c1114df635ca973528418a6e349d6e08522e465aea83856e154d040fc20b
 SHA512:
-  metadata.gz: 4b37b5c8de06125797aa9d23354a5d7b05c91761c14783902c16a2719a91159015e3073ec229bd5eb6ce047cf2ef9a7b4ff2b27ab520da61a124366fd7276331
-  data.tar.gz: 9d130c9f17aec1ff13ef1aee527dee2bdfc8276a5dbfa0d12a3ff42ce22fc88099d4706c55347f6df5322736b353e8b714a577332e196de996b09e6352577b91
+  metadata.gz: c05e1e7961fdcd92354d721b26e5bfd57bf5a64c1606c2c0940c4bf5c490860e85b36e165d3089d982b2fa1c0b405efc8c0f24f979f7807ddc8e28c3c17743f1
+  data.tar.gz: 1ffc6203b80784a28591d30617c035ca1f6b04ad8bbe1af2c8b1bd732f01a80758e468c30c6f188503a143023af1e87d64f01f804f9bcff63bd6592221265002

data/lib/ruby_event_store/broker.rb

@@ -2,19 +2,19 @@
 
 module RubyEventStore
   class Broker
-    def initialize(subscriptions:, dispatcher:)
+    def initialize(subscriptions: Subscriptions.new, dispatcher: Dispatcher.new)
       @subscriptions = subscriptions
       @dispatcher = dispatcher
     end
 
-    def call(event, record)
-      subscribers = subscriptions.all_for(event.event_type)
+    def call(topic, event, record)
+      subscribers = subscriptions.all_for(topic)
       subscribers.each { |subscriber| dispatcher.call(subscriber, event, record) }
     end
 
-    def add_subscription(subscriber, event_types)
+    def add_subscription(subscriber, topics)
       verify_subscription(subscriber)
-      subscriptions.add_subscription(subscriber, event_types)
+      subscriptions.add_subscription(subscriber, topics)
     end
 
     def add_global_subscription(subscriber)
@@ -22,9 +22,9 @@ module RubyEventStore
       subscriptions.add_global_subscription(subscriber)
     end
 
-    def add_thread_subscription(subscriber, event_types)
+    def add_thread_subscription(subscriber, topics)
       verify_subscription(subscriber)
-      subscriptions.add_thread_subscription(subscriber, event_types)
+      subscriptions.add_thread_subscription(subscriber, topics)
     end
 
     def add_thread_global_subscription(subscriber)
@@ -32,6 +32,10 @@ module RubyEventStore
       subscriptions.add_thread_global_subscription(subscriber)
     end
 
+    def all_subscriptions_for(topic)
+      subscriptions.all_for(topic)
+    end
+
     private
 
     attr_reader :dispatcher, :subscriptions

data/lib/ruby_event_store/client.rb

@@ -6,21 +6,48 @@ module RubyEventStore
   class Client
     def initialize(
       repository: InMemoryRepository.new,
-      mapper: Mappers::Default.new,
-      subscriptions: Subscriptions.new,
-      dispatcher: Dispatcher.new,
+      mapper: Mappers::BatchMapper.new,
+      subscriptions: nil,
+      dispatcher: nil,
+      message_broker: nil,
       clock: default_clock,
       correlation_id_generator: default_correlation_id_generator,
       event_type_resolver: EventTypeResolver.new
     )
       @repository = repository
-      @mapper = mapper
-      @subscriptions = subscriptions
-      @broker = Broker.new(subscriptions: subscriptions, dispatcher: dispatcher)
+      @mapper = batch_mapper?(mapper) ? mapper : Mappers::BatchMapper.new(mapper)
+      @broker =
+        message_broker ||
+          Broker.new(subscriptions: subscriptions || Subscriptions.new, dispatcher: dispatcher || Dispatcher.new)
       @clock = clock
       @metadata = Concurrent::ThreadLocalVar.new
       @correlation_id_generator = correlation_id_generator
       @event_type_resolver = event_type_resolver
+
+      if (subscriptions || dispatcher)
+        warn <<~EOW
+          Passing subscriptions and dispatcher to #{self.class} has been deprecated.
+
+          Pass it using message_broker argument. For example:
+
+          event_store = RubyEventStore::Client.new(
+            message_broker: RubyEventStore::Broker.new(
+              subscriptions: RubyEventStore::Subscriptions.new,
+              dispatcher: RubyEventStore::Dispatcher.new
+            )
+          )
+        EOW
+        warn <<~EOW if (message_broker)
+
+            Because message_broker has been provided,
+            arguments passed by subscriptions or dispatcher will be ignored.
+          EOW
+      end
+    end
+
+    def rescue_from_double_json_serialization!
+      return unless repository.respond_to? :rescue_from_double_json_serialization!
+      repository.rescue_from_double_json_serialization!
     end
 
     # Persists events and notifies subscribed handlers about them
@@ -29,13 +56,22 @@ module RubyEventStore
     # @param stream_name [String] name of the stream for persisting events.
     # @param expected_version [:any, :auto, :none, Integer] controls optimistic locking strategy. {http://railseventstore.org/docs/expected_version/ Read more}
     # @return [self]
-    def publish(events, stream_name: GLOBAL_STREAM, expected_version: :any)
+    def publish(events, topic: nil, stream_name: GLOBAL_STREAM, expected_version: :any)
       enriched_events = enrich_events_metadata(events)
       records = transform(enriched_events)
       append_records_to_stream(records, stream_name: stream_name, expected_version: expected_version)
       enriched_events.zip(records) do |event, record|
         with_metadata(correlation_id: event.metadata.fetch(:correlation_id), causation_id: event.event_id) do
-          broker.(event, record)
+          if broker.public_method(:call).arity == 3
+            broker.call(topic || event.event_type, event, record)
+          else
+            warn <<~EOW
+              Message broker shall support topics.
+              Topic WILL BE IGNORED in the current broker.
+              Modify the broker implementation to pass topic as an argument to broker.call method.
+            EOW
+            broker.call(event, record)
+          end
         end
       end
       self
@@ -49,7 +85,7 @@ module RubyEventStore
       append_records_to_stream(
         transform(enrich_events_metadata(events)),
         stream_name: stream_name,
-        expected_version: expected_version
+        expected_version: expected_version,
       )
       self
     end
@@ -167,7 +203,7 @@ module RubyEventStore
     # @param to [Class, String] type of events to get list of sybscribed handlers
     # @return [Array<Object, Class>]
     def subscribers_for(event_class)
-      subscriptions.all_for(event_type_resolver.call(event_class))
+      broker.all_subscriptions_for(event_type_resolver.call(event_class))
     end
 
     # Builder object for collecting temporary handlers (subscribers)
@@ -231,6 +267,7 @@ module RubyEventStore
       end
 
       private
+
       attr_reader :resolver
 
       def add_thread_subscribers
@@ -273,18 +310,18 @@ module RubyEventStore
     def deserialize(serializer:, event_type:, event_id:, data:, metadata:, timestamp: nil, valid_at: nil)
       extract_timestamp = lambda { |m| (m[:timestamp] || Time.parse(m.fetch("timestamp"))).iso8601 }
 
-      mapper.record_to_event(
-        SerializedRecord
-          .new(
+      mapper.records_to_events(
+        [
+          SerializedRecord.new(
             event_type: event_type,
             event_id: event_id,
             data: data,
             metadata: metadata,
             timestamp: timestamp || timestamp_ = extract_timestamp[serializer.load(metadata)],
-            valid_at: valid_at || timestamp_
-          )
-          .deserialize(serializer)
-      )
+            valid_at: valid_at || timestamp_,
+          ).deserialize(serializer),
+        ],
+      ).first
     end
 
     # Read additional metadata which will be added for published events
@@ -339,13 +376,12 @@ module RubyEventStore
     private
 
     def transform(events)
-      events.map { |ev| mapper.event_to_record(ev) }
+      mapper.events_to_records(events)
     end
 
     def enrich_events_metadata(events)
       events = Array(events)
       events.each { |event| enrich_event_metadata(event) }
-      events
     end
 
     def enrich_event_metadata(event)
@@ -361,6 +397,10 @@ module RubyEventStore
 
     protected
 
+    def batch_mapper?(mapper)
+      %i[events_to_records records_to_events].all? { |m| mapper.respond_to? m }
+    end
+
     def metadata=(value)
       @metadata.value = value
     end
@@ -373,6 +413,6 @@ module RubyEventStore
       -> { SecureRandom.uuid }
     end
 
-    attr_reader :repository, :mapper, :subscriptions, :broker, :clock, :correlation_id_generator, :event_type_resolver
+    attr_reader :repository, :mapper, :broker, :clock, :correlation_id_generator, :event_type_resolver
   end
 end

data/lib/ruby_event_store/composed_broker.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class ComposedBroker
+    def initialize(*brokers, multiple_brokers: false)
+      @brokers = brokers
+      @multiple_brokers = multiple_brokers
+    end
+
+    def call(event, record, topic)
+      brokers = verified_brokers(topic)
+      if brokers.empty?
+        warn "No broker found for topic '#{topic}'. Event #{event.event_id} will not be processed."
+      else
+        brokers.each { |broker| broker.call(event, record, topic) }
+      end
+    end
+
+    def add_subscription(subscriber, topics)
+      topics.each do |topic|
+        brokers = verified_brokers(topic)
+        raise SubscriptionsNotSupported, "No broker found for topic '#{topic}'." if brokers.empty?
+        brokers.each { |broker| broker.add_subscription(subscriber, topic) }
+      end
+    end
+
+    def add_global_subscription(subscriber)
+      brokers = verified_brokers(nil)
+      raise SubscriptionsNotSupported, "No broker found for global subscription." if brokers.empty?
+      brokers.each { |broker| broker.add_global_subscription(subscriber) }
+    end
+
+    def add_thread_subscription(subscriber, topics)
+      topics.each do |topic|
+        brokers = verified_brokers(topic)
+        raise SubscriptionsNotSupported, "No broker found for topic '#{topic}'." if brokers.empty?
+        brokers.each { |broker| broker.add_thread_subscription(subscriber, topic) }
+      end
+    end
+
+    def add_thread_global_subscription(subscriber)
+      brokers = verified_brokers(nil)
+      raise SubscriptionsNotSupported, "No broker found for global subscription." if brokers.empty?
+      brokers.each { |broker| broker.add_thread_global_subscription(subscriber) }
+    end
+
+    def all_subscriptions_for(topic)
+      @brokers.flat_map { |broker| broker.all_subscriptions_for(topic) }
+    end
+
+    def verify(topic)
+      !verified_brokers(topic).empty?
+    end
+
+    private
+
+    def verified_brokers(topic)
+      if @multiple_brokers
+        @brokers.select { |broker| broker.verify(topic) }
+      else
+        [@brokers.find { |broker| broker.verify(topic) }].compact
+      end
+    end
+  end
+end

data/lib/ruby_event_store/errors.rb

@@ -13,6 +13,7 @@ module RubyEventStore
   ReservedInternalName = Class.new(Error)
   InvalidHandler = Class.new(Error)
   EventNotFoundInStream = Class.new(Error)
+  SubscriptionsNotSupported = Class.new(Error)
 
   class EventNotFound < Error
     attr_reader :event_id

data/lib/ruby_event_store/in_memory_repository.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "ostruct"
 module RubyEventStore
   class InMemoryRepository
     class UnsupportedVersionAnyUsage < StandardError
@@ -108,16 +107,14 @@ module RubyEventStore
       records.each do |record|
         read_event(record.event_id)
         serialized_record =
-          Record
-            .new(
-              event_id: record.event_id,
-              event_type: record.event_type,
-              data: record.data,
-              metadata: record.metadata,
-              timestamp: Time.iso8601(storage.fetch(record.event_id).timestamp),
-              valid_at: record.valid_at
-            )
-            .serialize(serializer)
+          Record.new(
+            event_id: record.event_id,
+            event_type: record.event_type,
+            data: record.data,
+            metadata: record.metadata,
+            timestamp: Time.iso8601(storage.fetch(record.event_id).timestamp),
+            valid_at: record.valid_at,
+          ).serialize(serializer)
         storage[record.event_id] = serialized_record
       end
     end
@@ -145,33 +142,35 @@ module RubyEventStore
     def read_scope(spec)
       serialized_records = serialized_records_of_stream(spec.stream)
       serialized_records = ordered(serialized_records, spec)
-      serialized_records = serialized_records.select { |e| spec.with_ids.any? { |x| x.eql?(e.event_id) } } if spec
-        .with_ids?
-      serialized_records = serialized_records.select { |e| spec.with_types.any? { |x| x.eql?(e.event_type) } } if spec
-        .with_types?
+      serialized_records =
+        serialized_records.select { |e| spec.with_ids.any? { |x| x.eql?(e.event_id) } } if spec.with_ids?
+      serialized_records =
+        serialized_records.select { |e| spec.with_types.any? { |x| x.eql?(e.event_type) } } if spec.with_types?
       serialized_records = serialized_records.reverse if spec.backward?
       serialized_records = serialized_records.drop(index_of(serialized_records, spec.start) + 1) if spec.start
       serialized_records = serialized_records.take(index_of(serialized_records, spec.stop)) if spec.stop
       serialized_records = serialized_records.take(spec.limit) if spec.limit?
-      serialized_records = serialized_records.select { |sr| Time.iso8601(time_comparison_field(spec, sr)) < spec.older_than } if spec
-        .older_than
       serialized_records =
-        serialized_records.select { |sr| Time.iso8601(time_comparison_field(spec, sr)) <= spec.older_than_or_equal } if spec
-        .older_than_or_equal
-      serialized_records = serialized_records.select { |sr| Time.iso8601(time_comparison_field(spec, sr)) > spec.newer_than } if spec
-        .newer_than
+        serialized_records.select do |sr|
+          Time.iso8601(time_comparison_field(spec, sr)) < spec.older_than
+        end if spec.older_than
+      serialized_records =
+        serialized_records.select do |sr|
+          Time.iso8601(time_comparison_field(spec, sr)) <= spec.older_than_or_equal
+        end if spec.older_than_or_equal
       serialized_records =
-        serialized_records.select { |sr| Time.iso8601(time_comparison_field(spec, sr)) >= spec.newer_than_or_equal } if spec
-        .newer_than_or_equal
+        serialized_records.select do |sr|
+          Time.iso8601(time_comparison_field(spec, sr)) > spec.newer_than
+        end if spec.newer_than
+      serialized_records =
+        serialized_records.select do |sr|
+          Time.iso8601(time_comparison_field(spec, sr)) >= spec.newer_than_or_equal
+        end if spec.newer_than_or_equal
       serialized_records
     end
 
     def time_comparison_field(spec, sr)
-      if spec.time_sort_by_as_of?
-        sr.valid_at
-      else
-        sr.timestamp
-      end
+      spec.time_sort_by_as_of? ? sr.valid_at : sr.timestamp
     end
 
     def read_event(event_id)

data/lib/ruby_event_store/instrumented_broker.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  class InstrumentedBroker
+    def initialize(broker, instrumentation)
+      @broker = broker
+      @instrumentation = instrumentation
+    end
+
+    def call(topic, event, record)
+      instrumentation.instrument("call.broker.rails_event_store", topic: topic, event: event, record: record) do
+        if broker.public_method(:call).arity == 3
+          broker.call(topic, event, record)
+        else
+          warn <<~EOW
+            Message broker shall support topics.
+            Topic WILL BE IGNORED in the current broker.
+            Modify the broker implementation to pass topic as an argument to broker.call method.
+          EOW
+          broker.call(event, record)
+        end
+      end
+    end
+
+    def add_subscription(subscriber, topics)
+      instrumentation.instrument("add_subscription.broker.rails_event_store", subscriber: subscriber, topics: topics) do
+        broker.add_subscription(subscriber, topics)
+      end
+    end
+
+    def add_global_subscription(subscriber)
+      instrumentation.instrument("add_global_subscription.broker.rails_event_store", subscriber: subscriber) do
+        broker.add_global_subscription(subscriber)
+      end
+    end
+
+    def add_thread_subscription(subscriber, topics)
+      instrumentation.instrument(
+        "add_thread_subscription.broker.rails_event_store",
+        subscriber: subscriber,
+        topics: topics,
+      ) { broker.add_thread_subscription(subscriber, topics) }
+    end
+
+    def add_thread_global_subscription(subscriber)
+      instrumentation.instrument("add_thread_global_subscription.broker.rails_event_store", subscriber: subscriber) do
+        broker.add_thread_global_subscription(subscriber)
+      end
+    end
+
+    def all_subscriptions_for(topic)
+      instrumentation.instrument("all_subscriptions_for.broker.rails_event_store", topic: topic) do
+        broker.all_subscriptions_for(topic)
+      end
+    end
+
+    def method_missing(method_name, *arguments, **keyword_arguments, &block)
+      if respond_to?(method_name)
+        broker.public_send(method_name, *arguments, **keyword_arguments, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private)
+      broker.respond_to?(method_name)
+    end
+
+    private
+
+    attr_reader :instrumentation, :broker
+  end
+end

data/lib/ruby_event_store/instrumented_subscriptions.rb

@@ -14,9 +14,7 @@ module RubyEventStore
     end
 
     def add_global_subscription(subscriber)
-      instrument(subscriber: subscriber) do
-        subscriptions.add_global_subscription(subscriber)
-      end
+      instrument(subscriber: subscriber) { subscriptions.add_global_subscription(subscriber) }
     end
 
     def add_thread_subscription(subscriber, event_types)
@@ -26,9 +24,7 @@ module RubyEventStore
     end
 
     def add_thread_global_subscription(subscriber)
-      instrument(subscriber: subscriber) do
-        subscriptions.add_thread_global_subscription(subscriber)
-      end
+      instrument(subscriber: subscriber) { subscriptions.add_thread_global_subscription(subscriber) }
     end
 
     def method_missing(method_name, *arguments, &block)
@@ -48,11 +44,7 @@ module RubyEventStore
     def instrument(args)
       instrumentation.instrument("add.subscriptions.rails_event_store", args) do
         unsubscribe = yield
-        ->() {
-          instrumentation.instrument("remove.subscriptions.rails_event_store", args) do
-            unsubscribe.call
-          end
-        }
+        -> { instrumentation.instrument("remove.subscriptions.rails_event_store", args) { unsubscribe.call } }
       end
     end
 

data/lib/ruby_event_store/mappers/batch_mapper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class BatchMapper
+      def initialize(mapper = Default.new)
+        @mapper = mapper
+      end
+
+      def events_to_records(events)
+        events.map { |event| @mapper.event_to_record(event) }
+      end
+
+      def records_to_events(records)
+        records.map { |record| @mapper.record_to_event(record) }
+      end
+    end
+  end
+end

data/lib/ruby_event_store/mappers/default.rb

@@ -7,8 +7,8 @@ module RubyEventStore
         super(
           Pipeline.new(
             Transformation::EventClassRemapper.new(events_class_remapping),
-            Transformation::SymbolizeMetadataKeys.new
-          )
+            Transformation::SymbolizeMetadataKeys.new,
+          ),
         )
       end
     end

data/lib/ruby_event_store/mappers/encryption_key.rb

@@ -20,7 +20,14 @@ module RubyEventStore
         crypto = prepare_decrypt(cipher)
         crypto.iv = iv
         crypto.key = key
-        ciphertext = crypto.authenticated? ? ciphertext_from_authenticated(crypto, message) : message
+        ciphertext =
+          (
+            if crypto.authenticated?
+              ciphertext_from_authenticated(crypto, message)
+            else
+              message
+            end
+          )
         (crypto.update(ciphertext) + crypto.final).force_encoding("UTF-8")
       end
 

data/lib/ruby_event_store/mappers/encryption_mapper.rb

@@ -7,8 +7,8 @@ module RubyEventStore
         super(
           Pipeline.new(
             Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data),
-            Transformation::SymbolizeMetadataKeys.new
-          )
+            Transformation::SymbolizeMetadataKeys.new,
+          ),
         )
       end
     end

data/lib/ruby_event_store/mappers/instrumented_batch_mapper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Mappers
+    class InstrumentedBatchMapper
+      def initialize(mapper, instrumentation)
+        @mapper = mapper
+        @instrumentation = instrumentation
+      end
+
+      def events_to_records(events)
+        instrumentation.instrument("events_to_records.mapper.rails_event_store", domain_events: events) do
+          mapper.events_to_records(events)
+        end
+      end
+
+      def records_to_events(records)
+        instrumentation.instrument("records_to_events.mapper.rails_event_store", records: records) do
+          mapper.records_to_events(records)
+        end
+      end
+
+      private
+
+      attr_reader :instrumentation, :mapper
+    end
+  end
+end

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

@@ -14,18 +14,16 @@ module RubyEventStore
             data: event.data,
             event_type: event.event_type,
             timestamp: timestamp,
-            valid_at: valid_at
+            valid_at: valid_at,
           )
         end
 
         def load(record)
-          Object
-            .const_get(record.event_type)
-            .new(
-              event_id: record.event_id,
-              data: record.data,
-              metadata: record.metadata.merge(timestamp: record.timestamp, valid_at: record.valid_at)
-            )
+          Object.const_get(record.event_type).new(
+            event_id: record.event_id,
+            data: record.data,
+            metadata: record.metadata.merge(timestamp: record.timestamp, valid_at: record.valid_at),
+          )
         rescue NameError
           Event.new(
             event_id: record.event_id,
@@ -34,8 +32,8 @@ module RubyEventStore
               record.metadata.merge(
                 timestamp: record.timestamp,
                 valid_at: record.valid_at,
-                event_type: record.event_type
-              )
+                event_type: record.event_type,
+              ),
           )
         end
       end

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

@@ -37,7 +37,7 @@ module RubyEventStore
             data: encrypt_data(deep_dup(data), crypto_description),
             metadata: metadata,
             timestamp: record.timestamp,
-            valid_at: record.valid_at
+            valid_at: record.valid_at,
           )
         end
 
@@ -51,7 +51,7 @@ module RubyEventStore
             data: decrypt_data(record.data, crypto_description),
             metadata: metadata,
             timestamp: record.timestamp,
-            valid_at: record.valid_at
+            valid_at: record.valid_at,
           )
         end
 
@@ -66,7 +66,6 @@ module RubyEventStore
         def deep_dup(hash)
           duplicate = hash.dup
           duplicate.each { |k, v| duplicate[k] = v.instance_of?(Hash) ? deep_dup(v) : v }
-          duplicate
         end
 
         def encryption_metadata(data, schema)

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

@@ -19,7 +19,7 @@ module RubyEventStore
             data: record.data,
             metadata: record.metadata,
             timestamp: record.timestamp,
-            valid_at: record.valid_at
+            valid_at: record.valid_at,
           )
         end