ruby_event_store-rom 0.30.0 → 0.31.0

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

@@ -0,0 +1,206 @@
+require 'ruby_event_store/rom/event_repository'
+require 'ruby_event_store/spec/event_repository_lint'
+
+module RubyEventStore::ROM
+  RSpec.shared_examples :rom_event_repository do |repository_class|
+    subject(:repository) { repository_class.new(rom: env) }
+
+    let(:env) { rom_helper.env }
+    let(:container) { env.container }
+    let(:rom_db) { container.gateways[:default] }
+
+    around(:each) do |example|
+      rom_helper.run_lifecycle { example.run }
+    end
+
+    let(:test_race_conditions_auto)  { rom_helper.has_connection_pooling? }
+    let(:test_race_conditions_any)   { rom_helper.has_connection_pooling? }
+    let(:test_expected_version_auto) { true }
+    let(:test_link_events_to_stream) { true }
+    let(:test_binary) { false }
+
+    let(:default_stream) { RubyEventStore::Stream.new('stream') }
+    let(:global_stream) { RubyEventStore::Stream.new('all') }
+    let(:mapper) { RubyEventStore::Mappers::NullMapper.new }
+    
+    it_behaves_like :event_repository, repository_class
+
+    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")
+      end
+    end
+
+    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
+      RubyEventStore::ROM.env = nil
+    end
+
+    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
+      repository.append_to_stream(
+        [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)
+    end
+
+    specify "explicit sorting by position rather than accidental" do
+      events = [
+        SRecord.new(
+          event_id: u1 = SecureRandom.uuid,
+          data: YAML.dump({}),
+          metadata: YAML.dump({}),
+          event_type: "TestDomainEvent"
+        ),
+        SRecord.new(
+          event_id: u2 = SecureRandom.uuid,
+          data: YAML.dump({}),
+          metadata: YAML.dump({}),
+          event_type: "TestDomainEvent"
+        ),
+        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(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])
+    end
+
+    specify "explicit sorting by id rather than accidental for all events" do
+      events = [
+        SRecord.new(
+          event_id: u1 = SecureRandom.uuid,
+          data: YAML.dump({}),
+          metadata: YAML.dump({}),
+          event_type: "TestDomainEvent"
+        ),
+        SRecord.new(
+          event_id: u2 = SecureRandom.uuid,
+          data: YAML.dump({}),
+          metadata: YAML.dump({}),
+          event_type: "TestDomainEvent"
+        ),
+        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: 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])
+    end
+
+    specify "nested transaction - events still not persisted if append failed" do
+      repository.append_to_stream([
+        event = SRecord.new(event_id: SecureRandom.uuid),
+      ], default_stream, RubyEventStore::ExpectedVersion.none)
+
+      env.unit_of_work do
+        expect do
+          repository.append_to_stream([
+            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])
+      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])
+    end
+
+    def cleanup_concurrency_test
+      rom_helper.close_pool_connection
+    end
+
+    def verify_conncurency_assumptions
+      expect(rom_helper.connection_pool_size).to eq(5)
+    end
+
+    # 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)
+    end
+
+    private
+
+    # TODO: Port from AR to ROM
+    def count_queries(&block)
+      count = 0
+      counter_f = ->(_name, _started, _finished, _unique_id, payload) {
+        unless %w[ CACHE SCHEMA ].include?(payload[:name])
+          count += 1
+        end
+      }
+      # ActiveSupport::Notifications.subscribed(counter_f, "sql.active_record", &block)
+      count
+    end
+
+    # TODO: Port from AR to ROM
+    def expect_query(match, &block)
+      count = 0
+      counter_f = ->(_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
+  end
+end

data/lib/ruby_event_store/spec/rom/relations/events_lint.rb

@@ -0,0 +1,75 @@
+RSpec.shared_examples :events_relation do |relation_class|
+  subject(:relation) { container.relations[:events] }
+
+  let(:env) { rom_helper.env }
+  let(:container) { env.container }
+  let(:rom_db) { container.gateways[:default] }
+
+  around(:each) do |example|
+    rom_helper.run_lifecycle { example.run }
+  end
+
+  it 'just created is empty' do
+    expect(relation.to_a).to be_empty
+  end
+
+  specify '#exist? indicates if one instance of the record exists by primary key' do
+    event = {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now}
+
+    expect(relation.by_pk(event[:id]).exist?).to eq(false)
+
+    relation.insert(event)
+
+    expect(relation.by_pk(event[:id]).exist?).to eq(true)
+  end
+
+  specify '#insert verifies tuple is unique' do
+    events = [
+      {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now},
+      {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now},
+      {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now}
+    ]
+
+    relation.command(:create).call(events[0..1])
+
+    expect do
+      env.handle_error(:unique_violation) { relation.insert(events[0]) }
+    end.to raise_error(RubyEventStore::EventDuplicatedInStream)
+    expect do
+      env.handle_error(:unique_violation) { relation.insert(events[1]) }
+    end.to raise_error(RubyEventStore::EventDuplicatedInStream)
+    expect{relation.insert(events[2])}.not_to raise_error
+    expect do
+      env.handle_error(:unique_violation) { relation.insert(events[2]) }
+    end.to raise_error(RubyEventStore::EventDuplicatedInStream)
+  end
+
+  specify '#by_pk finds tuples by ID' do
+    events = [
+      {id: id = SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now},
+      {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now},
+      {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now}
+    ]
+
+    relation.command(:create).call(events)
+
+    expect(relation.by_pk(id).to_a.size).to eq(1)
+    expect(relation.by_pk(id).to_a.map { |e| e[:id] }).to eq([id])
+  end
+
+  specify 'each method returns proper type' do
+    events = [
+      {id: id = SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now},
+      {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now},
+      {id: SecureRandom.uuid, event_type: "TestEvent", data: "", metadata: "", created_at: Time.now}
+    ]
+
+    relation.command(:create).call(events)
+
+    expect(relation.by_pk(SecureRandom.uuid).exist?).to eq(false)
+    expect(relation.by_pk(id).exist?).to eq(true)
+
+    expect(relation.by_pk(id)).to be_a(relation.class)
+    # expect(relation.by_pk(id).first).to be_a(::ROM::Struct)
+  end
+end

data/lib/ruby_event_store/spec/rom/relations/stream_entries_lint.rb

@@ -0,0 +1,198 @@
+RSpec.shared_examples :stream_entries_relation do |relation_class|
+  subject(:relation) { container.relations[:stream_entries] }
+
+  let(:env) { rom_helper.env }
+  let(:container) { env.container }
+  let(:rom_db) { container.gateways[:default] }
+
+  around(:each) do |example|
+    rom_helper.run_lifecycle { example.run }
+  end
+
+  it 'just created is empty' do
+    expect(relation.to_a).to be_empty
+  end
+
+  specify '#insert verifies tuple is unique steam and event_id' do
+    stream_entries = [
+      {stream: 'stream', position: 0, event_id: id1 = SecureRandom.uuid},
+      {stream: 'stream', position: 1, event_id: SecureRandom.uuid},
+      {stream: 'stream', position: 2, event_id: SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    conflicting_event_id = {stream: 'stream', position: 3, event_id: id1, created_at: Time.now}
+
+    expect(relation.to_a.size).to eq(3)
+    expect do
+      env.handle_error(:unique_violation) { relation.insert(conflicting_event_id) }
+    end.to raise_error(RubyEventStore::EventDuplicatedInStream)
+
+    conflicting_position = {stream: 'stream', position: 2, event_id: SecureRandom.uuid, created_at: Time.now}
+
+    expect do
+      env.handle_error(:unique_violation) { relation.insert(conflicting_position) }
+    end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
+  end
+
+  specify '#take ignores nil' do
+    stream_entries = [
+      {stream: 'stream', position: 0, event_id: id1 = SecureRandom.uuid},
+      {stream: 'stream', position: 1, event_id: id2 = SecureRandom.uuid},
+      {stream: 'stream', position: 2, event_id: id3 = SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.to_a.size).to eq(3)
+    expect(relation.take(nil).to_a.size).to eq(3)
+    expect(relation.take(nil).map { |e| e[:event_id] }).to eq([id1, id2, id3])
+  end
+
+  specify '#take returns specified number of tuples' do
+    stream_entries = [
+      {stream: 'stream', position: 0, event_id: id1 = SecureRandom.uuid},
+      {stream: 'stream', position: 1, event_id: id2 = SecureRandom.uuid},
+      {stream: 'stream', position: 2, event_id: SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.to_a.size).to eq(3)
+    expect(relation.take(2).to_a.size).to eq(2)
+    expect(relation.take(2).map { |e| e[:event_id] }).to eq([id1, id2])
+  end
+
+  specify '#by_stream returns tuples for the specified stream' do
+    stream_entries = [
+      {stream: 'stream', position: 0, event_id: SecureRandom.uuid},
+      {stream: 'stream', position: 1, event_id: SecureRandom.uuid},
+      {stream: 'stream2', position: 2, event_id: SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.to_a.size).to eq(3)
+    expect(relation.by_stream(RubyEventStore::Stream.new('stream')).to_a.size).to eq(2)
+  end
+
+  specify '#by_stream_and_event_id returns a tuple for the specified stream and event_id' do
+    stream = RubyEventStore::Stream.new('stream')
+    stream2 = RubyEventStore::Stream.new('stream2')
+
+    stream_entries = [
+      {stream: stream.name, position: 0, event_id: id = SecureRandom.uuid},
+      {stream: stream.name, position: 1, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 2, event_id: SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.to_a.size).to eq(3)
+    expect(relation.by_stream_and_event_id(stream, id)[:event_id]).to eq(id)
+    expect{relation.by_stream_and_event_id(stream2, id)}.to raise_error(ROM::TupleCountMismatchError)
+  end
+
+  specify '#max_position gets the largest position value' do
+    stream = RubyEventStore::Stream.new('stream')
+    stream2 = RubyEventStore::Stream.new('stream2')
+    stream3 = RubyEventStore::Stream.new('stream3')
+
+    stream_entries = [
+      {stream: stream.name, position: 0, event_id: SecureRandom.uuid},
+      {stream: stream.name, position: 2, event_id: id = SecureRandom.uuid},
+      {stream: stream.name, position: 1, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 1, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 0, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 3, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 2, event_id: SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.to_a.size).to eq(7)
+    expect(relation.max_position(stream)).not_to be(nil)
+    expect(relation.max_position(stream)[:position]).to eq(2)
+    expect(relation.max_position(stream).to_h.keys).to eq([:position])
+    expect(relation.max_position(stream3)).to eq(nil)
+  end
+
+  specify '#ordered gets the stream entries :forward' do
+    stream = RubyEventStore::Stream.new('stream')
+    stream2 = RubyEventStore::Stream.new('stream2')
+
+    stream_entries = [
+      {stream: stream.name, position: 0, event_id: SecureRandom.uuid},
+      {stream: stream.name, position: 1, event_id: id1 = SecureRandom.uuid},
+      {stream: stream.name, position: 2, event_id: id2 = SecureRandom.uuid},
+      {stream: stream2.name, position: 0, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 1, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 2, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 3, event_id: SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.to_a.size).to eq(7)
+    expect(relation.ordered(:forward, stream).to_a.size).to eq(3)
+    expect(relation.ordered(:forward, stream).map { |e| e[:position] }).to eq([0, 1, 2])
+
+    offset1 = relation.by_stream_and_event_id(stream, id1)[:id]
+    offset2 = relation.by_stream_and_event_id(stream, id2)[:id]
+
+    expect(relation.ordered(:forward, stream, offset1).map { |e| e[:position] }).to eq([2])
+    expect(relation.ordered(:forward, stream, offset2).map { |e| e[:position] }).to eq([])
+  end
+
+  specify '#ordered gets the stream entries :backward' do
+    stream = RubyEventStore::Stream.new('stream')
+    stream2 = RubyEventStore::Stream.new('stream2')
+
+    stream_entries = [
+      {stream: stream.name, position: 0, event_id: id1 = SecureRandom.uuid},
+      {stream: stream.name, position: 1, event_id: id2 = SecureRandom.uuid},
+      {stream: stream.name, position: 2, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 0, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 1, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 2, event_id: SecureRandom.uuid},
+      {stream: stream2.name, position: 3, event_id: SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.to_a.size).to eq(7)
+    expect(relation.ordered(:backward, stream).to_a.size).to eq(3)
+    expect(relation.ordered(:backward, stream).map { |e| e[:position] }).to eq([2, 1, 0])
+
+    offset1 = relation.by_stream_and_event_id(stream, id1)[:id]
+    offset2 = relation.by_stream_and_event_id(stream, id2)[:id]
+
+    expect(relation.ordered(:backward, stream, offset1).map { |e| e[:position] }).to eq([])
+    expect(relation.ordered(:backward, stream, offset2).map { |e| e[:position] }).to eq([0])
+  end
+
+  specify 'each method returns proper type' do
+    stream = RubyEventStore::Stream.new('stream')
+    stream_entries = [
+      {stream: 'stream', position: 0, event_id: id1 = SecureRandom.uuid},
+      {stream: 'stream', position: 1, event_id: id2 = SecureRandom.uuid},
+      {stream: 'stream', position: 2, event_id: id3 = SecureRandom.uuid}
+    ]
+
+    relation.command(:create).call(stream_entries)
+
+    expect(relation.take(1)).to be_a(relation.class)
+    # expect(relation.take(1).one).to be_a(::ROM::Struct)
+
+    expect(relation.by_stream(stream)).to be_a(relation.class)
+    # expect(relation.by_stream(stream).take(1).one).to be_a(::ROM::Struct)
+
+    # expect(relation.by_stream_and_event_id(stream, id1)).to be_a(::ROM::Struct)
+    
+    # expect(relation.max_position(stream)).to be_a(::ROM::Struct)
+
+    expect(relation.ordered(:forward, stream)).to be_a(relation.class)
+    # expect(relation.ordered(:forward, stream).take(1).one).to be_a(::ROM::Struct)
+  end
+end

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

@@ -0,0 +1,15 @@
+module RubyEventStore::ROM
+  RSpec.shared_examples :rom_spec_helper do |rom_spec_helper_class|
+    let(:env) { rom_helper.env }
+    let(:container) { env.container }
+    let(:rom_db) { container.gateways[:default] }
+
+    around(:each) do |example|
+      rom_helper.run_lifecycle { example.run }
+    end
+
+    specify '#env gives access to ROM container' do
+      expect(subject.env.container).to be_a(::ROM::Container)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module RubyEventStore::ROM
+  RSpec.shared_examples :unit_of_work do |unit_of_work_class|
+    subject(:unit_of_work) { unit_of_work_class.new(rom: env) }
+
+    let(:env) { rom_helper.env }
+    let(:container) { env.container }
+    let(:rom_db) { container.gateways[:default] }
+
+    around(:each) do |example|
+      rom_helper.run_lifecycle { example.run }
+    end
+
+    specify '#env gives access to ROM container' do
+      expect(subject.env.container).to be_a(::ROM::Container)
+    end
+
+    specify '#call to throw an exeption' do
+      expect{subject.call(gateway: nil) {}}.to raise_error(KeyError)
+    end
+
+    specify '#env is the instance we specified' do
+      expect(subject.env).to eq(env)
+    end
+
+    specify '#env is the global instance' do
+      RubyEventStore::ROM.env = rom_helper.class.new.env
+
+      subject2 = unit_of_work_class.new
+
+      expect(subject2.env).to eq(RubyEventStore::ROM.env)
+      expect(subject2.env).not_to eq(subject.env)
+      expect(subject.env).not_to eq(RubyEventStore::ROM.env)
+
+      RubyEventStore::ROM.env = nil
+    end
+  end
+end

data/ruby_event_store-rom.gemspec

@@ -29,17 +29,17 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.6'
   spec.add_development_dependency 'sqlite3', '1.3.13'
-  spec.add_development_dependency 'pg', '0.21'
-  spec.add_development_dependency 'mysql2', '0.4.10'
-  spec.add_development_dependency 'mutant-rspec', '~> 0.8.14'
+  spec.add_development_dependency 'pg', '>= 0.21'
+  spec.add_development_dependency 'mysql2', '>= 0.4.10'
+  spec.add_development_dependency 'mutant-rspec', '>= 0.8.14'
   spec.add_development_dependency 'fakefs', '~> 0.11.2'
   spec.add_development_dependency 'childprocess'
   spec.add_development_dependency 'google-protobuf', '~> 3.5.1.2'
 
-  spec.add_dependency 'ruby_event_store', '= 0.30.0'
+  spec.add_dependency 'ruby_event_store', '= 0.31.0'
   spec.add_dependency 'sequel', '>= 4.49'
-  spec.add_dependency 'rom-sql', '~> 2.4'
-  spec.add_dependency 'rom-repository', '~> 2.0'
-  spec.add_dependency 'rom-changeset', '~> 1.0'
   spec.add_dependency 'dry-types', '~> 0.12.2'
+  spec.add_dependency 'rom-sql', '>= 2.4'
+  spec.add_dependency 'rom-repository', '>= 2.0'
+  spec.add_dependency 'rom-changeset', '>= 1.0'
 end