ruby_event_store-rom 0.31.1 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75f18165eba9aa2ff1cc6cbc0fa7c150b7496a2e7b2763a94728604d6750d60d
-  data.tar.gz: 1860e4bb2757c7882bb0ca6aed0a06e6e3ddf71573cb446c9f1823c7296ba8ef
+  metadata.gz: 995fff6b726e0326b38e8bfbcd9be6d919b402934768e828b57cd8db164ed7a2
+  data.tar.gz: 8ceb98b10e4da72899199c28f8e1626f28e946140ae58c2f937d03b0600a4c68
 SHA512:
-  metadata.gz: d68e654d8a78dd0747f4c7b7311ed93a65a145a30e818d6ba5e2acbc13d430dfeeda70d1a27640f87ee5a011fa014eb682fba9cf546c3f3fb9b3c7ed46f1abc7
-  data.tar.gz: bcd5d8ba1314ce02231751c14e8749669235a954519b9bc64bfdc01c96d4aa6a2e9f6bb6803f27dc83171c474bc6b7b98e41d90eb517148b9d36a78b457c5824
+  metadata.gz: bb9acb2c016ad4bc3d5987cbd0ad07e47de32d5c07e0f3acc34a8f813221ea40099af95c34e22d9360a533e250c66b9883749b63fbe604d2c37a8c3322b82c31
+  data.tar.gz: 3c3ca41d2308e2a55e8fe61904b845dab7953b6586b52848d6b09182f9896a920d94e74e0e20a0b0841a50aed61b426f60464df017f1648294a38743e38b8d35

data/Makefile

@@ -60,14 +60,14 @@ test-fast: ## Run unit tests with --fail-fast
 
 mutate: test ## Run mutation tests
 	@echo "Running mutation tests"
-	@DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
+	@MUTATING=true DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
 		$(addprefix --require ,$(REQUIRE)) \
 		$(addprefix --ignore-subject ,$(IGNORE)) \
 		--use rspec "$(SUBJECT)"
 
 mutate-fast: ## Run mutation tests with --fail-fast
 	@echo "Running mutation tests with --fail-fast"
-	@DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
+	@MUTATING=true DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
 		$(addprefix --require ,$(REQUIRE)) \
 		$(addprefix --ignore-subject ,$(IGNORE)) \
 		--fail-fast \

data/lib/ruby_event_store/rom/adapters/memory/relations/stream_entries.rb

@@ -26,7 +26,7 @@ module RubyEventStore
           def take(num)
             num.nil? ? self : super
           end
-          
+
           def insert(tuple)
             verify_uniquness!(tuple)
             super
@@ -35,32 +35,36 @@ module RubyEventStore
           def delete(tuple)
             super tuple.to_h
           end
-          
+
           def by_stream(stream)
             restrict(stream: normalize_stream_name(stream))
           end
-  
+
+          def by_event_id(event_id)
+            restrict(event_id: event_id)
+          end
+
           def by_stream_and_event_id(stream, event_id)
             restrict(stream: normalize_stream_name(stream), event_id: event_id).one!
           end
-  
+
           def max_position(stream)
             new(by_stream(stream).order(:position).dataset.reverse).project(:position).take(1).one
           end
-  
+
           DIRECTION_MAP = {
             forward:  [false,  :>],
             backward: [true, :<]
           }.freeze
-  
+
           def ordered(direction, stream, offset_entry_id = nil)
             reverse, operator = DIRECTION_MAP[direction]
-  
+
             raise ArgumentError, 'Direction must be :forward or :backward' if order.nil?
-  
+
             order_columns = %i[position id]
             order_columns.delete(:position) if stream.global?
-            
+
             query = by_stream(stream)
             query = query.restrict { |tuple| tuple[:id].public_send(operator, offset_entry_id) } if offset_entry_id
             query = query.order(*order_columns)
@@ -68,7 +72,7 @@ module RubyEventStore
 
             query
           end
-        
+
         private
 
           # Verifies uniqueness of [stream, event_id] and [stream, position]

data/lib/ruby_event_store/rom/adapters/sql/relations/stream_entries.rb

@@ -5,48 +5,52 @@ module RubyEventStore
         class StreamEntries < ::ROM::Relation[:sql]
           schema(:event_store_events_in_streams, as: :stream_entries, infer: true) do
             attribute :created_at, ::ROM::Types::Strict::Time.default { Time.now }
-            
+
             associations do
               belongs_to :events, as: :event, foreign_key: :event_id
             end
           end
 
           alias_method :take, :limit
-    
+
           SERIALIZED_GLOBAL_STREAM_NAME = 'all'.freeze
 
           def by_stream(stream)
             where(stream: normalize_stream_name(stream))
           end
 
+          def by_event_id(event_id)
+            where(event_id: event_id)
+          end
+
           def by_stream_and_event_id(stream, event_id)
             where(stream: normalize_stream_name(stream), event_id: event_id).one!
           end
-  
+
           def max_position(stream)
             by_stream(stream).select(:position).order(Sequel.desc(:position)).first
           end
-  
+
           DIRECTION_MAP = {
             forward:  [:asc,  :>],
             backward: [:desc, :<]
           }.freeze
-  
+
           def ordered(direction, stream, offset_entry_id = nil)
             order, operator = DIRECTION_MAP[direction]
-  
+
             raise ArgumentError, 'Direction must be :forward or :backward' if order.nil?
-  
+
             order_columns = %i[position id]
             order_columns.delete(:position) if stream.global?
-            
+
             query = by_stream(stream)
             query = query.where { id.public_send(operator, offset_entry_id) } if offset_entry_id
             query.order { |r| order_columns.map { |c| r[:stream_entries][c].public_send(order) } }
           end
-          
+
           private
-  
+
           def normalize_stream_name(stream)
             stream.global? ? SERIALIZED_GLOBAL_STREAM_NAME : stream.name
           end

data/lib/ruby_event_store/rom/event_repository.rb

@@ -11,7 +11,7 @@ module RubyEventStore
 
       def initialize(rom: ROM.env)
         raise ArgumentError, "Must specify rom" unless rom && rom.instance_of?(Env)
-        
+
         @rom = rom
         @events = Repositories::Events.new(rom.container)
         @stream_entries = Repositories::StreamEntries.new(rom.container)
@@ -72,13 +72,7 @@ module RubyEventStore
       end
 
       def last_stream_event(stream)
-        @events.read(
-          :backward,
-          stream,
-          from: :head,
-          limit: 1,
-          batch_size: nil
-        ).first
+        @events.last_stream_event(stream)
       end
 
       def read_event(event_id)
@@ -88,15 +82,14 @@ module RubyEventStore
       end
 
       def read(specification)
-        raise ReservedInternalName if specification.stream_name.eql?(@stream_entries.stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME)
-
-        @events.read(
-          specification.direction,
-          specification.stream,
-          from: specification.start,
-          limit: (specification.count if specification.limit?),
-          batch_size: (specification.batch_size if specification.batched?)
-        )
+        raise ReservedInternalName if specification.stream.name.eql?(@stream_entries.stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME)
+
+        @events.read(specification)
+      end
+
+      def streams_of(event_id)
+        @stream_entries.streams_of(event_id)
+          .map{|name| Stream.new(name)}
       end
 
       private

data/lib/ruby_event_store/rom/repositories/events.rb

@@ -35,31 +35,54 @@ module RubyEventStore
           events.map_with(:event_to_serialized_record).by_pk(event_id).one!
         end
 
-        def read(direction, stream, from:, limit:, batch_size:)
-          unless from.equal?(:head)
-            offset_entry_id = stream_entries.by_stream_and_event_id(stream, from).fetch(:id)
+        def last_stream_event(stream)
+          query = stream_entries.ordered(:backward, stream)
+          query = query_builder(query, limit: 1)
+          query.first
+        end
+
+        def read(specification)
+          unless specification.head?
+            offset_entry_id = stream_entries.by_stream_and_event_id(specification.stream, specification.start).fetch(:id)
           end
 
-          if batch_size
+          direction = specification.forward? ? :forward : :backward
+          limit = specification.limit if specification.limit?
+          if specification.last? && specification.head?
+            direction = specification.forward? ? :backward : :forward
+          end
+
+          query = stream_entries.ordered(direction, specification.stream, offset_entry_id)
+
+          if specification.batched?
             reader = ->(offset, limit) do
-              stream_entries
-                .ordered(direction, stream, offset_entry_id)
-                .offset(offset)
-                .take(limit)
-                .combine(:event)
-                .map_with(:stream_entry_to_serialized_record, auto_struct: false)
-                .to_ary
+              query_builder(query, offset: offset, limit: limit).to_ary
             end
-            BatchEnumerator.new(batch_size, limit || Float::INFINITY, reader).each
+            BatchEnumerator.new(specification.batch_size, limit || Float::INFINITY, reader).each
           else
-            stream_entries
-              .ordered(direction, stream, offset_entry_id)
-              .take(limit)
-              .combine(:event)
-              .map_with(:stream_entry_to_serialized_record, auto_struct: false)
-              .each
+            query = query_builder(query, limit: limit)
+            if specification.head?
+              specification.first? || specification.last? ? query.first : query.each
+            else
+              if specification.last?
+                query.to_ary.last
+              else
+                specification.first? ? query.first : query.each
+              end
+            end
           end
         end
+
+      protected
+
+        def query_builder(query, offset: nil, limit: nil)
+          query = query.offset(offset) if offset
+          query = query.take(limit)    if limit
+
+          query
+            .combine(:event)
+            .map_with(:stream_entry_to_serialized_record, auto_struct: false)
+        end
       end
     end
   end

data/lib/ruby_event_store/rom/repositories/stream_entries.rb

@@ -14,7 +14,7 @@ module RubyEventStore
 
         def create_changeset(event_ids, stream, resolved_version, global_stream: nil)
           tuples = []
-          
+
           event_ids.each_with_index do |event_id, index|
             tuples << {
               stream: stream.name,
@@ -41,6 +41,11 @@ module RubyEventStore
             (stream_entries.max_position(stream) || {})[:position]
           })
         end
+
+        def streams_of(event_id)
+          stream_entries.by_event_id(event_id).map{|e| e[:stream]}
+            .reject{|s| s == stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME}
+        end
       end
     end
   end

data/lib/ruby_event_store/rom/version.rb

@@ -1,5 +1,5 @@
 module RubyEventStore
   module ROM
-    VERSION = "0.31.1"
+    VERSION = "0.32.0"
   end
 end

data/lib/ruby_event_store/spec/rom/event_repository_lint.rb

@@ -18,11 +18,15 @@ module RubyEventStore::ROM
     let(:test_expected_version_auto) { true }
     let(:test_link_events_to_stream) { true }
     let(:test_binary) { false }
+    let(:test_change) { false }
 
     let(:default_stream) { RubyEventStore::Stream.new('stream') }
     let(:global_stream) { RubyEventStore::Stream.new('all') }
     let(:mapper) { RubyEventStore::Mappers::NullMapper.new }
-    
+
+    let(:reader) { RubyEventStore::SpecificationReader.new(repository, mapper) }
+    let(:specification) { RubyEventStore::Specification.new(reader) }
+
     it_behaves_like :event_repository, repository_class
 
     specify "#initialize requires ROM::Env" do
@@ -45,80 +49,80 @@ module RubyEventStore::ROM
 
     specify "all considered internal detail" do
       repository.append_to_stream(
-        [SRecord.new],
+        [RubyEventStore::SRecord.new],
         RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
         RubyEventStore::ExpectedVersion.any
       )
       reserved_stream = RubyEventStore::Stream.new("all")
 
-      expect{ repository.read(RubyEventStore::Specification.new(repository, mapper).stream("all").result) }.to raise_error(RubyEventStore::ReservedInternalName)
-      expect{ repository.read(RubyEventStore::Specification.new(repository, mapper).stream("all").backward.result) }.to raise_error(RubyEventStore::ReservedInternalName)
-      expect{ repository.read(RubyEventStore::Specification.new(repository, mapper).stream("all").from(:head).limit(5).result) }.to raise_error(RubyEventStore::ReservedInternalName)
-      expect{ repository.read(RubyEventStore::Specification.new(repository, mapper).stream("all").from(:head).limit(5).backward.result) }.to raise_error(RubyEventStore::ReservedInternalName)
+      expect{ repository.read(specification.stream("all").result) }.to raise_error(RubyEventStore::ReservedInternalName)
+      expect{ repository.read(specification.stream("all").backward.result) }.to raise_error(RubyEventStore::ReservedInternalName)
+      expect{ repository.read(specification.stream("all").from(:head).limit(5).result) }.to raise_error(RubyEventStore::ReservedInternalName)
+      expect{ repository.read(specification.stream("all").from(:head).limit(5).backward.result) }.to raise_error(RubyEventStore::ReservedInternalName)
     end
 
     specify "explicit sorting by position rather than accidental" do
       events = [
-        SRecord.new(
+        RubyEventStore::SRecord.new(
           event_id: u1 = SecureRandom.uuid,
           data: YAML.dump({}),
           metadata: YAML.dump({}),
           event_type: "TestDomainEvent"
         ),
-        SRecord.new(
+        RubyEventStore::SRecord.new(
           event_id: u2 = SecureRandom.uuid,
           data: YAML.dump({}),
           metadata: YAML.dump({}),
           event_type: "TestDomainEvent"
         ),
-        SRecord.new(
+        RubyEventStore::SRecord.new(
           event_id: u3 = SecureRandom.uuid,
           data: YAML.dump({}),
           metadata: YAML.dump({}),
           event_type: "TestDomainEvent"
         )
       ]
-      
+
       repo = Repositories::Events.new(container)
       repo.create_changeset(events).commit
 
       expect(repo.events.to_a.size).to eq(3)
-      
+
       repo.stream_entries.changeset(Repositories::StreamEntries::Create, [
         {stream: default_stream.name, event_id: events[1].event_id, position: 1},
         {stream: default_stream.name, event_id: events[0].event_id, position: 0},
         {stream: default_stream.name, event_id: events[2].event_id, position: 2}
       ]).commit
-      
+
       expect(repo.stream_entries.to_a.size).to eq(3)
-      
+
       # ActiveRecord::Schema.define do
       #   self.verbose = false
       #   remove_index :event_store_events_in_streams, [:stream, :position]
       # end
 
-      expect(repository.read(RubyEventStore::Specification.new(repository, mapper).stream("stream").from(:head).limit(3).result).map(&:event_id)).to eq([u1,u2,u3])
-      expect(repository.read(RubyEventStore::Specification.new(repository, mapper).stream("stream").result).map(&:event_id)).to eq([u1,u2,u3])
+      expect(repository.read(specification.stream("stream").from(:head).limit(3).result).map(&:event_id)).to eq([u1,u2,u3])
+      expect(repository.read(specification.stream("stream").result).map(&:event_id)).to eq([u1,u2,u3])
 
-      expect(repository.read(RubyEventStore::Specification.new(repository, mapper).stream("stream").backward.from(:head).limit(3).result).map(&:event_id)).to eq([u3,u2,u1])
-      expect(repository.read(RubyEventStore::Specification.new(repository, mapper).stream("stream").backward.result).map(&:event_id)).to eq([u3,u2,u1])
+      expect(repository.read(specification.stream("stream").backward.from(:head).limit(3).result).map(&:event_id)).to eq([u3,u2,u1])
+      expect(repository.read(specification.stream("stream").backward.result).map(&:event_id)).to eq([u3,u2,u1])
     end
 
     specify "explicit sorting by id rather than accidental for all events" do
       events = [
-        SRecord.new(
+        RubyEventStore::SRecord.new(
           event_id: u1 = SecureRandom.uuid,
           data: YAML.dump({}),
           metadata: YAML.dump({}),
           event_type: "TestDomainEvent"
         ),
-        SRecord.new(
+        RubyEventStore::SRecord.new(
           event_id: u2 = SecureRandom.uuid,
           data: YAML.dump({}),
           metadata: YAML.dump({}),
           event_type: "TestDomainEvent"
         ),
-        SRecord.new(
+        RubyEventStore::SRecord.new(
           event_id: u3 = SecureRandom.uuid,
           data: YAML.dump({}),
           metadata: YAML.dump({}),
@@ -130,37 +134,37 @@ module RubyEventStore::ROM
       repo.create_changeset(events).commit
 
       expect(repo.events.to_a.size).to eq(3)
-      
+
       repo.stream_entries.changeset(Repositories::StreamEntries::Create, [
         {stream: global_stream.name, event_id: events[0].event_id, position: 1},
         {stream: global_stream.name, event_id: events[1].event_id, position: 0},
         {stream: global_stream.name, event_id: events[2].event_id, position: 2}
       ]).commit
-      
+
       expect(repo.stream_entries.to_a.size).to eq(3)
-      
-      expect(repository.read(RubyEventStore::Specification.new(repository, mapper).from(:head).limit(3).result).map(&:event_id)).to eq([u1,u2,u3])
-      expect(repository.read(RubyEventStore::Specification.new(repository, mapper).from(:head).limit(3).backward.result).map(&:event_id)).to eq([u3,u2,u1])
+
+      expect(repository.read(specification.from(:head).limit(3).result).map(&:event_id)).to eq([u1,u2,u3])
+      expect(repository.read(specification.from(:head).limit(3).backward.result).map(&:event_id)).to eq([u3,u2,u1])
     end
 
     specify "nested transaction - events still not persisted if append failed" do
       repository.append_to_stream([
-        event = SRecord.new(event_id: SecureRandom.uuid),
+        event = RubyEventStore::SRecord.new(event_id: SecureRandom.uuid),
       ], default_stream, RubyEventStore::ExpectedVersion.none)
 
       env.unit_of_work do
         expect do
           repository.append_to_stream([
-            SRecord.new(
+            RubyEventStore::SRecord.new(
               event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763'
             ),
           ], default_stream, RubyEventStore::ExpectedVersion.none)
         end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
         expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
-        expect(repository.read(RubyEventStore::Specification.new(repository, mapper).from(:head).limit(2).result).to_a).to eq([event])
+        expect(repository.read(specification.from(:head).limit(2).result).to_a).to eq([event])
       end
       expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
-      expect(repository.read(RubyEventStore::Specification.new(repository, mapper).from(:head).limit(2).result).to_a).to eq([event])
+      expect(repository.read(specification.from(:head).limit(2).result).to_a).to eq([event])
     end
 
     def cleanup_concurrency_test

data/ruby_event_store-rom.gemspec

@@ -36,9 +36,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'childprocess'
   spec.add_development_dependency 'google-protobuf', '~> 3.5.1.2'
 
-  spec.add_dependency 'ruby_event_store', '= 0.31.1'
+  spec.add_dependency 'ruby_event_store', '= 0.32.0'
   spec.add_dependency 'sequel', '>= 4.49'
   spec.add_dependency 'dry-types', '~> 0.12.2'
+  spec.add_dependency 'dry-initializer', '= 2.5.0'
   spec.add_dependency 'rom-sql', '>= 2.4'
   spec.add_dependency 'rom-repository', '>= 2.0'
   spec.add_dependency 'rom-changeset', '>= 1.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store-rom
 version: !ruby/object:Gem::Version
-  version: 0.31.1
+  version: 0.32.0
 platform: ruby
 authors:
 - Joel Van Horn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-17 00:00:00.000000000 Z
+date: 2018-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -156,14 +156,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.31.1
+        version: 0.32.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.31.1
+        version: 0.32.0
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -192,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: rom-sql
   requirement: !ruby/object:Gem::Requirement