ruby_event_store-rom 1.3.1 → 2.1.0

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module SQL
-      module Relations
-        class StreamEntries < ::ROM::Relation[:sql]
-          schema(:event_store_events_in_streams, as: :stream_entries, infer: true) do
-            attribute :created_at, RubyEventStore::ROM::Types::DateTime
-
-            associations do
-              belongs_to :events, as: :event, foreign_key: :event_id
-            end
-          end
-
-          alias take limit
-
-          SERIALIZED_GLOBAL_STREAM_NAME = 'all'.freeze
-
-          def create_changeset(tuples)
-            changeset(ROM::Changesets::CreateStreamEntries, tuples)
-          end
-
-          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_event_type(types)
-            join(:events).where(event_type: types)
-          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: %i[asc > <],
-            backward: %i[desc < >]
-          }.freeze
-
-          def ordered(direction, stream, offset_entry_id = nil, stop_entry_id = nil)
-            order, operator_offset, operator_stop = 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, offset_entry_id) } if offset_entry_id
-            query = query.where { id.public_send(operator_stop, stop_entry_id) } if stop_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
-        end
-      end
-    end
-  end
-end

data/lib/ruby_event_store/rom/adapters/sql/tasks/migration_tasks.rake

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby_event_store/rom/sql'
-
-MIGRATIONS_PATH = 'db/migrate'.freeze
-
-desc 'Setup ROM EventRespository environment'
-task 'db:setup' do
-  Dir.chdir(Dir.pwd)
-  ROM::SQL::RakeSupport.env = ::RubyEventStore::ROM.configure(:sql).rom_container
-end
-
-desc 'Copy RubyEventStore SQL migrations to db/migrate'
-task 'db:migrations:copy' => 'db:setup' do
-  # Optional data type for `data` and `metadata`
-  data_type = ENV['DATA_TYPE']
-
-  Dir[File.join(File.dirname(__FILE__), '../../../../../../', MIGRATIONS_PATH, '/*.rb')].each do |input|
-    contents = File.read(input)
-    name     = File.basename(input, '.*').sub(/\d+_/, '')
-
-    re_data_type = /(ENV.+?DATA_TYPE.+?\|\|=\s*)['"](jsonb?|text)['"]/
-
-    if data_type && contents =~ re_data_type
-      # Search/replace this string: ENV['DATA_TYPE'] ||= 'text'
-      contents = contents.sub(re_data_type, format('\1"%<data_type>s"', data_type: data_type))
-      name    += "_with_#{data_type}"
-    end
-
-    output = ROM::SQL::RakeSupport.create_migration(name, path: File.join(Dir.pwd, MIGRATIONS_PATH))
-
-    File.write output, contents
-
-    puts "<= migration file created #{output}"
-  end
-end

data/lib/ruby_event_store/rom/memory.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby_event_store/rom'
-require 'rom/memory'
-require_relative 'adapters/memory/unit_of_work'
-require_relative 'adapters/memory/relations/events'
-require_relative 'adapters/memory/relations/stream_entries'
-require_relative 'adapters/memory/changesets/create_events'
-require_relative 'adapters/memory/changesets/update_events'
-require_relative 'adapters/memory/changesets/create_stream_entries'
-
-module RubyEventStore
-  module ROM
-    module Memory
-      class << self
-        def fetch_next_id
-          @last_id ||= 0
-          @mutex ||= Mutex.new
-          @mutex.synchronize { @last_id += 1 }
-        end
-
-        def setup(config)
-          config.register_relation Relations::Events
-          config.register_relation Relations::StreamEntries
-        end
-
-        def configure(env)
-          env.register_unit_of_work_options(class: UnitOfWork)
-
-          env.register_error_handler :unique_violation, lambda { |ex|
-            case ex
-            when TupleUniquenessError
-              raise EventDuplicatedInStream if ex.message =~ /event_id/
-
-              raise WrongExpectedEventVersion
-            end
-          }
-        end
-      end
-
-      class SpecHelper
-        attr_reader :env
-        attr_reader :connection_pool_size, :close_pool_connection
-
-        def initialize
-          @connection_pool_size = 5
-          @env = ROM.setup(:memory)
-        end
-
-        def run_lifecycle
-          yield
-        ensure
-          drop_gateway_schema
-        end
-
-        def gateway
-          env.rom_container.gateways.fetch(:default)
-        end
-
-        def drop_gateway_schema
-          gateway.connection.data.values.each { |v| v.data.clear }
-        end
-
-        def close_gateway_connection
-          gateway.disconnect
-        end
-
-        def gateway_type?(name)
-          name == :memory
-        end
-
-        def has_connection_pooling?
-          true
-        end
-
-        def supports_upsert?
-          true
-        end
-      end
-    end
-  end
-end

data/lib/ruby_event_store/rom/sql.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby_event_store/rom'
-require 'rom/sql'
-require_relative 'adapters/sql/index_violation_detector'
-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
-    module SQL
-      class << self
-        def setup(config)
-          config.register_relation Relations::Events
-          config.register_relation Relations::StreamEntries
-        end
-
-        def configure(env)
-          # See: https://github.com/jeremyevans/sequel/blob/master/doc/transactions.rdoc
-          env.register_unit_of_work_options(
-            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, 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, lambda { |ex, event_id|
-            case ex
-            when ::ROM::TupleCountMismatchError
-              raise EventNotFound, event_id
-            when Sequel::DatabaseError
-              raise ex unless ex.message =~ /PG::InvalidTextRepresentation.*uuid/
-
-              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 >= 32_400
-          else
-            false
-          end
-        end
-      end
-
-      class SpecHelper
-        attr_reader :env
-
-        def initialize(database_uri = ENV['DATABASE_URL'])
-          config = ::ROM::Configuration.new(
-            :sql,
-            database_uri,
-            max_connections: database_uri =~ /sqlite/ ? 1 : 5,
-            preconnect: :concurrently
-            # sql_mode: %w[NO_AUTO_VALUE_ON_ZERO STRICT_ALL_TABLES]
-          )
-          # $stdout.sync = true
-          # 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
-
-          yield
-        ensure
-          drop_gateway_schema
-          close_gateway_connection
-        end
-
-        def gateway
-          env.rom_container.gateways.fetch(:default)
-        end
-
-        def gateway_type?(name)
-          gateway.connection.database_type.eql?(name)
-        end
-
-        def has_connection_pooling?
-          !gateway_type?(:sqlite)
-        end
-
-        def connection_pool_size
-          gateway.connection.pool.size
-        end
-
-        def close_pool_connection
-          gateway.connection.pool.disconnect
-        end
-
-        def supports_upsert?
-          SQL.supports_upsert?(gateway.connection)
-        end
-
-        protected
-
-        def establish_gateway_connection
-          # Manually preconnect because disconnecting and reconnecting
-          # seems to lose the "preconnect concurrently" setting
-          gateway.connection.pool.send(:preconnect, true)
-        end
-
-        def load_gateway_schema
-          gateway.run_migrations
-        end
-
-        def drop_gateway_schema
-          gateway.connection.drop_table?('event_store_events')
-          gateway.connection.drop_table?('event_store_events_in_streams')
-          gateway.connection.drop_table?('schema_migrations')
-        end
-
-        # See: https://github.com/rom-rb/rom-sql/blob/master/spec/shared/database_setup.rb
-        def close_gateway_connection
-          gateway.connection.disconnect
-          # Prevent the auto-reconnect when the test completed
-          # This will save from hardly reproducible connection run outs
-          gateway.connection.pool.available_connections.freeze
-        end
-      end
-    end
-  end
-end

data/lib/ruby_event_store/rom/tuple_uniqueness_error.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    class TupleUniquenessError < StandardError
-      class << self
-        def for_event_id(event_id)
-          new "Uniquness violated for event_id (#{event_id.inspect})"
-        end
-
-        def for_stream_and_event_id(stream_name, event_id)
-          new "Uniquness violated for stream (#{stream_name.inspect}) and event_id (#{event_id.inspect})"
-        end
-
-        def for_stream_and_position(stream_name, position)
-          new "Uniquness violated for stream (#{stream_name.inspect}) and position (#{position.inspect})"
-        end
-      end
-    end
-  end
-end

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

@@ -1,176 +0,0 @@
-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(:rom_container) { env.rom_container }
-    let(:rom_db) { rom_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_binary) { false }
-    let(:test_change) { rom_helper.supports_upsert? }
-
-    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) }
-
-    require 'ruby_event_store/rom/sql'
-    it_behaves_like :event_repository, repository_class, [ROM::SQL::Error]
-
-    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(
-        [RubyEventStore::SRecord.new],
-        RubyEventStore::Stream.new(RubyEventStore::GLOBAL_STREAM),
-        RubyEventStore::ExpectedVersion.any
-      )
-
-      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').limit(5).result) }.to raise_error(RubyEventStore::ReservedInternalName)
-      expect { repository.read(specification.stream('all').limit(5).backward.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
-      events = [
-        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(rom_container)
-      repo.create_changeset(events).commit
-
-      expect(repo.events.to_a.size).to eq(3)
-
-      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)
-
-      # ActiveRecord::Schema.define do
-      #   self.verbose = false
-      #   remove_index :event_store_events_in_streams, [:stream, :position]
-      # end
-
-      expect(repository.read(specification.stream('stream').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.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 = [
-        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(rom_container)
-      repo.create_changeset(events).commit
-
-      expect(repo.events.to_a.size).to eq(3)
-
-      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.limit(3).result).map(&:event_id)).to eq([u1, u2, u3])
-      expect(repository.read(specification.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 = 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)
-        end.to raise_error(RubyEventStore::WrongExpectedEventVersion)
-        expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
-        expect(repository.read(specification.limit(2).result).to_a).to eq([event])
-      end
-      expect(repository.has_event?('9bedf448-e4d0-41a3-a8cd-f94aec7aa763')).to be_falsey
-      expect(repository.read(specification.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 = rom_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
-      count = 0
-      # 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)
-      count = 0
-      # 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
-  end
-end

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

@@ -1,75 +0,0 @@
-RSpec.shared_examples :events_relation do |_relation_class|
-  subject(:relation) { rom_container.relations[:events] }
-
-  let(:env) { rom_helper.env }
-  let(:rom_container) { env.rom_container }
-  let(:rom_db) { rom_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