rails_event_store_active_record 0.27.1 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8570ebd9e95de577529ef0411550572cb797773f
-  data.tar.gz: d2cf335f4efcb6ce41c4971bc624b177a7245730
+SHA256:
+  metadata.gz: 5a0d4acb7008aec0595bba6cbe82ee841e120bec2206aef067832a839d502cea
+  data.tar.gz: d3d3ee18ff599b7c3f85ccc826f68101f4bf3c82d021c3c5b994da48efeabda3
 SHA512:
-  metadata.gz: 030c49e0c6c7821ca871b3edfef88d5772833773f0f59b58dd30449edb8ff6cbf1e7e54e5dd2c897e2818cc465db682f1e23dfdcf3852d0a112f321105c9dae0
-  data.tar.gz: 2437f7f2f6fe7d372b45dbbbe8c4c8a396e323c097b131cc213f0aa5ca69ca8d79c179b43b71a5a092ba06eb02cae3c0e824897668fabb22ee15edb99c49aebf
+  metadata.gz: 3a70559fa37a6185c93d46ce8454bf3b9907e8ff204713ca7e7fcdfe8327c1913bed69f54df43750fc79f2a147ce3ba5a9d6b972753644999bba0ad4a9979941
+  data.tar.gz: 7a0575b7006dfc80b027c702b7843268bdd28d38c686c8f0d57ff6148d0f2c3d3f745cdaf72b93d046e3ae73268f98ae02e7a3b5ff97931b78f8668480719a30

data/Gemfile

@@ -6,3 +6,4 @@ gem 'ruby_event_store', path: '../ruby_event_store'
 if v = ENV['RAILS_VERSION']
   gem 'rails', v
 end
+gem 'pry'

data/Makefile

@@ -12,20 +12,29 @@ install: ## Install gem dependencies
 	@BUNDLE_GEMFILE=spec/v1_v2_schema_migration/Gemfile bundle install
 	@BUNDLE_GEMFILE=spec/without_rails/Gemfile bundle install
 
+remove-lock:
+	@echo "Removing resolved dependency versions"
+	-rm Gemfile.lock
+	-rm spec/v1_v2_schema_migration/Gemfile.lock
+	-rm spec/without_rails/Gemfile.lock
+
+reinstall: remove-lock install ## Removing resolved dependency versions
+
+
 test: ## Run unit tests
 	@echo "Running unit tests"
-	@bundle exec rspec
+	@BUNDLE_GEMFILE=Gemfile bundle exec rspec
 
 mutate: test ## Run mutation tests
 	@echo "Running mutation tests"
-	@DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
+	@BUNDLE_GEMFILE=Gemfile 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 \
+	@BUNDLE_GEMFILE=Gemfile DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
 		$(addprefix --require ,$(REQUIRE)) \
 		$(addprefix --ignore-subject ,$(IGNORE)) \
 		--fail-fast \
@@ -39,7 +48,7 @@ build:
 
 push:
 	@echo "Pushing package to RubyGems"
-	@gem push pkg/$(GEM_NAME)-$(GEM_VERSION).gem
+	@gem push -k dev_arkency pkg/$(GEM_NAME)-$(GEM_VERSION).gem
 
 clean:
 	@echo "Removing previously built package"

data/README.md

@@ -1,5 +1,5 @@
 # RailsEventStoreActiveRecord
 
- An Active Record based implementation of events repository for [Rails Event Store](https://github.com/RailsEventStore/rails_event_store).
+An Active Record based implementation of events repository for [Rails Event Store](https://github.com/RailsEventStore/rails_event_store).
 
 This is the default repository used in `rails_event_store` gem.

data/lib/rails_event_store_active_record.rb

@@ -5,5 +5,4 @@ require 'rails_event_store_active_record/event_repository'
 require 'rails_event_store_active_record/event_repository_reader'
 require 'rails_event_store_active_record/correct_schema_verifier'
 require 'rails_event_store_active_record/index_violation_detector'
-require 'rails_event_store_active_record/legacy_event_repository'
 require 'rails_event_store_active_record/version'

data/lib/rails_event_store_active_record/correct_schema_verifier.rb

@@ -50,10 +50,14 @@ This migration must be run offline -- take that into consideration:
 
 
 If you cannot migrate right now -- you can for some time continue using
-old repository. In order to do so, change configuration accordingly:
+old repository. In order to do so:
+1. install 'rails_event_store_active_record-legacy' gem
+2. change configuration accordingly:
+
+  require 'rails_event_store_active_record/legacy'
 
   config.event_store = RailsEventStore::Client.new(
-                         repository: RailsEventStoreActiveRecord::LegacyEventRepository.new
+                         repository: RailsEventStoreActiveRecord::Legacy::EventRepository.new
                        )
 
 

data/lib/rails_event_store_active_record/event_repository.rb

@@ -2,103 +2,74 @@ require 'activerecord-import'
 
 module RailsEventStoreActiveRecord
   class EventRepository
-
     POSITION_SHIFT = 1
+    SERIALIZED_GLOBAL_STREAM_NAME = "all".freeze
 
-    def initialize(mapper: RubyEventStore::Mappers::Default.new)
+    def initialize
       verify_correct_schema_present
-      @mapper      = mapper
-      @repo_reader = EventRepositoryReader.new(mapper)
+      @repo_reader = EventRepositoryReader.new
     end
 
-    def append_to_stream(events, stream_name, expected_version)
-      add_to_stream(normalize_to_array(events), stream_name, expected_version, true) do |event|
+    def append_to_stream(events, stream, expected_version)
+      add_to_stream(normalize_to_array(events), stream, expected_version, true) do |event|
         build_event_record(event).save!
         event.event_id
       end
     end
 
-    def link_to_stream(event_ids, stream_name, expected_version)
+    def link_to_stream(event_ids, stream, expected_version)
       (normalize_to_array(event_ids) - Event.where(id: event_ids).pluck(:id)).each do |id|
         raise RubyEventStore::EventNotFound.new(id)
       end
-      add_to_stream(normalize_to_array(event_ids), stream_name, expected_version, nil) do |event_id|
+      add_to_stream(normalize_to_array(event_ids), stream, expected_version, nil) do |event_id|
         event_id
       end
     end
 
-    def delete_stream(stream_name)
-      EventInStream.where(stream: stream_name).delete_all
+    def delete_stream(stream)
+      EventInStream.where(stream: stream.name).delete_all
     end
 
     def has_event?(event_id)
       @repo_reader.has_event?(event_id)
     end
 
-    def last_stream_event(stream_name)
-      @repo_reader.last_stream_event(stream_name)
-    end
-
-    def read_events_forward(stream_name, after_event_id, count)
-      @repo_reader.read_events_forward(stream_name, after_event_id, count)
-    end
-
-    def read_events_backward(stream_name, before_event_id, count)
-      @repo_reader.read_events_backward(stream_name, before_event_id, count)
-    end
-
-    def read_stream_events_forward(stream_name)
-      @repo_reader.read_stream_events_forward(stream_name)
-    end
-
-    def read_stream_events_backward(stream_name)
-      @repo_reader.read_stream_events_backward(stream_name)
-    end
-
-    def read_all_streams_forward(after_event_id, count)
-      @repo_reader.read_all_streams_forward(after_event_id, count)
-    end
-
-    def read_all_streams_backward(before_event_id, count)
-      @repo_reader.read_all_streams_backward(before_event_id, count)
+    def last_stream_event(stream)
+      @repo_reader.last_stream_event(stream)
     end
 
     def read_event(event_id)
       @repo_reader.read_event(event_id)
     end
 
-    def get_all_streams
-      @repo_reader.get_all_streams
-    end
-
-    def add_metadata(event, key, value)
-      @mapper.add_metadata(event, key, value)
+    def read(specification)
+      @repo_reader.read(specification)
     end
 
     private
 
-    def add_to_stream(collection, stream_name, expected_version, include_global, &to_event_id)
-      raise RubyEventStore::InvalidExpectedVersion if stream_name.eql?(RubyEventStore::GLOBAL_STREAM) && !expected_version.equal?(:any)
-
-      expected_version = normalize_expected_version(expected_version, stream_name)
+    def add_to_stream(collection, stream, expected_version, include_global, &to_event_id)
+      last_stream_version = ->(stream_) { EventInStream.where(stream: stream_.name).order("position DESC").first.try(:position) }
+      resolved_version = expected_version.resolve_for(stream, last_stream_version)
 
       ActiveRecord::Base.transaction(requires_new: true) do
         in_stream = collection.flat_map.with_index do |element, index|
-          position = compute_position(expected_version, index)
+          position = compute_position(resolved_version, index)
           event_id = to_event_id.call(element)
           collection = []
           collection.unshift({
-            stream: RubyEventStore::GLOBAL_STREAM,
+            stream: SERIALIZED_GLOBAL_STREAM_NAME,
             position: nil,
-            event_id: event_id
+            event_id: event_id,
           }) if include_global
           collection.unshift({
-            stream:   stream_name,
+            stream:   stream.name,
             position: position,
             event_id: event_id
-          }) unless stream_name.eql?(RubyEventStore::GLOBAL_STREAM)
+          }) unless stream.global?
           collection
         end
+        fill_ids(in_stream)
         EventInStream.import(in_stream)
       end
       self
@@ -113,23 +84,9 @@ module RailsEventStoreActiveRecord
       raise RubyEventStore::WrongExpectedEventVersion
     end
 
-    def compute_position(expected_version, index)
-      unless expected_version.equal?(:any)
-        expected_version + index + POSITION_SHIFT
-      end
-    end
-
-    def normalize_expected_version(expected_version, stream_name)
-      case expected_version
-        when Integer, :any
-          expected_version
-        when :none
-          -1
-        when :auto
-          eis = EventInStream.where(stream: stream_name).order("position DESC").first
-          (eis && eis.position) || -1
-        else
-          raise RubyEventStore::InvalidExpectedVersion
+    def compute_position(resolved_version, index)
+      unless resolved_version.nil?
+        resolved_version + index + POSITION_SHIFT
       end
     end
 
@@ -137,8 +94,7 @@ module RailsEventStoreActiveRecord
       IndexViolationDetector.new.detect(message)
     end
 
-    def build_event_record(event)
-      serialized_record = @mapper.event_to_serialized_record(event)
+    def build_event_record(serialized_record)
       Event.new(
         id:         serialized_record.event_id,
         data:       serialized_record.data,
@@ -155,6 +111,10 @@ module RailsEventStoreActiveRecord
     def verify_correct_schema_present
       CorrectSchemaVerifier.new.verify
     end
+
+    # Overwritten in a sub-class
+    def fill_ids(_in_stream)
+    end
   end
 
 end

data/lib/rails_event_store_active_record/event_repository_reader.rb

@@ -1,102 +1,67 @@
 module RailsEventStoreActiveRecord
   class EventRepositoryReader
 
-    def initialize(mapper)
-      @mapper = mapper
-    end
-
     def has_event?(event_id)
       Event.exists?(id: event_id)
     end
 
-    def last_stream_event(stream_name)
-      record = EventInStream.where(stream: stream_name).order('position DESC, id DESC').first
+    def last_stream_event(stream)
+      record = EventInStream.where(stream: stream.name).order('position DESC, id DESC').first
       record && build_event_instance(record)
     end
 
-    def read_events_forward(stream_name, after_event_id, count)
-      stream = EventInStream.where(stream: stream_name)
-      unless after_event_id.equal?(:head)
-        after_event = stream.find_by!(event_id: after_event_id)
-        stream = stream.where('id > ?', after_event)
-      end
-
-      stream.preload(:event).order('position ASC, id ASC').limit(count)
-        .map(&method(:build_event_instance))
+    def read_event(event_id)
+      event = Event.find(event_id)
+      RubyEventStore::SerializedRecord.new(
+        event_id: event.id,
+        metadata: event.metadata,
+        data: event.data,
+        event_type: event.event_type
+      )
+    rescue ActiveRecord::RecordNotFound
+      raise RubyEventStore::EventNotFound.new(event_id)
     end
 
-    def read_events_backward(stream_name, before_event_id, count)
-      stream = EventInStream.where(stream: stream_name)
-      unless before_event_id.equal?(:head)
-        before_event = stream.find_by!(event_id: before_event_id)
-        stream = stream.where('id < ?', before_event)
-      end
-
-      stream.preload(:event).order('position DESC, id DESC').limit(count)
-        .map(&method(:build_event_instance))
-    end
+    def read(spec)
+      raise RubyEventStore::ReservedInternalName if spec.stream_name.eql?(EventRepository::SERIALIZED_GLOBAL_STREAM_NAME)
 
-    def read_stream_events_forward(stream_name)
-      EventInStream.preload(:event).where(stream: stream_name).order('position ASC, id ASC')
-        .map(&method(:build_event_instance))
-    end
+      stream = EventInStream.preload(:event).where(stream: normalize_stream_name(spec))
+      stream = stream.order(position: order(spec.direction)) unless spec.global_stream?
+      stream = stream.limit(spec.count) if spec.limit?
+      stream = stream.where(start_condition(spec)) unless spec.head?
+      stream = stream.order(id: order(spec.direction))
 
-    def read_stream_events_backward(stream_name)
-      EventInStream.preload(:event).where(stream: stream_name).order('position DESC, id DESC')
-        .map(&method(:build_event_instance))
+      stream.map(&method(:build_event_instance)).each
     end
 
-    def read_all_streams_forward(after_event_id, count)
-      stream = EventInStream.where(stream: RubyEventStore::GLOBAL_STREAM)
-      unless after_event_id.equal?(:head)
-        after_event = stream.find_by!(event_id: after_event_id)
-        stream = stream.where('id > ?', after_event)
-      end
+    private
 
-      stream.preload(:event).order('id ASC').limit(count)
-        .map(&method(:build_event_instance))
+    def normalize_stream_name(specification)
+      specification.global_stream? ? EventRepository::SERIALIZED_GLOBAL_STREAM_NAME : specification.stream_name
     end
 
-    def read_all_streams_backward(before_event_id, count)
-      stream = EventInStream.where(stream: RubyEventStore::GLOBAL_STREAM)
-      unless before_event_id.equal?(:head)
-        before_event = stream.find_by!(event_id: before_event_id)
-        stream = stream.where('id < ?', before_event)
+    def start_condition(specification)
+      event_record =
+        EventInStream.find_by!(event_id: specification.start, stream: normalize_stream_name(specification))
+      case specification.direction
+      when :forward
+        ['id > ?', event_record]
+      else
+        ['id < ?', event_record]
       end
-
-      stream.preload(:event).order('id DESC').limit(count)
-        .map(&method(:build_event_instance))
-    end
-
-    def read_event(event_id)
-      event             = Event.find(event_id)
-      serialized_record = RubyEventStore::SerializedRecord.new(
-        event_id:   event.id,
-        metadata:   event.metadata,
-        data:       event.data,
-        event_type: event.event_type
-      )
-      @mapper.serialized_record_to_event(serialized_record)
-    rescue ActiveRecord::RecordNotFound
-      raise RubyEventStore::EventNotFound.new(event_id)
     end
 
-    def get_all_streams
-      (["all"] + EventInStream.order(:id).pluck(:stream))
-        .uniq
-        .map { |name| RubyEventStore::Stream.new(name) }
+    def order(direction)
+      {forward: 'ASC', backward: 'DESC'}.fetch(direction)
     end
 
-    private
-
     def build_event_instance(record)
-      serialized_record = RubyEventStore::SerializedRecord.new(
-        event_id:         record.event.id,
-        metadata:   record.event.metadata,
-        data:       record.event.data,
+      RubyEventStore::SerializedRecord.new(
+        event_id: record.event.id,
+        metadata: record.event.metadata,
+        data: record.event.data,
         event_type: record.event.event_type
       )
-      @mapper.serialized_record_to_event(serialized_record)
     end
   end
 

data/lib/rails_event_store_active_record/version.rb

@@ -1,3 +1,3 @@
 module RailsEventStoreActiveRecord
-  VERSION = "0.27.1"
+  VERSION = "0.28.0"
 end

data/rails_event_store_active_record.gemspec

@@ -11,8 +11,14 @@ Gem::Specification.new do |spec|
   spec.email         = ['dev@arkency.com']
 
   spec.summary       = %q{Active Record events repository for Rails Event Store}
-  spec.description   = %q{Implementation of events repository based on Rails Active Record for Rails Event Store'}
-  spec.homepage      = 'https://github.com/RailsEventStore/rails_event_store_active_record'
+  spec.description   = %q{Implementation of events repository based on Rails Active Record for Rails Event Store}
+  spec.homepage      = 'https://railseventstore.org'
+  spec.metadata    = {
+    "homepage_uri" => "https://railseventstore.org/",
+    "changelog_uri" => "https://github.com/RailsEventStore/rails_event_store/releases",
+    "source_code_uri" => "https://github.com/RailsEventStore/rails_event_store",
+    "bug_tracker_uri" => "https://github.com/RailsEventStore/rails_event_store/issues",
+  }
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = 'exe'
@@ -22,7 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.6'
-  spec.add_development_dependency 'rails', '~> 5.1'
+  spec.add_development_dependency 'rails', '~> 5.2'
   spec.add_development_dependency 'sqlite3', '1.3.13'
   spec.add_development_dependency 'pg', '0.21'
   spec.add_development_dependency 'mysql2', '0.4.10'
@@ -31,7 +37,7 @@ 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.27.1'
+  spec.add_dependency 'ruby_event_store', '= 0.28.0'
   spec.add_dependency 'activesupport', '>= 3.0'
   spec.add_dependency 'activemodel', '>= 3.0'
   spec.add_dependency 'activerecord-import', '~> 0.21'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_event_store_active_record
 version: !ruby/object:Gem::Version
-  version: 0.27.1
+  version: 0.28.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-26 00:00:00.000000000 Z
+date: 2018-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -170,14 +170,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.27.1
+        version: 0.28.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.27.1
+        version: 0.28.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -221,7 +221,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.21'
 description: Implementation of events repository based on Rails Active Record for
-  Rails Event Store'
+  Rails Event Store
 email:
 - dev@arkency.com
 executables: []
@@ -244,13 +244,16 @@ files:
 - lib/rails_event_store_active_record/generators/templates/v1_v2_migration_template.rb
 - lib/rails_event_store_active_record/generators/v1_v2_migration_generator.rb
 - lib/rails_event_store_active_record/index_violation_detector.rb
-- lib/rails_event_store_active_record/legacy_event_repository.rb
 - lib/rails_event_store_active_record/version.rb
 - rails_event_store_active_record.gemspec
-homepage: https://github.com/RailsEventStore/rails_event_store_active_record
+homepage: https://railseventstore.org
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://railseventstore.org/
+  changelog_uri: https://github.com/RailsEventStore/rails_event_store/releases
+  source_code_uri: https://github.com/RailsEventStore/rails_event_store
+  bug_tracker_uri: https://github.com/RailsEventStore/rails_event_store/issues
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -267,7 +270,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Active Record events repository for Rails Event Store

data/lib/rails_event_store_active_record/legacy_event_repository.rb

@@ -1,176 +0,0 @@
-require 'active_record'
-
-module RailsEventStoreActiveRecord
-  class LegacyEventRepository
-    class LegacyEvent < ::ActiveRecord::Base
-      self.primary_key = :id
-      self.table_name = 'event_store_events'
-      serialize :metadata
-      serialize :data
-    end
-
-    private_constant :LegacyEvent
-
-    def initialize
-      warn <<-MSG
-`RailsEventStoreActiveRecord::LegacyEventRepository` has been deprecated.
-
-Please migrate to new database schema and use `RailsEventStoreActiveRecord::EventRepository`
-instead:
-
-  rails generate rails_event_store_active_record:v1_v2_migration
-
-      MSG
-
-      @mapper = RubyEventStore::Mappers::Default.new
-    end
-
-    def append_to_stream(events, stream_name, expected_version)
-      validate_expected_version_is_not_auto(expected_version)
-      validate_expected_version_is_any_for_global_stream(expected_version, stream_name)
-
-      case expected_version
-      when :none
-        validate_stream_is_empty(stream_name)
-      when :any
-      when Integer
-        validate_expected_version_number(expected_version, stream_name)
-      else
-        raise RubyEventStore::InvalidExpectedVersion
-      end
-
-      normalize_to_array(events).each do |event|
-        data = event.to_h.merge!(stream: stream_name, event_type: event.class)
-        LegacyEvent.create!(data)
-      end
-      self
-    rescue ActiveRecord::RecordNotUnique
-      raise RubyEventStore::EventDuplicatedInStream
-    end
-
-    def link_to_stream(_event_ids, _stream_name, _expected_version)
-      raise RubyEventStore::NotSupported
-    end
-
-    def delete_stream(stream_name)
-      LegacyEvent.where({stream: stream_name}).update_all(stream: RubyEventStore::GLOBAL_STREAM)
-    end
-
-    def has_event?(event_id)
-      LegacyEvent.exists?(event_id: event_id)
-    end
-
-    def last_stream_event(stream_name)
-      build_event_entity(LegacyEvent.where(stream: stream_name).last)
-    end
-
-    def read_events_forward(stream_name, start_event_id, count)
-      stream = LegacyEvent.where(stream: stream_name)
-      unless start_event_id.equal?(:head)
-        starting_event = LegacyEvent.find_by(event_id: start_event_id)
-        stream = stream.where('id > ?', starting_event)
-      end
-
-      stream.order('id ASC').limit(count)
-        .map(&method(:build_event_entity))
-    end
-
-    def read_events_backward(stream_name, start_event_id, count)
-      stream = LegacyEvent.where(stream: stream_name)
-      unless start_event_id.equal?(:head)
-        starting_event = LegacyEvent.find_by(event_id: start_event_id)
-        stream = stream.where('id < ?', starting_event)
-      end
-
-      stream.order('id DESC').limit(count)
-        .map(&method(:build_event_entity))
-    end
-
-    def read_stream_events_forward(stream_name)
-      LegacyEvent.where(stream: stream_name).order('id ASC')
-        .map(&method(:build_event_entity))
-    end
-
-    def read_stream_events_backward(stream_name)
-      LegacyEvent.where(stream: stream_name).order('id DESC')
-        .map(&method(:build_event_entity))
-    end
-
-    def read_all_streams_forward(start_event_id, count)
-      stream = LegacyEvent
-      unless start_event_id.equal?(:head)
-        starting_event = LegacyEvent.find_by(event_id: start_event_id)
-        stream = stream.where('id > ?', starting_event)
-      end
-
-      stream.order('id ASC').limit(count)
-        .map(&method(:build_event_entity))
-    end
-
-    def read_all_streams_backward(start_event_id, count)
-      stream = LegacyEvent
-      unless start_event_id.equal?(:head)
-        starting_event = LegacyEvent.find_by(event_id: start_event_id)
-        stream = stream.where('id < ?', starting_event)
-      end
-
-      stream.order('id DESC').limit(count)
-        .map(&method(:build_event_entity))
-    end
-
-    def read_event(event_id)
-      build_event_entity(LegacyEvent.find_by(event_id: event_id)) or raise RubyEventStore::EventNotFound.new(event_id)
-    end
-
-    def get_all_streams
-      (["all"] + LegacyEvent.pluck(:stream))
-        .uniq
-        .map { |name| RubyEventStore::Stream.new(name) }
-    end
-
-    def add_metadata(event, key, value)
-      @mapper.add_metadata(event, key, value)
-    end
-
-    private
-
-    def normalize_to_array(events)
-      return events if events.is_a?(Enumerable)
-      [events]
-    end
-
-    def build_event_entity(record)
-      return nil unless record
-      record.event_type.constantize.new(
-        event_id: record.event_id,
-        metadata: record.metadata,
-        data: record.data
-      )
-    end
-
-    def last_stream_version(stream_name)
-      LegacyEvent.where(stream: stream_name).count - 1
-    end
-
-    def stream_non_empty?(stream_name)
-      LegacyEvent.where(stream: stream_name).exists?
-    end
-
-    def validate_expected_version_is_any_for_global_stream(expected_version, stream_name)
-      raise RubyEventStore::InvalidExpectedVersion if stream_name.eql?(RubyEventStore::GLOBAL_STREAM) && !expected_version.equal?(:any)
-    end
-
-    def validate_stream_is_empty(stream_name)
-      raise RubyEventStore::WrongExpectedEventVersion if stream_non_empty?(stream_name)
-    end
-
-    def validate_expected_version_number(expected_version, stream_name)
-      raise RubyEventStore::WrongExpectedEventVersion unless last_stream_version(stream_name).equal?(expected_version)
-    end
-
-    def validate_expected_version_is_not_auto(expected_version)
-      raise RubyEventStore::InvalidExpectedVersion, ":auto mode is not supported by LegacyEventRepository" if expected_version.equal?(:auto)
-    end
-
-  end
-end