ruby_event_store 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8351508cfb25ee4e763b68e8ccdaecbf8b8ecb7209bd0063ed49fa05cc6b4fa
-  data.tar.gz: 76a337cc5a687292f9dd0ed89c60f6bac9a38071edcd775105606300422114e6
+  metadata.gz: 122d18b13759b12a2916e695e0f846a185912493275718bd7d8b1f665cdf6182
+  data.tar.gz: d744d6882572eeff995fe60d21a0e6ee1dc7bd486c4c9bd584b7f461c38c12c3
 SHA512:
-  metadata.gz: f8e16fca54e179cd4f5f458040338930a25566d0cd3b26a7456aec9367ec17d4894d717c0f2c0fe9f3314a1f8f7a40f757975786386780ab2112945db79887ca
-  data.tar.gz: fee4fc62bbae87d3421c6b35865872fedde255ce3115ae49dc96e9c63f2de4f7c9a28dcae0c0a4cd864a5325d9366e6058efec3de988adfa36a3ad8ab3d125c8
+  metadata.gz: 73529e99d9af66ee1c4bfba654854e48a7d381789fc12784e7f859bcfb509c66b3004c13cf3607a61871799d3b393683576eb28690829110e01935b9e422f071
+  data.tar.gz: b2d083b7458c6bf4b0b3dbc5800792b619028f679d7b3490f9c45d3941ec116a97410e9078f45acdc023fc486d85d81b27980ac2296667de428477bdfd0c9f6a

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

@@ -148,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
@@ -165,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
 

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/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/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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Arkency
@@ -112,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: 3.7.1
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Implementation of an event store in Ruby
 test_files: []