ruby_event_store-rom 0.35.0 → 0.36.0

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

@@ -1,35 +1,34 @@
 require_relative '../mappers/stream_entry_to_serialized_record'
+require_relative '../changesets/create_stream_entries'
 
 module RubyEventStore
   module ROM
     module Repositories
       class StreamEntries < ::ROM::Repository[:stream_entries]
-        class Create < ::ROM::Changeset::Create
-          map do |tuple|
-            Hash(created_at: Time.now).merge(tuple)
-          end
-        end
-
-        POSITION_SHIFT = 1.freeze
+        POSITION_SHIFT = 1
 
         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,
-              position: resolved_version && resolved_version + index + POSITION_SHIFT,
-              event_id: event_id
-             } unless stream.global?
+            unless stream.global?
+              tuples << {
+                stream: stream.name,
+                position: resolved_version && resolved_version + index + POSITION_SHIFT,
+                event_id: event_id
+              }
+            end
+
+            next unless global_stream
 
-             tuples << {
+            tuples << {
               stream: stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME,
               position: nil,
               event_id: event_id
-            } if global_stream
+            }
           end
 
-          stream_entries.changeset(Create, tuples)
+          stream_entries.create_changeset(tuples)
         end
 
         def delete(stream)
@@ -37,14 +36,14 @@ module RubyEventStore
         end
 
         def resolve_version(stream, expected_version)
-          expected_version.resolve_for(stream, ->(_stream) {
+          expected_version.resolve_for(stream, lambda { |_stream|
             (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}
+          stream_entries.by_event_id(event_id).map { |e| e[:stream] }
+                        .reject { |s| s == stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME }
         end
       end
     end

data/lib/ruby_event_store/rom/sql.rb

@@ -1,9 +1,10 @@
 require 'ruby_event_store/rom'
 require 'rom/sql'
 require_relative 'adapters/sql/index_violation_detector'
-require_relative 'adapters/sql/unit_of_work'
 require_relative 'adapters/sql/relations/events'
 require_relative 'adapters/sql/relations/stream_entries'
+require_relative 'adapters/sql/changesets/create_events'
+require_relative 'adapters/sql/changesets/update_events'
 
 module RubyEventStore
   module ROM
@@ -17,33 +18,74 @@ module RubyEventStore
         def configure(env)
           # See: https://github.com/jeremyevans/sequel/blob/master/doc/transactions.rdoc
           env.register_unit_of_work_options(
-            class: UnitOfWork,
-            savepoint: true
+            savepoint: true,
+            # Committing changesets concurrently causes MySQL deadlocks
+            # which are not caught and retried by Sequel's built-in
+            # :retry_on option. This appears to be a result of how ROM
+            # handles exceptions which don't bubble up so that Sequel
+            # can retry transactions with the :retry_on option when there's
+            # a deadlock.
+            #
+            # This is exacerbated by the fact that changesets insert multiple
+            # tuples with individual INSERT statements because ROM specifies
+            # to Sequel to return a list of primary keys created. The likelihood
+            # of a deadlock is reduced with batched INSERT statements.
+            #
+            # For this reason we need to manually insert changeset records to avoid
+            # MySQL deadlocks or to allow Sequel to retry transactions
+            # when the :retry_on option is specified.
+            retry_on: Sequel::SerializationFailure,
+            before_retry: lambda { |_num, ex|
+              env.logger.warn("RETRY TRANSACTION [#{self.class.name} => #{ex.class.name}] #{ex.message}")
+            }
           )
 
-          env.register_error_handler :unique_violation, -> ex {
+          env.register_error_handler :unique_violation, lambda { |ex|
             case ex
             when ::ROM::SQL::UniqueConstraintError, Sequel::UniqueConstraintViolation
               raise EventDuplicatedInStream if IndexViolationDetector.new.detect(ex.message)
+
               raise WrongExpectedEventVersion
             end
           }
 
-          env.register_error_handler :not_found, -> (ex, event_id) {
+          env.register_error_handler :not_found, lambda { |ex, event_id|
             case ex
             when ::ROM::TupleCountMismatchError
-              raise EventNotFound.new(event_id)
+              raise EventNotFound, event_id
             when Sequel::DatabaseError
               raise ex unless ex.message =~ /PG::InvalidTextRepresentation.*uuid/
-              raise EventNotFound.new(event_id)
+
+              raise EventNotFound, event_id
             end
           }
         end
+
+        def supports_upsert?(db)
+          supports_on_duplicate_key_update?(db) ||
+          supports_insert_conflict_update?(db)
+        end
+
+        def supports_on_duplicate_key_update?(db)
+          db.adapter_scheme =~ /mysql/
+        end
+
+        def supports_insert_conflict_update?(db)
+          case db.adapter_scheme
+          when :postgres
+            true
+          when :sqlite
+            # Sqlite 3.24.0+ supports PostgreSQL upsert syntax
+            db.sqlite_version >= 32400
+          else
+            false
+          end
+        end
       end
 
       class SpecHelper
         attr_reader :env
-        
+
         def initialize(database_uri = ENV['DATABASE_URL'])
           config = ::ROM::Configuration.new(
             :sql,
@@ -56,10 +98,10 @@ module RubyEventStore
           # config.default.use_logger Logger.new(STDOUT)
           # config.default.connection.pool.send(:preconnect, true)
           config.default.run_migrations
-    
+
           @env = ROM.setup(config)
         end
-        
+
         def run_lifecycle
           establish_gateway_connection
           load_gateway_schema
@@ -74,8 +116,12 @@ module RubyEventStore
           env.container.gateways.fetch(:default)
         end
 
+        def gateway_type?(name)
+          gateway.connection.database_type.eql?(name)
+        end
+
         def has_connection_pooling?
-          !gateway.connection.database_type.eql?(:sqlite)
+          !gateway_type?(:sqlite)
         end
 
         def connection_pool_size
@@ -86,7 +132,11 @@ module RubyEventStore
           gateway.connection.pool.disconnect
         end
 
-      protected
+        def supports_upsert?
+          SQL.supports_upsert?(gateway.connection)
+        end
+
+        protected
 
         def establish_gateway_connection
           # Manually preconnect because disconnecting and reconnecting

data/lib/ruby_event_store/rom/types.rb

@@ -0,0 +1,13 @@
+module RubyEventStore
+  module ROM
+    module Types
+      DateTime = ::ROM::Types::DateTime
+                 .constructor { |value| value.is_a?(::String) ? ::DateTime.iso8601(value) : value }
+                 .default { ::DateTime.now.new_offset(0) }
+
+      SerializedRecordSerializer = ::ROM::Types::String
+      # detects if the value is a Sequel::Postgres::JSONHash or Sequel::Postgres::JSONBHash
+      SerializedRecordDeserializer = ::ROM::Types::String.constructor { |v| v.class.name.upcase.include?('JSON') ? JSON.dump(v) : v }
+    end
+  end
+end

data/lib/ruby_event_store/rom/unit_of_work.rb

@@ -8,7 +8,7 @@ module RubyEventStore
       end
 
       def call(**options)
-        gateway = @env.container.gateways.fetch(options.delete(:gateway){:default})
+        gateway = @env.container.gateways.fetch(options.delete(:gateway) { :default })
 
         yield(changesets = [])
 

data/lib/ruby_event_store/rom/version.rb

@@ -1,5 +1,5 @@
 module RubyEventStore
   module ROM
-    VERSION = "0.35.0"
+    VERSION = "0.36.0"
   end
 end

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

@@ -18,7 +18,7 @@ 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(:test_change) { rom_helper.supports_upsert? }
 
     let(:default_stream) { RubyEventStore::Stream.new('stream') }
     let(:global_stream) { RubyEventStore::Stream.new('all') }
@@ -29,60 +29,44 @@ module RubyEventStore::ROM
 
     it_behaves_like :event_repository, repository_class
 
-    specify "#initialize requires ROM::Env" do
-      expect{repository_class.new(rom: nil)}.to raise_error do |err|
+    specify '#initialize requires ROM::Env' do
+      expect { repository_class.new(rom: nil) }.to raise_error do |err|
         expect(err).to be_a(ArgumentError)
-        expect(err.message).to eq("Must specify rom")
+        expect(err.message).to eq('Must specify rom')
       end
     end
 
-    specify "#initialize uses ROM.env by default" do
-      expect{repository_class.new}.to raise_error(ArgumentError)
+    specify '#initialize uses ROM.env by default' do
+      expect { repository_class.new }.to raise_error(ArgumentError)
       RubyEventStore::ROM.env = env
-      expect{repository_class.new}.not_to raise_error
+      expect { repository_class.new }.not_to raise_error
       RubyEventStore::ROM.env = nil
     end
 
-    specify "#has_event? to raise exception for bad ID" do
+    specify '#has_event? to raise exception for bad ID' do
       expect(repository.has_event?('0')).to eq(false)
     end
 
-    specify "all considered internal detail" do
+    specify 'all considered internal detail' do
       repository.append_to_stream(
         [RubyEventStore::SRecord.new],
         RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
         RubyEventStore::ExpectedVersion.any
       )
-      reserved_stream = RubyEventStore::Stream.new("all")
 
-      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)
+      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)
 
-      expect{ repository.count(specification.stream("all").result) }.to raise_error(RubyEventStore::ReservedInternalName)
+      expect { repository.count(specification.stream('all').result) }.to raise_error(RubyEventStore::ReservedInternalName)
     end
 
-    specify "explicit sorting by position rather than accidental" do
+    specify 'explicit sorting by position rather than accidental' do
       events = [
-        RubyEventStore::SRecord.new(
-          event_id: u1 = SecureRandom.uuid,
-          data: YAML.dump({}),
-          metadata: YAML.dump({}),
-          event_type: "TestDomainEvent"
-        ),
-        RubyEventStore::SRecord.new(
-          event_id: u2 = SecureRandom.uuid,
-          data: YAML.dump({}),
-          metadata: YAML.dump({}),
-          event_type: "TestDomainEvent"
-        ),
-        RubyEventStore::SRecord.new(
-          event_id: u3 = SecureRandom.uuid,
-          data: YAML.dump({}),
-          metadata: YAML.dump({}),
-          event_type: "TestDomainEvent"
-        )
+        RubyEventStore::SRecord.new(event_id: u1 = SecureRandom.uuid),
+        RubyEventStore::SRecord.new(event_id: u2 = SecureRandom.uuid),
+        RubyEventStore::SRecord.new(event_id: u3 = SecureRandom.uuid)
       ]
 
       repo = Repositories::Events.new(container)
@@ -90,11 +74,11 @@ module RubyEventStore::ROM
 
       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
+      repo.stream_entries.changeset(Changesets::CreateStreamEntries, [
+                                      { 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)
 
@@ -103,33 +87,18 @@ module RubyEventStore::ROM
       #   remove_index :event_store_events_in_streams, [:stream, :position]
       # end
 
-      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(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(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])
+      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
+    specify 'explicit sorting by id rather than accidental for all events' do
       events = [
-        RubyEventStore::SRecord.new(
-          event_id: u1 = SecureRandom.uuid,
-          data: YAML.dump({}),
-          metadata: YAML.dump({}),
-          event_type: "TestDomainEvent"
-        ),
-        RubyEventStore::SRecord.new(
-          event_id: u2 = SecureRandom.uuid,
-          data: YAML.dump({}),
-          metadata: YAML.dump({}),
-          event_type: "TestDomainEvent"
-        ),
-        RubyEventStore::SRecord.new(
-          event_id: u3 = SecureRandom.uuid,
-          data: YAML.dump({}),
-          metadata: YAML.dump({}),
-          event_type: "TestDomainEvent"
-        )
+        RubyEventStore::SRecord.new(event_id: u1 = SecureRandom.uuid),
+        RubyEventStore::SRecord.new(event_id: u2 = SecureRandom.uuid),
+        RubyEventStore::SRecord.new(event_id: u3 = SecureRandom.uuid)
       ]
 
       repo = Repositories::Events.new(container)
@@ -137,30 +106,28 @@ module RubyEventStore::ROM
 
       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
+      repo.stream_entries.changeset(Changesets::CreateStreamEntries, [
+                                      { 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(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])
+      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
+    specify 'nested transaction - events still not persisted if append failed' do
       repository.append_to_stream([
-        event = RubyEventStore::SRecord.new(event_id: SecureRandom.uuid),
-      ], default_stream, RubyEventStore::ExpectedVersion.none)
+                                    event = RubyEventStore::SRecord.new(event_id: SecureRandom.uuid)
+                                  ], default_stream, RubyEventStore::ExpectedVersion.none)
 
       env.unit_of_work do
         expect do
           repository.append_to_stream([
-            RubyEventStore::SRecord.new(
-              event_id: '9bedf448-e4d0-41a3-a8cd-f94aec7aa763'
-            ),
-          ], default_stream, RubyEventStore::ExpectedVersion.none)
+                                        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(specification.from(:head).limit(2).result).to_a).to eq([event])
@@ -179,32 +146,30 @@ module RubyEventStore::ROM
 
     # TODO: Port from AR to ROM
     def additional_limited_concurrency_for_auto_check
-      positions = container.relations[:stream_entries].
-        ordered(:forward, default_stream).
-        map { |entity| entity[:position] }
-      expect(positions).to eq((0..positions.size-1).to_a)
+      positions = container.relations[:stream_entries]
+                           .ordered(:forward, default_stream)
+                           .map { |entity| entity[:position] }
+      expect(positions).to eq((0..positions.size - 1).to_a)
     end
 
     private
 
     # TODO: Port from AR to ROM
-    def count_queries(&block)
+    def count_queries
       count = 0
-      counter_f = ->(_name, _started, _finished, _unique_id, payload) {
-        unless %w[ CACHE SCHEMA ].include?(payload[:name])
-          count += 1
-        end
-      }
+      # counter_f = lambda { |_name, _started, _finished, _unique_id, payload|
+      #   count += 1 unless %w[CACHE SCHEMA].include?(payload[:name])
+      # }
       # ActiveSupport::Notifications.subscribed(counter_f, "sql.active_record", &block)
       count
     end
 
     # TODO: Port from AR to ROM
-    def expect_query(match, &block)
+    def expect_query(_match)
       count = 0
-      counter_f = ->(_name, _started, _finished, _unique_id, payload) {
-        count += 1 if match === payload[:sql]
-      }
+      # counter_f = lambda { |_name, _started, _finished, _unique_id, payload|
+      #   count += 1 if match === payload[:sql]
+      # }
       # ActiveSupport::Notifications.subscribed(counter_f, "sql.active_record", &block)
       expect(count).to eq(1)
     end