ruby_event_store 2.17.1 → 2.19.0

data/lib/ruby_event_store/instrumented_repository.rb

@@ -2,50 +2,70 @@
 
 module RubyEventStore
   class InstrumentedRepository
+    DEPRECATION_MESSAGE = <<~EOW
+      Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
+      Use *.ruby_event_store instead.
+    EOW
+    private_constant :DEPRECATION_MESSAGE
+
     def initialize(repository, instrumentation)
       @repository = repository
       @instrumentation = instrumentation
     end
 
     def append_to_stream(records, stream, expected_version)
-      instrumentation.instrument("append_to_stream.repository.rails_event_store", events: records, stream: stream) do
-        repository.append_to_stream(records, stream, expected_version)
+      instrumentation.instrument("append_to_stream.repository.ruby_event_store", records: records, events: records, stream: stream) do
+        deprecated_instrument("append_to_stream.repository.rails_event_store", { records: records, events: records, stream: stream }) do
+          repository.append_to_stream(records, stream, expected_version)
+        end
       end
     end
 
     def link_to_stream(event_ids, stream, expected_version)
-      instrumentation.instrument("link_to_stream.repository.rails_event_store", event_ids: event_ids, stream: stream) do
-        repository.link_to_stream(event_ids, stream, expected_version)
+      instrumentation.instrument("link_to_stream.repository.ruby_event_store", event_ids: event_ids, stream: stream) do
+        deprecated_instrument("link_to_stream.repository.rails_event_store", event_ids: event_ids, stream: stream) do
+          repository.link_to_stream(event_ids, stream, expected_version)
+        end
       end
     end
 
     def delete_stream(stream)
-      instrumentation.instrument("delete_stream.repository.rails_event_store", stream: stream) do
-        repository.delete_stream(stream)
+      instrumentation.instrument("delete_stream.repository.ruby_event_store", stream: stream) do
+        deprecated_instrument("delete_stream.repository.rails_event_store", stream: stream) do
+          repository.delete_stream(stream)
+        end
       end
     end
 
     def read(specification)
-      instrumentation.instrument("read.repository.rails_event_store", specification: specification) do
-        repository.read(specification)
+      instrumentation.instrument("read.repository.ruby_event_store", specification: specification) do
+        deprecated_instrument("read.repository.rails_event_store", specification: specification) do
+          repository.read(specification)
+        end
       end
     end
 
     def count(specification)
-      instrumentation.instrument("count.repository.rails_event_store", specification: specification) do
-        repository.count(specification)
+      instrumentation.instrument("count.repository.ruby_event_store", specification: specification) do
+        deprecated_instrument("count.repository.rails_event_store", specification: specification) do
+          repository.count(specification)
+        end
       end
     end
 
-    def update_messages(messages)
-      instrumentation.instrument("update_messages.repository.rails_event_store", messages: messages) do
-        repository.update_messages(messages)
+    def update_messages(records)
+      instrumentation.instrument("update_messages.repository.ruby_event_store", records: records, messages: records) do
+        deprecated_instrument("update_messages.repository.rails_event_store", { records: records, messages: records }) do
+          repository.update_messages(records)
+        end
       end
     end
 
     def streams_of(event_id)
-      instrumentation.instrument("streams_of.repository.rails_event_store", event_id: event_id) do
-        repository.streams_of(event_id)
+      instrumentation.instrument("streams_of.repository.ruby_event_store", event_id: event_id) do
+        deprecated_instrument("streams_of.repository.rails_event_store", event_id: event_id) do
+          repository.streams_of(event_id)
+        end
       end
     end
 
@@ -64,5 +84,17 @@ module RubyEventStore
     private
 
     attr_reader :repository, :instrumentation
+
+    def deprecated_instrument(name, payload, &block)
+      canonical_name = name.sub("rails_event_store", "ruby_event_store")
+      old_listeners = instrumentation.notifier.all_listeners_for(name)
+      new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
+      if (old_listeners - new_listeners).any?
+        warn DEPRECATION_MESSAGE
+        instrumentation.instrument(name, payload, &block)
+      else
+        yield
+      end
+    end
   end
 end

data/lib/ruby_event_store/mappers/default.rb

@@ -4,12 +4,20 @@ module RubyEventStore
   module Mappers
     class Default < PipelineMapper
       def initialize(events_class_remapping: {})
-        super(
-          Pipeline.new(
-            Transformation::EventClassRemapper.new(events_class_remapping),
-            Transformation::SymbolizeMetadataKeys.new,
-          ),
-        )
+        if events_class_remapping.any?
+          warn <<~EOW
+            DEPRECATION WARNING: `events_class_remapping` option in `RubyEventStore::Mappers::Default` is deprecated and will be removed in the next major release.
+            Use `RubyEventStore::Mappers::Transformation::Upcast` instead.
+          EOW
+          super(
+            Pipeline.new(
+              Transformation::EventClassRemapper.new(events_class_remapping),
+              Transformation::SymbolizeMetadataKeys.new,
+            ),
+          )
+        else
+          super(Pipeline.new(Transformation::SymbolizeMetadataKeys.new))
+        end
       end
     end
   end

data/lib/ruby_event_store/mappers/instrumented_batch_mapper.rb

@@ -3,26 +3,48 @@
 module RubyEventStore
   module Mappers
     class InstrumentedBatchMapper
+      DEPRECATION_MESSAGE = <<~EOW
+        Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
+        Use *.ruby_event_store instead.
+      EOW
+      private_constant :DEPRECATION_MESSAGE
+
       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)
+        instrumentation.instrument("events_to_records.mapper.ruby_event_store", domain_events: events) do
+          deprecated_instrument("events_to_records.mapper.rails_event_store", domain_events: events) do
+            mapper.events_to_records(events)
+          end
         end
       end
 
       def records_to_events(records)
-        instrumentation.instrument("records_to_events.mapper.rails_event_store", records: records) do
-          mapper.records_to_events(records)
+        instrumentation.instrument("records_to_events.mapper.ruby_event_store", records: records) do
+          deprecated_instrument("records_to_events.mapper.rails_event_store", records: records) do
+            mapper.records_to_events(records)
+          end
         end
       end
 
       private
 
       attr_reader :instrumentation, :mapper
+
+      def deprecated_instrument(name, payload, &block)
+        canonical_name = name.sub("rails_event_store", "ruby_event_store")
+        old_listeners = instrumentation.notifier.all_listeners_for(name)
+        new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
+        if (old_listeners - new_listeners).any?
+          warn DEPRECATION_MESSAGE
+          instrumentation.instrument(name, payload, &block)
+        else
+          yield
+        end
+      end
     end
   end
 end

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -3,26 +3,63 @@
 module RubyEventStore
   module Mappers
     class InstrumentedMapper
+      DEPRECATION_MESSAGE = <<~EOW
+        Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.
+        Use *.ruby_event_store instead.
+      EOW
+      private_constant :DEPRECATION_MESSAGE
+
+      RENAME_DEPRECATION_MESSAGE = <<~EOW
+        Instrumentation event names serialize.mapper.ruby_event_store and deserialize.mapper.ruby_event_store are deprecated and will be removed in the next major release.
+        Use event_to_record.mapper.ruby_event_store and record_to_event.mapper.ruby_event_store instead.
+        The domain_event: payload key in serialize.mapper.ruby_event_store has been renamed to event: in event_to_record.mapper.ruby_event_store.
+      EOW
+      private_constant :RENAME_DEPRECATION_MESSAGE
+
       def initialize(mapper, instrumentation)
         @mapper = mapper
         @instrumentation = instrumentation
       end
 
       def event_to_record(event)
-        instrumentation.instrument("serialize.mapper.rails_event_store", domain_event: event) do
-          mapper.event_to_record(event)
+        instrumentation.instrument("event_to_record.mapper.ruby_event_store", event: event) do
+          deprecated_instrument("serialize.mapper.ruby_event_store", { domain_event: event },
+                                canonical: "event_to_record.mapper.ruby_event_store",
+                                message: RENAME_DEPRECATION_MESSAGE) do
+            deprecated_instrument("serialize.mapper.rails_event_store", { domain_event: event }) do
+              mapper.event_to_record(event)
+            end
+          end
         end
       end
 
       def record_to_event(record)
-        instrumentation.instrument("deserialize.mapper.rails_event_store", record: record) do
-          mapper.record_to_event(record)
+        instrumentation.instrument("record_to_event.mapper.ruby_event_store", record: record) do
+          deprecated_instrument("deserialize.mapper.ruby_event_store", { record: record },
+                                canonical: "record_to_event.mapper.ruby_event_store",
+                                message: RENAME_DEPRECATION_MESSAGE) do
+            deprecated_instrument("deserialize.mapper.rails_event_store", { record: record }) do
+              mapper.record_to_event(record)
+            end
+          end
         end
       end
 
       private
 
       attr_reader :instrumentation, :mapper
+
+      def deprecated_instrument(name, payload, canonical: nil, message: DEPRECATION_MESSAGE, &block)
+        canonical_name = canonical || name.sub("rails_event_store", "ruby_event_store")
+        old_listeners = instrumentation.notifier.all_listeners_for(name)
+        new_listeners = instrumentation.notifier.all_listeners_for(canonical_name)
+        if (old_listeners - new_listeners).any?
+          warn message
+          instrumentation.instrument(name, payload, &block)
+        else
+          yield
+        end
+      end
     end
   end
 end

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -4,6 +4,10 @@ module RubyEventStore
   module Mappers
     class NullMapper < PipelineMapper
       def initialize
+        warn <<~EOW
+          DEPRECATION WARNING: `RubyEventStore::Mappers::NullMapper` is deprecated and will be removed in the next major release.
+          Use `RubyEventStore::Mappers::Default.new` instead.
+        EOW
         super(Pipeline.new)
       end
     end

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

@@ -5,6 +5,10 @@ module RubyEventStore
     module Transformation
       class EventClassRemapper
         def initialize(class_map)
+          warn <<~EOW
+            DEPRECATION WARNING: `RubyEventStore::Mappers::Transformation::EventClassRemapper` is deprecated and will be removed in the next major release.
+            Use `RubyEventStore::Mappers::Transformation::Upcast` instead.
+          EOW
           @class_map = class_map
         end
 

data/lib/ruby_event_store/projection.rb

@@ -2,94 +2,126 @@
 
 module RubyEventStore
   class Projection
-    private_class_method :new
-
-    def self.from_stream(stream_or_streams)
-      streams = Array(stream_or_streams)
-      raise(ArgumentError, "At least one stream must be given") if streams.empty?
-      new(streams: streams)
+    ANONYMOUS_CLASS = "#<Class:".freeze
+    DEPRECATION_MESSAGE = <<~EOW
+      RubyEventStore::Projection from_stream/from_all_streams/init/when/run API is deprecated and will be removed in the next major release.
+      Use Projection.init(initial_state).on(EventClass) { |state, event| new_state }.call(scope) instead.
+    EOW
+    MULTI_SCOPE_DEPRECATION_MESSAGE = <<~EOW
+      Passing multiple scopes to RubyEventStore::Projection#call is deprecated and will be removed in the next major release.
+      Use a single scope instead, e.g. call(event_store.read.stream("stream_name")).
+    EOW
+    NEW_CONSTRUCTOR_DEPRECATION_MESSAGE = <<~EOW
+      RubyEventStore::Projection.new is deprecated and will be removed in the next major release.
+      Use Projection.init(initial_state) instead.
+    EOW
+    private_constant :ANONYMOUS_CLASS, :DEPRECATION_MESSAGE, :MULTI_SCOPE_DEPRECATION_MESSAGE, :NEW_CONSTRUCTOR_DEPRECATION_MESSAGE
+
+    def initialize(initial_state = nil, _internal: false)
+      warn NEW_CONSTRUCTOR_DEPRECATION_MESSAGE unless _internal
+      @handlers = {}
+      @init = -> { initial_state }
+      @streams = []
     end
 
-    def self.from_all_streams
-      new
+    def self.init(initial_state = nil)
+      new(initial_state, _internal: true)
     end
 
-    def initialize(streams: [])
-      @streams = streams
-      @handlers = {}
-      @init = -> { {} }
-    end
+    def on(*event_klasses, &block)
+      raise(ArgumentError, "No handler block given") unless block_given?
 
-    attr_reader :streams, :handlers
+      event_klasses.each do |event_klass|
+        name = event_klass.to_s
+        raise(ArgumentError, "Anonymous class is missing name") if name.start_with? ANONYMOUS_CLASS
 
-    def init(handler)
-      @init = handler
+        @handlers[name] = ->(state, event) { block.call(state, event) }
+      end
       self
     end
 
-    def when(events, handler)
-      Array(events).each { |event| handlers[event.to_s] = handler }
+    def call(*scopes)
+      return initial_state if handled_events.empty?
 
-      self
+      warn MULTI_SCOPE_DEPRECATION_MESSAGE if scopes.size > 1
+
+      scopes.reduce(initial_state) do |state, scope|
+        scope.of_type(handled_events).reduce(state, &method(:transition))
+      end
     end
 
-    def initial_state
-      @init.call
+    def self.from_stream(stream_or_streams)
+      warn DEPRECATION_MESSAGE
+      streams = Array(stream_or_streams)
+      raise(ArgumentError, "At least one stream must be given") if streams.empty?
+      projection = new(_internal: true)
+      projection.instance_variable_set(:@streams, streams)
+      projection
     end
 
-    def current_state
-      @current_state ||= initial_state
+    def self.from_all_streams
+      warn DEPRECATION_MESSAGE
+      new(_internal: true)
     end
 
-    def call(event)
-      handlers.fetch(event.event_type).(current_state, event)
+    def init(handler)
+      warn DEPRECATION_MESSAGE
+      @init = handler
+      self
     end
 
-    def handled_events
-      handlers.keys
+    def when(events, handler)
+      warn DEPRECATION_MESSAGE
+      Array(events).each do |event_klass|
+        name = event_klass.to_s
+        @handlers[name] = ->(state, event) { handler.call(state, event); state }
+      end
+      self
     end
 
     def run(event_store, start: nil, count: PAGE_SIZE)
-      return initial_state if handled_events.empty?
-      streams.any? ? reduce_from_streams(event_store, start, count) : reduce_from_all_streams(event_store, start, count)
+      warn DEPRECATION_MESSAGE
+
+      if @streams.any?
+        raise ArgumentError, "Start must be an array with event ids" unless valid_start_for_streams?(start)
+        scopes =
+          @streams.zip(start || []).map do |stream, start_event_id|
+            scope = event_store.read.stream(stream).in_batches(count)
+            scope = scope.from(start_event_id) if start_event_id
+            scope
+          end
+      else
+        raise ArgumentError, "Start must be valid event id" unless valid_start_for_all_streams?(start)
+        scope = event_store.read.in_batches(count)
+        scope = scope.from(start) if start
+        scopes = [scope]
+      end
+
+      call(*scopes)
     end
 
     private
 
-    def valid_starting_point?(start)
-      return true unless start
-      streams.any? ? (start.instance_of?(Array) && start.size === streams.size) : start.instance_of?(String)
-    end
-
-    def reduce_from_streams(event_store, start, count)
-      raise ArgumentError.new("Start must be an array with event ids") unless valid_starting_point?(start)
-      streams
-        .zip(start_events(start))
-        .reduce(initial_state) do |state, (stream_name, start_event_id)|
-          read_scope(event_store, stream_name, count, start_event_id).reduce(state, &method(:transition))
-        end
+    def initial_state
+      @init.call
     end
 
-    def reduce_from_all_streams(event_store, start, count)
-      raise ArgumentError.new("Start must be valid event id") unless valid_starting_point?(start)
-      read_scope(event_store, nil, count, start).reduce(initial_state, &method(:transition))
+    def handled_events
+      @handlers.keys
     end
 
-    def read_scope(event_store, stream, count, start)
-      scope = event_store.read.in_batches(count)
-      scope = scope.of_type(handled_events)
-      scope = scope.stream(stream) if stream
-      scope = scope.from(start) if start
-      scope
+    def transition(state, event)
+      @handlers.fetch(event.event_type).call(state, event)
     end
 
-    def start_events(start)
-      start ? start : Array.new
+    def valid_start_for_streams?(start)
+      return true unless start
+      start.instance_of?(Array) && start.size == @streams.size
     end
 
-    def transition(state, event)
-      handlers.fetch(event.event_type).call(state, event)
-      state
+    def valid_start_for_all_streams?(start)
+      return true unless start
+      start.instance_of?(String)
     end
   end
 end