ruby_event_store 2.19.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a38be596490cc7feffdf26968a8175a2a1606ba567f448382b2aecfe2e78ebd9
-  data.tar.gz: c64882bef174236d979680f84ed1d16b37f8ef2ba2a48b50a49d55286cff523e
+  metadata.gz: 122d18b13759b12a2916e695e0f846a185912493275718bd7d8b1f665cdf6182
+  data.tar.gz: d744d6882572eeff995fe60d21a0e6ee1dc7bd486c4c9bd584b7f461c38c12c3
 SHA512:
-  metadata.gz: 07a6509f6ac818e525834d0bae05b297ef2802643fee60cc45024cf3ea2faf49744f26dfe31896be18274dfc83e4a6be62abef1cb6faa27c67b8de8664998d11
-  data.tar.gz: f4846eedf860127e23bcdc38c37b13028896b39836a3af75689943de59bbdf633d7b2dd0e30cade9728486710cc2395db99ec4adef98a60fcfbdb4c494724e3f
+  metadata.gz: 73529e99d9af66ee1c4bfba654854e48a7d381789fc12784e7f859bcfb509c66b3004c13cf3607a61871799d3b393683576eb28690829110e01935b9e422f071
+  data.tar.gz: b2d083b7458c6bf4b0b3dbc5800792b619028f679d7b3490f9c45d3941ec116a97410e9078f45acdc023fc486d85d81b27980ac2296667de428477bdfd0c9f6a

data/lib/ruby_event_store/broker.rb

@@ -2,7 +2,7 @@
 
 module RubyEventStore
   class Broker
-    def initialize(subscriptions: Subscriptions.new, dispatcher: Dispatcher.new)
+    def initialize(subscriptions: Subscriptions.new, dispatcher: SyncScheduler.new)
       @subscriptions = subscriptions
       @dispatcher = dispatcher
     end

data/lib/ruby_event_store/client.rb

@@ -99,9 +99,7 @@ module RubyEventStore
     # @param expected_version (see #publish)
     # @return [self]
     def link(event_ids, stream_name:, expected_version: :any)
-      warn <<~EOW if event_ids.nil? || Array(event_ids).any?(&:nil?)
-          Passing `nil` to link is deprecated and will raise ArgumentError in RubyEventStore 3.0.
-        EOW
+      raise ArgumentError, "event_ids must not be nil" if event_ids.nil? || Array(event_ids).any?(&:nil?)
       @repository.link_to_stream(Array(event_ids), Stream.new(stream_name), ExpectedVersion.new(expected_version))
       self
     end
@@ -384,9 +382,7 @@ module RubyEventStore
     end
 
     def enrich_events_metadata(events)
-      warn <<~EOW if events.nil? || Array(events).any?(&:nil?)
-          Passing `nil` to publish/append is deprecated and will raise ArgumentError in RubyEventStore 3.0.
-        EOW
+      raise ArgumentError, "events must not be nil" if events.nil? || Array(events).any?(&:nil?)
       events = Array(events)
       events.each { |event| enrich_event_metadata(event) }
     end

data/lib/ruby_event_store/errors.rb

@@ -14,6 +14,8 @@ module RubyEventStore
   InvalidHandler = Class.new(Error)
   EventNotFoundInStream = Class.new(Error)
   SubscriptionsNotSupported = Class.new(Error)
+  StringsRequired = Class.new(Error)
+  InvalidUpcast = Class.new(Error)
 
   class EventNotFound < Error
     attr_reader :event_id

data/lib/ruby_event_store/in_memory_repository.rb

@@ -22,12 +22,11 @@ module RubyEventStore
       attr_reader :event_id, :position
     end
 
-    def initialize(serializer: NULL, ensure_supported_any_usage: false)
+    def initialize(serializer: NULL)
       @serializer = serializer
       @streams = Hash.new { |h, k| h[k] = Array.new }
       @mutex = Mutex.new
       @storage = Hash.new
-      @ensure_supported_any_usage = ensure_supported_any_usage
     end
 
     def append_to_stream(records, stream, expected_version)
@@ -149,7 +148,6 @@ module RubyEventStore
       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 do |sr|
           Time.iso8601(time_comparison_field(spec, sr)) < spec.older_than
@@ -166,6 +164,7 @@ module RubyEventStore
         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 = serialized_records.take(spec.limit) if spec.limit?
       serialized_records
     end
 
@@ -239,13 +238,7 @@ module RubyEventStore
         (resolved_version.nil? && !stream_positions.compact.empty?) ||
           (!resolved_version.nil? && stream_positions.include?(nil))
 
-      if violation
-        if @ensure_supported_any_usage
-          raise UnsupportedVersionAnyUsage
-        else
-          Deprecations.warn(:any_version_with_specific_position)
-        end
-      end
+      raise UnsupportedVersionAnyUsage if violation
     end
 
     attr_reader :streams, :mutex, :storage, :serializer

data/lib/ruby_event_store/instrumented_broker.rb

@@ -9,34 +9,28 @@ module RubyEventStore
 
     def call(topic, event, record)
       instrumentation.instrument("call.broker.ruby_event_store", topic: topic, event: event, record: record) do
-        deprecated_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
+        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.ruby_event_store", subscriber: subscriber, topics: topics) do
-        deprecated_instrument("add_subscription.broker.rails_event_store", subscriber: subscriber, topics: topics) do
-          broker.add_subscription(subscriber, topics)
-        end
+        broker.add_subscription(subscriber, topics)
       end
     end
 
     def add_global_subscription(subscriber)
       instrumentation.instrument("add_global_subscription.broker.ruby_event_store", subscriber: subscriber) do
-        deprecated_instrument("add_global_subscription.broker.rails_event_store", subscriber: subscriber) do
-          broker.add_global_subscription(subscriber)
-        end
+        broker.add_global_subscription(subscriber)
       end
     end
 
@@ -45,28 +39,18 @@ module RubyEventStore
         "add_thread_subscription.broker.ruby_event_store",
         subscriber: subscriber,
         topics: topics,
-      ) do
-        deprecated_instrument(
-          "add_thread_subscription.broker.rails_event_store",
-          subscriber: subscriber,
-          topics: topics,
-        ) { broker.add_thread_subscription(subscriber, topics) }
-      end
+      ) { broker.add_thread_subscription(subscriber, topics) }
     end
 
     def add_thread_global_subscription(subscriber)
       instrumentation.instrument("add_thread_global_subscription.broker.ruby_event_store", subscriber: subscriber) do
-        deprecated_instrument("add_thread_global_subscription.broker.rails_event_store", subscriber: subscriber) do
-          broker.add_thread_global_subscription(subscriber)
-        end
+        broker.add_thread_global_subscription(subscriber)
       end
     end
 
     def all_subscriptions_for(topic)
       instrumentation.instrument("all_subscriptions_for.broker.ruby_event_store", topic: topic) do
-        deprecated_instrument("all_subscriptions_for.broker.rails_event_store", topic: topic) do
-          broker.all_subscriptions_for(topic)
-        end
+        broker.all_subscriptions_for(topic)
       end
     end
 
@@ -85,17 +69,5 @@ module RubyEventStore
     private
 
     attr_reader :instrumentation, :broker
-
-    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?
-        Deprecations.warn(:instrumentation_renamed)
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -9,9 +9,7 @@ module RubyEventStore
 
     def call(subscriber, event, record)
       instrumentation.instrument("call.dispatcher.ruby_event_store", event: event, subscriber: subscriber) do
-        deprecated_instrument("call.dispatcher.rails_event_store", event: event, subscriber: subscriber) do
-          dispatcher.call(subscriber, event, record)
-        end
+        dispatcher.call(subscriber, event, record)
       end
     end
 
@@ -30,17 +28,5 @@ module RubyEventStore
     private
 
     attr_reader :instrumentation, :dispatcher
-
-    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?
-        Deprecations.warn(:instrumentation_renamed)
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

data/lib/ruby_event_store/instrumented_repository.rb

@@ -11,62 +11,43 @@ module RubyEventStore
       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 },
-        ) { repository.append_to_stream(records, stream, expected_version) }
-      end
+      ) { repository.append_to_stream(records, stream, expected_version) }
     end
 
     def 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
+        repository.link_to_stream(event_ids, stream, expected_version)
       end
     end
 
     def 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
+        repository.delete_stream(stream)
       end
     end
 
     def 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
+        repository.read(specification)
       end
     end
 
     def 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
+        repository.count(specification)
       end
     end
 
     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 },
-        ) { repository.update_messages(records) }
+      instrumentation.instrument("update_messages.repository.ruby_event_store", records: records) do
+        repository.update_messages(records)
       end
     end
 
     def 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
+        repository.streams_of(event_id)
       end
     end
 
@@ -85,17 +66,5 @@ 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?
-        Deprecations.warn(:instrumentation_renamed)
-        instrumentation.instrument(name, payload, &block)
-      else
-        yield
-      end
-    end
   end
 end

data/lib/ruby_event_store/instrumented_subscriptions.rb

@@ -42,9 +42,9 @@ module RubyEventStore
     private
 
     def instrument(args)
-      instrumentation.instrument("add.subscriptions.rails_event_store", args) do
+      instrumentation.instrument("add.subscriptions.ruby_event_store", args) do
         unsubscribe = yield
-        -> { instrumentation.instrument("remove.subscriptions.rails_event_store", args) { unsubscribe.call } }
+        -> { instrumentation.instrument("remove.subscriptions.ruby_event_store", args) { unsubscribe.call } }
       end
     end
 

data/lib/ruby_event_store/mappers/default.rb

@@ -3,18 +3,8 @@
 module RubyEventStore
   module Mappers
     class Default < PipelineMapper
-      def initialize(events_class_remapping: {})
-        if events_class_remapping.any?
-          Deprecations.warn(:events_class_remapping_option)
-          super(
-            Pipeline.new(
-              Transformation::EventClassRemapper.new(events_class_remapping),
-              Transformation::SymbolizeMetadataKeys.new,
-            ),
-          )
-        else
-          super(Pipeline.new(Transformation::SymbolizeMetadataKeys.new))
-        end
+      def initialize
+        super(Pipeline.new(Transformation::SymbolizeMetadataKeys.new))
       end
     end
   end

data/lib/ruby_event_store/mappers/instrumented_batch_mapper.rb

@@ -10,35 +10,19 @@ module RubyEventStore
 
       def 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
+          mapper.events_to_records(events)
         end
       end
 
       def 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
+          mapper.records_to_events(records)
         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?
-          Deprecations.warn(:instrumentation_renamed)
-          instrumentation.instrument(name, payload, &block)
-        else
-          yield
-        end
-      end
     end
   end
 end

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -10,49 +10,19 @@ module RubyEventStore
 
       def 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",
-            key: :instrumented_mapper_serialize_deprecated,
-          ) do
-            deprecated_instrument("serialize.mapper.rails_event_store", { domain_event: event }) do
-              mapper.event_to_record(event)
-            end
-          end
+          mapper.event_to_record(event)
         end
       end
 
       def 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",
-            key: :instrumented_mapper_serialize_deprecated,
-          ) do
-            deprecated_instrument("deserialize.mapper.rails_event_store", { record: record }) do
-              mapper.record_to_event(record)
-            end
-          end
+          mapper.record_to_event(record)
         end
       end
 
       private
 
       attr_reader :instrumentation, :mapper
-
-      def deprecated_instrument(name, payload, canonical: nil, key: :instrumentation_renamed, &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?
-          Deprecations.warn(key)
-          instrumentation.instrument(name, payload, &block)
-        else
-          yield
-        end
-      end
     end
   end
 end

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

@@ -12,7 +12,12 @@ module RubyEventStore
           def call(record)
             identity = lambda { |r| r }
             new_record = @upcast_map.fetch(record.event_type, identity)[record]
-            new_record.equal?(record) ? record : call(new_record)
+            return record if new_record.equal?(record)
+            if new_record.event_type == record.event_type
+              raise InvalidUpcast,
+                    "Upcast for '#{record.event_type}' returned the same event_type. In order to upcast provide a new event_type (e.g. '#{record.event_type}_v2')."
+            end
+            call(new_record)
           end
         end
 

data/lib/ruby_event_store/projection.rb

@@ -5,15 +5,15 @@ module RubyEventStore
     ANONYMOUS_CLASS = "#<Class:".freeze
     private_constant :ANONYMOUS_CLASS
 
-    def initialize(initial_state = nil, _internal: false)
-      Deprecations.warn(:projection_new_constructor) unless _internal
-      @handlers = {}
-      @init = -> { initial_state }
-      @streams = []
-    end
+    private_class_method :new
 
     def self.init(initial_state = nil)
-      new(initial_state, _internal: true)
+      new(initial_state)
+    end
+
+    def initialize(initial_state)
+      @handlers = {}
+      @init = -> { initial_state }
     end
 
     def on(*event_klasses, &block)
@@ -28,61 +28,10 @@ module RubyEventStore
       self
     end
 
-    def call(*scopes)
+    def call(scope)
       return initial_state if handled_events.empty?
 
-      Deprecations.warn(:projection_multiple_scopes) if scopes.size > 1
-
-      scopes.reduce(initial_state) { |state, scope| scope.of_type(handled_events).reduce(state, &method(:transition)) }
-    end
-
-    def self.from_stream(stream_or_streams)
-      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 self.from_all_streams
-      new(_internal: true)
-    end
-
-    def init(handler)
-      @init = handler
-      self
-    end
-
-    def when(events, handler)
-      Array(events).each do |event_klass|
-        name = event_klass.to_s
-        @handlers[name] = ->(state, event) do
-          handler.call(state, event)
-          state
-        end
-      end
-      self
-    end
-
-    def run(event_store, start: nil, count: PAGE_SIZE)
-      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)
+      scope.of_type(handled_events).reduce(initial_state, &method(:transition))
     end
 
     private
@@ -98,15 +47,5 @@ module RubyEventStore
     def transition(state, event)
       @handlers.fetch(event.event_type).call(state, event)
     end
-
-    def valid_start_for_streams?(start)
-      return true unless start
-      start.instance_of?(Array) && start.size == @streams.size
-    end
-
-    def valid_start_for_all_streams?(start)
-      return true unless start
-      start.instance_of?(String)
-    end
   end
 end

data/lib/ruby_event_store/record.rb

@@ -1,41 +1,11 @@
 # frozen_string_literal: true
 
 module RubyEventStore
-  class Record
-    StringsRequired = Class.new(StandardError)
+  Record = Data.define(:event_id, :data, :metadata, :event_type, :timestamp, :valid_at) do
     def initialize(event_id:, data:, metadata:, event_type:, timestamp:, valid_at:)
       raise StringsRequired unless [event_id, event_type].all? { |v| v.instance_of?(String) }
-      @event_id = event_id
-      @data = data
-      @metadata = metadata
-      @event_type = event_type
-      @timestamp = timestamp
-      @valid_at = valid_at
       @serialized_records = {}
-      freeze
-    end
-
-    attr_reader :event_id, :data, :metadata, :event_type, :timestamp, :valid_at
-
-    def hash
-      [event_id, data, metadata, event_type, timestamp, valid_at].hash ^ self.class.hash
-    end
-
-    def ==(other)
-      other.instance_of?(self.class) && other.event_id.eql?(event_id) && other.data.eql?(data) &&
-        other.metadata.eql?(metadata) && other.event_type.eql?(event_type) && other.timestamp.eql?(timestamp) &&
-        other.valid_at.eql?(valid_at)
-    end
-
-    def to_h
-      {
-        event_id: event_id,
-        data: data,
-        metadata: metadata,
-        event_type: event_type,
-        timestamp: timestamp,
-        valid_at: valid_at,
-      }
+      super
     end
 
     def serialize(serializer)
@@ -48,7 +18,6 @@ module RubyEventStore
         valid_at: valid_at.iso8601(TIMESTAMP_PRECISION),
       )
     end
-
-    alias_method :eql?, :==
   end
+  Record::StringsRequired = StringsRequired
 end

data/lib/ruby_event_store/serialized_record.rb

@@ -1,40 +1,10 @@
 # frozen_string_literal: true
 
 module RubyEventStore
-  class SerializedRecord
-    StringsRequired = Class.new(StandardError)
+  SerializedRecord = Data.define(:event_id, :data, :metadata, :event_type, :timestamp, :valid_at) do
     def initialize(event_id:, data:, metadata:, event_type:, timestamp:, valid_at:)
       raise StringsRequired unless [event_id, event_type].all? { |v| v.instance_of?(String) }
-      @event_id = event_id
-      @data = data
-      @metadata = metadata
-      @event_type = event_type
-      @timestamp = timestamp
-      @valid_at = valid_at
-      freeze
-    end
-
-    attr_reader :event_id, :data, :metadata, :event_type, :timestamp, :valid_at
-
-    def hash
-      [event_id, data, metadata, event_type, timestamp, valid_at].hash ^ self.class.hash
-    end
-
-    def ==(other)
-      other.instance_of?(self.class) && other.event_id.eql?(event_id) && other.data.eql?(data) &&
-        other.metadata.eql?(metadata) && other.event_type.eql?(event_type) && other.timestamp.eql?(timestamp) &&
-        other.valid_at.eql?(valid_at)
-    end
-
-    def to_h
-      {
-        event_id: event_id,
-        data: data,
-        metadata: metadata,
-        event_type: event_type,
-        timestamp: timestamp,
-        valid_at: valid_at,
-      }
+      super
     end
 
     def deserialize(serializer)
@@ -47,7 +17,6 @@ module RubyEventStore
         valid_at: Time.iso8601(valid_at),
       )
     end
-
-    alias_method :eql?, :==
   end
+  SerializedRecord::StringsRequired = StringsRequired
 end

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples "broker" do |broker_klass|
   let(:record) { instance_double(::RubyEventStore::Record) }
   let(:handler) { HandlerClass.new }
   let(:subscriptions) { ::RubyEventStore::Subscriptions.new }
-  let(:dispatcher) { ::RubyEventStore::Dispatcher.new }
+  let(:dispatcher) { ::RubyEventStore::SyncScheduler.new }
   let(:broker) { broker_klass.new(subscriptions: subscriptions, dispatcher: dispatcher) }
 
   specify "no dispatch when no subscriptions" do
@@ -56,7 +56,7 @@ RSpec.shared_examples "broker" do |broker_klass|
     allow(dispatcher).to receive(:verify).and_return(false)
     expect { broker.add_subscription(HandlerClass, []) }.to raise_error(
       RubyEventStore::InvalidHandler,
-      /Handler HandlerClass is invalid for dispatcher .*Dispatcher/,
+      /Handler HandlerClass is invalid for dispatcher .*SyncScheduler/,
     )
     expect { broker.add_global_subscription(HandlerClass) }.to raise_error(
       RubyEventStore::InvalidHandler,

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -1309,6 +1309,19 @@ module RubyEventStore
       )
     end
 
+    specify "limit applies to records matching the time filter, not before it" do
+      event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
+      event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
+      event_3 = SRecord.new(event_id: "d345f86d-b903-4d78-803f-38990c078d9e", timestamp: Time.utc(2020, 1, 3))
+      repository.append_to_stream([event_1, event_2, event_3], Stream.new("whatever"), version_any)
+
+      expect(
+        repository.read(
+          specification.stream("whatever").backward.older_than_or_equal(Time.utc(2020, 1, 2)).limit(2).result,
+        ).to_a,
+      ).to eq([event_2, event_1])
+    end
+
     specify "fetching records older than or equal to specified date in stream" do
       event_1 = SRecord.new(event_id: "8a6f053e-3ce2-4c82-a55b-4d02c66ae6ea", timestamp: Time.utc(2020, 1, 1))
       event_2 = SRecord.new(event_id: "8cee1139-4f96-483a-a175-2b947283c3c7", timestamp: Time.utc(2020, 1, 2))
@@ -1578,6 +1591,35 @@ module RubyEventStore
       )
     end
 
+    specify "named stream order is respected also when reading backward" do
+      repository.append_to_stream(
+        records = [
+          RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 29, 0))),
+          RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 28, 0))),
+          RubyEventStore::SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 27, 0))),
+          RubyEventStore::SRecord.new(
+            timestamp: with_precision(Time.new(2023, 1, 1, 12, 26, 0)),
+            valid_at: with_precision(Time.new(2023, 1, 1, 12, 30, 0)),
+          ),
+        ],
+        RubyEventStore::Stream.new("stream"),
+        RubyEventStore::ExpectedVersion.any,
+      )
+
+      expect(repository.read(specification.stream("stream").backward.result).to_a).to eq(
+        [records[3], records[2], records[1], records[0]],
+      )
+      expect(repository.read(specification.stream("stream").as_at.backward.result).to_a).to eq(
+        [records[0], records[1], records[2], records[3]],
+      )
+      expect(repository.read(specification.stream("stream").as_at.backward.limit(2).result).to_a).to eq(
+        [records[0], records[1]],
+      )
+      expect(repository.read(specification.stream("stream").as_of.backward.result).to_a).to eq(
+        [records[3], records[0], records[1], records[2]],
+      )
+    end
+
     specify "reading last event sorted by valid_at" do
       repository.append_to_stream(
         records = [

data/lib/ruby_event_store/specification.rb

@@ -245,10 +245,6 @@ module RubyEventStore
       )
     end
 
-    def in_batches_of(batch_size = DEFAULT_BATCH_SIZE)
-      in_batches(batch_size)
-    end
-
     # Specifies that only first event should be read.
     # {https://railseventstore.org/docs/core-concepts/read Find out more}.
     #
@@ -292,10 +288,6 @@ module RubyEventStore
       Specification.new(reader, result.dup { |r| r.with_types = types.flatten })
     end
 
-    def of_types(*types)
-      of_type(*types)
-    end
-
     # Limits the query to certain events by given even ids.
     # {https://railseventstore.org/docs/core-concepts/read Find out more}.
     #

data/lib/ruby_event_store/sync_scheduler.rb

@@ -3,24 +3,11 @@
 module RubyEventStore
   class SyncScheduler
     def call(subscriber, event, _)
-      if Class === subscriber
-        Deprecations.warn(:class_subscriber)
-        subscriber = subscriber.new
-      end
       subscriber.call(event)
     end
 
     def verify(subscriber)
-      if Class === subscriber
-        Deprecations.warn(:class_subscriber)
-        begin
-          subscriber.new.respond_to?(:call)
-        rescue ArgumentError
-          false
-        end
-      else
-        subscriber.respond_to?(:call)
-      end
+      subscriber.respond_to?(:call)
     end
   end
 end

data/lib/ruby_event_store/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyEventStore
-  VERSION = "2.19.2"
+  VERSION = "3.1.0"
 end

data/lib/ruby_event_store.rb

@@ -2,7 +2,6 @@
 
 require_relative "ruby_event_store/deprecations"
 require_relative "ruby_event_store/sync_scheduler"
-require_relative "ruby_event_store/dispatcher"
 require_relative "ruby_event_store/subscriptions"
 require_relative "ruby_event_store/broker"
 require_relative "ruby_event_store/in_memory_repository"
@@ -25,7 +24,6 @@ require_relative "ruby_event_store/mappers/encryption_key"
 require_relative "ruby_event_store/mappers/in_memory_encryption_key_repository"
 require_relative "ruby_event_store/mappers/transformation/domain_event"
 require_relative "ruby_event_store/mappers/transformation/encryption"
-require_relative "ruby_event_store/mappers/transformation/event_class_remapper"
 require_relative "ruby_event_store/mappers/transformation/upcast"
 require_relative "ruby_event_store/mappers/transformation/stringify_metadata_keys"
 require_relative "ruby_event_store/mappers/transformation/symbolize_metadata_keys"
@@ -38,14 +36,11 @@ require_relative "ruby_event_store/mappers/forgotten_data"
 require_relative "ruby_event_store/mappers/encryption_mapper"
 require_relative "ruby_event_store/mappers/instrumented_mapper"
 require_relative "ruby_event_store/mappers/instrumented_batch_mapper"
-require_relative "ruby_event_store/mappers/json_mapper"
-require_relative "ruby_event_store/mappers/null_mapper"
 require_relative "ruby_event_store/serializers/yaml"
 require_relative "ruby_event_store/batch_enumerator"
 require_relative "ruby_event_store/correlated_commands"
 require_relative "ruby_event_store/link_by_metadata"
 require_relative "ruby_event_store/immediate_dispatcher"
-require_relative "ruby_event_store/immediate_async_dispatcher"
 require_relative "ruby_event_store/composed_dispatcher"
 require_relative "ruby_event_store/composed_broker"
 require_relative "ruby_event_store/version"
@@ -54,4 +49,3 @@ require_relative "ruby_event_store/instrumented_dispatcher"
 require_relative "ruby_event_store/instrumented_subscriptions"
 require_relative "ruby_event_store/instrumented_broker"
 require_relative "ruby_event_store/event_type_resolver"
-require_relative "ruby_event_store/deprecated"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 2.19.2
+  version: 3.1.0
 platform: ruby
 authors:
 - Arkency
@@ -47,14 +47,11 @@ files:
 - lib/ruby_event_store/composed_dispatcher.rb
 - lib/ruby_event_store/constants.rb
 - lib/ruby_event_store/correlated_commands.rb
-- lib/ruby_event_store/deprecated.rb
 - lib/ruby_event_store/deprecations.rb
-- lib/ruby_event_store/dispatcher.rb
 - lib/ruby_event_store/errors.rb
 - lib/ruby_event_store/event.rb
 - lib/ruby_event_store/event_type_resolver.rb
 - lib/ruby_event_store/expected_version.rb
-- lib/ruby_event_store/immediate_async_dispatcher.rb
 - lib/ruby_event_store/immediate_dispatcher.rb
 - lib/ruby_event_store/in_memory_repository.rb
 - lib/ruby_event_store/instrumented_broker.rb
@@ -70,13 +67,10 @@ files:
 - lib/ruby_event_store/mappers/in_memory_encryption_key_repository.rb
 - lib/ruby_event_store/mappers/instrumented_batch_mapper.rb
 - lib/ruby_event_store/mappers/instrumented_mapper.rb
-- lib/ruby_event_store/mappers/json_mapper.rb
-- lib/ruby_event_store/mappers/null_mapper.rb
 - lib/ruby_event_store/mappers/pipeline.rb
 - lib/ruby_event_store/mappers/pipeline_mapper.rb
 - lib/ruby_event_store/mappers/transformation/domain_event.rb
 - lib/ruby_event_store/mappers/transformation/encryption.rb
-- lib/ruby_event_store/mappers/transformation/event_class_remapper.rb
 - lib/ruby_event_store/mappers/transformation/preserve_types.rb
 - lib/ruby_event_store/mappers/transformation/stringify_metadata_keys.rb
 - lib/ruby_event_store/mappers/transformation/symbolize_metadata_keys.rb
@@ -118,14 +112,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Implementation of an event store in Ruby
 test_files: []

data/lib/ruby_event_store/deprecated.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  Deprecations.register(
-    :dispatcher_renamed,
-    "`RubyEventStore::Dispatcher` is deprecated and will be removed in the next major release.\n" \
-      "Use `RubyEventStore::SyncScheduler` instead.",
-  )
-  Deprecations.deprecate(Dispatcher, :initialize, key: :dispatcher_renamed)
-
-  Deprecations.register(
-    :immediate_async_dispatcher_renamed,
-    "`RubyEventStore::ImmediateAsyncDispatcher` is deprecated and will be removed in the next major release.\n" \
-      "Use `RubyEventStore::ImmediateDispatcher` instead.",
-  )
-  Deprecations.deprecate(ImmediateAsyncDispatcher, :initialize, key: :immediate_async_dispatcher_renamed)
-
-  Deprecations.register(
-    :class_subscriber,
-    "Passing a class as a subscriber is deprecated and will be removed in the next major release.\n" \
-      "Pass an instance or lambda instead, e.g. subscribe(MyHandler.new, to: [MyEvent]).",
-  )
-
-  Deprecations.register(
-    :null_mapper,
-    "`RubyEventStore::Mappers::NullMapper` is deprecated and will be removed in the next major release.\n" \
-      "Use `RubyEventStore::Mappers::Default.new` instead.",
-  )
-  Deprecations.deprecate(Mappers::NullMapper, :initialize, key: :null_mapper)
-
-  Deprecations.register(
-    :events_class_remapping_option,
-    "`events_class_remapping` option in `RubyEventStore::Mappers::Default` is deprecated and will be removed in the next major release.\n" \
-      "Use `RubyEventStore::Mappers::Transformation::Upcast` instead.",
-  )
-
-  Deprecations.register(
-    :event_class_remapper,
-    "`RubyEventStore::Mappers::Transformation::EventClassRemapper` is deprecated and will be removed in the next major release.\n" \
-      "Use `RubyEventStore::Mappers::Transformation::Upcast` instead.",
-  )
-  Deprecations.deprecate(Mappers::Transformation::EventClassRemapper, :initialize, key: :event_class_remapper)
-
-  Deprecations.register(
-    :any_version_with_specific_position,
-    "Mixing expected version :any and specific position (or :auto) is deprecated and will raise UnsupportedVersionAnyUsage in RubyEventStore 3.0.",
-  )
-
-  Deprecations.register(
-    :projection_new_constructor,
-    "RubyEventStore::Projection.new is deprecated and will be removed in the next major release.\n" \
-      "Use Projection.init(initial_state) instead.",
-  )
-
-  Deprecations.register(
-    :projection_multiple_scopes,
-    "Passing multiple scopes to RubyEventStore::Projection#call is deprecated and will be removed in the next major release.\n" \
-      "Use a single scope instead, e.g. call(event_store.read.stream(\"stream_name\")).",
-  )
-
-  Deprecations.register(
-    :projection_old_api,
-    "RubyEventStore::Projection from_stream/from_all_streams/init/when/run API is deprecated and will be removed in the next major release.\n" \
-      "Use Projection.init(initial_state).on(EventClass) { |state, event| new_state }.call(scope) instead.",
-  )
-  Deprecations.deprecate_class_method(Projection, :from_stream, key: :projection_old_api)
-  Deprecations.deprecate_class_method(Projection, :from_all_streams, key: :projection_old_api)
-  Deprecations.deprecate(Projection, :init, key: :projection_old_api)
-  Deprecations.deprecate(Projection, :when, key: :projection_old_api)
-  Deprecations.deprecate(Projection, :run, key: :projection_old_api)
-
-  Deprecations.register(
-    :instrumentation_renamed,
-    "Instrumentation event names *.rails_event_store are deprecated and will be removed in the next major release.\n" \
-      "Use *.ruby_event_store instead.",
-  )
-
-  Deprecations.register(
-    :instrumented_mapper_serialize_deprecated,
-    "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.\n" \
-      "Use event_to_record.mapper.ruby_event_store and record_to_event.mapper.ruby_event_store instead.\n" \
-      "The domain_event: payload key in serialize.mapper.ruby_event_store has been renamed to event: in event_to_record.mapper.ruby_event_store.",
-  )
-
-  Deprecations.register(
-    :specification_in_batches_of,
-    "RubyEventStore::Specification#in_batches_of is deprecated and will be removed in the next major release.\n\n" \
-      "Use #in_batches instead.",
-  )
-  Deprecations.deprecate(Specification, :in_batches_of, key: :specification_in_batches_of)
-
-  Deprecations.register(
-    :specification_of_types,
-    "RubyEventStore::Specification#of_types is deprecated and will be removed in the next major release.\n\n" \
-      "Use #of_type instead.",
-  )
-  Deprecations.deprecate(Specification, :of_types, key: :specification_of_types)
-end

data/lib/ruby_event_store/dispatcher.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  class Dispatcher < SyncScheduler
-  end
-end

data/lib/ruby_event_store/immediate_async_dispatcher.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  class ImmediateAsyncDispatcher < ImmediateDispatcher
-  end
-end

data/lib/ruby_event_store/mappers/json_mapper.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module Mappers
-    class JSONMapper < Default
-      def initialize(events_class_remapping: {})
-        warn <<~EOW
-          Please replace RubyEventStore::Mappers::JSONMapper with RubyEventStore::Mappers::Default
-
-          They're now identical and the former will be removed in next major release.
-        EOW
-        super
-      end
-    end
-  end
-end

data/lib/ruby_event_store/mappers/null_mapper.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module Mappers
-    class NullMapper < PipelineMapper
-      def initialize
-        super(Pipeline.new)
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module Mappers
-    module Transformation
-      class EventClassRemapper
-        def initialize(class_map)
-          @class_map = class_map
-        end
-
-        def dump(record)
-          record
-        end
-
-        def load(record)
-          Record.new(
-            event_id: record.event_id,
-            event_type: class_map[record.event_type] || record.event_type,
-            data: record.data,
-            metadata: record.metadata,
-            timestamp: record.timestamp,
-            valid_at: record.valid_at,
-          )
-        end
-
-        private
-
-        attr_reader :class_map
-      end
-    end
-  end
-end