rails_event_store_active_record 0.18.2 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e99ab38f901b8cbb1549edf61c78a99071902cee
-  data.tar.gz: 57a0559599661585d7e9dd28b41063983c2b5358
+  metadata.gz: 3c45bf6b63a5317bf916c5bc831573fab866c762
+  data.tar.gz: a0a1a1ad2c1c662911b3da70829bae860741bc51
 SHA512:
-  metadata.gz: 626f434cb8efe63c81b13093be19668579a6e2c211fa3c9e1806d67ecf965b2e63fb52e55ba8200f2ba564529f4cc1ffabed74646f261688a6e65da836a52e28
-  data.tar.gz: 81b9f505ed8bf610cbce5491893548c912e8903d2c040d47b9d8ae74f5f3a9010a1ac1ebb9003d216fbfd6e72eb65052b9ab562633a1f906bb8dd48fc9bee949
+  metadata.gz: 4f936d894bf5b5d64395527873cbdc300abfe18b8ee9536c4989e53a48bfad17703bf5e4f7b81633279490917d73074863b7b0ed63330c32d7cff565219624cd
+  data.tar.gz: 6f5c2f8e1b899bb296439728a84b745bb4c772e4b1f39924e27c3d327b95d5a98c66b75eed88afbf932d02b5c90fd5c52a37165f941a1709aa7b38cb02762602

data/Makefile

@@ -3,6 +3,8 @@ GEM_VERSION  = `cat ../RES_VERSION`
 install: ## Install gem dependencies
 	@echo "Installing gem dependencies"
 	@bundle install
+	@echo "Installing v1_v2_schema_migration gem dependencies"
+	@BUNDLE_GEMFILE=spec/v1_v2_schema_migration/Gemfile bundle install
 
 test: ## Run tests
 	@echo "Running basic tests - beware: this won't guarantee build pass"
@@ -11,9 +13,9 @@ 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#read_events_forward" \
-		--ignore-subject "RailsEventStoreActiveRecord::EventRepository#read_all_streams_forward" \
-		--ignore-subject "RailsEventStoreActiveRecord::EventRepository#read_stream_events_forward"
+	  --ignore-subject "RailsEventStoreActiveRecord::EventRepository#normalize_to_array" \
+	  --ignore-subject "RailsEventStoreActiveRecord::LegacyEventRepository#normalize_to_array" \
+	  --ignore-subject "RailsEventStoreActiveRecord::EventRepository#detect_pkey_index_violated"
 
 build:
 	@gem build -V rails_event_store_active_record.gemspec

data/lib/rails_event_store_active_record/event.rb

@@ -7,4 +7,10 @@ module RailsEventStoreActiveRecord
     serialize :metadata
     serialize :data
   end
+
+  class EventInStream < ::ActiveRecord::Base
+    self.primary_key = :id
+    self.table_name = 'event_store_events_in_streams'
+    belongs_to :event
+  end
 end

data/lib/rails_event_store_active_record/event_repository.rb

@@ -1,92 +1,186 @@
+require 'activerecord-import'
+
 module RailsEventStoreActiveRecord
   class EventRepository
-    def initialize(adapter: Event)
-      @adapter = adapter
+    InvalidDatabaseSchema = Class.new(StandardError)
+
+    POSITION_SHIFT = 1
+
+    def initialize
+      verify_correct_schema_present
     end
-    attr_reader :adapter
 
-    def create(event, stream_name)
-      data = event.to_h.merge!(stream: stream_name, event_type: event.class)
-      adapter.create(data)
-      event
+    def append_to_stream(events, stream_name, expected_version)
+      raise RubyEventStore::InvalidExpectedVersion if stream_name.eql?(RubyEventStore::GLOBAL_STREAM) && !expected_version.equal?(:any)
+
+      events = normalize_to_array(events)
+      expected_version =
+        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
+        end
+
+      ActiveRecord::Base.transaction(requires_new: true) do
+        in_stream = events.flat_map.with_index do |event, index|
+          position = unless expected_version.equal?(:any)
+            expected_version + index + POSITION_SHIFT
+          end
+          Event.create!(
+            id: event.event_id,
+            data: event.data,
+            metadata: event.metadata,
+            event_type: event.class,
+          )
+          events = [{
+            stream: RubyEventStore::GLOBAL_STREAM,
+            event_id: event.event_id
+          }]
+          events.unshift({
+            stream:   stream_name,
+            position: position,
+            event_id: event.event_id
+          }) unless stream_name.eql?(RubyEventStore::GLOBAL_STREAM)
+          events
+        end
+        EventInStream.import(in_stream)
+      end
+      self
+    rescue ActiveRecord::RecordNotUnique => e
+      if detect_pkey_index_violated(e)
+        raise RubyEventStore::EventDuplicatedInStream
+      end
+      raise RubyEventStore::WrongExpectedEventVersion
     end
 
     def delete_stream(stream_name)
-      condition = {stream: stream_name}
-      adapter.destroy_all condition
+      EventInStream.where(stream: stream_name).delete_all
     end
 
     def has_event?(event_id)
-      adapter.exists?(event_id: event_id)
+      Event.exists?(id: event_id)
     end
 
     def last_stream_event(stream_name)
-      build_event_entity(adapter.where(stream: stream_name).last)
+      build_event_entity(
+        EventInStream.where(stream: stream_name).order('position DESC, id DESC').first
+      )
     end
 
-    def read_events_forward(stream_name, start_event_id, count)
-      stream = adapter.where(stream: stream_name)
-      unless start_event_id.equal?(:head)
-        starting_event = adapter.find_by(event_id: start_event_id)
-        stream = stream.where('id > ?', starting_event)
+    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.order('id ASC').limit(count)
+      stream.preload(:event).order('position ASC, id ASC').limit(count)
         .map(&method(:build_event_entity))
     end
 
-    def read_events_backward(stream_name, start_event_id, count)
-      stream = adapter.where(stream: stream_name)
-      unless start_event_id.equal?(:head)
-        starting_event = adapter.find_by(event_id: start_event_id)
-        stream = stream.where('id < ?', starting_event)
+    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.order('id DESC').limit(count)
+      stream.preload(:event).order('position DESC, id DESC').limit(count)
         .map(&method(:build_event_entity))
     end
 
     def read_stream_events_forward(stream_name)
-      adapter.where(stream: stream_name).order('id ASC')
+      EventInStream.preload(:event).where(stream: stream_name).order('position ASC, id ASC')
         .map(&method(:build_event_entity))
     end
 
     def read_stream_events_backward(stream_name)
-      adapter.where(stream: stream_name).order('id DESC')
+      EventInStream.preload(:event).where(stream: stream_name).order('position DESC, id DESC')
         .map(&method(:build_event_entity))
     end
 
-    def read_all_streams_forward(start_event_id, count)
-      stream = adapter
-      unless start_event_id.equal?(:head)
-        starting_event = adapter.find_by(event_id: start_event_id)
-        stream = stream.where('id > ?', starting_event)
+    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.order('id ASC').limit(count)
+      stream.preload(:event).order('id ASC').limit(count)
         .map(&method(:build_event_entity))
     end
 
-    def read_all_streams_backward(start_event_id, count)
-      stream = adapter
-      unless start_event_id.equal?(:head)
-        starting_event = adapter.find_by(event_id: start_event_id)
-        stream = stream.where('id < ?', starting_event)
+    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.order('id DESC').limit(count)
+      stream.preload(:event).order('id DESC').limit(count)
         .map(&method(:build_event_entity))
     end
 
     private
 
+    def detect_pkey_index_violated(e)
+      e.message.include?("for key 'PRIMARY'")       ||  # MySQL
+      e.message.include?("event_store_events_pkey") ||  # Postgresql
+      e.message.include?("event_store_events.id")       # Sqlite3
+    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
+      record.event.event_type.constantize.new(
+        event_id: record.event.id,
+        metadata: record.event.metadata,
+        data: record.event.data
       )
     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
+    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)
+    end
   end
 end

data/lib/rails_event_store_active_record/generators/templates/migration_template.rb

@@ -1,16 +1,37 @@
 class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table(:event_store_events) do |t|
+    postgres = ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+    enable_extension "pgcrypto" if postgres
+    create_table(:event_store_events_in_streams, force: false) do |t|
       t.string      :stream,      null: false
-      t.string      :event_type,  null: false
-      t.string      :event_id,    null: false
-      t.text        :metadata
-      t.text        :data,        null: false
+      t.integer     :position,    null: true
+      if postgres
+        t.references :event, null: false, type: :uuid
+      else
+        t.references :event, null: false, type: :string
+      end
       t.datetime    :created_at,  null: false
     end
-    add_index :event_store_events, :stream
+    add_index :event_store_events_in_streams, [:stream, :position], unique: true
+    add_index :event_store_events_in_streams, [:created_at]
+    add_index :event_store_events_in_streams, [:stream, :event_id], unique: true
+
+    if postgres
+      create_table(:event_store_events, id: :uuid, default: 'gen_random_uuid()', force: false) do |t|
+        t.string      :event_type,  null: false
+        t.text        :metadata
+        t.text        :data,        null: false
+        t.datetime    :created_at,  null: false
+      end
+    else
+      create_table(:event_store_events, id: false, force: false) do |t|
+        t.string :id, limit: 36, primary_key: true, null: false
+        t.string      :event_type,  null: false
+        t.text        :metadata
+        t.text        :data,        null: false
+        t.datetime    :created_at,  null: false
+      end
+    end
     add_index :event_store_events, :created_at
-    add_index :event_store_events, :event_type
-    add_index :event_store_events, :event_id, unique: true
   end
 end

data/lib/rails_event_store_active_record/generators/templates/v1_v2_migration_template.rb

@@ -0,0 +1,97 @@
+# This migration is not intended for live data  migration
+# It assumes no data is added at when it is running.
+# So stop your application servers from accepting new requests
+# and processing background jobs before running
+
+# Make sure you have a backup before running on production
+
+# 10_000_000 distinct stream names
+# can cause around 2GB of RAM usage
+# make sure you can run this migration on your production system
+class MigrateResSchemaV1ToV2 < ActiveRecord::Migration<%= migration_version %>
+  def up
+    postgres = ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+    mysql    = ActiveRecord::Base.connection.adapter_name == "Mysql2"
+    sqlite   = ActiveRecord::Base.connection.adapter_name == "SQLite"
+    enable_extension "pgcrypto" if postgres
+    create_table(:event_store_events_in_streams, force: false) do |t|
+      t.string      :stream,      null: false
+      t.integer     :position,    null: true
+      if postgres
+        t.references :event, null: false, type: :uuid
+      else
+        t.references :event, null: false, type: :string
+      end
+      t.datetime    :created_at,  null: false
+    end
+    streams = {}
+    RailsEventStoreActiveRecord::Event.reset_column_information
+    RailsEventStoreActiveRecord::Event.find_each do |ev|
+      position = nil
+      if preserve_positions?(ev.stream)
+        streams[ev.stream] ||= -1
+        position = streams[ev.stream] += 1
+      end
+      RailsEventStoreActiveRecord::EventInStream.create!(
+        stream: ev.stream,
+        position: position,
+        event_id: ev.event_id,
+        created_at: ev.created_at,
+      )
+      RailsEventStoreActiveRecord::EventInStream.create!(
+        stream: 'all',
+        position: nil,
+        event_id: ev.event_id,
+        created_at: ev.created_at,
+      ) unless ev.stream == 'all'
+    end
+
+    add_index :event_store_events_in_streams, [:stream, :position], unique: true
+    add_index :event_store_events_in_streams, [:stream, :event_id], unique: true
+    add_index :event_store_events_in_streams, [:created_at]
+
+    remove_index  :event_store_events, :event_type
+    remove_column :event_store_events, :stream
+    remove_column :event_store_events, :id
+    rename_column :event_store_events, :event_id, :id
+    change_column :event_store_events, :id, "uuid using id::uuid", default: -> { "gen_random_uuid()" } if postgres
+    change_column :event_store_events, :id, "string", limit: 36 if mysql || sqlite
+
+    case ActiveRecord::Base.connection.adapter_name
+    when "SQLite"
+      remove_index  :event_store_events, name: :index_event_store_events_on_id
+      rename_table :event_store_events, :old_event_store_events
+      create_table(:event_store_events, id: false, force: false) do |t|
+        t.string :id, limit: 36, primary_key: true, null: false
+        t.string      :event_type,  null: false
+        t.text        :metadata
+        t.text        :data,        null: false
+        t.datetime    :created_at,  null: false
+      end
+      add_index :event_store_events, :created_at
+      execute <<-SQL
+        INSERT INTO event_store_events(id, event_type, metadata, data, created_at)
+        SELECT id, event_type, metadata, data, created_at FROM old_event_store_events;
+      SQL
+      drop_table :old_event_store_events
+    else
+      execute "ALTER TABLE event_store_events ADD PRIMARY KEY (id);"
+      remove_index  :event_store_events, name: :index_event_store_events_on_id
+    end
+  end
+
+  def preserve_positions?(stream_name)
+    # http://railseventstore.org/docs/expected_version/
+    #
+    # return true if you use given stream for event sourcing
+    #   (especially with AggregateRoot gem)
+    # return true if you use an Integer or :none as
+    # expected_version when publishing in this stream
+    #
+    # return false if use use :any (the default) as expected_version
+    # when publishing to this stream
+
+    raise NotImplementedError
+    # false
+  end
+end

data/lib/rails_event_store_active_record/generators/v1_v2_migration_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators'
+
+module RailsEventStoreActiveRecord
+  class V1V2MigrationGenerator < Rails::Generators::Base
+    source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
+
+    def create_migration
+      template "v1_v2_migration_template.rb", "db/migrate/#{timestamp}_migrate_res_schema_v1_to_v2.rb"
+    end
+
+    private
+
+    def rails_version
+      Rails::VERSION::STRING
+    end
+
+    def migration_version
+      return nil if Gem::Version.new(rails_version) < Gem::Version.new("5.0.0")
+      "[4.2]"
+    end
+
+    def timestamp
+      Time.now.strftime("%Y%m%d%H%M%S")
+    end
+  end
+end

data/lib/rails_event_store_active_record/legacy_event_repository.rb

@@ -0,0 +1,143 @@
+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 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 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
+
+    private
+
+    def normalize_to_array(events)
+      [*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

data/lib/rails_event_store_active_record/version.rb

@@ -1,3 +1,3 @@
 module RailsEventStoreActiveRecord
-  VERSION = "0.18.2"
+  VERSION = "0.19.0"
 end

data/lib/rails_event_store_active_record.rb

@@ -1,4 +1,6 @@
 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/legacy_event_repository'
 require 'rails_event_store_active_record/version'

data/rails_event_store_active_record.gemspec

@@ -22,12 +22,16 @@ 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', '~> 4.2'
+  spec.add_development_dependency 'rails', '~> 5.1'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'postgresql'
+  spec.add_development_dependency 'mysql2'
   spec.add_development_dependency 'mutant-rspec', '~> 0.8.14'
-  spec.add_development_dependency "fakefs", "~> 0.11.2"
+  spec.add_development_dependency 'fakefs', '~> 0.11.2'
+  spec.add_development_dependency 'childprocess'
 
-  spec.add_dependency 'ruby_event_store', '= 0.18.2'
+  spec.add_dependency 'ruby_event_store', '= 0.19.0'
   spec.add_dependency 'activesupport', '>= 3.0'
   spec.add_dependency 'activemodel', '>= 3.0'
+  spec.add_dependency 'activerecord-import'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_event_store_active_record
 version: !ruby/object:Gem::Version
-  version: 0.18.2
+  version: 0.19.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-18 00:00:00.000000000 Z
+date: 2017-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: postgresql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mutant-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -108,20 +136,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby_event_store
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.2
+        version: 0.19.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.2
+        version: 0.19.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +192,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-import
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Implementation of events repository based on Rails Active Record for
   Rails Event Store'
 email:
@@ -169,6 +225,9 @@ files:
 - lib/rails_event_store_active_record/event_repository.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/legacy_event_repository.rb
 - lib/rails_event_store_active_record/version.rb
 - rails_event_store_active_record.gemspec
 homepage: https://github.com/arkency/rails_event_store_active_record