ruby_event_store 2.9.0 → 2.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdf55a1535ea6531b1953ba7413455903257db368dba2bc369783cd90325a31f
-  data.tar.gz: e7b071bbe5d4a389e47751af5d272a8dd9499af3c30c111b1dcba6ef8223e125
+  metadata.gz: 034aa1fb571c22b4e87df0161a00192535fdf8d6637df0e3db2fa9dc14c928d6
+  data.tar.gz: bbb8846d15f41eadf5e0c4cb3d63697ed80c536cfbd2c921453038ec40d0b3f9
 SHA512:
-  metadata.gz: 5c95bb40dfeb3a8261970077ce5c6ac9e840d3eefeb56f0994b5aa91eb7c764e46f23d99281e33dc4f221a4cc74a504c83b6693230dcac16803e0e1678d86e7d
-  data.tar.gz: a617e996ad6b0f72eb7d6cd7bfae02b2ad9151b001de72e71f2e03c28eed205be9abb35d633242487765d7b20e00bb37dc077475376ad89b8c0cf55662529491
+  metadata.gz: 5deb5169c06c20dfb077a0972a262fbf43fb1bf1e27257dd756a22d6f42eb34d1b486f34cebf7d55579bddb271b729ccd5e377d9f30ca5ed0abe814bba046ea5
+  data.tar.gz: 5188078974d0eb3d2311d00de74e69e5756e5d27b9afd7d1dc0cbbdc7b164fb26e6c27f52025215e2cd4978dc11e9eaa41f92f70502bd5516439a2205d8166b9

data/lib/ruby_event_store/client.rb

@@ -5,7 +5,7 @@ require "concurrent"
 module RubyEventStore
   class Client
     def initialize(
-      repository:,
+      repository: InMemoryRepository.new,
       mapper: Mappers::Default.new,
       subscriptions: Subscriptions.new,
       dispatcher: Dispatcher.new,

data/lib/ruby_event_store/in_memory_repository.rb

@@ -153,19 +153,27 @@ module RubyEventStore
       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(sr.timestamp) < spec.older_than } if spec
+      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(sr.timestamp) <= spec.older_than_or_equal } if spec
+        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(sr.timestamp) > spec.newer_than } if spec
+      serialized_records = serialized_records.select { |sr| Time.iso8601(time_comparison_field(spec, sr)) > spec.newer_than } if spec
         .newer_than
       serialized_records =
-        serialized_records.select { |sr| Time.iso8601(sr.timestamp) >= spec.newer_than_or_equal } if spec
+        serialized_records.select { |sr| Time.iso8601(time_comparison_field(spec, sr)) >= spec.newer_than_or_equal } 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
+    end
+
     def read_event(event_id)
       storage.fetch(event_id) { raise EventNotFound.new(event_id) }
     end

data/lib/ruby_event_store/mappers/encryption_mapper.rb

@@ -6,7 +6,8 @@ module RubyEventStore
       def initialize(key_repository, serializer: Serializers::YAML, forgotten_data: ForgottenData.new)
         super(
           Pipeline.new(
-            Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data)
+            Transformation::Encryption.new(key_repository, serializer: serializer, forgotten_data: forgotten_data),
+            Transformation::SymbolizeMetadataKeys.new
           )
         )
       end

data/lib/ruby_event_store/mappers/instrumented_mapper.rb

@@ -8,9 +8,9 @@ module RubyEventStore
         @instrumentation = instrumentation
       end
 
-      def event_to_record(domain_event)
-        instrumentation.instrument("serialize.mapper.rails_event_store", domain_event: domain_event) do
-          mapper.event_to_record(domain_event)
+      def event_to_record(event)
+        instrumentation.instrument("serialize.mapper.rails_event_store", domain_event: event) do
+          mapper.event_to_record(event)
         end
       end
 

data/lib/ruby_event_store/mappers/pipeline.rb

@@ -7,8 +7,8 @@ module RubyEventStore
         @transformations = [to_domain_event, transformations].flatten.freeze
       end
 
-      def dump(domain_event)
-        transformations.reduce(domain_event) { |item, transform| transform.dump(item) }
+      def dump(event)
+        transformations.reduce(event) { |item, transform| transform.dump(item) }
       end
 
       def load(record)

data/lib/ruby_event_store/mappers/pipeline_mapper.rb

@@ -7,8 +7,8 @@ module RubyEventStore
         @pipeline = pipeline
       end
 
-      def event_to_record(domain_event)
-        pipeline.dump(domain_event)
+      def event_to_record(event)
+        pipeline.dump(event)
       end
 
       def record_to_event(record)

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

@@ -4,15 +4,15 @@ module RubyEventStore
   module Mappers
     module Transformation
       class DomainEvent
-        def dump(domain_event)
-          metadata = domain_event.metadata.dup.to_h
+        def dump(event)
+          metadata = event.metadata.dup.to_h
           timestamp = metadata.delete(:timestamp)
           valid_at = metadata.delete(:valid_at)
           Record.new(
-            event_id: domain_event.event_id,
+            event_id: event.event_id,
             metadata: metadata,
-            data: domain_event.data,
-            event_type: domain_event.event_type,
+            data: event.data,
+            event_type: event.event_type,
             timestamp: timestamp,
             valid_at: valid_at
           )

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -33,7 +33,7 @@ end
 module RubyEventStore
   ::RSpec.shared_examples :event_repository do |mk_repository, helper|
     let(:repository) { mk_repository.call }
-    let(:specification) { Specification.new(SpecificationReader.new(repository, Mappers::NullMapper.new)) }
+    let(:specification) { Specification.new(SpecificationReader.new(repository, Mappers::Default.new)) }
     let(:global_stream) { Stream.new(GLOBAL_STREAM) }
     let(:stream) { Stream.new(SecureRandom.uuid) }
     let(:stream_flow) { Stream.new("flow") }
@@ -968,6 +968,22 @@ module RubyEventStore
       expect(batches[1]).to eq(events[100..198])
     end
 
+    specify do
+      events = Array.new(200) { RubyEventStore::SRecord.new }
+      repository.append_to_stream(
+        events,
+        RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+        RubyEventStore::ExpectedVersion.any
+      )
+
+      batches = repository.read(specification.as_at.forward.limit(101).in_batches.result).to_a
+      expect(batches.size).to eq(2)
+      expect(batches[0].size).to eq(100)
+      expect(batches[1].size).to eq(1)
+      expect(batches[0]).to eq(events[0..99])
+      expect(batches[1]).to eq([events[100]])
+    end
+
     specify do
       events = Array.new(200) { SRecord.new }
       repository.append_to_stream(events, Stream.new(GLOBAL_STREAM), ExpectedVersion.any)
@@ -1416,6 +1432,148 @@ module RubyEventStore
       )
       expect(repository.read(specification.result).count).to eq(0)
     end
+
+    specify "read in batches backward" do
+      events = Array.new(200) { RubyEventStore::SRecord.new }
+      repository.append_to_stream(
+        events,
+        RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+        RubyEventStore::ExpectedVersion.any
+      )
+
+      batches = repository.read(specification.backward.limit(101).in_batches.result).to_a
+      expect(batches.size).to eq(2)
+      expect(batches[0].size).to eq(100)
+      expect(batches[1].size).to eq(1)
+      expect(batches[0]).to eq(events[100..-1].reverse)
+      expect(batches[1]).to eq([events[99]])
+    end
+
+    specify "read in batches forward" do
+      events = Array.new(200) { RubyEventStore::SRecord.new }
+      repository.append_to_stream(
+        events,
+        RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+        RubyEventStore::ExpectedVersion.any
+      )
+
+      batches = repository.read(specification.forward.limit(101).in_batches.result).to_a
+      expect(batches.size).to eq(2)
+      expect(batches[0].size).to eq(100)
+      expect(batches[1].size).to eq(1)
+      expect(batches[0]).to eq(events[0..99])
+      expect(batches[1]).to eq([events[100]])
+    end
+
+    specify "read in batches forward from named stream" do
+      all_events = Array.new(400) { RubyEventStore::SRecord.new }
+      all_events.each_slice(2) do |(first, second)|
+        repository.append_to_stream(
+          [first],
+          RubyEventStore::Stream.new("bazinga"),
+          RubyEventStore::ExpectedVersion.any
+        )
+        repository.append_to_stream(
+          [second],
+          RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
+          RubyEventStore::ExpectedVersion.any
+        )
+      end
+      stream_events =
+        all_events.each_with_index.select { |event, idx| event if idx % 2 == 0 }.map { |event, idx| event }
+      batches = repository.read(specification.stream("bazinga").forward.limit(101).in_batches.result).to_a
+      expect(batches.size).to eq(2)
+      expect(batches[0].size).to eq(100)
+      expect(batches[1].size).to eq(1)
+      expect(batches[0]).to eq(stream_events[0..99])
+      expect(batches[1]).to eq([stream_events[100]])
+    end
+
+    specify "global stream order" 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(RubyEventStore::GLOBAL_STREAM),
+        RubyEventStore::ExpectedVersion.any
+      )
+
+      expect(repository.read(specification.result).to_a).to eq([records[0], records[1], records[2], records[3]])
+      expect(repository.read(specification.as_at.result).to_a).to eq([records[3], records[2], records[1], records[0]])
+      expect(repository.read(specification.as_of.result).to_a).to eq([records[2], records[1], records[0], records[3]])
+    end
+
+    specify "named stream order" 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").result).to_a).to eq([records[0], records[1], records[2], records[3]])
+      expect(repository.read(specification.stream("stream").as_at.result).to_a).to eq([records[3], records[2], records[1], records[0]])
+      expect(repository.read(specification.stream("stream").as_of.result).to_a).to eq([records[2], records[1], records[0], records[3]])
+    end
+
+    specify "reading last event sorted by valid_at" 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").as_of.read_last.result)).to eq(records[3])
+    end
+
+    specify "reading last event sorted by valid_at from global stream" do
+      repository.append_to_stream(
+        records = [
+          SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 29, 0))),
+          SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 28, 0))),
+          SRecord.new(timestamp: with_precision(Time.new(2023, 1, 1, 12, 27, 0))),
+          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))),
+        ],
+        Stream.new(GLOBAL_STREAM),
+        ExpectedVersion.any
+      )
+
+      expect(repository.read(specification.as_of.read_last.result)).to eq(records[3])
+    end
+
+    specify "filter time by older than" do
+      repository.append_to_stream(
+        records = [
+          SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 29))),
+          SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 28))),
+          SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 27))),
+          SRecord.new(timestamp: with_precision(Time.utc(2023, 1, 1, 12, 26)), valid_at: with_precision(Time.utc(2023, 1, 1, 12, 30))),
+        ],
+        Stream.new("stream"),
+        ExpectedVersion.any
+      )
+
+      expect(repository.read(specification.older_than(Time.utc(2023,1,1,12,28,1)).stream("stream").as_at.result).to_a).to eq([records[3], records[2], records[1]])
+      expect(repository.read(specification.older_than(Time.utc(2023,1,1,12,28,1)).stream("stream").as_of.result).to_a).to eq([records[2], records[1]])
+    end
+
+    private
+
+    def with_precision(time)
+      time.round(TIMESTAMP_PRECISION)
+    end
   end
 
   ::RSpec::Matchers.define :eq_ids do |expected_ids|

data/lib/ruby_event_store/spec/mapper_lint.rb

@@ -1,17 +1,17 @@
 module RubyEventStore
-  ::RSpec.shared_examples :mapper do |mapper, domain_event|
+  ::RSpec.shared_examples :mapper do |mapper, event|
     specify "event_to_record returns instance of Record" do
-      record = mapper.event_to_record(domain_event)
+      record = mapper.event_to_record(event)
 
       expect(record).to be_kind_of(Record)
-      expect(record.event_id).to eq(domain_event.event_id)
-      expect(record.event_type).to eq(domain_event.event_type)
+      expect(record.event_id).to eq(event.event_id)
+      expect(record.event_type).to eq(event.event_type)
     end
 
     specify "serialize and deserialize gives equal event" do
-      record = mapper.event_to_record(domain_event)
+      record = mapper.event_to_record(event)
 
-      expect(mapper.record_to_event(record)).to eq(domain_event)
+      expect(mapper.record_to_event(record)).to eq(event)
     end
   end
 end

data/lib/ruby_event_store/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.9.1
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-24 00:00:00.000000000 Z
+date: 2023-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -118,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Implementation of an event store in Ruby