rails_event_store_active_record 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06ea3fef184541012ee334e70e402adf48805ece
-  data.tar.gz: ebe5b085930e57e45abbe1015e6cd31ca84c0650
+  metadata.gz: aa7cbc8a46e69a907a86eb49221525581ced5792
+  data.tar.gz: e585c4784333d52636512824facd16ebc5b09657
 SHA512:
-  metadata.gz: bc05259c542106541612cc624832e3f2b475e579a510396b28e32adde6652e663151a2eb1ee5c8dd3f9f8e73340ae41c931482722d755b8513e8565b34ead33c
-  data.tar.gz: df3e1ce033b90271cdb4b0a77bef69455ac807b176b73ffae84fe380bd7964c8265729203180a781fcdac3d04b09c1a26b0fcf9f7b76d54f59f1ac1d5c8dfca3
+  metadata.gz: 919a3e5a8715712d4a4750d7885a8889cacf8acca6abb23f1e975f797149a10df2cd4f5971cd406d6ff9a46972fae6890d648dd17d06d50c4cc2dccf728678e0
+  data.tar.gz: 00da8c71db44a47186acd50b1d99dcca82646d47777cdcb22d39cee96f15734c57babb722cdc73d0fffa4c0d1e04e8b7f68ed9bc3e5ce391ad5e5a40ee9eec5e

data/Makefile

@@ -13,9 +13,7 @@ test: ## Run tests
 mutate: test  ## Run mutation tests
 	@echo "Running mutation tests - only 100% free mutation will be accepted"
 	@bundle exec mutant --include lib --require ruby_event_store --use rspec "RailsEventStoreActiveRecord*" \
-	  --ignore-subject "RailsEventStoreActiveRecord::EventRepository#normalize_to_array" \
-	  --ignore-subject "RailsEventStoreActiveRecord::LegacyEventRepository#normalize_to_array" \
-	  --ignore-subject "RailsEventStoreActiveRecord::EventRepository#detect_index_violated"
+	  --ignore-subject "RailsEventStoreActiveRecord::IndexViolationDetector#detect"
 
 build:
 	@gem build -V rails_event_store_active_record.gemspec

data/lib/rails_event_store_active_record.rb

@@ -2,5 +2,8 @@ require 'rails_event_store_active_record/generators/migration_generator'
 require 'rails_event_store_active_record/generators/v1_v2_migration_generator'
 require 'rails_event_store_active_record/event'
 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

@@ -0,0 +1,65 @@
+module RailsEventStoreActiveRecord
+
+  class EventRepository
+    InvalidDatabaseSchema = Class.new(StandardError)
+  end
+
+  class CorrectSchemaVerifier
+    def verify
+      return unless ActiveRecord::Base.connected?
+      raise_invalid_db_schema if legacy_columns.eql?(current_columns)
+    end
+
+    private
+
+    def raise_invalid_db_schema
+      raise EventRepository::InvalidDatabaseSchema.new(incorrect_schema_message)
+    end
+
+    def legacy_columns
+      [
+        "id",
+        "stream",
+        "event_type",
+        "event_id",
+        "metadata",
+        "data",
+        "created_at"
+      ]
+    end
+
+    def current_columns
+      ActiveRecord::Base.connection.columns("event_store_events").map(&:name)
+    end
+
+    def incorrect_schema_message
+      <<-MESSAGE
+Oh no!
+
+It seems you're using RailsEventStoreActiveRecord::EventRepository
+with incompaible database schema.
+
+We've redesigned database structure in order to fix several concurrency-related
+bugs. This repository is intended to work on that improved data layout.
+
+We've prepared migration that would take you from old schema to new one.
+This migration must be run offline -- take that into consideration:
+
+  rails g rails_event_store_active_record:v1_v2_migration
+  rake db:migrate
+
+
+If you cannot migrate right now -- you can for some time continue using
+old repository. In order to do so, change configuration accordingly:
+
+  config.event_store = RailsEventStore::Client.new(
+                         repository: RailsEventStoreActiveRecord::LegacyEventRepository.new
+                       )
+
+
+      MESSAGE
+    end
+  end
+
+  private_constant(:CorrectSchemaVerifier)
+end

data/lib/rails_event_store_active_record/event_repository.rb

@@ -2,17 +2,17 @@ require 'activerecord-import'
 
 module RailsEventStoreActiveRecord
   class EventRepository
-    InvalidDatabaseSchema = Class.new(StandardError)
 
     POSITION_SHIFT = 1
 
     def initialize(mapper: RubyEventStore::Mappers::Default.new)
       verify_correct_schema_present
-      @mapper = mapper
+      @mapper      = mapper
+      @repo_reader = EventRepositoryReader.new(mapper)
     end
 
     def append_to_stream(events, stream_name, expected_version)
-      add_to_stream(events, stream_name, expected_version, true) do |event|
+      add_to_stream(normalize_to_array(events), stream_name, expected_version, true) do |event|
         build_event_record(event).save!
         event.event_id
       end
@@ -22,7 +22,7 @@ module RailsEventStoreActiveRecord
       (normalize_to_array(event_ids) - Event.where(id: event_ids).pluck(:id)).each do |id|
         raise RubyEventStore::EventNotFound.new(id)
       end
-      add_to_stream(event_ids, stream_name, expected_version, nil) do |event_id|
+      add_to_stream(normalize_to_array(event_ids), stream_name, expected_version, nil) do |event_id|
         event_id
       end
     end
@@ -32,85 +32,43 @@ module RailsEventStoreActiveRecord
     end
 
     def has_event?(event_id)
-      Event.exists?(id: event_id)
+      @repo_reader.has_event?(event_id)
     end
 
     def last_stream_event(stream_name)
-      record = EventInStream.where(stream: stream_name).order('position DESC, id DESC').first
-      record && build_event_instance(record)
+      @repo_reader.last_stream_event(stream_name)
     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))
+      @repo_reader.read_events_forward(stream_name, after_event_id, count)
     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))
+      @repo_reader.read_events_backward(stream_name, before_event_id, count)
     end
 
     def read_stream_events_forward(stream_name)
-      EventInStream.preload(:event).where(stream: stream_name).order('position ASC, id ASC')
-        .map(&method(:build_event_instance))
+      @repo_reader.read_stream_events_forward(stream_name)
     end
 
     def read_stream_events_backward(stream_name)
-      EventInStream.preload(:event).where(stream: stream_name).order('position DESC, id DESC')
-        .map(&method(:build_event_instance))
+      @repo_reader.read_stream_events_backward(stream_name)
     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
-
-      stream.preload(:event).order('id ASC').limit(count)
-        .map(&method(:build_event_instance))
+      @repo_reader.read_all_streams_forward(after_event_id, count)
     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)
-      end
-
-      stream.preload(:event).order('id DESC').limit(count)
-        .map(&method(:build_event_instance))
+      @repo_reader.read_all_streams_backward(before_event_id, count)
     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)
+      @repo_reader.read_event(event_id)
     end
 
     def get_all_streams
-      (["all"] + EventInStream.pluck(:stream))
-        .uniq
-        .map { |name| RubyEventStore::Stream.new(name) }
+      @repo_reader.get_all_streams
     end
 
     private
@@ -120,7 +78,6 @@ module RailsEventStoreActiveRecord
     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)
 
-      collection = normalize_to_array(collection)
       expected_version = normalize_expected_version(expected_version, stream_name)
 
       ActiveRecord::Base.transaction(requires_new: true) do
@@ -148,7 +105,7 @@ module RailsEventStoreActiveRecord
     end
 
     def raise_error(e)
-      if detect_index_violated(e)
+      if detect_index_violated(e.message)
         raise RubyEventStore::EventDuplicatedInStream
       end
       raise RubyEventStore::WrongExpectedEventVersion
@@ -174,23 +131,8 @@ module RailsEventStoreActiveRecord
       end
     end
 
-    MYSQL_PKEY_ERROR    = "for key 'PRIMARY'"
-    POSTGRES_PKEY_ERROR = "event_store_events_pkey"
-    SQLITE3_PKEY_ERROR  = "event_store_events.id"
-
-    MYSQL_INDEX_ERROR    = "for key 'index_event_store_events_in_streams_on_stream_and_event_id'"
-    POSTGRES_INDEX_ERROR = "Key (stream, event_id)"
-    SQLITE3_INDEX_ERROR  = "event_store_events_in_streams.stream, event_store_events_in_streams.event_id"
-
-    def detect_index_violated(e)
-      m = e.message
-      m.include?(MYSQL_PKEY_ERROR)     ||
-      m.include?(POSTGRES_PKEY_ERROR)  ||
-      m.include?(SQLITE3_PKEY_ERROR)   ||
-
-      m.include?(MYSQL_INDEX_ERROR)    ||
-      m.include?(POSTGRES_INDEX_ERROR) ||
-      m.include?(SQLITE3_INDEX_ERROR)
+    def detect_index_violated(message)
+      IndexViolationDetector.new.detect(message)
     end
 
     def build_event_record(event)
@@ -203,53 +145,14 @@ module RailsEventStoreActiveRecord
       )
     end
 
-    def build_event_instance(record)
-      serialized_record = 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
-
     def normalize_to_array(events)
-      [*events]
-    end
-
-    def incorrect_schema_message
-      <<-MESSAGE
-Oh no!
-
-It seems you're using RailsEventStoreActiveRecord::EventRepository
-with incompaible database schema.
-
-We've redesigned database structure in order to fix several concurrency-related
-bugs. This repository is intended to work on that improved data layout.
-
-We've prepared migration that would take you from old schema to new one.
-This migration must be run offline -- take that into consideration:
-
-  rails g rails_event_store_active_record:v1_v2_migration
-  rake db:migrate
-
-
-If you cannot migrate right now -- you can for some time continue using
-old repository. In order to do so, change configuration accordingly:
-
-  config.event_store = RailsEventStore::Client.new(
-                         repository: RailsEventStoreActiveRecord::LegacyEventRepository.new
-                       )
-
-
-      MESSAGE
+      return events if events.is_a?(Enumerable)
+      [events]
     end
 
     def verify_correct_schema_present
-      return unless ActiveRecord::Base.connected?
-      legacy_columns  = ["id", "stream", "event_type", "event_id", "metadata", "data", "created_at"]
-      current_columns = ActiveRecord::Base.connection.columns("event_store_events").map(&:name)
-      raise InvalidDatabaseSchema.new(incorrect_schema_message) if legacy_columns.eql?(current_columns)
+      CorrectSchemaVerifier.new.verify
     end
   end
+
 end

data/lib/rails_event_store_active_record/event_repository_reader.rb

@@ -0,0 +1,104 @@
+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
+      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))
+    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_stream_events_forward(stream_name)
+      EventInStream.preload(:event).where(stream: stream_name).order('position ASC, id ASC')
+        .map(&method(:build_event_instance))
+    end
+
+    def read_stream_events_backward(stream_name)
+      EventInStream.preload(:event).where(stream: stream_name).order('position DESC, id DESC')
+        .map(&method(:build_event_instance))
+    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
+
+      stream.preload(:event).order('id ASC').limit(count)
+        .map(&method(:build_event_instance))
+    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)
+      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.pluck(:stream))
+        .uniq
+        .map { |name| RubyEventStore::Stream.new(name) }
+    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,
+        event_type: record.event.event_type
+      )
+      @mapper.serialized_record_to_event(serialized_record)
+    end
+  end
+
+  private_constant(:EventRepositoryReader)
+end

data/lib/rails_event_store_active_record/index_violation_detector.rb

@@ -0,0 +1,24 @@
+module RailsEventStoreActiveRecord
+  class IndexViolationDetector
+
+    MYSQL_PKEY_ERROR    = "for key 'PRIMARY'"
+    POSTGRES_PKEY_ERROR = "event_store_events_pkey"
+    SQLITE3_PKEY_ERROR  = "event_store_events.id"
+
+    MYSQL_INDEX_ERROR    = "for key 'index_event_store_events_in_streams_on_stream_and_event_id'"
+    POSTGRES_INDEX_ERROR = "Key (stream, event_id)"
+    SQLITE3_INDEX_ERROR  = "event_store_events_in_streams.stream, event_store_events_in_streams.event_id"
+
+    def detect(message)
+      message.include?(MYSQL_PKEY_ERROR)     ||
+      message.include?(POSTGRES_PKEY_ERROR)  ||
+      message.include?(SQLITE3_PKEY_ERROR)   ||
+
+      message.include?(MYSQL_INDEX_ERROR)    ||
+      message.include?(POSTGRES_INDEX_ERROR) ||
+      message.include?(SQLITE3_INDEX_ERROR)
+    end
+  end
+
+  private_constant(:IndexViolationDetector)
+end

data/lib/rails_event_store_active_record/legacy_event_repository.rb

@@ -129,7 +129,8 @@ instead:
     private
 
     def normalize_to_array(events)
-      [*events]
+      return events if events.is_a?(Enumerable)
+      [events]
     end
 
     def build_event_entity(record)

data/lib/rails_event_store_active_record/version.rb

@@ -1,3 +1,3 @@
 module RailsEventStoreActiveRecord
-  VERSION = "0.23.0"
+  VERSION = "0.24.0"
 end

data/rails_event_store_active_record.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'fakefs', '~> 0.11.2'
   spec.add_development_dependency 'childprocess'
 
-  spec.add_dependency 'ruby_event_store', '= 0.23.0'
+  spec.add_dependency 'ruby_event_store', '= 0.24.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.23.0
+  version: 0.24.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-11 00:00:00.000000000 Z
+date: 2018-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -156,14 +156,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: 0.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: 0.24.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -221,12 +221,15 @@ files:
 - bin/console
 - bin/setup
 - lib/rails_event_store_active_record.rb
+- lib/rails_event_store_active_record/correct_schema_verifier.rb
 - lib/rails_event_store_active_record/event.rb
 - lib/rails_event_store_active_record/event_repository.rb
+- lib/rails_event_store_active_record/event_repository_reader.rb
 - lib/rails_event_store_active_record/generators/migration_generator.rb
 - lib/rails_event_store_active_record/generators/templates/migration_template.rb
 - 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